@code-yeongyu/senpi 2026.8.20-2 → 2026.8.20

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

@@ -11,9 +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 { varint32read, varint64read } from "./varint.js";
+import { varint32read, varint32write, varint64read, varint64write, } from "./varint.js";
 import { protoInt64 } from "../proto-int64.js";
-import { emulateEncodeInto, getTextEncoding } from "./text-encoding.js";
+import { getTextEncoding } from "./text-encoding.js";
 /**
  * Protobuf binary format wire types.
  *
@@ -77,55 +77,34 @@ export const INT32_MAX = 0x7fffffff;
  */
 export const INT32_MIN = -0x80000000;
 export class BinaryWriter {
-    constructor(encodeUtf8) {
+    constructor(encodeUtf8 = getTextEncoding().encodeUtf8) {
+        this.encodeUtf8 = encodeUtf8;
         /**
-         * Previous fork positions (the write position at the time
-         * `fork()` was called).
+         * Previous fork states.
          */
-        this.stackPos = [];
-        this.encodeUtf8Into = encodeUtf8
-            ? emulateEncodeInto(encodeUtf8)
-            : getTextEncoding().encodeUtf8Into;
-        this.buffer = EMPTY_BUFFER;
-        this.viewCache = EMPTY_VIEW;
-        this.pos = 0;
-    }
-    ensureCapacity(size) {
-        const required = this.pos + size;
-        if (required > this.buffer.length) {
-            let newLen = this.buffer.length || INITIAL_SIZE;
-            while (newLen < required)
-                newLen *= 2;
-            const newBuf = new Uint8Array(newLen);
-            if (this.pos > 0)
-                newBuf.set(this.buffer);
-            this.buffer = newBuf;
-        }
-    }
-    /**
-     * The DataView over `buffer`, rebuilt only if the buffer has grown since it
-     * was last used.
-     */
-    view() {
-        const bytes = this.buffer;
-        const view = this.viewCache;
-        // Since ensureCapacity() only ever replaces the buffer with a strictly larger one,
-        // equal lengths mean the view is still current. This is faster than comparing
-        // buffers directly.
-        if (view.byteLength === bytes.byteLength)
-            return view;
-        const newView = new DataView(bytes.buffer);
-        this.viewCache = newView;
-        return newView;
+        this.stack = [];
+        this.chunks = [];
+        this.buf = [];
     }
     /**
      * Return all bytes written and reset this writer.
      */
     finish() {
-        const result = this.buffer.slice(0, this.pos);
-        this.pos = 0;
-        this.stackPos = [];
-        return result;
+        if (this.buf.length) {
+            this.chunks.push(new Uint8Array(this.buf)); // flush the buffer
+            this.buf = [];
+        }
+        let len = 0;
+        for (let i = 0; i < this.chunks.length; i++)
+            len += this.chunks[i].length;
+        let bytes = new Uint8Array(len);
+        let offset = 0;
+        for (let i = 0; i < this.chunks.length; i++) {
+            bytes.set(this.chunks[i], offset);
+            offset += this.chunks[i].length;
+        }
+        this.chunks = [];
+        return bytes;
     }
     /**
      * Start a new fork for length-delimited data like a message
@@ -134,11 +113,9 @@ export class BinaryWriter {
      * Must be joined later with `join()`.
      */
     fork() {
-        this.stackPos.push(this.pos);
-        // Reserve room for the length prefix. Payloads under 128 bytes, fairly
-        // common, will need no copy in join().
-        this.ensureCapacity(DEFAULT_LEN_PREFIX_SIZE);
-        this.buffer[this.pos++] = 0;
+        this.stack.push({ chunks: this.chunks, buf: this.buf });
+        this.chunks = [];
+        this.buf = [];
         return this;
     }
     /**
@@ -146,24 +123,17 @@ export class BinaryWriter {
      * return to the previous state.
      */
     join() {
-        const forkPos = this.stackPos.pop();
-        if (forkPos === undefined)
+        // get chunk of fork
+        let chunk = this.finish();
+        // restore previous state
+        let prev = this.stack.pop();
+        if (!prev)
             throw new Error("invalid state, fork stack empty");
-        // fork() presumed the payload would fit the prefix it reserved. If it
-        // doesn't, we need to shift the bytes we just wrote.
-        const len = this.pos - forkPos - DEFAULT_LEN_PREFIX_SIZE;
-        const lenPrefixSize = varint32Size(len);
-        if (lenPrefixSize > DEFAULT_LEN_PREFIX_SIZE) {
-            // Widening pushes the payload past the end of the buffer, so grow first:
-            // copyWithin clamps to the buffer instead of throwing, so a short buffer
-            // would silently drop the tail of the payload.
-            this.ensureCapacity(lenPrefixSize - DEFAULT_LEN_PREFIX_SIZE);
-            this.buffer.copyWithin(forkPos + lenPrefixSize, forkPos + DEFAULT_LEN_PREFIX_SIZE, this.pos);
-        }
-        this.pos = forkPos;
-        this.uint32(len);
-        this.pos += len;
-        return this;
+        this.chunks = prev.chunks;
+        this.buf = prev.buf;
+        // write length of chunk as varint
+        this.uint32(chunk.byteLength);
+        return this.raw(chunk);
     }
     /**
      * Writes a tag (field number and wire type).
@@ -179,9 +149,11 @@ export class BinaryWriter {
      * Write a chunk of raw bytes.
      */
     raw(chunk) {
-        this.ensureCapacity(chunk.length);
-        this.buffer.set(chunk, this.pos);
-        this.pos += chunk.length;
+        if (this.buf.length) {
+            this.chunks.push(new Uint8Array(this.buf));
+            this.buf = [];
+        }
+        this.chunks.push(chunk);
         return this;
     }
     /**
@@ -189,18 +161,12 @@ export class BinaryWriter {
      */
     uint32(value) {
         assertUInt32(value);
-        // uint32 varints are at most 5 bytes; reserve once and avoid per-byte
-        // capacity checks.
-        this.ensureCapacity(5);
-        if (value < 0x80) {
-            this.buffer[this.pos++] = value;
-            return this;
-        }
+        // write value as varint 32, inlined for speed
         while (value > 0x7f) {
-            this.buffer[this.pos++] = (value & 0x7f) | 0x80;
-            value >>>= 7;
+            this.buf.push((value & 0x7f) | 0x80);
+            value = value >>> 7;
         }
-        this.buffer[this.pos++] = value;
+        this.buf.push(value);
         return this;
     }
     /**
@@ -208,158 +174,101 @@ export class BinaryWriter {
      */
     int32(value) {
         assertInt32(value);
-        if (value >= 0) {
-            return this.uint32(value);
-        }
-        // Negative: sign-extend to 64 bits, encodes to 10 bytes.
-        this.ensureCapacity(10);
-        for (let i = 0; i < 9; i++) {
-            this.buffer[this.pos++] = (value & 0x7f) | 0x80;
-            value >>= 7;
-        }
-        this.buffer[this.pos++] = 1;
+        varint32write(value, this.buf);
         return this;
     }
     /**
      * Write a `bool` value, a varint.
      */
     bool(value) {
-        this.ensureCapacity(1);
-        this.buffer[this.pos++] = value ? 1 : 0;
+        this.buf.push(value ? 1 : 0);
         return this;
     }
     /**
      * Write a `bytes` value, length-delimited arbitrary data.
      */
     bytes(value) {
-        this.uint32(value.byteLength);
+        this.uint32(value.byteLength); // write length of chunk as varint
         return this.raw(value);
     }
     /**
      * Write a `string` value, length-delimited data converted to UTF-8 text.
      */
     string(value) {
-        // TextEncoder.encode() coerces its argument to string, but encodeInto()
-        // rejects non-strings.
-        if (typeof value !== "string") {
-            value = String(value);
-        }
-        const len = value.length;
-        // Fast path for ASCII.
-        if (len <= ASCII_MAX_LENGTH) {
-            this.ensureCapacity(len + 1);
-            const ascii = this.buffer;
-            let pos = this.pos;
-            ascii[pos++] = len;
-            let i = 0;
-            for (; i < len; i++) {
-                const code = value.charCodeAt(i);
-                if (code > 0x7f)
-                    break;
-                ascii[pos++] = code;
-            }
-            if (i == len) {
-                this.pos = pos;
-                return this;
-            }
-        }
-        // encodeUtf8Into needs the full-length buffer upfront. The length prefix
-        // can be upto 5 bytes, and a UTF-16 code unit takes at most 3 UTF-8 bytes.
-        this.ensureCapacity(len * 3 + 5);
-        // The length prefix goes first, but the byte length is only known after
-        // encoding. We guess the final varint size here (assuming most text is
-        // ASCII) and then encode.
-        const lenPrefixSizeGuess = varint32Size(len);
-        const buf = this.buffer;
-        const start = this.pos;
-        const { written } = this.encodeUtf8Into(value, buf.subarray(start + lenPrefixSizeGuess));
-        // If our guess was incorrect, we need to shift the bytes we just wrote.
-        const lenPrefixSize = varint32Size(written);
-        if (lenPrefixSize != lenPrefixSizeGuess) {
-            buf.copyWithin(start + lenPrefixSize, start + lenPrefixSizeGuess, start + lenPrefixSizeGuess + written);
-        }
-        // Write the lenPrefix and advance the pos.
-        this.uint32(written);
-        this.pos += written;
-        return this;
+        let chunk = this.encodeUtf8(value);
+        this.uint32(chunk.byteLength); // write length of chunk as varint
+        return this.raw(chunk);
     }
     /**
      * Write a `float` value, 32-bit floating point number.
      */
     float(value) {
         assertFloat32(value);
-        this.ensureCapacity(4);
-        this.view().setFloat32(this.pos, value, true);
-        this.pos += 4;
-        return this;
+        let chunk = new Uint8Array(4);
+        new DataView(chunk.buffer).setFloat32(0, value, true);
+        return this.raw(chunk);
     }
     /**
      * Write a `double` value, a 64-bit floating point number.
      */
     double(value) {
-        this.ensureCapacity(8);
-        this.view().setFloat64(this.pos, value, true);
-        this.pos += 8;
-        return this;
+        let chunk = new Uint8Array(8);
+        new DataView(chunk.buffer).setFloat64(0, value, true);
+        return this.raw(chunk);
     }
     /**
      * Write a `fixed32` value, an unsigned, fixed-length 32-bit integer.
      */
     fixed32(value) {
         assertUInt32(value);
-        this.ensureCapacity(4);
-        this.view().setUint32(this.pos, value, true);
-        this.pos += 4;
-        return this;
+        let chunk = new Uint8Array(4);
+        new DataView(chunk.buffer).setUint32(0, value, true);
+        return this.raw(chunk);
     }
     /**
      * Write a `sfixed32` value, a signed, fixed-length 32-bit integer.
      */
     sfixed32(value) {
         assertInt32(value);
-        this.ensureCapacity(4);
-        this.view().setInt32(this.pos, value, true);
-        this.pos += 4;
-        return this;
+        let chunk = new Uint8Array(4);
+        new DataView(chunk.buffer).setInt32(0, value, true);
+        return this.raw(chunk);
     }
     /**
      * Write a `sint32` value, a signed, zigzag-encoded 32-bit varint.
      */
     sint32(value) {
         assertInt32(value);
-        // zigzag encode then emit as uint32 varint
-        return this.uint32(((value << 1) ^ (value >> 31)) >>> 0);
+        // zigzag encode
+        value = ((value << 1) ^ (value >> 31)) >>> 0;
+        varint32write(value, this.buf);
+        return this;
     }
     /**
      * Write a `sfixed64` value, a signed, fixed-length 64-bit integer.
      */
     sfixed64(value) {
-        const tc = protoInt64.enc(value);
-        this.ensureCapacity(8);
-        const view = this.view();
-        view.setInt32(this.pos, tc.lo, true);
-        view.setInt32(this.pos + 4, tc.hi, true);
-        this.pos += 8;
-        return this;
+        let chunk = new Uint8Array(8), view = new DataView(chunk.buffer), tc = protoInt64.enc(value);
+        view.setInt32(0, tc.lo, true);
+        view.setInt32(4, tc.hi, true);
+        return this.raw(chunk);
     }
     /**
      * Write a `fixed64` value, an unsigned, fixed-length 64 bit integer.
      */
     fixed64(value) {
-        const tc = protoInt64.uEnc(value);
-        this.ensureCapacity(8);
-        const view = this.view();
-        view.setInt32(this.pos, tc.lo, true);
-        view.setInt32(this.pos + 4, tc.hi, true);
-        this.pos += 8;
-        return this;
+        let chunk = new Uint8Array(8), view = new DataView(chunk.buffer), tc = protoInt64.uEnc(value);
+        view.setInt32(0, tc.lo, true);
+        view.setInt32(4, tc.hi, true);
+        return this.raw(chunk);
     }
     /**
      * Write a `int64` value, a signed 64-bit varint.
      */
     int64(value) {
-        const tc = protoInt64.enc(value);
-        return this.writeVarint64(tc.lo, tc.hi);
+        let tc = protoInt64.enc(value);
+        varint64write(tc.lo, tc.hi, this.buf);
+        return this;
     }
     /**
      * Write a `sint64` value, a signed, zig-zag-encoded 64-bit varint.
@@ -368,102 +277,21 @@ export class BinaryWriter {
         const tc = protoInt64.enc(value), 
         // zigzag encode
         sign = tc.hi >> 31, lo = (tc.lo << 1) ^ sign, hi = ((tc.hi << 1) | (tc.lo >>> 31)) ^ sign;
-        return this.writeVarint64(lo, hi);
+        varint64write(lo, hi, this.buf);
+        return this;
     }
     /**
      * Write a `uint64` value, an unsigned 64-bit varint.
      */
     uint64(value) {
         const tc = protoInt64.uEnc(value);
-        return this.writeVarint64(tc.lo, tc.hi);
-    }
-    /**
-     * 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
-     */
-    writeVarint64(lo, hi) {
-        // Worst case: 10 bytes.
-        this.ensureCapacity(10);
-        const buf = this.buffer;
-        let pos = this.pos;
-        for (let i = 0; i < 28; i = i + 7) {
-            const shift = lo >>> i;
-            const hasNext = !(shift >>> 7 == 0 && hi == 0);
-            buf[pos++] = (hasNext ? shift | 0x80 : shift) & 0xff;
-            if (!hasNext) {
-                this.pos = pos;
-                return this;
-            }
-        }
-        const splitBits = ((lo >>> 28) & 0x0f) | ((hi & 0x07) << 4);
-        const hasMoreBits = !(hi >> 3 == 0);
-        buf[pos++] = (hasMoreBits ? splitBits | 0x80 : splitBits) & 0xff;
-        if (!hasMoreBits) {
-            this.pos = pos;
-            return this;
-        }
-        for (let i = 3; i < 31; i = i + 7) {
-            const shift = hi >>> i;
-            const hasNext = !(shift >>> 7 == 0);
-            buf[pos++] = (hasNext ? shift | 0x80 : shift) & 0xff;
-            if (!hasNext) {
-                this.pos = pos;
-                return this;
-            }
-        }
-        buf[pos++] = (hi >>> 31) & 0x01;
-        this.pos = pos;
+        varint64write(tc.lo, tc.hi, this.buf);
         return this;
     }
 }
-/**
- * Capacity of the buffer allocated by the first write..
- */
-const INITIAL_SIZE = 128;
-/**
- * Bytes `fork()` reserves for the length prefix, betting that the payload will
- * be under 128 bytes. `join()` fills them in, and widens them if the bet was
- * wrong.
- */
-const DEFAULT_LEN_PREFIX_SIZE = 1;
-/**
- * Shared empty buffer used as the initial value before the first write.
- * Avoids allocating and zeroing `INITIAL_SIZE` bytes per BinaryWriter when a
- * writer is only used for a tiny message (or not used at all).
- */
-const EMPTY_BUFFER = new Uint8Array(0);
-/**
- * Shared empty view, paired with `EMPTY_BUFFER`. Never written to: any
- * fixed-width write first grows the buffer, which replaces this view.
- */
-const EMPTY_VIEW = new DataView(EMPTY_BUFFER.buffer);
-/**
- * Longest string on the ASCII fast paths. Must stay below 0x80, so
- * that the writer's length prefix always fits a single varint byte.
- */
-const ASCII_MAX_LENGTH = 32;
-/**
- * Number of bytes needed to encode `value` as an unsigned 32-bit varint.
- */
-function varint32Size(value) {
-    if (value < 0x80)
-        return 1;
-    if (value < 0x4000)
-        return 2;
-    if (value < 0x200000)
-        return 3;
-    if (value < 0x10000000)
-        return 4;
-    return 5;
-}
 export class BinaryReader {
     constructor(buf, decodeUtf8 = getTextEncoding().decodeUtf8) {
         this.decodeUtf8 = decodeUtf8;
-        this.varint64Lo = 0;
-        this.varint64Hi = 0;
         this.varint64 = varint64read; // dirty cast for `this`
         /**
          * Read a `uint32` field, an unsigned 32 bit varint.
@@ -564,23 +392,19 @@ export class BinaryReader {
      * Read a `int64` field, a signed 64-bit varint.
      */
     int64() {
-        this.varint64();
-        return protoInt64.dec(this.varint64Lo, this.varint64Hi);
+        return protoInt64.dec(...this.varint64());
     }
     /**
      * Read a `uint64` field, an unsigned 64-bit varint.
      */
     uint64() {
-        this.varint64();
-        return protoInt64.uDec(this.varint64Lo, this.varint64Hi);
+        return protoInt64.uDec(...this.varint64());
     }
     /**
      * Read a `sint64` field, a signed, zig-zag-encoded 64-bit varint.
      */
     sint64() {
-        this.varint64();
-        let lo = this.varint64Lo;
-        let hi = this.varint64Hi;
+        let [lo, hi] = this.varint64();
         // decode zig zag
         let s = -(lo & 1);
         lo = ((lo >>> 1) | ((hi & 1) << 31)) ^ s;
@@ -591,14 +415,8 @@ export class BinaryReader {
      * Read a `bool` field, a variant.
      */
     bool() {
-        // Fast path: most bools are 0x0 or 0x1.
-        const b = this.buf[this.pos];
-        if (b < 0x80) {
-            this.pos++;
-            return b !== 0;
-        }
-        this.varint64();
-        return this.varint64Lo !== 0 || this.varint64Hi !== 0;
+        let [lo, hi] = this.varint64();
+        return lo !== 0 || hi !== 0;
     }
     /**
      * Read a `fixed32` field, an unsigned, fixed-length 32-bit integer.
@@ -654,21 +472,7 @@ export class BinaryReader {
      * `strict` is true, throw on invalid UTF-8 instead of substituting U+FFFD.
      */
     string(strict) {
-        const bytes = this.bytes();
-        const len = bytes.length;
-        // Fast path for ASCII.
-        if (len <= ASCII_MAX_LENGTH) {
-            const codes = new Array(len);
-            for (let i = 0; i < len; i++) {
-                const byte = bytes[i];
-                if (byte > 0x7f) {
-                    return this.decodeUtf8(bytes, strict);
-                }
-                codes[i] = byte;
-            }
-            return String.fromCharCode.apply(String, codes);
-        }
-        return this.decodeUtf8(bytes, strict);
+        return this.decodeUtf8(this.bytes(), strict);
     }
 }
 /**

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

@@ -1,5 +1,5 @@
 export * from "./binary-encoding.js";
 export * from "./base64-encoding.js";
-export { getTextEncoding, configureTextEncoding } from "./text-encoding.js";
+export * from "./text-encoding.js";
 export * from "./text-format.js";
 export * from "./size-delimited.js";

package/node_modules/@bufbuild/protobuf/dist/esm/wire/index.js

@@ -13,6 +13,6 @@
 // limitations under the License.
 export * from "./binary-encoding.js";
 export * from "./base64-encoding.js";
-export { getTextEncoding, configureTextEncoding } from "./text-encoding.js";
+export * from "./text-encoding.js";
 export * from "./text-format.js";
 export * from "./size-delimited.js";

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

@@ -7,12 +7,6 @@ interface TextEncoding {
      * Encode UTF-8 text to binary.
      */
     encodeUtf8: (text: string) => Uint8Array<ArrayBuffer>;
-    /**
-     * Encode UTF-8 text to a Uint8Array. The destination must be large enough.
-     */
-    encodeUtf8Into: (text: string, dest: Uint8Array) => {
-        written: number;
-    };
     /**
      * Decode UTF-8 text from binary. If `strict` is true, throw on invalid byte
      * sequences instead of silently substituting U+FFFD. Implementations that
@@ -20,26 +14,15 @@ interface TextEncoding {
      */
     decodeUtf8: (bytes: Uint8Array, strict?: boolean) => string;
 }
-type TextEncodingConfig = Omit<TextEncoding, "encodeUtf8Into"> & Partial<Pick<TextEncoding, "encodeUtf8Into">>;
 /**
  * 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.
  *
- * 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().
  */
-export declare function configureTextEncoding(textEncoding: TextEncodingConfig): void;
+export declare function configureTextEncoding(textEncoding: TextEncoding): void;
 export declare function getTextEncoding(): TextEncoding;
-/**
- * Simplistic polyfill for encodeUtf8Into.
- *
- * @private
- */
-export declare function emulateEncodeInto(encodeUtf8: (str: string) => Uint8Array): TextEncoding["encodeUtf8Into"];
 export {};

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

@@ -18,37 +18,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().
  */
 export 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;
 }
 export 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 {
@@ -60,31 +52,6 @@ export 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
- */
-export function emulateEncodeInto(encodeUtf8) {
-    return (text, dest) => {
-        const bytes = encodeUtf8(text);
-        dest.set(bytes);
-        return { written: bytes.byteLength };
-    };
+    return globalThis[symbol];
 }