@code-yeongyu/senpi 2026.8.19 → 2026.8.20-2

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

@@ -11,9 +11,14 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-import { reflect } from "./reflect/reflect.js";
 import { BinaryWriter, WireType } from "./wire/binary-encoding.js";
 import { ScalarType } from "./descriptors.js";
+import { FieldError } from "./reflect/error.js";
+import { unsafeLocal } from "./reflect/unsafe.js";
+import { localMessageMapper } from "./reflect/message.js";
+import { protoInt64 } from "./proto-int64.js";
+// bootstrap-inject google.protobuf.FeatureSet.FieldPresence.IMPLICIT: const $name = $number;
+const IMPLICIT = 2;
 // bootstrap-inject google.protobuf.FeatureSet.FieldPresence.LEGACY_REQUIRED: const $name = $number;
 const LEGACY_REQUIRED = 3;
 // Default options for serializing binary data.
@@ -24,157 +29,390 @@ function makeWriteOptions(options) {
     return options ? Object.assign(Object.assign({}, writeDefaults), options) : writeDefaults;
 }
 export function toBinary(schema, message, options) {
-    return writeFields(new BinaryWriter(), makeWriteOptions(options), reflect(schema, message)).finish();
-}
-function writeFields(writer, opts, msg) {
-    var _a;
-    for (const f of msg.sortedFields) {
-        if (!msg.isSet(f)) {
-            if (f.presence == LEGACY_REQUIRED) {
-                throw new Error(`cannot encode ${f} to binary: required field not set`);
-            }
-            continue;
-        }
-        writeField(writer, opts, msg, f);
+    const writer = new BinaryWriter();
+    compiledWriter(schema)(writer, makeWriteOptions(options), message);
+    return writer.finish();
+}
+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);
     }
-    if (opts.writeUnknownFields) {
-        for (const { no, wireType, data } of (_a = msg.getUnknown()) !== null && _a !== void 0 ? _a : []) {
-            writer.tag(no, wireType).raw(data);
+    return compiled;
+}
+function compileMessage(desc) {
+    const typeName = desc.typeName;
+    const sortedFields = desc.fields.concat().sort((a, b) => a.number - b.number);
+    // The field reported in ForeignFieldError.
+    const foreignField = sortedFields[0];
+    const fieldWriters = [];
+    const compiled = (writer, opts, message) => {
+        if (message.$typeName !== typeName && foreignField !== undefined) {
+            throw new FieldError(foreignField, `cannot use ${foreignField} with message ${message.$typeName}`, "ForeignFieldError");
         }
+        for (let i = 0; i < fieldWriters.length; i++) {
+            fieldWriters[i](writer, opts, message);
+        }
+        const unknown = message.$unknown;
+        if (unknown !== undefined && opts.writeUnknownFields) {
+            for (let i = 0; i < unknown.length; i++) {
+                const { no, wireType, data } = unknown[i];
+                writer.tag(no, wireType).raw(data);
+            }
+        }
+    };
+    // Register before compiling fields, so that recursive message types
+    // resolve to this instance instead of compiling endlessly.
+    compiledWriters.set(desc, compiled);
+    for (const field of sortedFields) {
+        fieldWriters.push(compileField(field));
     }
-    return writer;
+    return compiled;
 }
-/**
- * @private
- */
-export function writeField(writer, opts, msg, field) {
-    var _a;
+function compileField(field) {
     switch (field.fieldKind) {
+        case "message":
         case "scalar":
         case "enum":
-            writeScalar(writer, msg.desc.typeName, field.name, (_a = field.scalar) !== null && _a !== void 0 ? _a : ScalarType.INT32, field.number, msg.get(field));
-            break;
+            return compileSingularField(field);
         case "list":
-            writeListField(writer, opts, field, msg.get(field));
-            break;
-        case "message":
-            writeMessageField(writer, opts, field, msg.get(field));
-            break;
+            return compileListField(field);
         case "map":
-            for (const [key, val] of msg.get(field)) {
-                writeMapEntry(writer, opts, field, key, val);
-            }
-            break;
+            return compileMapField(field);
     }
 }
-function writeScalar(writer, msgName, fieldName, scalarType, fieldNo, value) {
-    writeScalarValue(writer.tag(fieldNo, writeTypeOfScalar(scalarType)), msgName, fieldName, scalarType, value);
-}
-function writeMessageField(writer, opts, field, message) {
-    if (field.delimitedEncoding) {
-        writeFields(writer.tag(field.number, WireType.StartGroup), opts, message).tag(field.number, WireType.EndGroup);
+/**
+ * Compile an encoder for a singular field: the presence check, and the
+ * value encoder.
+ */
+function compileSingularField(field) {
+    const writeValue = compileSingularValue(field);
+    const localName = field.localName;
+    if (field.oneof) {
+        const oneofLocalName = field.oneof.localName;
+        return (writer, opts, message) => {
+            const oneof = message[oneofLocalName];
+            if (oneof.case === localName) {
+                writeValue(writer, opts, oneof.value);
+            }
+        };
     }
-    else {
-        writeFields(writer.tag(field.number, WireType.LengthDelimited).fork(), opts, message).join();
+    if (field.presence != IMPLICIT) {
+        const requiredError = field.presence == LEGACY_REQUIRED
+            ? `cannot encode ${field} to binary: required field not set`
+            : undefined;
+        return (writer, opts, message) => {
+            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)) {
+                writeValue(writer, opts, value);
+            }
+            else if (requiredError !== undefined) {
+                throw new Error(requiredError);
+            }
+        };
+    }
+    // Implicit presence: the field is set when the value is not the zero
+    // value. The check is inlined per type, see isScalarZeroValue.
+    if (field.fieldKind == "enum") {
+        const zero = field.enum.values[0].number;
+        return (writer, opts, message) => {
+            const value = message[localName];
+            if (value !== zero) {
+                writeValue(writer, opts, value);
+            }
+        };
+    }
+    switch (field.scalar) {
+        case ScalarType.BOOL:
+            return (writer, opts, message) => {
+                const value = message[localName];
+                if (value !== false) {
+                    writeValue(writer, opts, value);
+                }
+            };
+        case ScalarType.STRING:
+            return (writer, opts, message) => {
+                const value = message[localName];
+                if (value !== "") {
+                    writeValue(writer, opts, value);
+                }
+            };
+        case ScalarType.BYTES:
+            return (writer, opts, message) => {
+                const value = message[localName];
+                if (!(value instanceof Uint8Array) || value.byteLength > 0) {
+                    writeValue(writer, opts, value);
+                }
+            };
+        case ScalarType.DOUBLE:
+        case ScalarType.FLOAT:
+            return (writer, opts, message) => {
+                const value = message[localName];
+                // Object.is distinguishes -0 from 0.
+                if (!Object.is(value, 0)) {
+                    writeValue(writer, opts, value);
+                }
+            };
+        default:
+            return (writer, opts, message) => {
+                const value = message[localName];
+                // Loose comparison matches 0n, 0 and "0".
+                if (value != 0) {
+                    writeValue(writer, opts, value);
+                }
+            };
     }
 }
-function writeListField(writer, opts, field, list) {
-    var _a;
-    if (field.listKind == "message") {
-        for (const item of list) {
-            writeMessageField(writer, opts, field, item);
+/**
+ * Compile an encoder for the value of a singular field, including the tag.
+ */
+function compileSingularValue(field) {
+    switch (field.fieldKind) {
+        case "message": {
+            const { toMessage } = localMessageMapper(field);
+            const writeChild = compileChildWriter(field);
+            return (writer, opts, value) => {
+                writeChild(writer, opts, toMessage(value));
+            };
+        }
+        case "scalar":
+        case "enum": {
+            const scalarType = field.fieldKind == "enum" ? ScalarType.INT32 : field.scalar;
+            const fieldNo = field.number;
+            const wireType = writeTypeOfScalar(scalarType);
+            const writeScalar = compileScalarValue(scalarType, field.parent.typeName, field.name);
+            return (writer, opts, value) => {
+                writer.tag(fieldNo, wireType);
+                writeScalar(writer, value);
+            };
         }
-        return;
     }
-    const scalarType = (_a = field.scalar) !== null && _a !== void 0 ? _a : ScalarType.INT32;
-    if (field.packed) {
-        if (!list.size) {
-            return;
+}
+function compileListField(field) {
+    const localName = field.localName;
+    const fieldNo = field.number;
+    switch (field.listKind) {
+        case "message": {
+            const { toMessage } = localMessageMapper(field);
+            const writeChild = compileChildWriter(field);
+            return (writer, opts, message) => {
+                const items = message[localName];
+                for (let i = 0; i < items.length; i++) {
+                    writeChild(writer, opts, toMessage(items[i]));
+                }
+            };
         }
-        writer.tag(field.number, WireType.LengthDelimited).fork();
-        for (const item of list) {
-            writeScalarValue(writer, field.parent.typeName, field.name, scalarType, item);
+        case "scalar":
+        case "enum": {
+            const scalarType = field.listKind == "enum" ? ScalarType.INT32 : field.scalar;
+            const writeScalar = compileScalarValue(scalarType, field.parent.typeName, field.name);
+            if (field.packed) {
+                return (writer, opts, message) => {
+                    const items = message[localName];
+                    if (items.length == 0) {
+                        return;
+                    }
+                    writer.tag(fieldNo, WireType.LengthDelimited).fork();
+                    for (let i = 0; i < items.length; i++) {
+                        writeScalar(writer, items[i]);
+                    }
+                    writer.join();
+                };
+            }
+            const wireType = writeTypeOfScalar(scalarType);
+            return (writer, opts, message) => {
+                const items = message[localName];
+                for (let i = 0; i < items.length; i++) {
+                    writer.tag(fieldNo, wireType);
+                    writeScalar(writer, items[i]);
+                }
+            };
         }
-        writer.join();
-        return;
-    }
-    for (const item of list) {
-        writeScalar(writer, field.parent.typeName, field.name, scalarType, field.number, item);
     }
 }
-function writeMapEntry(writer, opts, field, key, value) {
-    var _a;
-    writer.tag(field.number, WireType.LengthDelimited).fork();
-    // write key, expecting key field number = 1
-    writeScalar(writer, field.parent.typeName, field.name, field.mapKey, 1, key);
-    // write value, expecting value field number = 2
-    switch (field.mapKind) {
-        case "scalar":
-        case "enum":
-            writeScalar(writer, field.parent.typeName, field.name, (_a = field.scalar) !== null && _a !== void 0 ? _a : ScalarType.INT32, 2, value);
-            break;
-        case "message":
-            writeFields(writer.tag(2, WireType.LengthDelimited).fork(), opts, value).join();
-            break;
+function compileMapField(field) {
+    const localName = field.localName;
+    const fieldNo = field.number;
+    const writeKey = compileMapKey(field);
+    if (field.mapKind == "message") {
+        const { toMessage } = localMessageMapper(field);
+        const writeMessage = compiledWriter(field.message);
+        return (writer, opts, message) => {
+            const record = message[localName];
+            const keys = Object.keys(record);
+            for (let i = 0; i < keys.length; i++) {
+                const key = keys[i];
+                writer.tag(fieldNo, WireType.LengthDelimited).fork();
+                writeKey(writer, key);
+                // The value of a map entry is always field number 2.
+                writer.tag(2, WireType.LengthDelimited).fork();
+                writeMessage(writer, opts, toMessage(record[key]));
+                writer.join();
+                writer.join();
+            }
+        };
     }
-    writer.join();
-}
-function writeScalarValue(writer, msgName, fieldName, type, value) {
-    try {
-        switch (type) {
-            case ScalarType.STRING:
-                writer.string(value);
-                break;
-            case ScalarType.BOOL:
-                writer.bool(value);
-                break;
-            case ScalarType.DOUBLE:
-                writer.double(value);
-                break;
-            case ScalarType.FLOAT:
-                writer.float(value);
-                break;
-            case ScalarType.INT32:
-                writer.int32(value);
-                break;
-            case ScalarType.INT64:
-                writer.int64(value);
-                break;
-            case ScalarType.UINT64:
-                writer.uint64(value);
-                break;
-            case ScalarType.FIXED64:
-                writer.fixed64(value);
-                break;
-            case ScalarType.BYTES:
-                writer.bytes(value);
-                break;
-            case ScalarType.FIXED32:
-                writer.fixed32(value);
-                break;
-            case ScalarType.SFIXED32:
-                writer.sfixed32(value);
-                break;
-            case ScalarType.SFIXED64:
-                writer.sfixed64(value);
-                break;
-            case ScalarType.SINT64:
-                writer.sint64(value);
-                break;
-            case ScalarType.UINT32:
-                writer.uint32(value);
-                break;
-            case ScalarType.SINT32:
-                writer.sint32(value);
-                break;
+    const scalarType = field.mapKind == "enum" ? ScalarType.INT32 : field.scalar;
+    const valueWireType = writeTypeOfScalar(scalarType);
+    const writeScalar = compileScalarValue(scalarType, field.parent.typeName, field.name);
+    return (writer, opts, message) => {
+        const record = message[localName];
+        const keys = Object.keys(record);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            writer.tag(fieldNo, WireType.LengthDelimited).fork();
+            writeKey(writer, key);
+            // The value of a map entry is always field number 2.
+            writer.tag(2, valueWireType);
+            writeScalar(writer, record[key]);
+            writer.join();
         }
+    };
+}
+/**
+ * Compile an encoder for a map key. Map keys are stored as object keys and
+ * are always strings locally. Convert them to their scalar type before
+ * writing, like the reflect API does when iterating map entries.
+ */
+function compileMapKey(field) {
+    const wireType = writeTypeOfScalar(field.mapKey);
+    const writeScalar = compileScalarValue(field.mapKey, field.parent.typeName, field.name);
+    const convertKey = compileMapKeyConverter(field.mapKey);
+    return (writer, key) => {
+        // The key of a map entry is always field number 1.
+        writer.tag(1, wireType);
+        writeScalar(writer, convertKey(key));
+    };
+}
+/**
+ * Returns a converter from an object key (always a string) to the closest
+ * possible type for the map key type. Invalid keys are passed through to
+ * the scalar writer, which raises an error for them.
+ */
+function compileMapKeyConverter(type) {
+    switch (type) {
+        case ScalarType.STRING:
+            return (key) => key;
+        case ScalarType.BOOL:
+            return (key) => (key === "true" ? true : key === "false" ? false : key);
+        case ScalarType.UINT64:
+        case ScalarType.FIXED64:
+            return (key) => {
+                try {
+                    return protoInt64.uParse(key);
+                }
+                catch (_a) {
+                    return key;
+                }
+            };
+        case ScalarType.INT64:
+        case ScalarType.SFIXED64:
+        case ScalarType.SINT64:
+            return (key) => {
+                try {
+                    return protoInt64.parse(key);
+                }
+                catch (_a) {
+                    return key;
+                }
+            };
+        default:
+            // Handles INT32, UINT32, SINT32, FIXED32, SFIXED32.
+            // We do not use individual cases to save a few bytes code size.
+            return (key) => {
+                const n = Number.parseInt(key);
+                return Number.isFinite(n) ? n : key;
+            };
     }
-    catch (e) {
-        if (e instanceof Error) {
-            throw new Error(`cannot encode field ${msgName}.${fieldName} to binary: ${e.message}`);
+}
+/**
+ * Compile an encoder for a bare scalar value (no tag), wrapping errors from
+ * the writer with the message and field name.
+ */
+function compileScalarValue(type, messageName, fieldName) {
+    const writeScalar = compileScalarWrite(type);
+    return (writer, value) => {
+        try {
+            writeScalar(writer, value);
         }
-        throw e;
+        catch (e) {
+            if (e instanceof Error) {
+                throw new Error(`cannot encode field ${messageName}.${fieldName} to binary: ${e.message}`);
+            }
+            throw e;
+        }
+    };
+}
+function compileScalarWrite(type) {
+    switch (type) {
+        case ScalarType.STRING:
+            return (writer, value) => writer.string(value);
+        case ScalarType.BOOL:
+            return (writer, value) => writer.bool(value);
+        case ScalarType.DOUBLE:
+            return (writer, value) => writer.double(value);
+        case ScalarType.FLOAT:
+            return (writer, value) => writer.float(value);
+        case ScalarType.INT32:
+            return (writer, value) => writer.int32(value);
+        case ScalarType.INT64:
+            return (writer, value) => writer.int64(value);
+        case ScalarType.UINT64:
+            return (writer, value) => writer.uint64(value);
+        case ScalarType.FIXED64:
+            return (writer, value) => writer.fixed64(value);
+        case ScalarType.BYTES:
+            return (writer, value) => writer.bytes(value);
+        case ScalarType.FIXED32:
+            return (writer, value) => writer.fixed32(value);
+        case ScalarType.SFIXED32:
+            return (writer, value) => writer.sfixed32(value);
+        case ScalarType.SFIXED64:
+            return (writer, value) => writer.sfixed64(value);
+        case ScalarType.SINT64:
+            return (writer, value) => writer.sint64(value);
+        case ScalarType.UINT32:
+            return (writer, value) => writer.uint32(value);
+        case ScalarType.SINT32:
+            return (writer, value) => writer.sint32(value);
+    }
+}
+/**
+ * Write a single field to binary format, if it is set. Used to serialize
+ * extensions: extensions always have explicit presence, so an extension
+ * value that was just set on the container is always written.
+ *
+ * @private
+ */
+export function writeField(writer, opts, msg, field) {
+    compileField(field)(writer, opts, msg[unsafeLocal]);
+}
+/**
+ * Compile an encoder for the wire format of a message field, honoring the
+ * delimited encoding of the field. The tag is written by the encoder.
+ */
+function compileChildWriter(field) {
+    const fieldNo = field.number;
+    const writeMessage = compiledWriter(field.message);
+    if (field.delimitedEncoding) {
+        return (writer, opts, child) => {
+            writer.tag(fieldNo, WireType.StartGroup);
+            writeMessage(writer, opts, child);
+            writer.tag(fieldNo, WireType.EndGroup);
+        };
     }
+    return (writer, opts, child) => {
+        writer.tag(fieldNo, WireType.LengthDelimited).fork();
+        writeMessage(writer, opts, child);
+        writer.join();
+    };
 }
 function writeTypeOfScalar(type) {
     switch (type) {