@code-yeongyu/senpi 2026.8.20-2 → 2026.8.20

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

@@ -10,7 +10,6 @@
  *   no padding
  */
 export declare function base64Decode(base64Str: string): Uint8Array<ArrayBuffer>;
-type Base64Encoding = "std" | "std_raw" | "url";
 /**
  * Encode a byte array to a base64 string.
  *
@@ -21,5 +20,4 @@ type Base64Encoding = "std" | "std_raw" | "url";
  * To encode with the URL encoding, use encoding = "url", which replaces the
  * characters +/ by their URL-safe counterparts -_, and omits padding.
  */
-export declare function base64Encode(bytes: Uint8Array, encoding?: Base64Encoding): string;
-export {};
+export declare function base64Encode(bytes: Uint8Array, encoding?: "std" | "std_raw" | "url"): string;

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

@@ -11,8 +11,6 @@
 // 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.
-// Native Uint8Array.prototype.setFromBase64, if the runtime provides it.
-const nativeSetFromBase64 = Uint8Array.prototype.setFromBase64;
 /**
  * Decodes a base64 string to a byte array.
  *
@@ -25,35 +23,14 @@ const nativeSetFromBase64 = Uint8Array.prototype.setFromBase64;
  *   no padding
  */
 export function base64Decode(base64Str) {
-    const len = base64Str.length;
-    // Decoded size, assuming a well-formed string: three bytes per group of
-    // four characters, minus one byte for each padding character.
-    let size = len - ((len + 3) >> 2);
-    if ((len & 3) == 0 && base64Str[len - 1] == "=") {
-        size -= base64Str[len - 2] == "=" ? 2 : 1;
-    }
-    const bytes = new Uint8Array(size);
-    let written = -1;
-    if (nativeSetFromBase64) {
-        try {
-            const result = nativeSetFromBase64.call(bytes, base64Str);
-            if (result.read == len) {
-                written = result.written;
-            }
-        }
-        catch (_a) {
-            // The native decoder rejects base64url and inner padding, which we accept.
-        }
-    }
-    if (written < 0) {
-        written = setFromBase64(bytes, base64Str);
-    }
-    return written == size ? bytes : bytes.subarray(0, written);
-}
-/** Writes into `bytes` from index 0 and returns the number of bytes written. */
-function setFromBase64(bytes, base64Str) {
     const table = getDecodeTable();
-    let bytePos = 0, // position in byte array
+    // estimate byte size, not accounting for inner padding and whitespace
+    let es = (base64Str.length * 3) / 4;
+    if (base64Str[base64Str.length - 2] == "=")
+        es -= 2;
+    else if (base64Str[base64Str.length - 1] == "=")
+        es -= 1;
+    let bytes = new Uint8Array(es), bytePos = 0, // position in byte array
     groupPos = 0, // position in base64 group
     b, // current byte
     p = 0; // previous byte
@@ -96,14 +73,8 @@ function setFromBase64(bytes, base64Str) {
     }
     if (groupPos == 1)
         throw Error("invalid base64 string");
-    return bytePos;
+    return bytes.subarray(0, bytePos);
 }
-const nativeToBase64 = Uint8Array.prototype.toBase64;
-const toBase64OptionsMap = {
-    std: { alphabet: "base64", omitPadding: false },
-    std_raw: { alphabet: "base64", omitPadding: true },
-    url: { alphabet: "base64url", omitPadding: true },
-};
 /**
  * Encode a byte array to a base64 string.
  *
@@ -115,9 +86,6 @@ const toBase64OptionsMap = {
  * characters +/ by their URL-safe counterparts -_, and omits padding.
  */
 export function base64Encode(bytes, encoding = "std") {
-    if (nativeToBase64) {
-        return nativeToBase64.call(bytes, toBase64OptionsMap[encoding]);
-    }
     const table = getEncodeTable(encoding);
     const pad = encoding == "std";
     let base64 = "", groupPos = 0, // position in base64 group

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

@@ -60,37 +60,29 @@ export declare const INT32_MAX = 2147483647;
  */
 export declare const INT32_MIN = -2147483648;
 export declare class BinaryWriter {
+    private readonly encodeUtf8;
     /**
-     * Growable byte buffer. We allocate a reasonably sized
-     * initial buffer and double its capacity when needed.
-     */
-    private buffer;
-    /**
-     * Cached DataView for fixed-width writes. Read it via `view()`, which
-     * rebuilds it if `buffer` has since grown.
-     */
-    private viewCache;
-    /**
-     * Current write position in the buffer.
+     * We cannot allocate a buffer for the entire output
+     * because we don't know its size.
+     *
+     * So we collect smaller chunks of known size and
+     * concat them later.
+     *
+     * Use `raw()` to push data to this array. It will flush
+     * `buf` first.
      */
-    private pos;
+    private chunks;
     /**
-     * Previous fork positions (the write position at the time
-     * `fork()` was called).
+     * A growing buffer for byte values. If you don't know
+     * the size of the data you are writing, push to this
+     * array.
      */
-    private stackPos;
+    protected buf: number[];
     /**
-     * UTF-8 codec used by `string()`. Uses the text encoding's `encodeUtf8Into`,
-     * or emulates it if a custom `encodeUtf8` was passed to the constructor.
+     * Previous fork states.
      */
-    private readonly encodeUtf8Into;
+    private stack;
     constructor(encodeUtf8?: (text: string) => Uint8Array);
-    private ensureCapacity;
-    /**
-     * The DataView over `buffer`, rebuilt only if the buffer has grown since it
-     * was last used.
-     */
-    private view;
     /**
      * Return all bytes written and reset this writer.
      */
@@ -179,14 +171,6 @@ export declare class BinaryWriter {
      * Write a `uint64` value, an unsigned 64-bit varint.
      */
     uint64(value: string | number | bigint): this;
-    /**
-     * Write a 64-bit varint directly into the buffer. Accepts the value as
-     * split low/high 32-bit words.
-     *
-     * Ported from varint64write() to avoid the intermediate number[] buffer.
-     * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/writer.js#L344
-     */
-    private writeVarint64;
 }
 export declare class BinaryReader {
     private readonly decodeUtf8;
@@ -198,7 +182,7 @@ export declare class BinaryReader {
      * Number of bytes available in this reader.
      */
     readonly len: number;
-    private readonly buf;
+    protected readonly buf: Uint8Array;
     private readonly view;
     constructor(buf: Uint8Array, decodeUtf8?: (bytes: Uint8Array, strict?: boolean) => string);
     /**
@@ -215,13 +199,11 @@ export declare class BinaryReader {
      * this method throws.
      */
     skip(wireType: WireType, fieldNo?: number, recursionLimit?: number): Uint8Array;
-    private varint64Lo;
-    private varint64Hi;
-    private varint64;
+    protected varint64: () => [number, number];
     /**
      * Throws error if position in byte array is out of range.
      */
-    private assertBounds;
+    protected assertBounds(): void;
     /**
      * Read a `uint32` field, an unsigned 32 bit varint.
      */