@code-yeongyu/senpi 2026.8.16 → 2026.8.17

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

@@ -0,0 +1,241 @@
+// Copyright 2021-2026 Buf Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// 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 { ScalarType } from "./descriptors.js";
+import { scalarZeroValue } from "./reflect/scalar.js";
+import { reflect } from "./reflect/reflect.js";
+import { BinaryReader, WireType } from "./wire/binary-encoding.js";
+import { varint32write } from "./wire/varint.js";
+/**
+ * @private Only exported for getExtension()
+ */
+export function makeReadContext(options) {
+    return Object.assign(Object.assign({ readUnknownFields: true, recursionLimit: 100 }, options), { depth: 0 });
+}
+/**
+ * Parse serialized binary data.
+ */
+export function fromBinary(schema, bytes, options) {
+    const msg = reflect(schema, undefined, false);
+    readMessage(msg, new BinaryReader(bytes), makeReadContext(options), false, bytes.byteLength);
+    return msg.message;
+}
+/**
+ * Parse from binary data, merging fields.
+ *
+ * Repeated fields are appended. Map entries are added, overwriting
+ * existing keys.
+ *
+ * If a message field is already present, it will be merged with the
+ * new data.
+ */
+export function mergeFromBinary(schema, target, bytes, options) {
+    readMessage(reflect(schema, target, false), new BinaryReader(bytes), makeReadContext(options), false, bytes.byteLength);
+    return target;
+}
+/**
+ * If `delimited` is false, read the length given in `lengthOrDelimitedFieldNo`.
+ *
+ * If `delimited` is true, read until an EndGroup tag. `lengthOrDelimitedFieldNo`
+ * is the expected field number.
+ *
+ * @private
+ */
+function readMessage(message, reader, ctx, delimited, lengthOrDelimitedFieldNo) {
+    var _a;
+    if (++ctx.depth > ctx.recursionLimit) {
+        throw new Error(`cannot decode ${message.desc} from binary: maximum recursion depth of ${ctx.recursionLimit} reached`);
+    }
+    const end = delimited ? reader.len : reader.pos + lengthOrDelimitedFieldNo;
+    let fieldNo;
+    let wireType;
+    const unknownFields = (_a = message.getUnknown()) !== null && _a !== void 0 ? _a : [];
+    while (reader.pos < end) {
+        [fieldNo, wireType] = reader.tag();
+        if (delimited && wireType == WireType.EndGroup) {
+            break;
+        }
+        const field = message.findNumber(fieldNo);
+        if (!field) {
+            // Use remaining recursion budget for skipping nested groups
+            const recursionLimit = ctx.recursionLimit - ctx.depth;
+            const data = reader.skip(wireType, fieldNo, recursionLimit);
+            if (ctx.readUnknownFields) {
+                unknownFields.push({ no: fieldNo, wireType, data });
+            }
+            continue;
+        }
+        readField(message, reader, field, wireType, ctx);
+    }
+    if (delimited) {
+        if (wireType != WireType.EndGroup || fieldNo !== lengthOrDelimitedFieldNo) {
+            throw new Error("invalid end group tag");
+        }
+    }
+    if (unknownFields.length > 0) {
+        message.setUnknown(unknownFields);
+    }
+    ctx.depth--;
+}
+/**
+ * @private Only exported for getExtension()
+ */
+export function readField(message, reader, field, wireType, ctx) {
+    var _a;
+    switch (field.fieldKind) {
+        case "scalar":
+            message.set(field, readScalar(reader, field.scalar, field.utf8Validation));
+            break;
+        case "enum":
+            const val = readScalar(reader, ScalarType.INT32);
+            if (field.enum.open) {
+                message.set(field, val);
+            }
+            else {
+                const ok = field.enum.values.some((v) => v.number === val);
+                if (ok) {
+                    message.set(field, val);
+                }
+                else if (ctx.readUnknownFields) {
+                    const bytes = [];
+                    varint32write(val, bytes);
+                    const unknownFields = (_a = message.getUnknown()) !== null && _a !== void 0 ? _a : [];
+                    unknownFields.push({
+                        no: field.number,
+                        wireType,
+                        data: new Uint8Array(bytes),
+                    });
+                    message.setUnknown(unknownFields);
+                }
+            }
+            break;
+        case "message":
+            message.set(field, readMessageField(reader, ctx, field, message.get(field)));
+            break;
+        case "list":
+            readListField(reader, wireType, message.get(field), ctx);
+            break;
+        case "map":
+            readMapEntry(reader, message.get(field), ctx);
+            break;
+    }
+}
+// Read a map field, expecting key field = 1, value field = 2
+function readMapEntry(reader, map, ctx) {
+    const field = map.field();
+    let key;
+    let val;
+    // Read the length of the map entry, which is a varint.
+    const len = reader.uint32();
+    // WARNING: Calculate end AFTER advancing reader.pos (above), so that
+    //          reader.pos is at the start of the map entry.
+    const end = reader.pos + len;
+    while (reader.pos < end) {
+        const [fieldNo] = reader.tag();
+        switch (fieldNo) {
+            case 1:
+                key = readScalar(reader, field.mapKey, field.utf8Validation);
+                break;
+            case 2:
+                switch (field.mapKind) {
+                    case "scalar":
+                        val = readScalar(reader, field.scalar, field.utf8Validation);
+                        break;
+                    case "enum":
+                        val = reader.int32();
+                        break;
+                    case "message":
+                        val = readMessageField(reader, ctx, field);
+                        break;
+                }
+                break;
+        }
+    }
+    if (key === undefined) {
+        key = scalarZeroValue(field.mapKey, false);
+    }
+    if (val === undefined) {
+        switch (field.mapKind) {
+            case "scalar":
+                val = scalarZeroValue(field.scalar, false);
+                break;
+            case "enum":
+                val = field.enum.values[0].number;
+                break;
+            case "message":
+                val = reflect(field.message, undefined, false);
+                break;
+        }
+    }
+    map.set(key, val);
+}
+function readListField(reader, wireType, list, ctx) {
+    var _a;
+    const field = list.field();
+    if (field.listKind === "message") {
+        list.add(readMessageField(reader, ctx, field));
+        return;
+    }
+    const scalarType = (_a = field.scalar) !== null && _a !== void 0 ? _a : ScalarType.INT32;
+    const packed = wireType == WireType.LengthDelimited &&
+        scalarType != ScalarType.STRING &&
+        scalarType != ScalarType.BYTES;
+    if (!packed) {
+        list.add(readScalar(reader, scalarType, field.utf8Validation));
+        return;
+    }
+    const e = reader.uint32() + reader.pos;
+    while (reader.pos < e) {
+        list.add(readScalar(reader, scalarType, field.utf8Validation));
+    }
+}
+function readMessageField(reader, ctx, field, mergeMessage) {
+    const delimited = field.delimitedEncoding;
+    const message = mergeMessage !== null && mergeMessage !== void 0 ? mergeMessage : reflect(field.message, undefined, false);
+    readMessage(message, reader, ctx, delimited, delimited ? field.number : reader.uint32());
+    return message;
+}
+function readScalar(reader, type, validateUtf8 = false) {
+    switch (type) {
+        case ScalarType.STRING:
+            return reader.string(validateUtf8);
+        case ScalarType.BOOL:
+            return reader.bool();
+        case ScalarType.DOUBLE:
+            return reader.double();
+        case ScalarType.FLOAT:
+            return reader.float();
+        case ScalarType.INT32:
+            return reader.int32();
+        case ScalarType.INT64:
+            return reader.int64();
+        case ScalarType.UINT64:
+            return reader.uint64();
+        case ScalarType.FIXED64:
+            return reader.fixed64();
+        case ScalarType.BYTES:
+            return reader.bytes();
+        case ScalarType.FIXED32:
+            return reader.fixed32();
+        case ScalarType.SFIXED32:
+            return reader.sfixed32();
+        case ScalarType.SFIXED64:
+            return reader.sfixed64();
+        case ScalarType.SINT64:
+            return reader.sint64();
+        case ScalarType.UINT32:
+            return reader.uint32();
+        case ScalarType.SINT32:
+            return reader.sint32();
+    }
+}

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

@@ -0,0 +1,73 @@
+import { type DescEnum, type DescMessage } from "./descriptors.js";
+import type { JsonValue } from "./json-value.js";
+import type { Registry } from "./registry.js";
+import type { EnumJsonType, EnumShape, MessageShape } from "./types.js";
+/**
+ * Options for parsing JSON data.
+ */
+export interface JsonReadOptions {
+    /**
+     * Ignore unknown fields: Proto3 JSON parser should reject unknown fields
+     * by default. This option ignores unknown fields in parsing, as well as
+     * unrecognized enum string representations.
+     */
+    ignoreUnknownFields: boolean;
+    /**
+     * This option is required to read `google.protobuf.Any` and extensions
+     * from JSON format.
+     */
+    registry?: Registry | undefined;
+    /**
+     * The maximum depth of nested messages to parse. If a message nests deeper
+     * than this limit, parsing fails with an error instead of exhausting the
+     * call stack. Defaults to 100.
+     */
+    recursionLimit: number;
+}
+/**
+ * Parse a message from a JSON string.
+ *
+ * Duplicate keys are rejected.
+ */
+export declare function fromJsonString<Desc extends DescMessage>(schema: Desc, json: string, options?: Partial<JsonReadOptions>): MessageShape<Desc>;
+/**
+ * Parse a message from a JSON string, merging fields into the target.
+ *
+ * Repeated fields are appended. Map entries are added, overwriting
+ * existing keys.
+ *
+ * If a message field is already present, it will be merged with the
+ * new data.
+ *
+ * Duplicate keys in the JSON are rejected, as in `fromJsonString`.
+ */
+export declare function mergeFromJsonString<Desc extends DescMessage>(schema: Desc, target: MessageShape<Desc>, json: string, options?: Partial<JsonReadOptions>): MessageShape<Desc>;
+/**
+ * Parse a message from a JSON value.
+ *
+ * Duplicate keys are rejected, but a value parsed by JSON.parse has already
+ * dropped duplicates (the last one wins). Use `fromJsonString` for strict
+ * duplicate-key checking.
+ */
+export declare function fromJson<Desc extends DescMessage>(schema: Desc, json: JsonValue, options?: Partial<JsonReadOptions>): MessageShape<Desc>;
+/**
+ * Parse a message from a JSON value, merging fields into the target.
+ *
+ * Repeated fields are appended. Map entries are added, overwriting
+ * existing keys.
+ *
+ * If a message field is already present, it will be merged with the
+ * new data.
+ *
+ * Duplicate keys are rejected as in `fromJson`; use `mergeFromJsonString`
+ * for strict checking.
+ */
+export declare function mergeFromJson<Desc extends DescMessage>(schema: Desc, target: MessageShape<Desc>, json: JsonValue, options?: Partial<JsonReadOptions>): MessageShape<Desc>;
+/**
+ * Parses an enum value from JSON.
+ */
+export declare function enumFromJson<Desc extends DescEnum>(descEnum: Desc, json: EnumJsonType<Desc>): EnumShape<Desc>;
+/**
+ * Is the given value a JSON enum value?
+ */
+export declare function isEnumJson<Desc extends DescEnum>(descEnum: Desc, value: unknown): value is EnumJsonType<Desc>;