@prisma/migrate 6.6.0-integration-feat-orm-693-d1-driver-create-migration-adapter-using-new-http-binding.4 → 6.6.0-integration-mcp.1

package/dist/{multipart-parser-ASKQAOL4-WZ47HU6G.js → multipart-parser-AOASR4DL-AXIJXW2B.js}

@@ -16,11 +16,11 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var multipart_parser_ASKQAOL4_WZ47HU6G_exports = {};
-__export(multipart_parser_ASKQAOL4_WZ47HU6G_exports, {
-  default: () => multipart_parser_ASKQAOL4_WZ47HU6G_default
+var multipart_parser_AOASR4DL_AXIJXW2B_exports = {};
+__export(multipart_parser_AOASR4DL_AXIJXW2B_exports, {
+  default: () => multipart_parser_AOASR4DL_AXIJXW2B_default
 });
-module.exports = __toCommonJS(multipart_parser_ASKQAOL4_WZ47HU6G_exports);
+module.exports = __toCommonJS(multipart_parser_AOASR4DL_AXIJXW2B_exports);
 var import_chunk_2ESYSVXG = require("./chunk-2ESYSVXG.js");
 var require_chunk_QGM4M3NI = (0, import_chunk_2ESYSVXG.__commonJS)({
   "../fetch-engine/dist/chunk-QGM4M3NI.js"(exports, module2) {
@@ -82,8 +82,8 @@ var require_chunk_QGM4M3NI = (0, import_chunk_2ESYSVXG.__commonJS)({
     ));
   }
 });
-var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
-  "../fetch-engine/dist/chunk-RXM4EBGR.js"(exports, module2) {
+var require_chunk_BYDIRBHB = (0, import_chunk_2ESYSVXG.__commonJS)({
+  "../fetch-engine/dist/chunk-BYDIRBHB.js"(exports, module2) {
     "use strict";
     var __defProp2 = Object.defineProperty;
     var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
@@ -102,51 +102,47 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
       return to;
     };
     var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
-    var chunk_RXM4EBGR_exports = {};
-    __export2(chunk_RXM4EBGR_exports, {
+    var chunk_BYDIRBHB_exports = {};
+    __export2(chunk_BYDIRBHB_exports, {
       FormData: () => FormData,
       fetch_blob_default: () => fetch_blob_default,
       file_default: () => file_default,
       formDataToBlob: () => formDataToBlob
     });
-    module2.exports = __toCommonJS2(chunk_RXM4EBGR_exports);
+    module2.exports = __toCommonJS2(chunk_BYDIRBHB_exports);
     var import_chunk_QGM4M3NI = require_chunk_QGM4M3NI();
     var import_node_fs = (0, import_chunk_2ESYSVXG.__require)("node:fs");
     var require_ponyfill_es2018 = (0, import_chunk_QGM4M3NI.__commonJS)({
-      "../../node_modules/.pnpm/web-streams-polyfill@3.2.1/node_modules/web-streams-polyfill/dist/ponyfill.es2018.js"(exports2, module22) {
+      "../../node_modules/.pnpm/web-streams-polyfill@3.3.3/node_modules/web-streams-polyfill/dist/ponyfill.es2018.js"(exports2, module22) {
         "use strict";
         (function(global2, factory) {
           typeof exports2 === "object" && typeof module22 !== "undefined" ? factory(exports2) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, factory(global2.WebStreamsPolyfill = {}));
         })(exports2, function(exports22) {
           "use strict";
-          const SymbolPolyfill = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? Symbol : (description) => `Symbol(${description})`;
           function noop() {
             return void 0;
           }
-          function getGlobals() {
-            if (typeof self !== "undefined") {
-              return self;
-            } else if (typeof window !== "undefined") {
-              return window;
-            } else if (typeof global !== "undefined") {
-              return global;
-            }
-            return void 0;
-          }
-          const globals = getGlobals();
           function typeIsObject(x2) {
             return typeof x2 === "object" && x2 !== null || typeof x2 === "function";
           }
           const rethrowAssertionErrorRejection = noop;
+          function setFunctionName(fn, name) {
+            try {
+              Object.defineProperty(fn, "name", {
+                value: name,
+                configurable: true
+              });
+            } catch (_a2) {
+            }
+          }
           const originalPromise = Promise;
           const originalPromiseThen = Promise.prototype.then;
-          const originalPromiseResolve = Promise.resolve.bind(originalPromise);
           const originalPromiseReject = Promise.reject.bind(originalPromise);
           function newPromise(executor) {
             return new originalPromise(executor);
           }
           function promiseResolvedWith(value) {
-            return originalPromiseResolve(value);
+            return newPromise((resolve) => resolve(value));
           }
           function promiseRejectedWith(reason) {
             return originalPromiseReject(reason);
@@ -169,14 +165,15 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
           function setPromiseIsHandledToTrue(promise) {
             PerformPromiseThen(promise, void 0, rethrowAssertionErrorRejection);
           }
-          const queueMicrotask = (() => {
-            const globalQueueMicrotask = globals && globals.queueMicrotask;
-            if (typeof globalQueueMicrotask === "function") {
-              return globalQueueMicrotask;
+          let _queueMicrotask = (callback) => {
+            if (typeof queueMicrotask === "function") {
+              _queueMicrotask = queueMicrotask;
+            } else {
+              const resolvedPromise = promiseResolvedWith(void 0);
+              _queueMicrotask = (cb) => PerformPromiseThen(resolvedPromise, cb);
             }
-            const resolvedPromise = promiseResolvedWith(void 0);
-            return (fn) => PerformPromiseThen(resolvedPromise, fn);
-          })();
+            return _queueMicrotask(callback);
+          };
           function reflectCall(F, V, args) {
             if (typeof F !== "function") {
               throw new TypeError("Argument is not a function");
@@ -280,6 +277,11 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
               return front._elements[cursor];
             }
           }
+          const AbortSteps = Symbol("[[AbortSteps]]");
+          const ErrorSteps = Symbol("[[ErrorSteps]]");
+          const CancelSteps = Symbol("[[CancelSteps]]");
+          const PullSteps = Symbol("[[PullSteps]]");
+          const ReleaseSteps = Symbol("[[ReleaseSteps]]");
           function ReadableStreamReaderGenericInitialize(reader, stream) {
             reader._ownerReadableStream = stream;
             stream._reader = reader;
@@ -296,12 +298,14 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
             return ReadableStreamCancel(stream, reason);
           }
           function ReadableStreamReaderGenericRelease(reader) {
-            if (reader._ownerReadableStream._state === "readable") {
+            const stream = reader._ownerReadableStream;
+            if (stream._state === "readable") {
               defaultReaderClosedPromiseReject(reader, new TypeError(`Reader was released and can no longer be used to monitor the stream's closedness`));
             } else {
               defaultReaderClosedPromiseResetToRejected(reader, new TypeError(`Reader was released and can no longer be used to monitor the stream's closedness`));
             }
-            reader._ownerReadableStream._reader = void 0;
+            stream._readableStreamController[ReleaseSteps]();
+            stream._reader = void 0;
             reader._ownerReadableStream = void 0;
           }
           function readerLockException(name) {
@@ -341,10 +345,6 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
             reader._closedPromise_resolve = void 0;
             reader._closedPromise_reject = void 0;
           }
-          const AbortSteps = SymbolPolyfill("[[AbortSteps]]");
-          const ErrorSteps = SymbolPolyfill("[[ErrorSteps]]");
-          const CancelSteps = SymbolPolyfill("[[CancelSteps]]");
-          const PullSteps = SymbolPolyfill("[[PullSteps]]");
           const NumberIsFinite = Number.isFinite || function(x2) {
             return typeof x2 === "number" && isFinite(x2);
           };
@@ -515,10 +515,7 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
               if (this._ownerReadableStream === void 0) {
                 return;
               }
-              if (this._readRequests.length > 0) {
-                throw new TypeError("Tried to release a reader lock when that reader has pending read() calls un-settled");
-              }
-              ReadableStreamReaderGenericRelease(this);
+              ReadableStreamDefaultReaderRelease(this);
             }
           }
           Object.defineProperties(ReadableStreamDefaultReader.prototype, {
@@ -527,8 +524,11 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
             releaseLock: { enumerable: true },
             closed: { enumerable: true }
           });
-          if (typeof SymbolPolyfill.toStringTag === "symbol") {
-            Object.defineProperty(ReadableStreamDefaultReader.prototype, SymbolPolyfill.toStringTag, {
+          setFunctionName(ReadableStreamDefaultReader.prototype.cancel, "cancel");
+          setFunctionName(ReadableStreamDefaultReader.prototype.read, "read");
+          setFunctionName(ReadableStreamDefaultReader.prototype.releaseLock, "releaseLock");
+          if (typeof Symbol.toStringTag === "symbol") {
+            Object.defineProperty(ReadableStreamDefaultReader.prototype, Symbol.toStringTag, {
               value: "ReadableStreamDefaultReader",
               configurable: true
             });
@@ -553,6 +553,18 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
               stream._readableStreamController[PullSteps](readRequest);
             }
           }
+          function ReadableStreamDefaultReaderRelease(reader) {
+            ReadableStreamReaderGenericRelease(reader);
+            const e2 = new TypeError("Reader was released");
+            ReadableStreamDefaultReaderErrorReadRequests(reader, e2);
+          }
+          function ReadableStreamDefaultReaderErrorReadRequests(reader, e2) {
+            const readRequests = reader._readRequests;
+            reader._readRequests = new SimpleQueue();
+            readRequests.forEach((readRequest) => {
+              readRequest._errorSteps(e2);
+            });
+          }
           function defaultReaderBrandCheckException(name) {
             return new TypeError(`ReadableStreamDefaultReader.prototype.${name} can only be used on a ReadableStreamDefaultReader`);
           }
@@ -579,9 +591,6 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
                 return Promise.resolve({ value: void 0, done: true });
               }
               const reader = this._reader;
-              if (reader._ownerReadableStream === void 0) {
-                return promiseRejectedWith(readerLockException("iterate"));
-              }
               let resolvePromise;
               let rejectPromise;
               const promise = newPromise((resolve, reject) => {
@@ -591,7 +600,7 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
               const readRequest = {
                 _chunkSteps: (chunk) => {
                   this._ongoingPromise = void 0;
-                  queueMicrotask(() => resolvePromise({ value: chunk, done: false }));
+                  _queueMicrotask(() => resolvePromise({ value: chunk, done: false }));
                 },
                 _closeSteps: () => {
                   this._ongoingPromise = void 0;
@@ -615,9 +624,6 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
               }
               this._isFinished = true;
               const reader = this._reader;
-              if (reader._ownerReadableStream === void 0) {
-                return promiseRejectedWith(readerLockException("finish iterating"));
-              }
               if (!this._preventCancel) {
                 const result = ReadableStreamReaderGenericCancel(reader, value);
                 ReadableStreamReaderGenericRelease(reader);
@@ -641,9 +647,7 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
               return this._asyncIteratorImpl.return(value);
             }
           };
-          if (AsyncIteratorPrototype !== void 0) {
-            Object.setPrototypeOf(ReadableStreamAsyncIteratorPrototype, AsyncIteratorPrototype);
-          }
+          Object.setPrototypeOf(ReadableStreamAsyncIteratorPrototype, AsyncIteratorPrototype);
           function AcquireReadableStreamAsyncIterator(stream, preventCancel) {
             const reader = AcquireReadableStreamDefaultReader(stream);
             const impl = new ReadableStreamAsyncIteratorImpl(reader, preventCancel);
@@ -660,7 +664,7 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
             }
             try {
               return x2._asyncIteratorImpl instanceof ReadableStreamAsyncIteratorImpl;
-            } catch (_a) {
+            } catch (_a2) {
               return false;
             }
           }
@@ -670,18 +674,31 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
           const NumberIsNaN = Number.isNaN || function(x2) {
             return x2 !== x2;
           };
+          var _a, _b, _c;
           function CreateArrayFromList(elements) {
             return elements.slice();
           }
           function CopyDataBlockBytes(dest, destOffset, src, srcOffset, n) {
             new Uint8Array(dest).set(new Uint8Array(src, srcOffset, n), destOffset);
           }
-          function TransferArrayBuffer(O) {
-            return O;
-          }
-          function IsDetachedBuffer(O) {
-            return false;
-          }
+          let TransferArrayBuffer = (O) => {
+            if (typeof O.transfer === "function") {
+              TransferArrayBuffer = (buffer) => buffer.transfer();
+            } else if (typeof structuredClone === "function") {
+              TransferArrayBuffer = (buffer) => structuredClone(buffer, { transfer: [buffer] });
+            } else {
+              TransferArrayBuffer = (buffer) => buffer;
+            }
+            return TransferArrayBuffer(O);
+          };
+          let IsDetachedBuffer = (O) => {
+            if (typeof O.detached === "boolean") {
+              IsDetachedBuffer = (buffer) => buffer.detached;
+            } else {
+              IsDetachedBuffer = (buffer) => buffer.byteLength === 0;
+            }
+            return IsDetachedBuffer(O);
+          };
           function ArrayBufferSlice(buffer, begin, end) {
             if (buffer.slice) {
               return buffer.slice(begin, end);
@@ -691,6 +708,63 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
             CopyDataBlockBytes(slice, 0, buffer, begin, length);
             return slice;
           }
+          function GetMethod(receiver, prop) {
+            const func = receiver[prop];
+            if (func === void 0 || func === null) {
+              return void 0;
+            }
+            if (typeof func !== "function") {
+              throw new TypeError(`${String(prop)} is not a function`);
+            }
+            return func;
+          }
+          function CreateAsyncFromSyncIterator(syncIteratorRecord) {
+            const syncIterable = {
+              [Symbol.iterator]: () => syncIteratorRecord.iterator
+            };
+            const asyncIterator = async function* () {
+              return yield* syncIterable;
+            }();
+            const nextMethod = asyncIterator.next;
+            return { iterator: asyncIterator, nextMethod, done: false };
+          }
+          const SymbolAsyncIterator = (_c = (_a = Symbol.asyncIterator) !== null && _a !== void 0 ? _a : (_b = Symbol.for) === null || _b === void 0 ? void 0 : _b.call(Symbol, "Symbol.asyncIterator")) !== null && _c !== void 0 ? _c : "@@asyncIterator";
+          function GetIterator(obj, hint = "sync", method) {
+            if (method === void 0) {
+              if (hint === "async") {
+                method = GetMethod(obj, SymbolAsyncIterator);
+                if (method === void 0) {
+                  const syncMethod = GetMethod(obj, Symbol.iterator);
+                  const syncIteratorRecord = GetIterator(obj, "sync", syncMethod);
+                  return CreateAsyncFromSyncIterator(syncIteratorRecord);
+                }
+              } else {
+                method = GetMethod(obj, Symbol.iterator);
+              }
+            }
+            if (method === void 0) {
+              throw new TypeError("The object is not iterable");
+            }
+            const iterator = reflectCall(method, obj, []);
+            if (!typeIsObject(iterator)) {
+              throw new TypeError("The iterator method must return an object");
+            }
+            const nextMethod = iterator.next;
+            return { iterator, nextMethod, done: false };
+          }
+          function IteratorNext(iteratorRecord) {
+            const result = reflectCall(iteratorRecord.nextMethod, iteratorRecord.iterator, []);
+            if (!typeIsObject(result)) {
+              throw new TypeError("The iterator.next() method must return an object");
+            }
+            return result;
+          }
+          function IteratorComplete(iterResult) {
+            return Boolean(iterResult.done);
+          }
+          function IteratorValue(iterResult) {
+            return iterResult.value;
+          }
           function IsNonNegativeNumber(v) {
             if (typeof v !== "number") {
               return false;
@@ -730,6 +804,18 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
             container._queue = new SimpleQueue();
             container._queueTotalSize = 0;
           }
+          function isDataViewConstructor(ctor) {
+            return ctor === DataView;
+          }
+          function isDataView(view) {
+            return isDataViewConstructor(view.constructor);
+          }
+          function arrayBufferViewElementSize(ctor) {
+            if (isDataViewConstructor(ctor)) {
+              return 1;
+            }
+            return ctor.BYTES_PER_ELEMENT;
+          }
           class ReadableStreamBYOBRequest {
             constructor() {
               throw new TypeError("Illegal constructor");
@@ -752,7 +838,9 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
               if (this._associatedReadableByteStreamController === void 0) {
                 throw new TypeError("This BYOB request has been invalidated");
               }
-              if (IsDetachedBuffer(this._view.buffer)) ;
+              if (IsDetachedBuffer(this._view.buffer)) {
+                throw new TypeError(`The BYOB request's buffer has been detached and so cannot be used as a response`);
+              }
               ReadableByteStreamControllerRespond(this._associatedReadableByteStreamController, bytesWritten);
             }
             respondWithNewView(view) {
@@ -766,7 +854,9 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
               if (this._associatedReadableByteStreamController === void 0) {
                 throw new TypeError("This BYOB request has been invalidated");
               }
-              if (IsDetachedBuffer(view.buffer)) ;
+              if (IsDetachedBuffer(view.buffer)) {
+                throw new TypeError("The given view's buffer has been detached and so cannot be used as a response");
+              }
               ReadableByteStreamControllerRespondWithNewView(this._associatedReadableByteStreamController, view);
             }
           }
@@ -775,8 +865,10 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
             respondWithNewView: { enumerable: true },
             view: { enumerable: true }
           });
-          if (typeof SymbolPolyfill.toStringTag === "symbol") {
-            Object.defineProperty(ReadableStreamBYOBRequest.prototype, SymbolPolyfill.toStringTag, {
+          setFunctionName(ReadableStreamBYOBRequest.prototype.respond, "respond");
+          setFunctionName(ReadableStreamBYOBRequest.prototype.respondWithNewView, "respondWithNewView");
+          if (typeof Symbol.toStringTag === "symbol") {
+            Object.defineProperty(ReadableStreamBYOBRequest.prototype, Symbol.toStringTag, {
               value: "ReadableStreamBYOBRequest",
               configurable: true
             });
@@ -865,11 +957,7 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
             [PullSteps](readRequest) {
               const stream = this._controlledReadableByteStream;
               if (this._queueTotalSize > 0) {
-                const entry = this._queue.shift();
-                this._queueTotalSize -= entry.byteLength;
-                ReadableByteStreamControllerHandleQueueDrain(this);
-                const view = new Uint8Array(entry.buffer, entry.byteOffset, entry.byteLength);
-                readRequest._chunkSteps(view);
+                ReadableByteStreamControllerFillReadRequestFromQueue(this, readRequest);
                 return;
               }
               const autoAllocateChunkSize = this._autoAllocateChunkSize;
@@ -887,6 +975,7 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
                   byteOffset: 0,
                   byteLength: autoAllocateChunkSize,
                   bytesFilled: 0,
+                  minimumFill: 1,
                   elementSize: 1,
                   viewConstructor: Uint8Array,
                   readerType: "default"
@@ -896,6 +985,15 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
               ReadableStreamAddReadRequest(stream, readRequest);
               ReadableByteStreamControllerCallPullIfNeeded(this);
             }
+            /** @internal */
+            [ReleaseSteps]() {
+              if (this._pendingPullIntos.length > 0) {
+                const firstPullInto = this._pendingPullIntos.peek();
+                firstPullInto.readerType = "none";
+                this._pendingPullIntos = new SimpleQueue();
+                this._pendingPullIntos.push(firstPullInto);
+              }
+            }
           }
           Object.defineProperties(ReadableByteStreamController.prototype, {
             close: { enumerable: true },
@@ -904,8 +1002,11 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
             byobRequest: { enumerable: true },
             desiredSize: { enumerable: true }
           });
-          if (typeof SymbolPolyfill.toStringTag === "symbol") {
-            Object.defineProperty(ReadableByteStreamController.prototype, SymbolPolyfill.toStringTag, {
+          setFunctionName(ReadableByteStreamController.prototype.close, "close");
+          setFunctionName(ReadableByteStreamController.prototype.enqueue, "enqueue");
+          setFunctionName(ReadableByteStreamController.prototype.error, "error");
+          if (typeof Symbol.toStringTag === "symbol") {
+            Object.defineProperty(ReadableByteStreamController.prototype, Symbol.toStringTag, {
               value: "ReadableByteStreamController",
               configurable: true
             });
@@ -945,8 +1046,10 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
                 controller._pullAgain = false;
                 ReadableByteStreamControllerCallPullIfNeeded(controller);
               }
+              return null;
             }, (e2) => {
               ReadableByteStreamControllerError(controller, e2);
+              return null;
             });
           }
           function ReadableByteStreamControllerClearPendingPullIntos(controller) {
@@ -974,15 +1077,30 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
             controller._queue.push({ buffer, byteOffset, byteLength });
             controller._queueTotalSize += byteLength;
           }
+          function ReadableByteStreamControllerEnqueueClonedChunkToQueue(controller, buffer, byteOffset, byteLength) {
+            let clonedChunk;
+            try {
+              clonedChunk = ArrayBufferSlice(buffer, byteOffset, byteOffset + byteLength);
+            } catch (cloneE) {
+              ReadableByteStreamControllerError(controller, cloneE);
+              throw cloneE;
+            }
+            ReadableByteStreamControllerEnqueueChunkToQueue(controller, clonedChunk, 0, byteLength);
+          }
+          function ReadableByteStreamControllerEnqueueDetachedPullIntoToQueue(controller, firstDescriptor) {
+            if (firstDescriptor.bytesFilled > 0) {
+              ReadableByteStreamControllerEnqueueClonedChunkToQueue(controller, firstDescriptor.buffer, firstDescriptor.byteOffset, firstDescriptor.bytesFilled);
+            }
+            ReadableByteStreamControllerShiftPendingPullInto(controller);
+          }
           function ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) {
-            const elementSize = pullIntoDescriptor.elementSize;
-            const currentAlignedBytes = pullIntoDescriptor.bytesFilled - pullIntoDescriptor.bytesFilled % elementSize;
             const maxBytesToCopy = Math.min(controller._queueTotalSize, pullIntoDescriptor.byteLength - pullIntoDescriptor.bytesFilled);
             const maxBytesFilled = pullIntoDescriptor.bytesFilled + maxBytesToCopy;
-            const maxAlignedBytes = maxBytesFilled - maxBytesFilled % elementSize;
             let totalBytesToCopyRemaining = maxBytesToCopy;
             let ready = false;
-            if (maxAlignedBytes > currentAlignedBytes) {
+            const remainderBytes = maxBytesFilled % pullIntoDescriptor.elementSize;
+            const maxAlignedBytes = maxBytesFilled - remainderBytes;
+            if (maxAlignedBytes >= pullIntoDescriptor.minimumFill) {
               totalBytesToCopyRemaining = maxAlignedBytes - pullIntoDescriptor.bytesFilled;
               ready = true;
             }
@@ -1035,20 +1153,36 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
               }
             }
           }
-          function ReadableByteStreamControllerPullInto(controller, view, readIntoRequest) {
-            const stream = controller._controlledReadableByteStream;
-            let elementSize = 1;
-            if (view.constructor !== DataView) {
-              elementSize = view.constructor.BYTES_PER_ELEMENT;
+          function ReadableByteStreamControllerProcessReadRequestsUsingQueue(controller) {
+            const reader = controller._controlledReadableByteStream._reader;
+            while (reader._readRequests.length > 0) {
+              if (controller._queueTotalSize === 0) {
+                return;
+              }
+              const readRequest = reader._readRequests.shift();
+              ReadableByteStreamControllerFillReadRequestFromQueue(controller, readRequest);
             }
+          }
+          function ReadableByteStreamControllerPullInto(controller, view, min, readIntoRequest) {
+            const stream = controller._controlledReadableByteStream;
             const ctor = view.constructor;
-            const buffer = TransferArrayBuffer(view.buffer);
+            const elementSize = arrayBufferViewElementSize(ctor);
+            const { byteOffset, byteLength } = view;
+            const minimumFill = min * elementSize;
+            let buffer;
+            try {
+              buffer = TransferArrayBuffer(view.buffer);
+            } catch (e2) {
+              readIntoRequest._errorSteps(e2);
+              return;
+            }
             const pullIntoDescriptor = {
               buffer,
               bufferByteLength: buffer.byteLength,
-              byteOffset: view.byteOffset,
-              byteLength: view.byteLength,
+              byteOffset,
+              byteLength,
               bytesFilled: 0,
+              minimumFill,
               elementSize,
               viewConstructor: ctor,
               readerType: "byob"
@@ -1082,6 +1216,9 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
             ReadableByteStreamControllerCallPullIfNeeded(controller);
           }
           function ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor) {
+            if (firstDescriptor.readerType === "none") {
+              ReadableByteStreamControllerShiftPendingPullInto(controller);
+            }
             const stream = controller._controlledReadableByteStream;
             if (ReadableStreamHasBYOBReader(stream)) {
               while (ReadableStreamGetNumReadIntoRequests(stream) > 0) {
@@ -1092,15 +1229,19 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
           }
           function ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, pullIntoDescriptor) {
             ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesWritten, pullIntoDescriptor);
-            if (pullIntoDescriptor.bytesFilled < pullIntoDescriptor.elementSize) {
+            if (pullIntoDescriptor.readerType === "none") {
+              ReadableByteStreamControllerEnqueueDetachedPullIntoToQueue(controller, pullIntoDescriptor);
+              ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);
+              return;
+            }
+            if (pullIntoDescriptor.bytesFilled < pullIntoDescriptor.minimumFill) {
               return;
             }
             ReadableByteStreamControllerShiftPendingPullInto(controller);
             const remainderSize = pullIntoDescriptor.bytesFilled % pullIntoDescriptor.elementSize;
             if (remainderSize > 0) {
               const end = pullIntoDescriptor.byteOffset + pullIntoDescriptor.bytesFilled;
-              const remainder = ArrayBufferSlice(pullIntoDescriptor.buffer, end - remainderSize, end);
-              ReadableByteStreamControllerEnqueueChunkToQueue(controller, remainder, 0, remainder.byteLength);
+              ReadableByteStreamControllerEnqueueClonedChunkToQueue(controller, pullIntoDescriptor.buffer, end - remainderSize, remainderSize);
             }
             pullIntoDescriptor.bytesFilled -= remainderSize;
             ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableByteStream, pullIntoDescriptor);
@@ -1111,7 +1252,7 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
             ReadableByteStreamControllerInvalidateBYOBRequest(controller);
             const state = controller._controlledReadableByteStream._state;
             if (state === "closed") {
-              ReadableByteStreamControllerRespondInClosedState(controller);
+              ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor);
             } else {
               ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, firstDescriptor);
             }
@@ -1159,7 +1300,7 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
             }
             if (controller._pendingPullIntos.length > 0) {
               const firstPendingPullInto = controller._pendingPullIntos.peek();
-              if (firstPendingPullInto.bytesFilled > 0) {
+              if (firstPendingPullInto.bytesFilled % firstPendingPullInto.elementSize !== 0) {
                 const e2 = new TypeError("Insufficient bytes to fill elements in the given buffer");
                 ReadableByteStreamControllerError(controller, e2);
                 throw e2;
@@ -1173,17 +1314,24 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
             if (controller._closeRequested || stream._state !== "readable") {
               return;
             }
-            const buffer = chunk.buffer;
-            const byteOffset = chunk.byteOffset;
-            const byteLength = chunk.byteLength;
+            const { buffer, byteOffset, byteLength } = chunk;
+            if (IsDetachedBuffer(buffer)) {
+              throw new TypeError("chunk's buffer is detached and so cannot be enqueued");
+            }
             const transferredBuffer = TransferArrayBuffer(buffer);
             if (controller._pendingPullIntos.length > 0) {
               const firstPendingPullInto = controller._pendingPullIntos.peek();
-              if (IsDetachedBuffer(firstPendingPullInto.buffer)) ;
+              if (IsDetachedBuffer(firstPendingPullInto.buffer)) {
+                throw new TypeError("The BYOB request's buffer has been detached and so cannot be filled with an enqueued chunk");
+              }
+              ReadableByteStreamControllerInvalidateBYOBRequest(controller);
               firstPendingPullInto.buffer = TransferArrayBuffer(firstPendingPullInto.buffer);
+              if (firstPendingPullInto.readerType === "none") {
+                ReadableByteStreamControllerEnqueueDetachedPullIntoToQueue(controller, firstPendingPullInto);
+              }
             }
-            ReadableByteStreamControllerInvalidateBYOBRequest(controller);
             if (ReadableStreamHasDefaultReader(stream)) {
+              ReadableByteStreamControllerProcessReadRequestsUsingQueue(controller);
               if (ReadableStreamGetNumReadRequests(stream) === 0) {
                 ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);
               } else {
@@ -1211,6 +1359,13 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
             ReadableByteStreamControllerClearAlgorithms(controller);
             ReadableStreamError(stream, e2);
           }
+          function ReadableByteStreamControllerFillReadRequestFromQueue(controller, readRequest) {
+            const entry = controller._queue.shift();
+            controller._queueTotalSize -= entry.byteLength;
+            ReadableByteStreamControllerHandleQueueDrain(controller);
+            const view = new Uint8Array(entry.buffer, entry.byteOffset, entry.byteLength);
+            readRequest._chunkSteps(view);
+          }
           function ReadableByteStreamControllerGetBYOBRequest(controller) {
             if (controller._byobRequest === null && controller._pendingPullIntos.length > 0) {
               const firstDescriptor = controller._pendingPullIntos.peek();
@@ -1293,23 +1448,31 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
             uponPromise(promiseResolvedWith(startResult), () => {
               controller._started = true;
               ReadableByteStreamControllerCallPullIfNeeded(controller);
+              return null;
             }, (r2) => {
               ReadableByteStreamControllerError(controller, r2);
+              return null;
             });
           }
           function SetUpReadableByteStreamControllerFromUnderlyingSource(stream, underlyingByteSource, highWaterMark) {
             const controller = Object.create(ReadableByteStreamController.prototype);
-            let startAlgorithm = () => void 0;
-            let pullAlgorithm = () => promiseResolvedWith(void 0);
-            let cancelAlgorithm = () => promiseResolvedWith(void 0);
+            let startAlgorithm;
+            let pullAlgorithm;
+            let cancelAlgorithm;
             if (underlyingByteSource.start !== void 0) {
               startAlgorithm = () => underlyingByteSource.start(controller);
+            } else {
+              startAlgorithm = () => void 0;
             }
             if (underlyingByteSource.pull !== void 0) {
               pullAlgorithm = () => underlyingByteSource.pull(controller);
+            } else {
+              pullAlgorithm = () => promiseResolvedWith(void 0);
             }
             if (underlyingByteSource.cancel !== void 0) {
               cancelAlgorithm = (reason) => underlyingByteSource.cancel(reason);
+            } else {
+              cancelAlgorithm = () => promiseResolvedWith(void 0);
             }
             const autoAllocateChunkSize = underlyingByteSource.autoAllocateChunkSize;
             if (autoAllocateChunkSize === 0) {
@@ -1327,6 +1490,28 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
           function byteStreamControllerBrandCheckException(name) {
             return new TypeError(`ReadableByteStreamController.prototype.${name} can only be used on a ReadableByteStreamController`);
           }
+          function convertReaderOptions(options, context) {
+            assertDictionary(options, context);
+            const mode = options === null || options === void 0 ? void 0 : options.mode;
+            return {
+              mode: mode === void 0 ? void 0 : convertReadableStreamReaderMode(mode, `${context} has member 'mode' that`)
+            };
+          }
+          function convertReadableStreamReaderMode(mode, context) {
+            mode = `${mode}`;
+            if (mode !== "byob") {
+              throw new TypeError(`${context} '${mode}' is not a valid enumeration value for ReadableStreamReaderMode`);
+            }
+            return mode;
+          }
+          function convertByobReadOptions(options, context) {
+            var _a2;
+            assertDictionary(options, context);
+            const min = (_a2 = options === null || options === void 0 ? void 0 : options.min) !== null && _a2 !== void 0 ? _a2 : 1;
+            return {
+              min: convertUnsignedLongLongWithEnforceRange(min, `${context} has member 'min' that`)
+            };
+          }
           function AcquireReadableStreamBYOBReader(stream) {
             return new ReadableStreamBYOBReader(stream);
           }
@@ -1390,12 +1575,7 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
               }
               return ReadableStreamReaderGenericCancel(this, reason);
             }
-            /**
-             * Attempts to reads bytes into view, and returns a promise resolved with the result.
-             *
-             * If reading a chunk causes the queue to become empty, more data will be pulled from the underlying source.
-             */
-            read(view) {
+            read(view, rawOptions = {}) {
               if (!IsReadableStreamBYOBReader(this)) {
                 return promiseRejectedWith(byobReaderBrandCheckException("read"));
               }
@@ -1408,7 +1588,26 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
               if (view.buffer.byteLength === 0) {
                 return promiseRejectedWith(new TypeError(`view's buffer must have non-zero byteLength`));
               }
-              if (IsDetachedBuffer(view.buffer)) ;
+              if (IsDetachedBuffer(view.buffer)) {
+                return promiseRejectedWith(new TypeError("view's buffer has been detached"));
+              }
+              let options;
+              try {
+                options = convertByobReadOptions(rawOptions, "options");
+              } catch (e2) {
+                return promiseRejectedWith(e2);
+              }
+              const min = options.min;
+              if (min === 0) {
+                return promiseRejectedWith(new TypeError("options.min must be greater than 0"));
+              }
+              if (!isDataView(view)) {
+                if (min > view.length) {
+                  return promiseRejectedWith(new RangeError("options.min must be less than or equal to view's length"));
+                }
+              } else if (min > view.byteLength) {
+                return promiseRejectedWith(new RangeError("options.min must be less than or equal to view's byteLength"));
+              }
               if (this._ownerReadableStream === void 0) {
                 return promiseRejectedWith(readerLockException("read from"));
               }
@@ -1423,7 +1622,7 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
                 _closeSteps: (chunk) => resolvePromise({ value: chunk, done: true }),
                 _errorSteps: (e2) => rejectPromise(e2)
               };
-              ReadableStreamBYOBReaderRead(this, view, readIntoRequest);
+              ReadableStreamBYOBReaderRead(this, view, min, readIntoRequest);
               return promise;
             }
             /**
@@ -1442,10 +1641,7 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
               if (this._ownerReadableStream === void 0) {
                 return;
               }
-              if (this._readIntoRequests.length > 0) {
-                throw new TypeError("Tried to release a reader lock when that reader has pending read() calls un-settled");
-              }
-              ReadableStreamReaderGenericRelease(this);
+              ReadableStreamBYOBReaderRelease(this);
             }
           }
           Object.defineProperties(ReadableStreamBYOBReader.prototype, {
@@ -1454,8 +1650,11 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
             releaseLock: { enumerable: true },
             closed: { enumerable: true }
           });
-          if (typeof SymbolPolyfill.toStringTag === "symbol") {
-            Object.defineProperty(ReadableStreamBYOBReader.prototype, SymbolPolyfill.toStringTag, {
+          setFunctionName(ReadableStreamBYOBReader.prototype.cancel, "cancel");
+          setFunctionName(ReadableStreamBYOBReader.prototype.read, "read");
+          setFunctionName(ReadableStreamBYOBReader.prototype.releaseLock, "releaseLock");
+          if (typeof Symbol.toStringTag === "symbol") {
+            Object.defineProperty(ReadableStreamBYOBReader.prototype, Symbol.toStringTag, {
               value: "ReadableStreamBYOBReader",
               configurable: true
             });
@@ -1469,15 +1668,27 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
             }
             return x2 instanceof ReadableStreamBYOBReader;
           }
-          function ReadableStreamBYOBReaderRead(reader, view, readIntoRequest) {
+          function ReadableStreamBYOBReaderRead(reader, view, min, readIntoRequest) {
             const stream = reader._ownerReadableStream;
             stream._disturbed = true;
             if (stream._state === "errored") {
               readIntoRequest._errorSteps(stream._storedError);
             } else {
-              ReadableByteStreamControllerPullInto(stream._readableStreamController, view, readIntoRequest);
+              ReadableByteStreamControllerPullInto(stream._readableStreamController, view, min, readIntoRequest);
             }
           }
+          function ReadableStreamBYOBReaderRelease(reader) {
+            ReadableStreamReaderGenericRelease(reader);
+            const e2 = new TypeError("Reader was released");
+            ReadableStreamBYOBReaderErrorReadIntoRequests(reader, e2);
+          }
+          function ReadableStreamBYOBReaderErrorReadIntoRequests(reader, e2) {
+            const readIntoRequests = reader._readIntoRequests;
+            reader._readIntoRequests = new SimpleQueue();
+            readIntoRequests.forEach((readIntoRequest) => {
+              readIntoRequest._errorSteps(e2);
+            });
+          }
           function byobReaderBrandCheckException(name) {
             return new TypeError(`ReadableStreamBYOBReader.prototype.${name} can only be used on a ReadableStreamBYOBReader`);
           }
@@ -1553,7 +1764,7 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
             }
             try {
               return typeof value.aborted === "boolean";
-            } catch (_a) {
+            } catch (_a2) {
               return false;
             }
           }
@@ -1650,8 +1861,11 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
             getWriter: { enumerable: true },
             locked: { enumerable: true }
           });
-          if (typeof SymbolPolyfill.toStringTag === "symbol") {
-            Object.defineProperty(WritableStream.prototype, SymbolPolyfill.toStringTag, {
+          setFunctionName(WritableStream.prototype.abort, "abort");
+          setFunctionName(WritableStream.prototype.close, "close");
+          setFunctionName(WritableStream.prototype.getWriter, "getWriter");
+          if (typeof Symbol.toStringTag === "symbol") {
+            Object.defineProperty(WritableStream.prototype, Symbol.toStringTag, {
               value: "WritableStream",
               configurable: true
             });
@@ -1694,12 +1908,12 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
             return true;
           }
           function WritableStreamAbort(stream, reason) {
-            var _a;
+            var _a2;
             if (stream._state === "closed" || stream._state === "errored") {
               return promiseResolvedWith(void 0);
             }
             stream._writableStreamController._abortReason = reason;
-            (_a = stream._writableStreamController._abortController) === null || _a === void 0 ? void 0 : _a.abort();
+            (_a2 = stream._writableStreamController._abortController) === null || _a2 === void 0 ? void 0 : _a2.abort(reason);
             const state = stream._state;
             if (state === "closed" || state === "errored") {
               return promiseResolvedWith(void 0);
@@ -1799,9 +2013,11 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
             uponPromise(promise, () => {
               abortRequest._resolve();
               WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
+              return null;
             }, (reason) => {
               abortRequest._reject(reason);
               WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
+              return null;
             });
           }
           function WritableStreamFinishInFlightWrite(stream) {
@@ -2016,8 +2232,12 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
             desiredSize: { enumerable: true },
             ready: { enumerable: true }
           });
-          if (typeof SymbolPolyfill.toStringTag === "symbol") {
-            Object.defineProperty(WritableStreamDefaultWriter.prototype, SymbolPolyfill.toStringTag, {
+          setFunctionName(WritableStreamDefaultWriter.prototype.abort, "abort");
+          setFunctionName(WritableStreamDefaultWriter.prototype.close, "close");
+          setFunctionName(WritableStreamDefaultWriter.prototype.releaseLock, "releaseLock");
+          setFunctionName(WritableStreamDefaultWriter.prototype.write, "write");
+          if (typeof Symbol.toStringTag === "symbol") {
+            Object.defineProperty(WritableStreamDefaultWriter.prototype, Symbol.toStringTag, {
               value: "WritableStreamDefaultWriter",
               configurable: true
             });
@@ -2167,8 +2387,8 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
             signal: { enumerable: true },
             error: { enumerable: true }
           });
-          if (typeof SymbolPolyfill.toStringTag === "symbol") {
-            Object.defineProperty(WritableStreamDefaultController.prototype, SymbolPolyfill.toStringTag, {
+          if (typeof Symbol.toStringTag === "symbol") {
+            Object.defineProperty(WritableStreamDefaultController.prototype, Symbol.toStringTag, {
               value: "WritableStreamDefaultController",
               configurable: true
             });
@@ -2203,28 +2423,38 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
             uponPromise(startPromise, () => {
               controller._started = true;
               WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
+              return null;
             }, (r2) => {
               controller._started = true;
               WritableStreamDealWithRejection(stream, r2);
+              return null;
             });
           }
           function SetUpWritableStreamDefaultControllerFromUnderlyingSink(stream, underlyingSink, highWaterMark, sizeAlgorithm) {
             const controller = Object.create(WritableStreamDefaultController.prototype);
-            let startAlgorithm = () => void 0;
-            let writeAlgorithm = () => promiseResolvedWith(void 0);
-            let closeAlgorithm = () => promiseResolvedWith(void 0);
-            let abortAlgorithm = () => promiseResolvedWith(void 0);
+            let startAlgorithm;
+            let writeAlgorithm;
+            let closeAlgorithm;
+            let abortAlgorithm;
             if (underlyingSink.start !== void 0) {
               startAlgorithm = () => underlyingSink.start(controller);
+            } else {
+              startAlgorithm = () => void 0;
             }
             if (underlyingSink.write !== void 0) {
               writeAlgorithm = (chunk) => underlyingSink.write(chunk, controller);
+            } else {
+              writeAlgorithm = () => promiseResolvedWith(void 0);
             }
             if (underlyingSink.close !== void 0) {
               closeAlgorithm = () => underlyingSink.close();
+            } else {
+              closeAlgorithm = () => promiseResolvedWith(void 0);
             }
             if (underlyingSink.abort !== void 0) {
               abortAlgorithm = (reason) => underlyingSink.abort(reason);
+            } else {
+              abortAlgorithm = () => promiseResolvedWith(void 0);
             }
             SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm);
           }
@@ -2299,8 +2529,10 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
             WritableStreamDefaultControllerClearAlgorithms(controller);
             uponPromise(sinkClosePromise, () => {
               WritableStreamFinishInFlightClose(stream);
+              return null;
             }, (reason) => {
               WritableStreamFinishInFlightCloseWithError(stream, reason);
+              return null;
             });
           }
           function WritableStreamDefaultControllerProcessWrite(controller, chunk) {
@@ -2316,11 +2548,13 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
                 WritableStreamUpdateBackpressure(stream, backpressure);
               }
               WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
+              return null;
             }, (reason) => {
               if (stream._state === "writable") {
                 WritableStreamDefaultControllerClearAlgorithms(controller);
               }
               WritableStreamFinishInFlightWriteWithError(stream, reason);
+              return null;
             });
           }
           function WritableStreamDefaultControllerGetBackpressure(controller) {
@@ -2421,19 +2655,36 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
             writer._readyPromise_reject = void 0;
             writer._readyPromiseState = "fulfilled";
           }
-          const NativeDOMException = typeof DOMException !== "undefined" ? DOMException : void 0;
+          function getGlobals() {
+            if (typeof globalThis !== "undefined") {
+              return globalThis;
+            } else if (typeof self !== "undefined") {
+              return self;
+            } else if (typeof global !== "undefined") {
+              return global;
+            }
+            return void 0;
+          }
+          const globals = getGlobals();
           function isDOMExceptionConstructor(ctor) {
             if (!(typeof ctor === "function" || typeof ctor === "object")) {
               return false;
             }
+            if (ctor.name !== "DOMException") {
+              return false;
+            }
             try {
               new ctor();
               return true;
-            } catch (_a) {
+            } catch (_a2) {
               return false;
             }
           }
-          function createDOMExceptionPolyfill() {
+          function getFromGlobal() {
+            const ctor = globals === null || globals === void 0 ? void 0 : globals.DOMException;
+            return isDOMExceptionConstructor(ctor) ? ctor : void 0;
+          }
+          function createPolyfill() {
             const ctor = function DOMException3(message, name) {
               this.message = message || "";
               this.name = name || "Error";
@@ -2441,11 +2692,12 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
                 Error.captureStackTrace(this, this.constructor);
               }
             };
+            setFunctionName(ctor, "DOMException");
             ctor.prototype = Object.create(Error.prototype);
             Object.defineProperty(ctor.prototype, "constructor", { value: ctor, writable: true, configurable: true });
             return ctor;
           }
-          const DOMException$1 = isDOMExceptionConstructor(NativeDOMException) ? NativeDOMException : createDOMExceptionPolyfill();
+          const DOMException2 = getFromGlobal() || createPolyfill();
           function ReadableStreamPipeTo(source, dest, preventClose, preventAbort, preventCancel, signal) {
             const reader = AcquireReadableStreamDefaultReader(source);
             const writer = AcquireWritableStreamDefaultWriter(dest);
@@ -2456,7 +2708,7 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
               let abortAlgorithm;
               if (signal !== void 0) {
                 abortAlgorithm = () => {
-                  const error = new DOMException$1("Aborted", "AbortError");
+                  const error = signal.reason !== void 0 ? signal.reason : new DOMException2("Aborted", "AbortError");
                   const actions = [];
                   if (!preventAbort) {
                     actions.push(() => {
@@ -2517,6 +2769,7 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
                 } else {
                   shutdown(true, storedError);
                 }
+                return null;
               });
               isOrBecomesErrored(dest, writer._closedPromise, (storedError) => {
                 if (!preventCancel) {
@@ -2524,6 +2777,7 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
                 } else {
                   shutdown(true, storedError);
                 }
+                return null;
               });
               isOrBecomesClosed(source, reader._closedPromise, () => {
                 if (!preventClose) {
@@ -2531,6 +2785,7 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
                 } else {
                   shutdown();
                 }
+                return null;
               });
               if (WritableStreamCloseQueuedOrInFlight(dest) || dest._state === "closed") {
                 const destClosed = new TypeError("the destination writable stream closed before all data could be piped to it");
@@ -2571,6 +2826,7 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
                 }
                 function doTheRest() {
                   uponPromise(action(), () => finalize(originalIsError, originalError), (newError) => finalize(true, newError));
+                  return null;
                 }
               }
               function shutdown(isError, error) {
@@ -2595,6 +2851,7 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
                 } else {
                   resolve(void 0);
                 }
+                return null;
               }
             });
           }
@@ -2667,6 +2924,9 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
                 ReadableStreamDefaultControllerCallPullIfNeeded(this);
               }
             }
+            /** @internal */
+            [ReleaseSteps]() {
+            }
           }
           Object.defineProperties(ReadableStreamDefaultController.prototype, {
             close: { enumerable: true },
@@ -2674,8 +2934,11 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
             error: { enumerable: true },
             desiredSize: { enumerable: true }
           });
-          if (typeof SymbolPolyfill.toStringTag === "symbol") {
-            Object.defineProperty(ReadableStreamDefaultController.prototype, SymbolPolyfill.toStringTag, {
+          setFunctionName(ReadableStreamDefaultController.prototype.close, "close");
+          setFunctionName(ReadableStreamDefaultController.prototype.enqueue, "enqueue");
+          setFunctionName(ReadableStreamDefaultController.prototype.error, "error");
+          if (typeof Symbol.toStringTag === "symbol") {
+            Object.defineProperty(ReadableStreamDefaultController.prototype, Symbol.toStringTag, {
               value: "ReadableStreamDefaultController",
               configurable: true
             });
@@ -2706,8 +2969,10 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
                 controller._pullAgain = false;
                 ReadableStreamDefaultControllerCallPullIfNeeded(controller);
               }
+              return null;
             }, (e2) => {
               ReadableStreamDefaultControllerError(controller, e2);
+              return null;
             });
           }
           function ReadableStreamDefaultControllerShouldCallPull(controller) {
@@ -2817,23 +3082,31 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
             uponPromise(promiseResolvedWith(startResult), () => {
               controller._started = true;
               ReadableStreamDefaultControllerCallPullIfNeeded(controller);
+              return null;
             }, (r2) => {
               ReadableStreamDefaultControllerError(controller, r2);
+              return null;
             });
           }
           function SetUpReadableStreamDefaultControllerFromUnderlyingSource(stream, underlyingSource, highWaterMark, sizeAlgorithm) {
             const controller = Object.create(ReadableStreamDefaultController.prototype);
-            let startAlgorithm = () => void 0;
-            let pullAlgorithm = () => promiseResolvedWith(void 0);
-            let cancelAlgorithm = () => promiseResolvedWith(void 0);
+            let startAlgorithm;
+            let pullAlgorithm;
+            let cancelAlgorithm;
             if (underlyingSource.start !== void 0) {
               startAlgorithm = () => underlyingSource.start(controller);
+            } else {
+              startAlgorithm = () => void 0;
             }
             if (underlyingSource.pull !== void 0) {
               pullAlgorithm = () => underlyingSource.pull(controller);
+            } else {
+              pullAlgorithm = () => promiseResolvedWith(void 0);
             }
             if (underlyingSource.cancel !== void 0) {
               cancelAlgorithm = (reason) => underlyingSource.cancel(reason);
+            } else {
+              cancelAlgorithm = () => promiseResolvedWith(void 0);
             }
             SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm);
           }
@@ -2868,7 +3141,7 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
               reading = true;
               const readRequest = {
                 _chunkSteps: (chunk) => {
-                  queueMicrotask(() => {
+                  _queueMicrotask(() => {
                     readAgain = false;
                     const chunk1 = chunk;
                     const chunk2 = chunk;
@@ -2933,6 +3206,7 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
               if (!canceled1 || !canceled2) {
                 resolveCancelPromise(void 0);
               }
+              return null;
             });
             return [branch1, branch2];
           }
@@ -2954,13 +3228,14 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
             function forwardReaderError(thisReader) {
               uponRejection(thisReader._closedPromise, (r2) => {
                 if (thisReader !== reader) {
-                  return;
+                  return null;
                 }
                 ReadableByteStreamControllerError(branch1._readableStreamController, r2);
                 ReadableByteStreamControllerError(branch2._readableStreamController, r2);
                 if (!canceled1 || !canceled2) {
                   resolveCancelPromise(void 0);
                 }
+                return null;
               });
             }
             function pullWithDefaultReader() {
@@ -2971,7 +3246,7 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
               }
               const readRequest = {
                 _chunkSteps: (chunk) => {
-                  queueMicrotask(() => {
+                  _queueMicrotask(() => {
                     readAgainForBranch1 = false;
                     readAgainForBranch2 = false;
                     const chunk1 = chunk;
@@ -3034,7 +3309,7 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
               const otherBranch = forBranch2 ? branch1 : branch2;
               const readIntoRequest = {
                 _chunkSteps: (chunk) => {
-                  queueMicrotask(() => {
+                  _queueMicrotask(() => {
                     readAgainForBranch1 = false;
                     readAgainForBranch2 = false;
                     const byobCanceled = forBranch2 ? canceled2 : canceled1;
@@ -3090,7 +3365,7 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
                   reading = false;
                 }
               };
-              ReadableStreamBYOBReaderRead(reader, view, readIntoRequest);
+              ReadableStreamBYOBReaderRead(reader, view, 1, readIntoRequest);
             }
             function pull1Algorithm() {
               if (reading) {
@@ -3148,6 +3423,100 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
             forwardReaderError(reader);
             return [branch1, branch2];
           }
+          function isReadableStreamLike(stream) {
+            return typeIsObject(stream) && typeof stream.getReader !== "undefined";
+          }
+          function ReadableStreamFrom(source) {
+            if (isReadableStreamLike(source)) {
+              return ReadableStreamFromDefaultReader(source.getReader());
+            }
+            return ReadableStreamFromIterable(source);
+          }
+          function ReadableStreamFromIterable(asyncIterable) {
+            let stream;
+            const iteratorRecord = GetIterator(asyncIterable, "async");
+            const startAlgorithm = noop;
+            function pullAlgorithm() {
+              let nextResult;
+              try {
+                nextResult = IteratorNext(iteratorRecord);
+              } catch (e2) {
+                return promiseRejectedWith(e2);
+              }
+              const nextPromise = promiseResolvedWith(nextResult);
+              return transformPromiseWith(nextPromise, (iterResult) => {
+                if (!typeIsObject(iterResult)) {
+                  throw new TypeError("The promise returned by the iterator.next() method must fulfill with an object");
+                }
+                const done = IteratorComplete(iterResult);
+                if (done) {
+                  ReadableStreamDefaultControllerClose(stream._readableStreamController);
+                } else {
+                  const value = IteratorValue(iterResult);
+                  ReadableStreamDefaultControllerEnqueue(stream._readableStreamController, value);
+                }
+              });
+            }
+            function cancelAlgorithm(reason) {
+              const iterator = iteratorRecord.iterator;
+              let returnMethod;
+              try {
+                returnMethod = GetMethod(iterator, "return");
+              } catch (e2) {
+                return promiseRejectedWith(e2);
+              }
+              if (returnMethod === void 0) {
+                return promiseResolvedWith(void 0);
+              }
+              let returnResult;
+              try {
+                returnResult = reflectCall(returnMethod, iterator, [reason]);
+              } catch (e2) {
+                return promiseRejectedWith(e2);
+              }
+              const returnPromise = promiseResolvedWith(returnResult);
+              return transformPromiseWith(returnPromise, (iterResult) => {
+                if (!typeIsObject(iterResult)) {
+                  throw new TypeError("The promise returned by the iterator.return() method must fulfill with an object");
+                }
+                return void 0;
+              });
+            }
+            stream = CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, 0);
+            return stream;
+          }
+          function ReadableStreamFromDefaultReader(reader) {
+            let stream;
+            const startAlgorithm = noop;
+            function pullAlgorithm() {
+              let readPromise;
+              try {
+                readPromise = reader.read();
+              } catch (e2) {
+                return promiseRejectedWith(e2);
+              }
+              return transformPromiseWith(readPromise, (readResult) => {
+                if (!typeIsObject(readResult)) {
+                  throw new TypeError("The promise returned by the reader.read() method must fulfill with an object");
+                }
+                if (readResult.done) {
+                  ReadableStreamDefaultControllerClose(stream._readableStreamController);
+                } else {
+                  const value = readResult.value;
+                  ReadableStreamDefaultControllerEnqueue(stream._readableStreamController, value);
+                }
+              });
+            }
+            function cancelAlgorithm(reason) {
+              try {
+                return promiseResolvedWith(reader.cancel(reason));
+              } catch (e2) {
+                return promiseRejectedWith(e2);
+              }
+            }
+            stream = CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, 0);
+            return stream;
+          }
           function convertUnderlyingDefaultOrByteSource(source, context) {
             assertDictionary(source, context);
             const original = source;
@@ -3183,20 +3552,6 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
             }
             return type;
           }
-          function convertReaderOptions(options, context) {
-            assertDictionary(options, context);
-            const mode = options === null || options === void 0 ? void 0 : options.mode;
-            return {
-              mode: mode === void 0 ? void 0 : convertReadableStreamReaderMode(mode, `${context} has member 'mode' that`)
-            };
-          }
-          function convertReadableStreamReaderMode(mode, context) {
-            mode = `${mode}`;
-            if (mode !== "byob") {
-              throw new TypeError(`${context} '${mode}' is not a valid enumeration value for ReadableStreamReaderMode`);
-            }
-            return mode;
-          }
           function convertIteratorOptions(options, context) {
             assertDictionary(options, context);
             const preventCancel = options === null || options === void 0 ? void 0 : options.preventCancel;
@@ -3355,7 +3710,22 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
               const options = convertIteratorOptions(rawOptions, "First parameter");
               return AcquireReadableStreamAsyncIterator(this, options.preventCancel);
             }
+            [SymbolAsyncIterator](options) {
+              return this.values(options);
+            }
+            /**
+             * Creates a new ReadableStream wrapping the provided iterable or async iterable.
+             *
+             * This can be used to adapt various kinds of objects into a readable stream,
+             * such as an array, an async generator, or a Node.js readable stream.
+             */
+            static from(asyncIterable) {
+              return ReadableStreamFrom(asyncIterable);
+            }
           }
+          Object.defineProperties(ReadableStream2, {
+            from: { enumerable: true }
+          });
           Object.defineProperties(ReadableStream2.prototype, {
             cancel: { enumerable: true },
             getReader: { enumerable: true },
@@ -3365,19 +3735,24 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
             values: { enumerable: true },
             locked: { enumerable: true }
           });
-          if (typeof SymbolPolyfill.toStringTag === "symbol") {
-            Object.defineProperty(ReadableStream2.prototype, SymbolPolyfill.toStringTag, {
+          setFunctionName(ReadableStream2.from, "from");
+          setFunctionName(ReadableStream2.prototype.cancel, "cancel");
+          setFunctionName(ReadableStream2.prototype.getReader, "getReader");
+          setFunctionName(ReadableStream2.prototype.pipeThrough, "pipeThrough");
+          setFunctionName(ReadableStream2.prototype.pipeTo, "pipeTo");
+          setFunctionName(ReadableStream2.prototype.tee, "tee");
+          setFunctionName(ReadableStream2.prototype.values, "values");
+          if (typeof Symbol.toStringTag === "symbol") {
+            Object.defineProperty(ReadableStream2.prototype, Symbol.toStringTag, {
               value: "ReadableStream",
               configurable: true
             });
           }
-          if (typeof SymbolPolyfill.asyncIterator === "symbol") {
-            Object.defineProperty(ReadableStream2.prototype, SymbolPolyfill.asyncIterator, {
-              value: ReadableStream2.prototype.values,
-              writable: true,
-              configurable: true
-            });
-          }
+          Object.defineProperty(ReadableStream2.prototype, SymbolAsyncIterator, {
+            value: ReadableStream2.prototype.values,
+            writable: true,
+            configurable: true
+          });
           function CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark = 1, sizeAlgorithm = () => 1) {
             const stream = Object.create(ReadableStream2.prototype);
             InitializeReadableStream(stream);
@@ -3424,10 +3799,11 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
             ReadableStreamClose(stream);
             const reader = stream._reader;
             if (reader !== void 0 && IsReadableStreamBYOBReader(reader)) {
-              reader._readIntoRequests.forEach((readIntoRequest) => {
+              const readIntoRequests = reader._readIntoRequests;
+              reader._readIntoRequests = new SimpleQueue();
+              readIntoRequests.forEach((readIntoRequest) => {
                 readIntoRequest._closeSteps(void 0);
               });
-              reader._readIntoRequests = new SimpleQueue();
             }
             const sourceCancelPromise = stream._readableStreamController[CancelSteps](reason);
             return transformPromiseWith(sourceCancelPromise, noop);
@@ -3440,10 +3816,11 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
             }
             defaultReaderClosedPromiseResolve(reader);
             if (IsReadableStreamDefaultReader(reader)) {
-              reader._readRequests.forEach((readRequest) => {
+              const readRequests = reader._readRequests;
+              reader._readRequests = new SimpleQueue();
+              readRequests.forEach((readRequest) => {
                 readRequest._closeSteps();
               });
-              reader._readRequests = new SimpleQueue();
             }
           }
           function ReadableStreamError(stream, e2) {
@@ -3455,15 +3832,9 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
             }
             defaultReaderClosedPromiseReject(reader, e2);
             if (IsReadableStreamDefaultReader(reader)) {
-              reader._readRequests.forEach((readRequest) => {
-                readRequest._errorSteps(e2);
-              });
-              reader._readRequests = new SimpleQueue();
+              ReadableStreamDefaultReaderErrorReadRequests(reader, e2);
             } else {
-              reader._readIntoRequests.forEach((readIntoRequest) => {
-                readIntoRequest._errorSteps(e2);
-              });
-              reader._readIntoRequests = new SimpleQueue();
+              ReadableStreamBYOBReaderErrorReadIntoRequests(reader, e2);
             }
           }
           function streamBrandCheckException$1(name) {
@@ -3480,13 +3851,7 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
           const byteLengthSizeFunction = (chunk) => {
             return chunk.byteLength;
           };
-          try {
-            Object.defineProperty(byteLengthSizeFunction, "name", {
-              value: "size",
-              configurable: true
-            });
-          } catch (_a) {
-          }
+          setFunctionName(byteLengthSizeFunction, "size");
           class ByteLengthQueuingStrategy {
             constructor(options) {
               assertRequiredArgument(options, 1, "ByteLengthQueuingStrategy");
@@ -3516,8 +3881,8 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
             highWaterMark: { enumerable: true },
             size: { enumerable: true }
           });
-          if (typeof SymbolPolyfill.toStringTag === "symbol") {
-            Object.defineProperty(ByteLengthQueuingStrategy.prototype, SymbolPolyfill.toStringTag, {
+          if (typeof Symbol.toStringTag === "symbol") {
+            Object.defineProperty(ByteLengthQueuingStrategy.prototype, Symbol.toStringTag, {
               value: "ByteLengthQueuingStrategy",
               configurable: true
             });
@@ -3537,13 +3902,7 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
           const countSizeFunction = () => {
             return 1;
           };
-          try {
-            Object.defineProperty(countSizeFunction, "name", {
-              value: "size",
-              configurable: true
-            });
-          } catch (_a) {
-          }
+          setFunctionName(countSizeFunction, "size");
           class CountQueuingStrategy {
             constructor(options) {
               assertRequiredArgument(options, 1, "CountQueuingStrategy");
@@ -3574,8 +3933,8 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
             highWaterMark: { enumerable: true },
             size: { enumerable: true }
           });
-          if (typeof SymbolPolyfill.toStringTag === "symbol") {
-            Object.defineProperty(CountQueuingStrategy.prototype, SymbolPolyfill.toStringTag, {
+          if (typeof Symbol.toStringTag === "symbol") {
+            Object.defineProperty(CountQueuingStrategy.prototype, Symbol.toStringTag, {
               value: "CountQueuingStrategy",
               configurable: true
             });
@@ -3594,12 +3953,14 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
           }
           function convertTransformer(original, context) {
             assertDictionary(original, context);
+            const cancel = original === null || original === void 0 ? void 0 : original.cancel;
             const flush = original === null || original === void 0 ? void 0 : original.flush;
             const readableType = original === null || original === void 0 ? void 0 : original.readableType;
             const start = original === null || original === void 0 ? void 0 : original.start;
             const transform = original === null || original === void 0 ? void 0 : original.transform;
             const writableType = original === null || original === void 0 ? void 0 : original.writableType;
             return {
+              cancel: cancel === void 0 ? void 0 : convertTransformerCancelCallback(cancel, original, `${context} has member 'cancel' that`),
               flush: flush === void 0 ? void 0 : convertTransformerFlushCallback(flush, original, `${context} has member 'flush' that`),
               readableType,
               start: start === void 0 ? void 0 : convertTransformerStartCallback(start, original, `${context} has member 'start' that`),
@@ -3619,6 +3980,10 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
             assertFunction(fn, context);
             return (chunk, controller) => promiseCall(fn, original, [chunk, controller]);
           }
+          function convertTransformerCancelCallback(fn, original, context) {
+            assertFunction(fn, context);
+            return (reason) => promiseCall(fn, original, [reason]);
+          }
           class TransformStream {
             constructor(rawTransformer = {}, rawWritableStrategy = {}, rawReadableStrategy = {}) {
               if (rawTransformer === void 0) {
@@ -3672,8 +4037,8 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
             readable: { enumerable: true },
             writable: { enumerable: true }
           });
-          if (typeof SymbolPolyfill.toStringTag === "symbol") {
-            Object.defineProperty(TransformStream.prototype, SymbolPolyfill.toStringTag, {
+          if (typeof Symbol.toStringTag === "symbol") {
+            Object.defineProperty(TransformStream.prototype, Symbol.toStringTag, {
               value: "TransformStream",
               configurable: true
             });
@@ -3696,8 +4061,7 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
               return TransformStreamDefaultSourcePullAlgorithm(stream);
             }
             function cancelAlgorithm(reason) {
-              TransformStreamErrorWritableAndUnblockWrite(stream, reason);
-              return promiseResolvedWith(void 0);
+              return TransformStreamDefaultSourceCancelAlgorithm(stream, reason);
             }
             stream._readable = CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, readableHighWaterMark, readableSizeAlgorithm);
             stream._backpressure = void 0;
@@ -3722,6 +4086,9 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
           function TransformStreamErrorWritableAndUnblockWrite(stream, e2) {
             TransformStreamDefaultControllerClearAlgorithms(stream._transformStreamController);
             WritableStreamDefaultControllerErrorIfNeeded(stream._writable._writableStreamController, e2);
+            TransformStreamUnblockWrite(stream);
+          }
+          function TransformStreamUnblockWrite(stream) {
             if (stream._backpressure) {
               TransformStreamSetBackpressure(stream, false);
             }
@@ -3782,8 +4149,11 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
             terminate: { enumerable: true },
             desiredSize: { enumerable: true }
           });
-          if (typeof SymbolPolyfill.toStringTag === "symbol") {
-            Object.defineProperty(TransformStreamDefaultController.prototype, SymbolPolyfill.toStringTag, {
+          setFunctionName(TransformStreamDefaultController.prototype.enqueue, "enqueue");
+          setFunctionName(TransformStreamDefaultController.prototype.error, "error");
+          setFunctionName(TransformStreamDefaultController.prototype.terminate, "terminate");
+          if (typeof Symbol.toStringTag === "symbol") {
+            Object.defineProperty(TransformStreamDefaultController.prototype, Symbol.toStringTag, {
               value: "TransformStreamDefaultController",
               configurable: true
             });
@@ -3797,34 +4167,49 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
             }
             return x2 instanceof TransformStreamDefaultController;
           }
-          function SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm) {
+          function SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm, cancelAlgorithm) {
             controller._controlledTransformStream = stream;
             stream._transformStreamController = controller;
             controller._transformAlgorithm = transformAlgorithm;
             controller._flushAlgorithm = flushAlgorithm;
+            controller._cancelAlgorithm = cancelAlgorithm;
+            controller._finishPromise = void 0;
+            controller._finishPromise_resolve = void 0;
+            controller._finishPromise_reject = void 0;
           }
           function SetUpTransformStreamDefaultControllerFromTransformer(stream, transformer) {
             const controller = Object.create(TransformStreamDefaultController.prototype);
-            let transformAlgorithm = (chunk) => {
-              try {
-                TransformStreamDefaultControllerEnqueue(controller, chunk);
-                return promiseResolvedWith(void 0);
-              } catch (transformResultE) {
-                return promiseRejectedWith(transformResultE);
-              }
-            };
-            let flushAlgorithm = () => promiseResolvedWith(void 0);
+            let transformAlgorithm;
+            let flushAlgorithm;
+            let cancelAlgorithm;
             if (transformer.transform !== void 0) {
               transformAlgorithm = (chunk) => transformer.transform(chunk, controller);
+            } else {
+              transformAlgorithm = (chunk) => {
+                try {
+                  TransformStreamDefaultControllerEnqueue(controller, chunk);
+                  return promiseResolvedWith(void 0);
+                } catch (transformResultE) {
+                  return promiseRejectedWith(transformResultE);
+                }
+              };
             }
             if (transformer.flush !== void 0) {
               flushAlgorithm = () => transformer.flush(controller);
+            } else {
+              flushAlgorithm = () => promiseResolvedWith(void 0);
+            }
+            if (transformer.cancel !== void 0) {
+              cancelAlgorithm = (reason) => transformer.cancel(reason);
+            } else {
+              cancelAlgorithm = () => promiseResolvedWith(void 0);
             }
-            SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm);
+            SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm, cancelAlgorithm);
           }
           function TransformStreamDefaultControllerClearAlgorithms(controller) {
             controller._transformAlgorithm = void 0;
             controller._flushAlgorithm = void 0;
+            controller._cancelAlgorithm = void 0;
           }
           function TransformStreamDefaultControllerEnqueue(controller, chunk) {
             const stream = controller._controlledTransformStream;
@@ -3876,31 +4261,112 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
             return TransformStreamDefaultControllerPerformTransform(controller, chunk);
           }
           function TransformStreamDefaultSinkAbortAlgorithm(stream, reason) {
-            TransformStreamError(stream, reason);
-            return promiseResolvedWith(void 0);
+            const controller = stream._transformStreamController;
+            if (controller._finishPromise !== void 0) {
+              return controller._finishPromise;
+            }
+            const readable = stream._readable;
+            controller._finishPromise = newPromise((resolve, reject) => {
+              controller._finishPromise_resolve = resolve;
+              controller._finishPromise_reject = reject;
+            });
+            const cancelPromise = controller._cancelAlgorithm(reason);
+            TransformStreamDefaultControllerClearAlgorithms(controller);
+            uponPromise(cancelPromise, () => {
+              if (readable._state === "errored") {
+                defaultControllerFinishPromiseReject(controller, readable._storedError);
+              } else {
+                ReadableStreamDefaultControllerError(readable._readableStreamController, reason);
+                defaultControllerFinishPromiseResolve(controller);
+              }
+              return null;
+            }, (r2) => {
+              ReadableStreamDefaultControllerError(readable._readableStreamController, r2);
+              defaultControllerFinishPromiseReject(controller, r2);
+              return null;
+            });
+            return controller._finishPromise;
           }
           function TransformStreamDefaultSinkCloseAlgorithm(stream) {
-            const readable = stream._readable;
             const controller = stream._transformStreamController;
+            if (controller._finishPromise !== void 0) {
+              return controller._finishPromise;
+            }
+            const readable = stream._readable;
+            controller._finishPromise = newPromise((resolve, reject) => {
+              controller._finishPromise_resolve = resolve;
+              controller._finishPromise_reject = reject;
+            });
             const flushPromise = controller._flushAlgorithm();
             TransformStreamDefaultControllerClearAlgorithms(controller);
-            return transformPromiseWith(flushPromise, () => {
+            uponPromise(flushPromise, () => {
               if (readable._state === "errored") {
-                throw readable._storedError;
+                defaultControllerFinishPromiseReject(controller, readable._storedError);
+              } else {
+                ReadableStreamDefaultControllerClose(readable._readableStreamController);
+                defaultControllerFinishPromiseResolve(controller);
               }
-              ReadableStreamDefaultControllerClose(readable._readableStreamController);
+              return null;
             }, (r2) => {
-              TransformStreamError(stream, r2);
-              throw readable._storedError;
+              ReadableStreamDefaultControllerError(readable._readableStreamController, r2);
+              defaultControllerFinishPromiseReject(controller, r2);
+              return null;
             });
+            return controller._finishPromise;
           }
           function TransformStreamDefaultSourcePullAlgorithm(stream) {
             TransformStreamSetBackpressure(stream, false);
             return stream._backpressureChangePromise;
           }
+          function TransformStreamDefaultSourceCancelAlgorithm(stream, reason) {
+            const controller = stream._transformStreamController;
+            if (controller._finishPromise !== void 0) {
+              return controller._finishPromise;
+            }
+            const writable = stream._writable;
+            controller._finishPromise = newPromise((resolve, reject) => {
+              controller._finishPromise_resolve = resolve;
+              controller._finishPromise_reject = reject;
+            });
+            const cancelPromise = controller._cancelAlgorithm(reason);
+            TransformStreamDefaultControllerClearAlgorithms(controller);
+            uponPromise(cancelPromise, () => {
+              if (writable._state === "errored") {
+                defaultControllerFinishPromiseReject(controller, writable._storedError);
+              } else {
+                WritableStreamDefaultControllerErrorIfNeeded(writable._writableStreamController, reason);
+                TransformStreamUnblockWrite(stream);
+                defaultControllerFinishPromiseResolve(controller);
+              }
+              return null;
+            }, (r2) => {
+              WritableStreamDefaultControllerErrorIfNeeded(writable._writableStreamController, r2);
+              TransformStreamUnblockWrite(stream);
+              defaultControllerFinishPromiseReject(controller, r2);
+              return null;
+            });
+            return controller._finishPromise;
+          }
           function defaultControllerBrandCheckException(name) {
             return new TypeError(`TransformStreamDefaultController.prototype.${name} can only be used on a TransformStreamDefaultController`);
           }
+          function defaultControllerFinishPromiseResolve(controller) {
+            if (controller._finishPromise_resolve === void 0) {
+              return;
+            }
+            controller._finishPromise_resolve();
+            controller._finishPromise_resolve = void 0;
+            controller._finishPromise_reject = void 0;
+          }
+          function defaultControllerFinishPromiseReject(controller, reason) {
+            if (controller._finishPromise_reject === void 0) {
+              return;
+            }
+            setPromiseIsHandledToTrue(controller._finishPromise);
+            controller._finishPromise_reject(reason);
+            controller._finishPromise_resolve = void 0;
+            controller._finishPromise_reject = void 0;
+          }
           function streamBrandCheckException(name) {
             return new TypeError(`TransformStream.prototype.${name} can only be used on a TransformStream`);
           }
@@ -3917,7 +4383,6 @@ var require_chunk_RXM4EBGR = (0, import_chunk_2ESYSVXG.__commonJS)({
           exports22.WritableStream = WritableStream;
           exports22.WritableStreamDefaultController = WritableStreamDefaultController;
           exports22.WritableStreamDefaultWriter = WritableStreamDefaultWriter;
-          Object.defineProperty(exports22, "__esModule", { value: true });
         });
       }
     });
@@ -4305,8 +4770,8 @@ Content-Type: ${v.type || "application/octet-stream"}\r
     var { stat } = import_node_fs.promises;
   }
 });
-var require_multipart_parser_ASKQAOL4 = (0, import_chunk_2ESYSVXG.__commonJS)({
-  "../fetch-engine/dist/multipart-parser-ASKQAOL4.js"(exports, module2) {
+var require_multipart_parser_AOASR4DL = (0, import_chunk_2ESYSVXG.__commonJS)({
+  "../fetch-engine/dist/multipart-parser-AOASR4DL.js"(exports, module2) {
     var __defProp2 = Object.defineProperty;
     var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
     var __getOwnPropNames2 = Object.getOwnPropertyNames;
@@ -4324,12 +4789,12 @@ var require_multipart_parser_ASKQAOL4 = (0, import_chunk_2ESYSVXG.__commonJS)({
       return to;
     };
     var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
-    var multipart_parser_ASKQAOL4_exports = {};
-    __export2(multipart_parser_ASKQAOL4_exports, {
+    var multipart_parser_AOASR4DL_exports = {};
+    __export2(multipart_parser_AOASR4DL_exports, {
       toFormData: () => toFormData
     });
-    module2.exports = __toCommonJS2(multipart_parser_ASKQAOL4_exports);
-    var import_chunk_RXM4EBGR = require_chunk_RXM4EBGR();
+    module2.exports = __toCommonJS2(multipart_parser_AOASR4DL_exports);
+    var import_chunk_BYDIRBHB = require_chunk_BYDIRBHB();
     var import_chunk_QGM4M3NI = require_chunk_QGM4M3NI();
     var s = 0;
     var S = {
@@ -4622,7 +5087,7 @@ var require_multipart_parser_ASKQAOL4 = (0, import_chunk_2ESYSVXG.__commonJS)({
       let contentType;
       let filename;
       const entryChunks = [];
-      const formData = new import_chunk_RXM4EBGR.FormData();
+      const formData = new import_chunk_BYDIRBHB.FormData();
       const onPartData = (ui8a) => {
         entryValue += decoder.decode(ui8a, { stream: true });
       };
@@ -4630,7 +5095,7 @@ var require_multipart_parser_ASKQAOL4 = (0, import_chunk_2ESYSVXG.__commonJS)({
         entryChunks.push(ui8a);
       };
       const appendFileToFormData = () => {
-        const file = new import_chunk_RXM4EBGR.file_default(entryChunks, filename, { type: contentType });
+        const file = new import_chunk_BYDIRBHB.file_default(entryChunks, filename, { type: contentType });
         formData.append(entryName, file);
       };
       const appendEntryToFormData = () => {
@@ -4682,9 +5147,18 @@ var require_multipart_parser_ASKQAOL4 = (0, import_chunk_2ESYSVXG.__commonJS)({
     }
   }
 });
-var multipart_parser_ASKQAOL4_WZ47HU6G_default = require_multipart_parser_ASKQAOL4();
+var multipart_parser_AOASR4DL_AXIJXW2B_default = require_multipart_parser_AOASR4DL();
 /*! Bundled license information:
 
+web-streams-polyfill/dist/ponyfill.es2018.js:
+  (**
+   * @license
+   * web-streams-polyfill v3.3.3
+   * Copyright 2024 Mattias Buelens, Diwank Singh Tomer and other contributors.
+   * This code is released under the MIT license.
+   * SPDX-License-Identifier: MIT
+   *)
+
 node-domexception/index.js:
   (*! node-domexception. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> *)