@code-yeongyu/senpi 2026.8.20-2 → 2026.8.20

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

@@ -15,7 +15,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.configureTextEncoding = configureTextEncoding;
 exports.getTextEncoding = getTextEncoding;
-exports.emulateEncodeInto = emulateEncodeInto;
 const symbol = Symbol.for("@bufbuild/protobuf/text-encoding");
 /**
  * Protobuf-ES requires the Text Encoding API to convert UTF-8 from and to
@@ -23,37 +22,29 @@ const symbol = Symbol.for("@bufbuild/protobuf/text-encoding");
  * ECMAScript standard. On runtimes where it is not available, use this
  * function to provide your own implementation.
  *
- * Providing `encodeUtf8Into` is optional for backwards compatibility. If it
- * is omitted, we emulate it with a wrapper that calls `encodeUtf8`.
- *
  * Note that the Text Encoding API does not provide a way to validate UTF-8.
- * Our implementation uses String.prototype.isWellFormed, and falls back
- * to use encodeURIComponent().
+ * Our implementation falls back to use encodeURIComponent().
  */
 function configureTextEncoding(textEncoding) {
-    var _a;
-    globalThis[symbol] = Object.assign(Object.assign({}, textEncoding), { encodeUtf8Into: (_a = textEncoding.encodeUtf8Into) !== null && _a !== void 0 ? _a : emulateEncodeInto(textEncoding.encodeUtf8.bind(textEncoding)) });
+    globalThis[symbol] = textEncoding;
 }
 function getTextEncoding() {
-    const globals = globalThis;
-    if (!globals[symbol]) {
-        const textEncoder = new globals.TextEncoder();
-        const textDecoder = new globals.TextDecoder();
-        let textDecoderStrict;
-        const config = {
+    if (globalThis[symbol] == undefined) {
+        const te = new globalThis.TextEncoder();
+        const td = new globalThis.TextDecoder();
+        let tdStrict;
+        globalThis[symbol] = {
             encodeUtf8(text) {
-                return textEncoder.encode(text);
+                return te.encode(text);
             },
             decodeUtf8(bytes, strict) {
                 if (strict) {
-                    if (!textDecoderStrict) {
-                        textDecoderStrict = new globals.TextDecoder("utf-8", {
-                            fatal: true,
-                        });
+                    if (tdStrict === undefined) {
+                        tdStrict = new globalThis.TextDecoder("utf-8", { fatal: true });
                     }
-                    return textDecoderStrict.decode(bytes);
+                    return tdStrict.decode(bytes);
                 }
-                return textDecoder.decode(bytes);
+                return td.decode(bytes);
             },
             checkUtf8(text) {
                 try {
@@ -65,31 +56,6 @@ function getTextEncoding() {
                 }
             },
         };
-        // If encodeInto is available, use it. Otherwise, configureTextEncoding
-        // fills in a slower fallback that uses encodeUtf8.
-        if (textEncoder.encodeInto) {
-            config.encodeUtf8Into = textEncoder.encodeInto.bind(textEncoder);
-        }
-        // Native String.prototype.isWellFormed, if the runtime provides it.
-        const nativeStringIsWellFormed = String.prototype.isWellFormed;
-        if (nativeStringIsWellFormed) {
-            config.checkUtf8 = (text) => {
-                return nativeStringIsWellFormed.call(text);
-            };
-        }
-        configureTextEncoding(config);
     }
-    return globals[symbol];
-}
-/**
- * Simplistic polyfill for encodeUtf8Into.
- *
- * @private
- */
-function emulateEncodeInto(encodeUtf8) {
-    return (text, dest) => {
-        const bytes = encodeUtf8(text);
-        dest.set(bytes);
-        return { written: bytes.byteLength };
-    };
+    return globalThis[symbol];
 }

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

@@ -1,13 +1,15 @@
 /**
  * Read a 64 bit varint as two JS numbers.
  *
- * Stores the low and high words on the reader.
+ * 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): void;
+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.
  *
@@ -63,8 +65,6 @@ type ReaderLike = {
     buf: Uint8Array;
     pos: number;
     len: number;
-    varint64Lo: number;
-    varint64Hi: number;
     assertBounds(): void;
 };
 export {};

package/node_modules/@bufbuild/protobuf/dist/commonjs/wire/varint.js

@@ -42,49 +42,40 @@ exports.varint32read = varint32read;
 /**
  * Read a 64 bit varint as two JS numbers.
  *
- * Stores the low and high words on the reader.
+ * 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
  */
 function varint64read() {
-    const buf = this.buf;
-    let pos = this.pos;
-    let lo = 0;
-    let hi = 0;
+    let lowBits = 0;
+    let highBits = 0;
     for (let shift = 0; shift < 28; shift += 7) {
-        const b = buf[pos++];
-        lo |= (b & 0x7f) << shift;
+        let b = this.buf[this.pos++];
+        lowBits |= (b & 0x7f) << shift;
         if ((b & 0x80) == 0) {
-            this.pos = pos;
             this.assertBounds();
-            this.varint64Lo = lo;
-            this.varint64Hi = hi;
-            return;
+            return [lowBits, highBits];
         }
     }
-    const middleByte = buf[pos++];
+    let middleByte = this.buf[this.pos++];
     // last four bits of the first 32 bit number
-    lo |= (middleByte & 0x0f) << 28;
+    lowBits |= (middleByte & 0x0f) << 28;
     // 3 upper bits are part of the next 32 bit number
-    hi = (middleByte & 0x70) >> 4;
+    highBits = (middleByte & 0x70) >> 4;
     if ((middleByte & 0x80) == 0) {
-        this.pos = pos;
         this.assertBounds();
-        this.varint64Lo = lo;
-        this.varint64Hi = hi;
-        return;
+        return [lowBits, highBits];
     }
     for (let shift = 3; shift <= 31; shift += 7) {
-        const b = buf[pos++];
-        hi |= (b & 0x7f) << shift;
+        let b = this.buf[this.pos++];
+        highBits |= (b & 0x7f) << shift;
         if ((b & 0x80) == 0) {
-            this.pos = pos;
             this.assertBounds();
-            this.varint64Lo = lo;
-            this.varint64Hi = hi;
-            return;
+            return [lowBits, highBits];
         }
     }
     throw new Error("invalid varint");
@@ -272,10 +263,6 @@ const decimalFrom1e7WithLeadingZeros = (digit1e7) => {
  * See https://github.com/protocolbuffers/protobuf/blob/1b18833f4f2a2f681f4e4a25cdf3b0a43115ec26/js/binary/encoder.js#L144
  */
 function varint32write(value, bytes) {
-    if (value >>> 0 < 0x80) {
-        bytes.push(value);
-        return;
-    }
     if (value >= 0) {
         // write value as varint 32
         while (value > 0x7f) {
@@ -299,26 +286,26 @@ function varint32write(value, bytes) {
  */
 function varint32read() {
     let b = this.buf[this.pos++];
-    if ((b & 0x80) === 0) {
+    let result = b & 0x7f;
+    if ((b & 0x80) == 0) {
         this.assertBounds();
-        return b;
+        return result;
     }
-    let result = b & 0x7f;
     b = this.buf[this.pos++];
     result |= (b & 0x7f) << 7;
-    if ((b & 0x80) === 0) {
+    if ((b & 0x80) == 0) {
         this.assertBounds();
         return result;
     }
     b = this.buf[this.pos++];
     result |= (b & 0x7f) << 14;
-    if ((b & 0x80) === 0) {
+    if ((b & 0x80) == 0) {
         this.assertBounds();
         return result;
     }
     b = this.buf[this.pos++];
     result |= (b & 0x7f) << 21;
-    if ((b & 0x80) === 0) {
+    if ((b & 0x80) == 0) {
         this.assertBounds();
         return result;
     }
@@ -327,8 +314,9 @@ function varint32read() {
     result |= (b & 0x0f) << 28;
     for (let readBytes = 5; (b & 0x80) !== 0 && readBytes < 10; readBytes++)
         b = this.buf[this.pos++];
-    if ((b & 0x80) !== 0)
+    if ((b & 0x80) != 0)
         throw new Error("invalid varint");
     this.assertBounds();
+    // Result can have 32 bits, convert it to unsigned
     return result >>> 0;
 }

package/node_modules/@bufbuild/protobuf/dist/commonjs/wkt/wrappers.js

@@ -50,17 +50,17 @@ function hasCustomJsonRepresentation(desc) {
             return isWrapperDesc(desc);
     }
 }
-const wrapperTypeNames = /*@__PURE__*/ new Set([
-    "google.protobuf.DoubleValue",
-    "google.protobuf.FloatValue",
-    "google.protobuf.Int64Value",
-    "google.protobuf.UInt64Value",
-    "google.protobuf.Int32Value",
-    "google.protobuf.UInt32Value",
-    "google.protobuf.BoolValue",
-    "google.protobuf.StringValue",
-    "google.protobuf.BytesValue",
-]);
 function isWrapperTypeName(name) {
-    return wrapperTypeNames.has(name);
+    return (name.startsWith("google.protobuf.") &&
+        [
+            "DoubleValue",
+            "FloatValue",
+            "Int64Value",
+            "UInt64Value",
+            "Int32Value",
+            "UInt32Value",
+            "BoolValue",
+            "StringValue",
+            "BytesValue",
+        ].includes(name.substring(16)));
 }