@code-yeongyu/senpi 2026.8.20-2 → 2026.8.20

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

@@ -11,14 +11,9 @@
 // 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.
@@ -29,390 +24,157 @@ function makeWriteOptions(options) {
     return options ? Object.assign(Object.assign({}, writeDefaults), options) : writeDefaults;
 }
 export function toBinary(schema, message, options) {
-    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);
-    }
-    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);
+    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);
+    }
+    if (opts.writeUnknownFields) {
+        for (const { no, wireType, data } of (_a = msg.getUnknown()) !== null && _a !== void 0 ? _a : []) {
+            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 compiled;
+    return writer;
 }
-function compileField(field) {
+/**
+ * @private
+ */
+export function writeField(writer, opts, msg, field) {
+    var _a;
     switch (field.fieldKind) {
-        case "message":
         case "scalar":
         case "enum":
-            return compileSingularField(field);
+            writeScalar(writer, msg.desc.typeName, field.name, (_a = field.scalar) !== null && _a !== void 0 ? _a : ScalarType.INT32, field.number, msg.get(field));
+            break;
         case "list":
-            return compileListField(field);
+            writeListField(writer, opts, field, msg.get(field));
+            break;
+        case "message":
+            writeMessageField(writer, opts, field, msg.get(field));
+            break;
         case "map":
-            return compileMapField(field);
-    }
-}
-/**
- * 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);
+            for (const [key, val] of msg.get(field)) {
+                writeMapEntry(writer, opts, field, key, val);
             }
-        };
+            break;
     }
-    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);
-            }
-        };
+}
+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);
     }
-    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);
-                }
-            };
+    else {
+        writeFields(writer.tag(field.number, WireType.LengthDelimited).fork(), opts, message).join();
     }
 }
-/**
- * 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);
-            };
+function writeListField(writer, opts, field, list) {
+    var _a;
+    if (field.listKind == "message") {
+        for (const item of list) {
+            writeMessageField(writer, opts, field, item);
         }
+        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]));
-                }
-            };
+    const scalarType = (_a = field.scalar) !== null && _a !== void 0 ? _a : ScalarType.INT32;
+    if (field.packed) {
+        if (!list.size) {
+            return;
         }
-        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.tag(field.number, WireType.LengthDelimited).fork();
+        for (const item of list) {
+            writeScalarValue(writer, field.parent.typeName, field.name, scalarType, item);
         }
+        writer.join();
+        return;
     }
-}
-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();
-            }
-        };
+    for (const item of list) {
+        writeScalar(writer, field.parent.typeName, field.name, scalarType, field.number, item);
     }
-    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;
-            };
+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;
     }
-}
-/**
- * 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);
+    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;
         }
-        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);
-        };
+    catch (e) {
+        if (e instanceof Error) {
+            throw new Error(`cannot encode field ${msgName}.${fieldName} to binary: ${e.message}`);
+        }
+        throw e;
     }
-    return (writer, opts, child) => {
-        writer.tag(fieldNo, WireType.LengthDelimited).fork();
-        writeMessage(writer, opts, child);
-        writer.join();
-    };
 }
 function writeTypeOfScalar(type) {
     switch (type) {