@code-yeongyu/senpi 2026.8.20-2 → 2026.8.20

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

@@ -13,16 +13,12 @@
 // 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;
@@ -41,7 +37,7 @@ function makeWriteOptions(options) {
  * passed to JSON.stringify().
  */
 export function toJson(schema, message, options) {
-    return compiledWriter(schema)(makeWriteOptions(options), message);
+    return reflectToJson(reflect(schema, message), makeWriteOptions(options));
 }
 /**
  * Serialize the message to a JSON string.
@@ -65,337 +61,123 @@ export function enumToJson(descEnum, value) {
     }
     return name;
 }
-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");
+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`);
             }
-            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 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));
-    }
-    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);
-                };
+            if (!opts.alwaysEmitImplicit || f.presence !== IMPLICIT) {
+                // Fields with implicit presence omit zero values (e.g. empty string) by default
+                continue;
             }
-            return undefined;
-    }
-}
-function compileField(field) {
-    switch (field.fieldKind) {
-        case "scalar":
-        case "enum":
-        case "message":
-            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;
-                }
-            };
+        }
+        const jsonValue = fieldToJson(f, msg.get(f), opts);
+        if (jsonValue !== undefined) {
+            json[jsonName(f, opts)] = jsonValue;
         }
     }
-}
-/**
- * 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);
+    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;
                 }
-            };
-        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);
+                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 json;
 }
-/**
- * Compile an encoder for the value of a field of any kind. Used for
- * extension values.
- */
-function compileFieldValue(field) {
-    switch (field.fieldKind) {
+function fieldToJson(f, val, opts) {
+    switch (f.fieldKind) {
         case "scalar":
-        case "enum":
+            return scalarToJson(f, val);
         case "message":
-            return compileSingularValue(field);
+            return reflectToJson(val, opts);
+        case "enum":
+            return enumToJsonInternal(f.enum, val, opts.enumAsInteger);
         case "list":
-            return compileListValue(field);
+            return listToJson(val, opts);
         case "map":
-            return compileMapValue(field);
+            return mapToJson(val, opts);
     }
 }
-/**
- * Compile an encoder for the value of a singular field.
- */
-function compileSingularValue(field) {
-    switch (field.fieldKind) {
+function mapToJson(map, opts) {
+    const f = map.field();
+    const jsonObj = {};
+    switch (f.mapKind) {
         case "scalar":
-            return compileScalarValue(field);
-        case "enum":
-            return compileEnumValue(field);
+            for (const [entryKey, entryValue] of map) {
+                jsonObj[entryKey] = scalarToJson(f, entryValue);
+            }
+            break;
         case "message":
-            return compileMessageValue(field);
-    }
-}
-/**
- * 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":
-            return compileScalarValue(field);
+            for (const [entryKey, entryValue] of map) {
+                jsonObj[entryKey] = reflectToJson(entryValue, opts);
+            }
+            break;
         case "enum":
-            return compileEnumValue(field);
-        case "message":
-            return compileMessageValue(field);
+            for (const [entryKey, entryValue] of map) {
+                jsonObj[entryKey] = enumToJsonInternal(f.enum, entryValue, opts.enumAsInteger);
+            }
+            break;
     }
+    return opts.alwaysEmitImplicit || map.size > 0 ? jsonObj : undefined;
 }
-/**
- * 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) {
+function listToJson(list, opts) {
+    const f = list.field();
+    const jsonArr = [];
+    switch (f.listKind) {
         case "scalar":
-            return compileScalarValue(field);
+            for (const item of list) {
+                jsonArr.push(scalarToJson(f, item));
+            }
+            break;
         case "enum":
-            return compileEnumValue(field);
+            for (const item of list) {
+                jsonArr.push(enumToJsonInternal(f.enum, item, opts.enumAsInteger));
+            }
+            break;
         case "message":
-            return compileMessageValue(field);
+            for (const item of list) {
+                jsonArr.push(reflectToJson(item, opts));
+            }
+            break;
     }
+    return opts.alwaysEmitImplicit || jsonArr.length > 0 ? jsonArr : undefined;
 }
-/**
- * Compile an encoder for an enum value.
- */
-function compileEnumValue(field) {
-    const desc = field.enum;
+function enumToJsonInternal(desc, value, enumAsInteger) {
+    var _a;
+    if (typeof value != "number") {
+        throw new Error(`cannot encode ${desc} to JSON: expected number, got ${formatVal(value)}`);
+    }
     if (desc.typeName == "google.protobuf.NullValue") {
-        return (opts, value) => {
-            if (typeof value != "number") {
-                throw errorEnumValue(desc, value);
-            }
-            return null;
-        };
+        return null;
     }
-    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 errorEnumValue(desc, value) {
-    return new Error(`cannot encode ${desc} to JSON: expected number, got ${formatVal(value)}`);
+    if (enumAsInteger) {
+        return value;
+    }
+    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
 }
-/**
- * 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) {
+function scalarToJson(field, value) {
+    var _a, _b, _c, _d, _e, _f;
     switch (field.scalar) {
         // int32, fixed32, uint32: JSON value will be a decimal number. Either numbers or strings are accepted.
         case ScalarType.INT32:
@@ -403,100 +185,86 @@ function compileScalarValue(field) {
         case ScalarType.SINT32:
         case ScalarType.FIXED32:
         case ScalarType.UINT32:
-            return (opts, value) => {
-                if (typeof value != "number") {
-                    throw errorScalarValue(field, value);
-                }
-                return value;
-            };
+            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;
         // 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:
-            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;
-            };
+        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;
         // string:
         case ScalarType.STRING:
-            return (opts, value) => {
-                if (typeof value != "string") {
-                    throw errorScalarValue(field, value);
-                }
-                return value;
-            };
+            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;
         // bool:
         case ScalarType.BOOL:
-            return (opts, value) => {
-                if (typeof value != "boolean") {
-                    throw errorScalarValue(field, value);
-                }
-                return value;
-            };
+            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;
         // 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:
-            return (opts, value) => {
-                if (typeof value == "bigint" ||
-                    typeof value == "string" ||
-                    (typeof value == "number" && Number.isInteger(value))) {
-                    return value.toString();
-                }
-                throw errorScalarValue(field, value);
-            };
+            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}`);
         // 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:
-            return (opts, value) => {
-                if (value instanceof Uint8Array) {
-                    return base64Encode(value);
-                }
-                throw errorScalarValue(field, value);
-            };
+            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}`);
     }
 }
-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}`);
+function jsonName(f, opts) {
+    return opts.useProtoFieldName ? f.name : f.jsonName;
 }
-/**
- * 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;
+// returns a json value if wkt, otherwise returns undefined.
+function tryWktToJson(msg, opts) {
+    if (!msg.desc.typeName.startsWith("google.protobuf.")) {
+        return undefined;
     }
-    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;
-            }
-            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;
+    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));
             }
-        }
+            return undefined;
     }
 }
 function anyToJson(val, opts) {
@@ -515,18 +283,17 @@ 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: compiledWriter(desc)(opts, message),
-        }
-        : compiledWriter(desc)(opts, message);
+        ? { value: tryWktToJson(reflected, opts) }
+        : reflectToJson(reflected, opts);
     json["@type"] = val.typeUrl;
     return json;
 }
 function durationToJson(val) {
     const seconds = Number(val.seconds);
     const nanos = val.nanos;
-    if (seconds > durationSecondsMax || seconds < durationSecondsMin) {
+    if (seconds > 315576000000 || seconds < -315576000000) {
         throw new Error(`cannot encode message ${val.$typeName} to JSON: value out of range`);
     }
     if ((seconds > 0 && nanos < 0) || (seconds < 0 && nanos > 0)) {
@@ -561,10 +328,8 @@ function fieldMaskToJson(val) {
 }
 function structToJson(val) {
     const json = {};
-    const keys = Object.keys(val.fields);
-    for (let i = 0; i < keys.length; i++) {
-        const key = keys[i];
-        json[key] = valueToJson(val.fields[key]);
+    for (const [k, v] of Object.entries(val.fields)) {
+        json[k] = valueToJson(v);
     }
     return json;
 }
@@ -594,7 +359,8 @@ function listValueToJson(val) {
 }
 function timestampToJson(val) {
     const ms = Number(val.seconds) * 1000;
-    if (ms < timestampMsMin || ms > timestampMsMax) {
+    if (ms < Date.parse("0001-01-01T00:00:00Z") ||
+        ms > Date.parse("9999-12-31T23:59:59Z")) {
         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) {