@code-yeongyu/senpi 2026.8.19 → 2026.8.20-2

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

@@ -13,12 +13,16 @@
 // limitations under the License.
 import { ScalarType, } from "./descriptors.js";
 import { protoCamelCase, protoSnakeCase } from "./reflect/names.js";
-import { reflect } from "./reflect/reflect.js";
 import { anyUnpack } from "./wkt/index.js";
 import { hasCustomJsonRepresentation, isWrapperDesc } from "./wkt/wrappers.js";
+import { durationSecondsMax, durationSecondsMin, timestampMsMax, timestampMsMin, } from "./wkt/json.js";
 import { base64Encode } from "./wire/index.js";
 import { createExtensionContainer, getExtension } from "./extensions.js";
 import { checkField, formatVal } from "./reflect/reflect-check.js";
+import { FieldError } from "./reflect/error.js";
+import { unsafeLocal } from "./reflect/unsafe.js";
+import { scalarZeroValue } from "./reflect/scalar.js";
+import { localMessageMapper } from "./reflect/message.js";
 // bootstrap-inject google.protobuf.FeatureSet.FieldPresence.LEGACY_REQUIRED: const $name = $number;
 const LEGACY_REQUIRED = 3;
 // bootstrap-inject google.protobuf.FeatureSet.FieldPresence.IMPLICIT: const $name = $number;
@@ -37,7 +41,7 @@ function makeWriteOptions(options) {
  * passed to JSON.stringify().
  */
 export function toJson(schema, message, options) {
-    return reflectToJson(reflect(schema, message), makeWriteOptions(options));
+    return compiledWriter(schema)(makeWriteOptions(options), message);
 }
 /**
  * Serialize the message to a JSON string.
@@ -61,123 +65,337 @@ export function enumToJson(descEnum, value) {
     }
     return name;
 }
-function reflectToJson(msg, opts) {
-    var _a;
-    const wktJson = tryWktToJson(msg, opts);
-    if (wktJson !== undefined)
-        return wktJson;
-    const json = {};
-    for (const f of msg.sortedFields) {
-        if (!msg.isSet(f)) {
-            if (f.presence == LEGACY_REQUIRED) {
-                throw new Error(`cannot encode ${f} to JSON: required field not set`);
-            }
-            if (!opts.alwaysEmitImplicit || f.presence !== IMPLICIT) {
-                // Fields with implicit presence omit zero values (e.g. empty string) by default
-                continue;
+const compiledWriters = new WeakMap();
+/**
+ * Return the compiled encoder for a message, compiling it on first use.
+ */
+function compiledWriter(desc) {
+    let compiled = compiledWriters.get(desc);
+    if (compiled === undefined) {
+        compiled = compileMessage(desc);
+    }
+    return compiled;
+}
+function compileMessage(desc) {
+    const typeName = desc.typeName;
+    const writeWkt = compileWkt(desc);
+    if (writeWkt !== undefined) {
+        // The field reported in ForeignFieldError. All well-known types with a
+        // custom JSON representation have at least one field.
+        const foreignField = desc.fields[0];
+        const compiledWriter = (opts, message) => {
+            if (message.$typeName !== typeName && foreignField !== undefined) {
+                throw new FieldError(foreignField, `cannot use ${foreignField} with message ${message.$typeName}`, "ForeignFieldError");
             }
+            return writeWkt(opts, message);
+        };
+        compiledWriters.set(desc, compiledWriter);
+        return compiledWriter;
+    }
+    const sortedFields = desc.fields.concat().sort((a, b) => a.number - b.number);
+    // The field reported in ForeignFieldError.
+    const foreignField = sortedFields[0];
+    const fieldWriters = [];
+    const compiledWriter = (opts, message) => {
+        if (message.$typeName !== typeName && foreignField !== undefined) {
+            throw new FieldError(foreignField, `cannot use ${foreignField} with message ${message.$typeName}`, "ForeignFieldError");
         }
-        const jsonValue = fieldToJson(f, msg.get(f), opts);
-        if (jsonValue !== undefined) {
-            json[jsonName(f, opts)] = jsonValue;
+        const json = {};
+        for (let i = 0; i < fieldWriters.length; i++) {
+            fieldWriters[i](opts, message, json);
         }
+        if (opts.registry) {
+            writeExtensions(json, opts, opts.registry, message, desc);
+        }
+        return json;
+    };
+    // Register before compiling fields, so that recursive message types
+    // resolve to this instance instead of compiling endlessly.
+    compiledWriters.set(desc, compiledWriter);
+    for (const field of sortedFields) {
+        fieldWriters.push(compileField(field));
     }
-    if (opts.registry) {
-        const tagSeen = new Set();
-        for (const { no } of (_a = msg.getUnknown()) !== null && _a !== void 0 ? _a : []) {
-            // Same tag can appear multiple times, so we
-            // keep track and skip identical ones.
-            if (!tagSeen.has(no)) {
-                tagSeen.add(no);
-                const extension = opts.registry.getExtensionFor(msg.desc, no);
-                if (!extension) {
-                    continue;
-                }
-                const value = getExtension(msg.message, extension);
-                const [container, field] = createExtensionContainer(extension, value);
-                const jsonValue = fieldToJson(field, container.get(field), opts);
-                if (jsonValue !== undefined) {
-                    json[extension.jsonName] = jsonValue;
-                }
+    return compiledWriter;
+}
+/**
+ * Compile an encoder for a well-known type with a custom JSON representation,
+ * or return undefined for other messages.
+ */
+function compileWkt(desc) {
+    if (!desc.typeName.startsWith("google.protobuf.")) {
+        return undefined;
+    }
+    switch (desc.typeName) {
+        case "google.protobuf.Any":
+            return (opts, message) => anyToJson(message, opts);
+        case "google.protobuf.Timestamp":
+            return (opts, message) => timestampToJson(message);
+        case "google.protobuf.Duration":
+            return (opts, message) => durationToJson(message);
+        case "google.protobuf.FieldMask":
+            return (opts, message) => fieldMaskToJson(message);
+        case "google.protobuf.Struct":
+            return (opts, message) => structToJson(message);
+        case "google.protobuf.Value":
+            return (opts, message) => valueToJson(message);
+        case "google.protobuf.ListValue":
+            return (opts, message) => listValueToJson(message);
+        default:
+            if (isWrapperDesc(desc)) {
+                const valueField = desc.fields[0];
+                const localName = valueField.localName;
+                const zero = scalarZeroValue(valueField.scalar, false);
+                const writeScalar = compileScalarValue(valueField);
+                return (opts, message) => {
+                    const value = message[localName];
+                    return writeScalar(opts, value === undefined ? zero : value);
+                };
             }
-        }
+            return undefined;
     }
-    return json;
 }
-function fieldToJson(f, val, opts) {
-    switch (f.fieldKind) {
+function compileField(field) {
+    switch (field.fieldKind) {
         case "scalar":
-            return scalarToJson(f, val);
+        case "enum":
         case "message":
-            return reflectToJson(val, opts);
+            return compileSingularField(field);
+        case "list":
+        case "map": {
+            const writeValue = field.fieldKind == "list"
+                ? compileListValue(field)
+                : compileMapValue(field);
+            const protoName = field.name;
+            const jsonKey = field.jsonName;
+            const localName = field.localName;
+            return (opts, message, json) => {
+                const value = writeValue(opts, message[localName]);
+                if (value !== undefined) {
+                    json[opts.useProtoFieldName ? protoName : jsonKey] = value;
+                }
+            };
+        }
+    }
+}
+/**
+ * Compile an encoder for a singular field: the presence check, and the
+ * value encoder.
+ */
+function compileSingularField(field) {
+    const writeValue = compileSingularValue(field);
+    const protoName = field.name;
+    const jsonKey = field.jsonName;
+    const localName = field.localName;
+    if (field.oneof) {
+        const oneofLocalName = field.oneof.localName;
+        return (opts, message, json) => {
+            const oneof = message[oneofLocalName];
+            if (oneof.case === localName) {
+                json[opts.useProtoFieldName ? protoName : jsonKey] = writeValue(opts, oneof.value);
+            }
+        };
+    }
+    if (field.presence != IMPLICIT) {
+        const requiredError = field.presence == LEGACY_REQUIRED
+            ? `cannot encode ${field} to JSON: required field not set`
+            : undefined;
+        return (opts, message, json) => {
+            const value = message[localName];
+            // Fields with explicit presence have properties on the prototype
+            // chain for default / zero values (except for proto3).
+            if (value !== undefined &&
+                Object.prototype.hasOwnProperty.call(message, localName)) {
+                json[opts.useProtoFieldName ? protoName : jsonKey] = writeValue(opts, value);
+            }
+            else if (requiredError !== undefined) {
+                throw new Error(requiredError);
+            }
+        };
+    }
+    // Implicit presence: the field is emitted when the value is not the zero
+    // value, or when alwaysEmitImplicit is enabled. The zero check is inlined
+    // per type, see isScalarZeroValue.
+    if (field.fieldKind == "enum") {
+        const zero = field.enum.values[0].number;
+        return (opts, message, json) => {
+            const value = message[localName];
+            if (value !== zero || opts.alwaysEmitImplicit) {
+                json[opts.useProtoFieldName ? protoName : jsonKey] = writeValue(opts, value);
+            }
+        };
+    }
+    switch (field.scalar) {
+        case ScalarType.BOOL:
+            return (opts, message, json) => {
+                const value = message[localName];
+                if (value !== false || opts.alwaysEmitImplicit) {
+                    json[opts.useProtoFieldName ? protoName : jsonKey] = writeValue(opts, value);
+                }
+            };
+        case ScalarType.STRING:
+            return (opts, message, json) => {
+                const value = message[localName];
+                if (value !== "" || opts.alwaysEmitImplicit) {
+                    json[opts.useProtoFieldName ? protoName : jsonKey] = writeValue(opts, value);
+                }
+            };
+        case ScalarType.BYTES:
+            return (opts, message, json) => {
+                const value = message[localName];
+                if (!(value instanceof Uint8Array) ||
+                    value.byteLength > 0 ||
+                    opts.alwaysEmitImplicit) {
+                    json[opts.useProtoFieldName ? protoName : jsonKey] = writeValue(opts, value);
+                }
+            };
+        case ScalarType.DOUBLE:
+        case ScalarType.FLOAT:
+            return (opts, message, json) => {
+                const value = message[localName];
+                // Object.is distinguishes -0 from 0.
+                if (!Object.is(value, 0) || opts.alwaysEmitImplicit) {
+                    json[opts.useProtoFieldName ? protoName : jsonKey] = writeValue(opts, value);
+                }
+            };
+        default:
+            return (opts, message, json) => {
+                const value = message[localName];
+                // Loose comparison matches 0n, 0 and "0".
+                if (value != 0 || opts.alwaysEmitImplicit) {
+                    json[opts.useProtoFieldName ? protoName : jsonKey] = writeValue(opts, value);
+                }
+            };
+    }
+}
+/**
+ * Compile an encoder for the value of a field of any kind. Used for
+ * extension values.
+ */
+function compileFieldValue(field) {
+    switch (field.fieldKind) {
+        case "scalar":
         case "enum":
-            return enumToJsonInternal(f.enum, val, opts.enumAsInteger);
+        case "message":
+            return compileSingularValue(field);
         case "list":
-            return listToJson(val, opts);
+            return compileListValue(field);
         case "map":
-            return mapToJson(val, opts);
+            return compileMapValue(field);
     }
 }
-function mapToJson(map, opts) {
-    const f = map.field();
-    const jsonObj = {};
-    switch (f.mapKind) {
+/**
+ * Compile an encoder for the value of a singular field.
+ */
+function compileSingularValue(field) {
+    switch (field.fieldKind) {
         case "scalar":
-            for (const [entryKey, entryValue] of map) {
-                jsonObj[entryKey] = scalarToJson(f, entryValue);
-            }
-            break;
-        case "message":
-            for (const [entryKey, entryValue] of map) {
-                jsonObj[entryKey] = reflectToJson(entryValue, opts);
-            }
-            break;
+            return compileScalarValue(field);
         case "enum":
-            for (const [entryKey, entryValue] of map) {
-                jsonObj[entryKey] = enumToJsonInternal(f.enum, entryValue, opts.enumAsInteger);
-            }
-            break;
+            return compileEnumValue(field);
+        case "message":
+            return compileMessageValue(field);
     }
-    return opts.alwaysEmitImplicit || map.size > 0 ? jsonObj : undefined;
 }
-function listToJson(list, opts) {
-    const f = list.field();
-    const jsonArr = [];
-    switch (f.listKind) {
+/**
+ * Compile an encoder for the value of a message field.
+ */
+function compileMessageValue(field) {
+    const { toMessage } = localMessageMapper(field);
+    const writeMessage = compiledWriter(field.message);
+    return (opts, value) => writeMessage(opts, toMessage(value));
+}
+/**
+ * Compile an encoder for a list field value. Returns undefined for an empty
+ * list, unless alwaysEmitImplicit is enabled.
+ */
+function compileListValue(field) {
+    const writeItem = compileListItemValue(field);
+    return (opts, value) => {
+        const items = value;
+        if (items.length == 0 && !opts.alwaysEmitImplicit) {
+            return undefined;
+        }
+        const jsonArray = [];
+        for (let i = 0; i < items.length; i++) {
+            jsonArray.push(writeItem(opts, items[i]));
+        }
+        return jsonArray;
+    };
+}
+function compileListItemValue(field) {
+    switch (field.listKind) {
         case "scalar":
-            for (const item of list) {
-                jsonArr.push(scalarToJson(f, item));
-            }
-            break;
+            return compileScalarValue(field);
         case "enum":
-            for (const item of list) {
-                jsonArr.push(enumToJsonInternal(f.enum, item, opts.enumAsInteger));
-            }
-            break;
+            return compileEnumValue(field);
         case "message":
-            for (const item of list) {
-                jsonArr.push(reflectToJson(item, opts));
-            }
-            break;
+            return compileMessageValue(field);
     }
-    return opts.alwaysEmitImplicit || jsonArr.length > 0 ? jsonArr : undefined;
 }
-function enumToJsonInternal(desc, value, enumAsInteger) {
-    var _a;
-    if (typeof value != "number") {
-        throw new Error(`cannot encode ${desc} to JSON: expected number, got ${formatVal(value)}`);
+/**
+ * Compile an encoder for a map field value. Returns undefined for an empty
+ * map, unless alwaysEmitImplicit is enabled. Map keys are stored as object
+ * keys and are used as JSON keys as-is.
+ */
+function compileMapValue(field) {
+    const writeMapValue = compileMapEntryValue(field);
+    return (opts, value) => {
+        const record = value;
+        const keys = Object.keys(record);
+        if (keys.length == 0 && !opts.alwaysEmitImplicit) {
+            return undefined;
+        }
+        const jsonObject = {};
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            jsonObject[key] = writeMapValue(opts, record[key]);
+        }
+        return jsonObject;
+    };
+}
+function compileMapEntryValue(field) {
+    switch (field.mapKind) {
+        case "scalar":
+            return compileScalarValue(field);
+        case "enum":
+            return compileEnumValue(field);
+        case "message":
+            return compileMessageValue(field);
     }
+}
+/**
+ * Compile an encoder for an enum value.
+ */
+function compileEnumValue(field) {
+    const desc = field.enum;
     if (desc.typeName == "google.protobuf.NullValue") {
-        return null;
-    }
-    if (enumAsInteger) {
-        return value;
+        return (opts, value) => {
+            if (typeof value != "number") {
+                throw errorEnumValue(desc, value);
+            }
+            return null;
+        };
     }
-    const val = desc.value[value];
-    return (_a = val === null || val === void 0 ? void 0 : val.name) !== null && _a !== void 0 ? _a : value; // if we don't know the enum value, just return the number
+    return (opts, value) => {
+        var _a, _b;
+        if (typeof value != "number") {
+            throw errorEnumValue(desc, value);
+        }
+        if (opts.enumAsInteger) {
+            return value;
+        }
+        // If we don't know the enum value, just return the number.
+        return (_b = (_a = desc.value[value]) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : value;
+    };
 }
-function scalarToJson(field, value) {
-    var _a, _b, _c, _d, _e, _f;
+function errorEnumValue(desc, value) {
+    return new Error(`cannot encode ${desc} to JSON: expected number, got ${formatVal(value)}`);
+}
+/**
+ * Compile an encoder for a scalar value. Errors report the original field
+ * descriptor, which may be a list or map field for items of those fields.
+ */
+function compileScalarValue(field) {
     switch (field.scalar) {
         // int32, fixed32, uint32: JSON value will be a decimal number. Either numbers or strings are accepted.
         case ScalarType.INT32:
@@ -185,86 +403,100 @@ function scalarToJson(field, value) {
         case ScalarType.SINT32:
         case ScalarType.FIXED32:
         case ScalarType.UINT32:
-            if (typeof value != "number") {
-                throw new Error(`cannot encode ${field} to JSON: ${(_a = checkField(field, value)) === null || _a === void 0 ? void 0 : _a.message}`);
-            }
-            return value;
+            return (opts, value) => {
+                if (typeof value != "number") {
+                    throw errorScalarValue(field, value);
+                }
+                return value;
+            };
         // float, double: JSON value will be a number or one of the special string values "NaN", "Infinity", and "-Infinity".
         // Either numbers or strings are accepted. Exponent notation is also accepted.
         case ScalarType.FLOAT:
-        case ScalarType.DOUBLE: // eslint-disable-line no-fallthrough
-            if (typeof value != "number") {
-                throw new Error(`cannot encode ${field} to JSON: ${(_b = checkField(field, value)) === null || _b === void 0 ? void 0 : _b.message}`);
-            }
-            if (Number.isNaN(value))
-                return "NaN";
-            if (value === Number.POSITIVE_INFINITY)
-                return "Infinity";
-            if (value === Number.NEGATIVE_INFINITY)
-                return "-Infinity";
-            return value;
+        case ScalarType.DOUBLE:
+            return (opts, value) => {
+                if (typeof value != "number") {
+                    throw errorScalarValue(field, value);
+                }
+                if (Number.isNaN(value))
+                    return "NaN";
+                if (value === Number.POSITIVE_INFINITY)
+                    return "Infinity";
+                if (value === Number.NEGATIVE_INFINITY)
+                    return "-Infinity";
+                return value;
+            };
         // string:
         case ScalarType.STRING:
-            if (typeof value != "string") {
-                throw new Error(`cannot encode ${field} to JSON: ${(_c = checkField(field, value)) === null || _c === void 0 ? void 0 : _c.message}`);
-            }
-            return value;
+            return (opts, value) => {
+                if (typeof value != "string") {
+                    throw errorScalarValue(field, value);
+                }
+                return value;
+            };
         // bool:
         case ScalarType.BOOL:
-            if (typeof value != "boolean") {
-                throw new Error(`cannot encode ${field} to JSON: ${(_d = checkField(field, value)) === null || _d === void 0 ? void 0 : _d.message}`);
-            }
-            return value;
+            return (opts, value) => {
+                if (typeof value != "boolean") {
+                    throw errorScalarValue(field, value);
+                }
+                return value;
+            };
         // JSON value will be a decimal string. Either numbers or strings are accepted.
         case ScalarType.UINT64:
         case ScalarType.FIXED64:
         case ScalarType.INT64:
         case ScalarType.SFIXED64:
         case ScalarType.SINT64:
-            if (typeof value == "bigint" ||
-                typeof value == "string" ||
-                (typeof value == "number" && Number.isInteger(value))) {
-                return value.toString();
-            }
-            throw new Error(`cannot encode ${field} to JSON: ${(_e = checkField(field, value)) === null || _e === void 0 ? void 0 : _e.message}`);
+            return (opts, value) => {
+                if (typeof value == "bigint" ||
+                    typeof value == "string" ||
+                    (typeof value == "number" && Number.isInteger(value))) {
+                    return value.toString();
+                }
+                throw errorScalarValue(field, value);
+            };
         // 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 (value instanceof Uint8Array) {
-                return base64Encode(value);
-            }
-            throw new Error(`cannot encode ${field} to JSON: ${(_f = checkField(field, value)) === null || _f === void 0 ? void 0 : _f.message}`);
+            return (opts, value) => {
+                if (value instanceof Uint8Array) {
+                    return base64Encode(value);
+                }
+                throw errorScalarValue(field, value);
+            };
     }
 }
-function jsonName(f, opts) {
-    return opts.useProtoFieldName ? f.name : f.jsonName;
+function errorScalarValue(field, value) {
+    var _a;
+    return new Error(`cannot encode ${field} to JSON: ${(_a = checkField(field, value)) === null || _a === void 0 ? void 0 : _a.message}`);
 }
-// returns a json value if wkt, otherwise returns undefined.
-function tryWktToJson(msg, opts) {
-    if (!msg.desc.typeName.startsWith("google.protobuf.")) {
-        return undefined;
+/**
+ * Write extensions for unknown fields that are found in the registry.
+ */
+function writeExtensions(json, opts, registry, message, desc) {
+    const unknown = message.$unknown;
+    if (unknown === undefined) {
+        return;
     }
-    switch (msg.desc.typeName) {
-        case "google.protobuf.Any":
-            return anyToJson(msg.message, opts);
-        case "google.protobuf.Timestamp":
-            return timestampToJson(msg.message);
-        case "google.protobuf.Duration":
-            return durationToJson(msg.message);
-        case "google.protobuf.FieldMask":
-            return fieldMaskToJson(msg.message);
-        case "google.protobuf.Struct":
-            return structToJson(msg.message);
-        case "google.protobuf.Value":
-            return valueToJson(msg.message);
-        case "google.protobuf.ListValue":
-            return listValueToJson(msg.message);
-        default:
-            if (isWrapperDesc(msg.desc)) {
-                const valueField = msg.desc.fields[0];
-                return scalarToJson(valueField, msg.get(valueField));
+    const tagSeen = new Set();
+    for (let i = 0; i < unknown.length; i++) {
+        const { no } = unknown[i];
+        // Same tag can appear multiple times, so we
+        // keep track and skip identical ones.
+        if (!tagSeen.has(no)) {
+            tagSeen.add(no);
+            const extension = registry.getExtensionFor(desc, no);
+            if (!extension) {
+                continue;
             }
-            return undefined;
+            const value = getExtension(message, extension);
+            const [container, field] = createExtensionContainer(extension, value);
+            const local = container[unsafeLocal];
+            const jsonValue = compileFieldValue(field)(opts, local[field.localName]);
+            if (jsonValue !== undefined) {
+                json[extension.jsonName] = jsonValue;
+            }
+        }
     }
 }
 function anyToJson(val, opts) {
@@ -283,17 +515,18 @@ function anyToJson(val, opts) {
     if (!desc || !message) {
         throw new Error(`cannot encode message ${val.$typeName} to JSON: "${val.typeUrl}" is not in the type registry`);
     }
-    const reflected = reflect(desc, message);
     const json = hasCustomJsonRepresentation(desc)
-        ? { value: tryWktToJson(reflected, opts) }
-        : reflectToJson(reflected, opts);
+        ? {
+            value: compiledWriter(desc)(opts, message),
+        }
+        : compiledWriter(desc)(opts, message);
     json["@type"] = val.typeUrl;
     return json;
 }
 function durationToJson(val) {
     const seconds = Number(val.seconds);
     const nanos = val.nanos;
-    if (seconds > 315576000000 || seconds < -315576000000) {
+    if (seconds > durationSecondsMax || seconds < durationSecondsMin) {
         throw new Error(`cannot encode message ${val.$typeName} to JSON: value out of range`);
     }
     if ((seconds > 0 && nanos < 0) || (seconds < 0 && nanos > 0)) {
@@ -328,8 +561,10 @@ function fieldMaskToJson(val) {
 }
 function structToJson(val) {
     const json = {};
-    for (const [k, v] of Object.entries(val.fields)) {
-        json[k] = valueToJson(v);
+    const keys = Object.keys(val.fields);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        json[key] = valueToJson(val.fields[key]);
     }
     return json;
 }
@@ -359,8 +594,7 @@ function listValueToJson(val) {
 }
 function timestampToJson(val) {
     const ms = Number(val.seconds) * 1000;
-    if (ms < Date.parse("0001-01-01T00:00:00Z") ||
-        ms > Date.parse("9999-12-31T23:59:59Z")) {
+    if (ms < timestampMsMin || ms > timestampMsMax) {
         throw new Error(`cannot encode message ${val.$typeName} to JSON: must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive`);
     }
     if (val.nanos < 0) {