@code-yeongyu/senpi 2026.8.16 → 2026.8.17

package/node_modules/@bufbuild/protobuf/dist/esm/wire/size-delimited.js

@@ -0,0 +1,186 @@
+// 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.
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+import { toBinary } from "../to-binary.js";
+import { BinaryReader, BinaryWriter } from "./binary-encoding.js";
+import { fromBinary } from "../from-binary.js";
+/**
+ * Serialize a message, prefixing it with its size.
+ *
+ * A size-delimited message is a varint size in bytes, followed by exactly
+ * that many bytes of a message serialized with the binary format.
+ *
+ * This size-delimited format is compatible with other implementations.
+ * For details, see https://github.com/protocolbuffers/protobuf/issues/10229
+ */
+export function sizeDelimitedEncode(messageDesc, message, options) {
+    const writer = new BinaryWriter();
+    writer.bytes(toBinary(messageDesc, message, options));
+    return writer.finish();
+}
+// Default for SizeDelimitedDecodeOptions.readMaxBytes.
+const defaultReadMaxBytes = 64 * 1024 * 1024; // 64 MiB
+/**
+ * A growable byte buffer. Used in place of a resizable ArrayBuffer, which is
+ * not widely available.
+ */
+class ByteBuffer {
+    constructor() {
+        this.buffer = new Uint8Array(0);
+        this.length = 0;
+    }
+    get byteLength() {
+        return this.length;
+    }
+    bytes() {
+        return this.buffer.subarray(0, this.length);
+    }
+    append(chunk) {
+        const newByteLength = this.length + chunk.byteLength;
+        if (newByteLength > this.buffer.byteLength) {
+            const grown = new Uint8Array(Math.max(this.buffer.byteLength * 2, newByteLength));
+            grown.set(this.buffer.subarray(0, this.length));
+            this.buffer = grown;
+        }
+        this.buffer.set(chunk, this.length);
+        this.length += chunk.byteLength;
+    }
+}
+/**
+ * Parse a stream of size-delimited messages.
+ *
+ * A size-delimited message is a varint size in bytes, followed by exactly
+ * that many bytes of a message serialized with the binary format.
+ *
+ * This size-delimited format is compatible with other implementations.
+ * For details, see https://github.com/protocolbuffers/protobuf/issues/10229
+ *
+ * Messages exceeding the limit given with the option readMaxBytes raise an
+ * error. The limit is 64 MiB by default. All other options are the
+ * standard binary read options, passed through to decode each message.
+ */
+export function sizeDelimitedDecodeStream(messageDesc, iterable, options) {
+    return __asyncGenerator(this, arguments, function* sizeDelimitedDecodeStream_1() {
+        var _a, e_1, _b, _c;
+        var _d;
+        const readMaxBytes = (_d = options === null || options === void 0 ? void 0 : options.readMaxBytes) !== null && _d !== void 0 ? _d : defaultReadMaxBytes;
+        let buffer = new ByteBuffer();
+        try {
+            for (var _e = true, iterable_1 = __asyncValues(iterable), iterable_1_1; iterable_1_1 = yield __await(iterable_1.next()), _a = iterable_1_1.done, !_a; _e = true) {
+                _c = iterable_1_1.value;
+                _e = false;
+                const chunk = _c;
+                buffer.append(chunk);
+                const bytes = buffer.bytes();
+                let offset = 0;
+                for (;;) {
+                    const size = sizeDelimitedPeek(bytes.subarray(offset));
+                    if (size.eof) {
+                        // size is incomplete, buffer more data
+                        break;
+                    }
+                    if (size.size > readMaxBytes) {
+                        throw new Error(`message size ${size.size} is larger than configured readMaxBytes ${readMaxBytes}`);
+                    }
+                    const messageStart = offset + size.offset;
+                    const messageEnd = messageStart + size.size;
+                    if (messageEnd > bytes.byteLength) {
+                        // message is incomplete, buffer more data
+                        break;
+                    }
+                    yield yield __await(fromBinary(messageDesc, bytes.subarray(messageStart, messageEnd), options));
+                    offset = messageEnd;
+                }
+                if (offset > 0) {
+                    buffer = new ByteBuffer();
+                    buffer.append(bytes.subarray(offset));
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_e && !_a && (_b = iterable_1.return)) yield __await(_b.call(iterable_1));
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        if (buffer.byteLength > 0) {
+            throw new Error("incomplete data");
+        }
+    });
+}
+/**
+ * Decodes the size from the given size-delimited message, which may be
+ * incomplete.
+ *
+ * Returns an object with the following properties:
+ * - size: The size of the delimited message in bytes
+ * - offset: The offset in the given byte array where the message starts
+ * - eof: true
+ *
+ * If the size-delimited data does not include all bytes of the varint size,
+ * the following object is returned:
+ * - size: null
+ * - offset: null
+ * - eof: false
+ *
+ * This function can be used to implement parsing of size-delimited messages
+ * from a stream.
+ */
+export function sizeDelimitedPeek(data) {
+    const sizeEof = { eof: true, size: null, offset: null };
+    for (let i = 0; i < 10; i++) {
+        if (i > data.byteLength) {
+            return sizeEof;
+        }
+        if ((data[i] & 0x80) == 0) {
+            const reader = new BinaryReader(data);
+            let size;
+            try {
+                size = reader.uint32();
+            }
+            catch (e) {
+                if (e instanceof RangeError) {
+                    return sizeEof;
+                }
+                throw e;
+            }
+            return {
+                eof: false,
+                size,
+                offset: reader.pos,
+            };
+        }
+    }
+    throw new Error("invalid varint");
+}

package/node_modules/@bufbuild/protobuf/dist/esm/wire/text-encoding.d.ts

@@ -0,0 +1,28 @@
+interface TextEncoding {
+    /**
+     * Verify that the given text is valid UTF-8.
+     */
+    checkUtf8: (text: string) => boolean;
+    /**
+     * Encode UTF-8 text to binary.
+     */
+    encodeUtf8: (text: string) => Uint8Array<ArrayBuffer>;
+    /**
+     * Decode UTF-8 text from binary. If `strict` is true, throw on invalid byte
+     * sequences instead of silently substituting U+FFFD. Implementations that
+     * do not support strict decoding may ignore the flag.
+     */
+    decodeUtf8: (bytes: Uint8Array, strict?: boolean) => string;
+}
+/**
+ * Protobuf-ES requires the Text Encoding API to convert UTF-8 from and to
+ * binary. This WHATWG API is widely available, but it is not part of the
+ * ECMAScript standard. On runtimes where it is not available, use this
+ * function to provide your own implementation.
+ *
+ * Note that the Text Encoding API does not provide a way to validate UTF-8.
+ * Our implementation falls back to use encodeURIComponent().
+ */
+export declare function configureTextEncoding(textEncoding: TextEncoding): void;
+export declare function getTextEncoding(): TextEncoding;
+export {};

package/node_modules/@bufbuild/protobuf/dist/esm/wire/text-encoding.js

@@ -0,0 +1,57 @@
+// 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.
+const symbol = Symbol.for("@bufbuild/protobuf/text-encoding");
+/**
+ * Protobuf-ES requires the Text Encoding API to convert UTF-8 from and to
+ * binary. This WHATWG API is widely available, but it is not part of the
+ * ECMAScript standard. On runtimes where it is not available, use this
+ * function to provide your own implementation.
+ *
+ * Note that the Text Encoding API does not provide a way to validate UTF-8.
+ * Our implementation falls back to use encodeURIComponent().
+ */
+export function configureTextEncoding(textEncoding) {
+    globalThis[symbol] = textEncoding;
+}
+export function getTextEncoding() {
+    if (globalThis[symbol] == undefined) {
+        const te = new globalThis.TextEncoder();
+        const td = new globalThis.TextDecoder();
+        let tdStrict;
+        globalThis[symbol] = {
+            encodeUtf8(text) {
+                return te.encode(text);
+            },
+            decodeUtf8(bytes, strict) {
+                if (strict) {
+                    if (tdStrict === undefined) {
+                        tdStrict = new globalThis.TextDecoder("utf-8", { fatal: true });
+                    }
+                    return tdStrict.decode(bytes);
+                }
+                return td.decode(bytes);
+            },
+            checkUtf8(text) {
+                try {
+                    encodeURIComponent(text);
+                    return true;
+                }
+                catch (_) {
+                    return false;
+                }
+            },
+        };
+    }
+    return globalThis[symbol];
+}

package/node_modules/@bufbuild/protobuf/dist/esm/wire/text-format.d.ts

@@ -0,0 +1,13 @@
+import { type DescEnum, ScalarType } from "../descriptors.js";
+/**
+ * Parse an enum value from the Protobuf text format.
+ *
+ * @private
+ */
+export declare function parseTextFormatEnumValue(descEnum: DescEnum, value: string): number;
+/**
+ * Parse a scalar value from the Protobuf text format.
+ *
+ * @private
+ */
+export declare function parseTextFormatScalarValue(type: ScalarType, value: string): number | boolean | string | bigint | Uint8Array;

package/node_modules/@bufbuild/protobuf/dist/esm/wire/text-format.js

@@ -0,0 +1,195 @@
+// 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 { protoInt64 } from "../proto-int64.js";
+/**
+ * Parse an enum value from the Protobuf text format.
+ *
+ * @private
+ */
+export function parseTextFormatEnumValue(descEnum, value) {
+    const enumValue = descEnum.values.find((v) => v.name === value);
+    if (!enumValue) {
+        throw new Error(`cannot parse ${descEnum} default value: ${value}`);
+    }
+    return enumValue.number;
+}
+/**
+ * Parse a scalar value from the Protobuf text format.
+ *
+ * @private
+ */
+export function parseTextFormatScalarValue(type, value) {
+    switch (type) {
+        case ScalarType.STRING:
+            return value;
+        case ScalarType.BYTES: {
+            const u = unescapeBytesDefaultValue(value);
+            if (u === false) {
+                throw new Error(`cannot parse ${ScalarType[type]} default value: ${value}`);
+            }
+            return u;
+        }
+        case ScalarType.INT64:
+        case ScalarType.SFIXED64:
+        case ScalarType.SINT64:
+            return protoInt64.parse(value);
+        case ScalarType.UINT64:
+        case ScalarType.FIXED64:
+            return protoInt64.uParse(value);
+        case ScalarType.DOUBLE:
+        case ScalarType.FLOAT:
+            switch (value) {
+                case "inf":
+                    return Number.POSITIVE_INFINITY;
+                case "-inf":
+                    return Number.NEGATIVE_INFINITY;
+                case "nan":
+                    return Number.NaN;
+                default:
+                    return parseFloat(value);
+            }
+        case ScalarType.BOOL:
+            return value === "true";
+        case ScalarType.INT32:
+        case ScalarType.UINT32:
+        case ScalarType.SINT32:
+        case ScalarType.FIXED32:
+        case ScalarType.SFIXED32:
+            return parseInt(value, 10);
+    }
+}
+/**
+ * Parses a text-encoded default value (proto2) of a BYTES field.
+ */
+function unescapeBytesDefaultValue(str) {
+    const b = [];
+    const input = {
+        tail: str,
+        c: "",
+        next() {
+            if (this.tail.length == 0) {
+                return false;
+            }
+            this.c = this.tail[0];
+            this.tail = this.tail.substring(1);
+            return true;
+        },
+        take(n) {
+            if (this.tail.length >= n) {
+                const r = this.tail.substring(0, n);
+                this.tail = this.tail.substring(n);
+                return r;
+            }
+            return false;
+        },
+    };
+    while (input.next()) {
+        switch (input.c) {
+            case "\\":
+                if (input.next()) {
+                    switch (input.c) {
+                        case "\\":
+                            b.push(input.c.charCodeAt(0));
+                            break;
+                        case "b":
+                            b.push(0x08);
+                            break;
+                        case "f":
+                            b.push(0x0c);
+                            break;
+                        case "n":
+                            b.push(0x0a);
+                            break;
+                        case "r":
+                            b.push(0x0d);
+                            break;
+                        case "t":
+                            b.push(0x09);
+                            break;
+                        case "v":
+                            b.push(0x0b);
+                            break;
+                        case "0":
+                        case "1":
+                        case "2":
+                        case "3":
+                        case "4":
+                        case "5":
+                        case "6":
+                        case "7": {
+                            const s = input.c;
+                            const t = input.take(2);
+                            if (t === false) {
+                                return false;
+                            }
+                            const n = parseInt(s + t, 8);
+                            if (Number.isNaN(n)) {
+                                return false;
+                            }
+                            b.push(n);
+                            break;
+                        }
+                        case "x": {
+                            const s = input.c;
+                            const t = input.take(2);
+                            if (t === false) {
+                                return false;
+                            }
+                            const n = parseInt(s + t, 16);
+                            if (Number.isNaN(n)) {
+                                return false;
+                            }
+                            b.push(n);
+                            break;
+                        }
+                        case "u": {
+                            const s = input.c;
+                            const t = input.take(4);
+                            if (t === false) {
+                                return false;
+                            }
+                            const n = parseInt(s + t, 16);
+                            if (Number.isNaN(n)) {
+                                return false;
+                            }
+                            const chunk = new Uint8Array(4);
+                            const view = new DataView(chunk.buffer);
+                            view.setInt32(0, n, true);
+                            b.push(chunk[0], chunk[1], chunk[2], chunk[3]);
+                            break;
+                        }
+                        case "U": {
+                            const s = input.c;
+                            const t = input.take(8);
+                            if (t === false) {
+                                return false;
+                            }
+                            const tc = protoInt64.uEnc(s + t);
+                            const chunk = new Uint8Array(8);
+                            const view = new DataView(chunk.buffer);
+                            view.setInt32(0, tc.lo, true);
+                            view.setInt32(4, tc.hi, true);
+                            b.push(chunk[0], chunk[1], chunk[2], chunk[3], chunk[4], chunk[5], chunk[6], chunk[7]);
+                            break;
+                        }
+                    }
+                }
+                break;
+            default:
+                b.push(input.c.charCodeAt(0));
+        }
+    }
+    return new Uint8Array(b);
+}

package/node_modules/@bufbuild/protobuf/dist/esm/wire/varint.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Read a 64 bit varint as two JS numbers.
+ *
+ * Returns tuple:
+ * [0]: low bits
+ * [1]: high bits
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/buffer_decoder.js#L175
+ */
+export declare function varint64read<T extends ReaderLike>(this: T): [number, number];
+/**
+ * Write a 64 bit varint, given as two JS numbers, to the given bytes array.
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/writer.js#L344
+ */
+export declare function varint64write(lo: number, hi: number, bytes: number[]): void;
+/**
+ * Parse decimal string of 64 bit integer value as two JS numbers.
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf-javascript/blob/a428c58273abad07c66071d9753bc4d1289de426/experimental/runtime/int64.js#L10
+ */
+export declare function int64FromString(dec: string): {
+    lo: number;
+    hi: number;
+};
+/**
+ * Losslessly converts a 64-bit signed integer in 32:32 split representation
+ * into a decimal string.
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf-javascript/blob/a428c58273abad07c66071d9753bc4d1289de426/experimental/runtime/int64.js#L10
+ */
+export declare function int64ToString(lo: number, hi: number): string;
+/**
+ * Losslessly converts a 64-bit unsigned integer in 32:32 split representation
+ * into a decimal string.
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf-javascript/blob/a428c58273abad07c66071d9753bc4d1289de426/experimental/runtime/int64.js#L10
+ */
+export declare function uInt64ToString(lo: number, hi: number): string;
+/**
+ * Write a 32 bit varint, signed or unsigned. Same as `varint64write(0, value, bytes)`
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf/blob/1b18833f4f2a2f681f4e4a25cdf3b0a43115ec26/js/binary/encoder.js#L144
+ */
+export declare function varint32write(value: number, bytes: number[]): void;
+/**
+ * Read an unsigned 32 bit varint.
+ *
+ * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/buffer_decoder.js#L220
+ */
+export declare function varint32read<T extends ReaderLike>(this: T): number;
+type ReaderLike = {
+    buf: Uint8Array;
+    pos: number;
+    len: number;
+    assertBounds(): void;
+};
+export {};