web-streams-polyfill 3.2.0 → 3.3.0

package/dist/polyfill.es6.mjs

@@ -1,44 +1,48 @@
 /**
- * web-streams-polyfill v3.2.0
+ * @license
+ * web-streams-polyfill v3.3.0
+ * Copyright 2024 Mattias Buelens, Diwank Singh Tomer and other contributors.
+ * This code is released under the MIT license.
+ * SPDX-License-Identifier: MIT
  */
 /// <reference lib="es2015.symbol" />
 const SymbolPolyfill = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol' ?
     Symbol :
     description => `Symbol(${description})`;
 
-/// <reference lib="dom" />
 function noop() {
     return undefined;
 }
-function getGlobals() {
-    if (typeof self !== 'undefined') {
-        return self;
-    }
-    else if (typeof window !== 'undefined') {
-        return window;
-    }
-    else if (typeof global !== 'undefined') {
-        return global;
-    }
-    return undefined;
-}
-const globals = getGlobals();
 
 function typeIsObject(x) {
     return (typeof x === 'object' && x !== null) || typeof x === 'function';
 }
 const rethrowAssertionErrorRejection = noop;
+function setFunctionName(fn, name) {
+    try {
+        Object.defineProperty(fn, 'name', {
+            value: name,
+            configurable: true
+        });
+    }
+    catch (_a) {
+        // This property is non-configurable in older browsers, so ignore if this throws.
+        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name#browser_compatibility
+    }
+}
 
 const originalPromise = Promise;
 const originalPromiseThen = Promise.prototype.then;
-const originalPromiseResolve = Promise.resolve.bind(originalPromise);
 const originalPromiseReject = Promise.reject.bind(originalPromise);
+// https://webidl.spec.whatwg.org/#a-new-promise
 function newPromise(executor) {
     return new originalPromise(executor);
 }
+// https://webidl.spec.whatwg.org/#a-promise-resolved-with
 function promiseResolvedWith(value) {
-    return originalPromiseResolve(value);
+    return newPromise(resolve => resolve(value));
 }
+// https://webidl.spec.whatwg.org/#a-promise-rejected-with
 function promiseRejectedWith(reason) {
     return originalPromiseReject(reason);
 }
@@ -47,6 +51,9 @@ function PerformPromiseThen(promise, onFulfilled, onRejected) {
     // approximation.
     return originalPromiseThen.call(promise, onFulfilled, onRejected);
 }
+// Bluebird logs a warning when a promise is created within a fulfillment handler, but then isn't returned
+// from that handler. To prevent this, return null instead of void from all handlers.
+// http://bluebirdjs.com/docs/warning-explanations.html#warning-a-promise-was-created-in-a-handler-but-was-not-returned-from-it
 function uponPromise(promise, onFulfilled, onRejected) {
     PerformPromiseThen(PerformPromiseThen(promise, onFulfilled, onRejected), undefined, rethrowAssertionErrorRejection);
 }
@@ -62,14 +69,16 @@ function transformPromiseWith(promise, fulfillmentHandler, rejectionHandler) {
 function setPromiseIsHandledToTrue(promise) {
     PerformPromiseThen(promise, undefined, rethrowAssertionErrorRejection);
 }
-const queueMicrotask = (() => {
-    const globalQueueMicrotask = globals && globals.queueMicrotask;
-    if (typeof globalQueueMicrotask === 'function') {
-        return globalQueueMicrotask;
+let _queueMicrotask = callback => {
+    if (typeof queueMicrotask === 'function') {
+        _queueMicrotask = queueMicrotask;
     }
-    const resolvedPromise = promiseResolvedWith(undefined);
-    return (fn) => PerformPromiseThen(resolvedPromise, fn);
-})();
+    else {
+        const resolvedPromise = promiseResolvedWith(undefined);
+        _queueMicrotask = cb => PerformPromiseThen(resolvedPromise, cb);
+    }
+    return _queueMicrotask(callback);
+};
 function reflectCall(F, V, args) {
     if (typeof F !== 'function') {
         throw new TypeError('Argument is not a function');
@@ -193,6 +202,12 @@ class SimpleQueue {
     }
 }
 
+const AbortSteps = SymbolPolyfill('[[AbortSteps]]');
+const ErrorSteps = SymbolPolyfill('[[ErrorSteps]]');
+const CancelSteps = SymbolPolyfill('[[CancelSteps]]');
+const PullSteps = SymbolPolyfill('[[PullSteps]]');
+const ReleaseSteps = SymbolPolyfill('[[ReleaseSteps]]');
+
 function ReadableStreamReaderGenericInitialize(reader, stream) {
     reader._ownerReadableStream = stream;
     stream._reader = reader;
@@ -213,13 +228,15 @@ function ReadableStreamReaderGenericCancel(reader, reason) {
     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 = undefined;
+    stream._readableStreamController[ReleaseSteps]();
+    stream._reader = undefined;
     reader._ownerReadableStream = undefined;
 }
 // Helper functions for the readers.
@@ -262,11 +279,6 @@ function defaultReaderClosedPromiseResolve(reader) {
     reader._closedPromise_reject = undefined;
 }
 
-const AbortSteps = SymbolPolyfill('[[AbortSteps]]');
-const ErrorSteps = SymbolPolyfill('[[ErrorSteps]]');
-const CancelSteps = SymbolPolyfill('[[CancelSteps]]');
-const PullSteps = SymbolPolyfill('[[PullSteps]]');
-
 /// <reference lib="es2015.core" />
 // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isFinite#Polyfill
 const NumberIsFinite = Number.isFinite || function (x) {
@@ -462,10 +474,7 @@ class ReadableStreamDefaultReader {
         if (this._ownerReadableStream === undefined) {
             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, {
@@ -474,6 +483,9 @@ Object.defineProperties(ReadableStreamDefaultReader.prototype, {
     releaseLock: { enumerable: true },
     closed: { enumerable: true }
 });
+setFunctionName(ReadableStreamDefaultReader.prototype.cancel, 'cancel');
+setFunctionName(ReadableStreamDefaultReader.prototype.read, 'read');
+setFunctionName(ReadableStreamDefaultReader.prototype.releaseLock, 'releaseLock');
 if (typeof SymbolPolyfill.toStringTag === 'symbol') {
     Object.defineProperty(ReadableStreamDefaultReader.prototype, SymbolPolyfill.toStringTag, {
         value: 'ReadableStreamDefaultReader',
@@ -503,6 +515,18 @@ function ReadableStreamDefaultReaderRead(reader, readRequest) {
         stream._readableStreamController[PullSteps](readRequest);
     }
 }
+function ReadableStreamDefaultReaderRelease(reader) {
+    ReadableStreamReaderGenericRelease(reader);
+    const e = new TypeError('Reader was released');
+    ReadableStreamDefaultReaderErrorReadRequests(reader, e);
+}
+function ReadableStreamDefaultReaderErrorReadRequests(reader, e) {
+    const readRequests = reader._readRequests;
+    reader._readRequests = new SimpleQueue();
+    readRequests.forEach(readRequest => {
+        readRequest._errorSteps(e);
+    });
+}
 // Helper functions for the ReadableStreamDefaultReader.
 function defaultReaderBrandCheckException(name) {
     return new TypeError(`ReadableStreamDefaultReader.prototype.${name} can only be used on a ReadableStreamDefaultReader`);
@@ -549,9 +573,6 @@ class ReadableStreamAsyncIteratorImpl {
             return Promise.resolve({ value: undefined, done: true });
         }
         const reader = this._reader;
-        if (reader._ownerReadableStream === undefined) {
-            return promiseRejectedWith(readerLockException('iterate'));
-        }
         let resolvePromise;
         let rejectPromise;
         const promise = newPromise((resolve, reject) => {
@@ -563,7 +584,7 @@ class ReadableStreamAsyncIteratorImpl {
                 this._ongoingPromise = undefined;
                 // This needs to be delayed by one microtask, otherwise we stop pulling too early which breaks a test.
                 // FIXME Is this a bug in the specification, or in the test?
-                queueMicrotask(() => resolvePromise({ value: chunk, done: false }));
+                _queueMicrotask(() => resolvePromise({ value: chunk, done: false }));
             },
             _closeSteps: () => {
                 this._ongoingPromise = undefined;
@@ -587,9 +608,6 @@ class ReadableStreamAsyncIteratorImpl {
         }
         this._isFinished = true;
         const reader = this._reader;
-        if (reader._ownerReadableStream === undefined) {
-            return promiseRejectedWith(readerLockException('finish iterating'));
-        }
         if (!this._preventCancel) {
             const result = ReadableStreamReaderGenericCancel(reader, value);
             ReadableStreamReaderGenericRelease(reader);
@@ -652,6 +670,70 @@ const NumberIsNaN = Number.isNaN || function (x) {
     return x !== x;
 };
 
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol */
+
+
+function __values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+
+function __await(v) {
+    return this instanceof __await ? (this.v = v, this) : new __await(v);
+}
+
+function __asyncGenerator(thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+}
+
+function __asyncDelegator(o) {
+    var i, p;
+    return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
+    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }
+}
+
+function __asyncValues(o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
 function CreateArrayFromList(elements) {
     // We use arrays to represent lists, so this is basically a no-op.
     // Do a slice though just in case we happen to depend on the unique-ness.
@@ -660,15 +742,29 @@ function CreateArrayFromList(elements) {
 function CopyDataBlockBytes(dest, destOffset, src, srcOffset, n) {
     new Uint8Array(dest).set(new Uint8Array(src, srcOffset, n), destOffset);
 }
-// Not implemented correctly
-function TransferArrayBuffer(O) {
-    return O;
-}
-// Not implemented correctly
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-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 {
+        // Not implemented correctly
+        TransferArrayBuffer = buffer => buffer;
+    }
+    return TransferArrayBuffer(O);
+};
+let IsDetachedBuffer = (O) => {
+    if (typeof O.detached === 'boolean') {
+        IsDetachedBuffer = buffer => buffer.detached;
+    }
+    else {
+        // Not implemented correctly
+        IsDetachedBuffer = buffer => buffer.byteLength === 0;
+    }
+    return IsDetachedBuffer(O);
+};
 function ArrayBufferSlice(buffer, begin, end) {
     // ArrayBuffer.prototype.slice is not available on IE10
     // https://www.caniuse.com/mdn-javascript_builtins_arraybuffer_slice
@@ -680,6 +776,70 @@ function ArrayBufferSlice(buffer, begin, end) {
     CopyDataBlockBytes(slice, 0, buffer, begin, length);
     return slice;
 }
+function GetMethod(receiver, prop) {
+    const func = receiver[prop];
+    if (func === undefined || func === null) {
+        return undefined;
+    }
+    if (typeof func !== 'function') {
+        throw new TypeError(`${String(prop)} is not a function`);
+    }
+    return func;
+}
+function CreateAsyncFromSyncIterator(syncIteratorRecord) {
+    // Instead of re-implementing CreateAsyncFromSyncIterator and %AsyncFromSyncIteratorPrototype%,
+    // we use yield* inside an async generator function to achieve the same result.
+    // Wrap the sync iterator inside a sync iterable, so we can use it with yield*.
+    const syncIterable = {
+        [SymbolPolyfill.iterator]: () => syncIteratorRecord.iterator
+    };
+    // Create an async generator function and immediately invoke it.
+    const asyncIterator = (function () {
+        return __asyncGenerator(this, arguments, function* () {
+            return yield __await(yield __await(yield* __asyncDelegator(__asyncValues(syncIterable))));
+        });
+    }());
+    // Return as an async iterator record.
+    const nextMethod = asyncIterator.next;
+    return { iterator: asyncIterator, nextMethod, done: false };
+}
+function GetIterator(obj, hint = 'sync', method) {
+    if (method === undefined) {
+        if (hint === 'async') {
+            method = GetMethod(obj, SymbolPolyfill.asyncIterator);
+            if (method === undefined) {
+                const syncMethod = GetMethod(obj, SymbolPolyfill.iterator);
+                const syncIteratorRecord = GetIterator(obj, 'sync', syncMethod);
+                return CreateAsyncFromSyncIterator(syncIteratorRecord);
+            }
+        }
+        else {
+            method = GetMethod(obj, SymbolPolyfill.iterator);
+        }
+    }
+    if (method === undefined) {
+        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') {
@@ -722,6 +882,19 @@ function ResetQueue(container) {
     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;
+}
+
 /**
  * A pull-into request in a {@link ReadableByteStreamController}.
  *
@@ -749,7 +922,9 @@ class ReadableStreamBYOBRequest {
         if (this._associatedReadableByteStreamController === undefined) {
             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) {
@@ -763,7 +938,9 @@ class ReadableStreamBYOBRequest {
         if (this._associatedReadableByteStreamController === undefined) {
             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);
     }
 }
@@ -772,6 +949,8 @@ Object.defineProperties(ReadableStreamBYOBRequest.prototype, {
     respondWithNewView: { enumerable: true },
     view: { enumerable: true }
 });
+setFunctionName(ReadableStreamBYOBRequest.prototype.respond, 'respond');
+setFunctionName(ReadableStreamBYOBRequest.prototype.respondWithNewView, 'respondWithNewView');
 if (typeof SymbolPolyfill.toStringTag === 'symbol') {
     Object.defineProperty(ReadableStreamBYOBRequest.prototype, SymbolPolyfill.toStringTag, {
         value: 'ReadableStreamBYOBRequest',
@@ -867,11 +1046,7 @@ class ReadableByteStreamController {
     [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;
@@ -890,6 +1065,7 @@ class ReadableByteStreamController {
                 byteOffset: 0,
                 byteLength: autoAllocateChunkSize,
                 bytesFilled: 0,
+                minimumFill: 1,
                 elementSize: 1,
                 viewConstructor: Uint8Array,
                 readerType: 'default'
@@ -899,6 +1075,15 @@ class ReadableByteStreamController {
         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 },
@@ -907,6 +1092,9 @@ Object.defineProperties(ReadableByteStreamController.prototype, {
     byobRequest: { enumerable: true },
     desiredSize: { enumerable: true }
 });
+setFunctionName(ReadableByteStreamController.prototype.close, 'close');
+setFunctionName(ReadableByteStreamController.prototype.enqueue, 'enqueue');
+setFunctionName(ReadableByteStreamController.prototype.error, 'error');
 if (typeof SymbolPolyfill.toStringTag === 'symbol') {
     Object.defineProperty(ReadableByteStreamController.prototype, SymbolPolyfill.toStringTag, {
         value: 'ReadableByteStreamController',
@@ -950,8 +1138,10 @@ function ReadableByteStreamControllerCallPullIfNeeded(controller) {
             controller._pullAgain = false;
             ReadableByteStreamControllerCallPullIfNeeded(controller);
         }
+        return null;
     }, e => {
         ReadableByteStreamControllerError(controller, e);
+        return null;
     });
 }
 function ReadableByteStreamControllerClearPendingPullIntos(controller) {
@@ -980,15 +1170,33 @@ function ReadableByteStreamControllerEnqueueChunkToQueue(controller, buffer, byt
     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;
+    // A descriptor for a read() request that is not yet filled up to its minimum length will stay at the head
+    // of the queue, so the underlying source can keep filling it.
+    if (maxAlignedBytes >= pullIntoDescriptor.minimumFill) {
         totalBytesToCopyRemaining = maxAlignedBytes - pullIntoDescriptor.bytesFilled;
         ready = true;
     }
@@ -1043,25 +1251,37 @@ function ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(contro
         }
     }
 }
-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;
-    // try {
-    const buffer = TransferArrayBuffer(view.buffer);
-    // } catch (e) {
-    //   readIntoRequest._errorSteps(e);
-    //   return;
-    // }
+    const elementSize = arrayBufferViewElementSize(ctor);
+    const { byteOffset, byteLength } = view;
+    const minimumFill = min * elementSize;
+    let buffer;
+    try {
+        buffer = TransferArrayBuffer(view.buffer);
+    }
+    catch (e) {
+        readIntoRequest._errorSteps(e);
+        return;
+    }
     const pullIntoDescriptor = {
         buffer,
         bufferByteLength: buffer.byteLength,
-        byteOffset: view.byteOffset,
-        byteLength: view.byteLength,
+        byteOffset,
+        byteLength,
         bytesFilled: 0,
+        minimumFill,
         elementSize,
         viewConstructor: ctor,
         readerType: 'byob'
@@ -1098,6 +1318,9 @@ function ReadableByteStreamControllerPullInto(controller, view, readIntoRequest)
     ReadableByteStreamControllerCallPullIfNeeded(controller);
 }
 function ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor) {
+    if (firstDescriptor.readerType === 'none') {
+        ReadableByteStreamControllerShiftPendingPullInto(controller);
+    }
     const stream = controller._controlledReadableByteStream;
     if (ReadableStreamHasBYOBReader(stream)) {
         while (ReadableStreamGetNumReadIntoRequests(stream) > 0) {
@@ -1108,15 +1331,21 @@ function ReadableByteStreamControllerRespondInClosedState(controller, firstDescr
 }
 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) {
+        // A descriptor for a read() request that is not yet filled up to its minimum length will stay at the head
+        // of the queue, so the underlying source can keep filling it.
         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);
@@ -1127,7 +1356,7 @@ function ReadableByteStreamControllerRespondInternal(controller, bytesWritten) {
     ReadableByteStreamControllerInvalidateBYOBRequest(controller);
     const state = controller._controlledReadableByteStream._state;
     if (state === 'closed') {
-        ReadableByteStreamControllerRespondInClosedState(controller);
+        ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor);
     }
     else {
         ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, firstDescriptor);
@@ -1177,7 +1406,7 @@ function ReadableByteStreamControllerClose(controller) {
     }
     if (controller._pendingPullIntos.length > 0) {
         const firstPendingPullInto = controller._pendingPullIntos.peek();
-        if (firstPendingPullInto.bytesFilled > 0) {
+        if (firstPendingPullInto.bytesFilled % firstPendingPullInto.elementSize !== 0) {
             const e = new TypeError('Insufficient bytes to fill elements in the given buffer');
             ReadableByteStreamControllerError(controller, e);
             throw e;
@@ -1191,17 +1420,24 @@ function ReadableByteStreamControllerEnqueue(controller, chunk) {
     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);
         }
@@ -1233,6 +1469,13 @@ function ReadableByteStreamControllerError(controller, e) {
     ReadableByteStreamControllerClearAlgorithms(controller);
     ReadableStreamError(stream, e);
 }
+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();
@@ -1318,24 +1561,35 @@ function SetUpReadableByteStreamController(stream, controller, startAlgorithm, p
     uponPromise(promiseResolvedWith(startResult), () => {
         controller._started = true;
         ReadableByteStreamControllerCallPullIfNeeded(controller);
+        return null;
     }, r => {
         ReadableByteStreamControllerError(controller, r);
+        return null;
     });
 }
 function SetUpReadableByteStreamControllerFromUnderlyingSource(stream, underlyingByteSource, highWaterMark) {
     const controller = Object.create(ReadableByteStreamController.prototype);
-    let startAlgorithm = () => undefined;
-    let pullAlgorithm = () => promiseResolvedWith(undefined);
-    let cancelAlgorithm = () => promiseResolvedWith(undefined);
+    let startAlgorithm;
+    let pullAlgorithm;
+    let cancelAlgorithm;
     if (underlyingByteSource.start !== undefined) {
         startAlgorithm = () => underlyingByteSource.start(controller);
     }
+    else {
+        startAlgorithm = () => undefined;
+    }
     if (underlyingByteSource.pull !== undefined) {
         pullAlgorithm = () => underlyingByteSource.pull(controller);
     }
+    else {
+        pullAlgorithm = () => promiseResolvedWith(undefined);
+    }
     if (underlyingByteSource.cancel !== undefined) {
         cancelAlgorithm = reason => underlyingByteSource.cancel(reason);
     }
+    else {
+        cancelAlgorithm = () => promiseResolvedWith(undefined);
+    }
     const autoAllocateChunkSize = underlyingByteSource.autoAllocateChunkSize;
     if (autoAllocateChunkSize === 0) {
         throw new TypeError('autoAllocateChunkSize must be greater than 0');
@@ -1355,6 +1609,29 @@ 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 === undefined ? undefined : 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 _a;
+    assertDictionary(options, context);
+    const min = (_a = options === null || options === void 0 ? void 0 : options.min) !== null && _a !== void 0 ? _a : 1;
+    return {
+        min: convertUnsignedLongLongWithEnforceRange(min, `${context} has member 'min' that`)
+    };
+}
+
 // Abstract operations for the ReadableStream.
 function AcquireReadableStreamBYOBReader(stream) {
     return new ReadableStreamBYOBReader(stream);
@@ -1427,12 +1704,7 @@ class ReadableStreamBYOBReader {
         }
         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'));
         }
@@ -1445,7 +1717,28 @@ class ReadableStreamBYOBReader {
         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 (e) {
+            return promiseRejectedWith(e);
+        }
+        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 === undefined) {
             return promiseRejectedWith(readerLockException('read from'));
         }
@@ -1460,7 +1753,7 @@ class ReadableStreamBYOBReader {
             _closeSteps: chunk => resolvePromise({ value: chunk, done: true }),
             _errorSteps: e => rejectPromise(e)
         };
-        ReadableStreamBYOBReaderRead(this, view, readIntoRequest);
+        ReadableStreamBYOBReaderRead(this, view, min, readIntoRequest);
         return promise;
     }
     /**
@@ -1479,10 +1772,7 @@ class ReadableStreamBYOBReader {
         if (this._ownerReadableStream === undefined) {
             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, {
@@ -1491,6 +1781,9 @@ Object.defineProperties(ReadableStreamBYOBReader.prototype, {
     releaseLock: { enumerable: true },
     closed: { enumerable: true }
 });
+setFunctionName(ReadableStreamBYOBReader.prototype.cancel, 'cancel');
+setFunctionName(ReadableStreamBYOBReader.prototype.read, 'read');
+setFunctionName(ReadableStreamBYOBReader.prototype.releaseLock, 'releaseLock');
 if (typeof SymbolPolyfill.toStringTag === 'symbol') {
     Object.defineProperty(ReadableStreamBYOBReader.prototype, SymbolPolyfill.toStringTag, {
         value: 'ReadableStreamBYOBReader',
@@ -1507,16 +1800,28 @@ function IsReadableStreamBYOBReader(x) {
     }
     return x 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 e = new TypeError('Reader was released');
+    ReadableStreamBYOBReaderErrorReadIntoRequests(reader, e);
+}
+function ReadableStreamBYOBReaderErrorReadIntoRequests(reader, e) {
+    const readIntoRequests = reader._readIntoRequests;
+    reader._readIntoRequests = new SimpleQueue();
+    readIntoRequests.forEach(readIntoRequest => {
+        readIntoRequest._errorSteps(e);
+    });
+}
 // Helper functions for the ReadableStreamBYOBReader.
 function byobReaderBrandCheckException(name) {
     return new TypeError(`ReadableStreamBYOBReader.prototype.${name} can only be used on a ReadableStreamBYOBReader`);
@@ -1717,6 +2022,9 @@ Object.defineProperties(WritableStream.prototype, {
     getWriter: { enumerable: true },
     locked: { enumerable: true }
 });
+setFunctionName(WritableStream.prototype.abort, 'abort');
+setFunctionName(WritableStream.prototype.close, 'close');
+setFunctionName(WritableStream.prototype.getWriter, 'getWriter');
 if (typeof SymbolPolyfill.toStringTag === 'symbol') {
     Object.defineProperty(WritableStream.prototype, SymbolPolyfill.toStringTag, {
         value: 'WritableStream',
@@ -1782,7 +2090,7 @@ function WritableStreamAbort(stream, reason) {
         return promiseResolvedWith(undefined);
     }
     stream._writableStreamController._abortReason = reason;
-    (_a = stream._writableStreamController._abortController) === null || _a === void 0 ? void 0 : _a.abort();
+    (_a = stream._writableStreamController._abortController) === null || _a === void 0 ? void 0 : _a.abort(reason);
     // TypeScript narrows the type of `stream._state` down to 'writable' | 'erroring',
     // but it doesn't know that signaling abort runs author code that might have changed the state.
     // Widen the type again by casting to WritableStreamState.
@@ -1887,9 +2195,11 @@ function WritableStreamFinishErroring(stream) {
     uponPromise(promise, () => {
         abortRequest._resolve();
         WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
+        return null;
     }, (reason) => {
         abortRequest._reject(reason);
         WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
+        return null;
     });
 }
 function WritableStreamFinishInFlightWrite(stream) {
@@ -2117,6 +2427,10 @@ Object.defineProperties(WritableStreamDefaultWriter.prototype, {
     desiredSize: { enumerable: true },
     ready: { enumerable: true }
 });
+setFunctionName(WritableStreamDefaultWriter.prototype.abort, 'abort');
+setFunctionName(WritableStreamDefaultWriter.prototype.close, 'close');
+setFunctionName(WritableStreamDefaultWriter.prototype.releaseLock, 'releaseLock');
+setFunctionName(WritableStreamDefaultWriter.prototype.write, 'write');
 if (typeof SymbolPolyfill.toStringTag === 'symbol') {
     Object.defineProperty(WritableStreamDefaultWriter.prototype, SymbolPolyfill.toStringTag, {
         value: 'WritableStreamDefaultWriter',
@@ -2322,29 +2636,43 @@ function SetUpWritableStreamDefaultController(stream, controller, startAlgorithm
     uponPromise(startPromise, () => {
         controller._started = true;
         WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
+        return null;
     }, r => {
         controller._started = true;
         WritableStreamDealWithRejection(stream, r);
+        return null;
     });
 }
 function SetUpWritableStreamDefaultControllerFromUnderlyingSink(stream, underlyingSink, highWaterMark, sizeAlgorithm) {
     const controller = Object.create(WritableStreamDefaultController.prototype);
-    let startAlgorithm = () => undefined;
-    let writeAlgorithm = () => promiseResolvedWith(undefined);
-    let closeAlgorithm = () => promiseResolvedWith(undefined);
-    let abortAlgorithm = () => promiseResolvedWith(undefined);
+    let startAlgorithm;
+    let writeAlgorithm;
+    let closeAlgorithm;
+    let abortAlgorithm;
     if (underlyingSink.start !== undefined) {
         startAlgorithm = () => underlyingSink.start(controller);
     }
+    else {
+        startAlgorithm = () => undefined;
+    }
     if (underlyingSink.write !== undefined) {
         writeAlgorithm = chunk => underlyingSink.write(chunk, controller);
     }
+    else {
+        writeAlgorithm = () => promiseResolvedWith(undefined);
+    }
     if (underlyingSink.close !== undefined) {
         closeAlgorithm = () => underlyingSink.close();
     }
+    else {
+        closeAlgorithm = () => promiseResolvedWith(undefined);
+    }
     if (underlyingSink.abort !== undefined) {
         abortAlgorithm = reason => underlyingSink.abort(reason);
     }
+    else {
+        abortAlgorithm = () => promiseResolvedWith(undefined);
+    }
     SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm);
 }
 // ClearAlgorithms may be called twice. Erroring the same stream in multiple ways will often result in redundant calls.
@@ -2423,8 +2751,10 @@ function WritableStreamDefaultControllerProcessClose(controller) {
     WritableStreamDefaultControllerClearAlgorithms(controller);
     uponPromise(sinkClosePromise, () => {
         WritableStreamFinishInFlightClose(stream);
+        return null;
     }, reason => {
         WritableStreamFinishInFlightCloseWithError(stream, reason);
+        return null;
     });
 }
 function WritableStreamDefaultControllerProcessWrite(controller, chunk) {
@@ -2440,11 +2770,13 @@ function WritableStreamDefaultControllerProcessWrite(controller, chunk) {
             WritableStreamUpdateBackpressure(stream, backpressure);
         }
         WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
+        return null;
     }, reason => {
         if (stream._state === 'writable') {
             WritableStreamDefaultControllerClearAlgorithms(controller);
         }
         WritableStreamFinishInFlightWriteWithError(stream, reason);
+        return null;
     });
 }
 function WritableStreamDefaultControllerGetBackpressure(controller) {
@@ -2551,13 +2883,28 @@ function defaultWriterReadyPromiseResolve(writer) {
 }
 
 /// <reference lib="dom" />
-const NativeDOMException = typeof DOMException !== 'undefined' ? DOMException : undefined;
+function getGlobals() {
+    if (typeof globalThis !== 'undefined') {
+        return globalThis;
+    }
+    else if (typeof self !== 'undefined') {
+        return self;
+    }
+    else if (typeof global !== 'undefined') {
+        return global;
+    }
+    return undefined;
+}
+const globals = getGlobals();
 
 /// <reference types="node" />
 function isDOMExceptionConstructor(ctor) {
     if (!(typeof ctor === 'function' || typeof ctor === 'object')) {
         return false;
     }
+    if (ctor.name !== 'DOMException') {
+        return false;
+    }
     try {
         new ctor();
         return true;
@@ -2566,8 +2913,21 @@ function isDOMExceptionConstructor(ctor) {
         return false;
     }
 }
-function createDOMExceptionPolyfill() {
-    // eslint-disable-next-line no-shadow
+/**
+ * Support:
+ * - Web browsers
+ * - Node 18 and higher (https://github.com/nodejs/node/commit/e4b1fb5e6422c1ff151234bb9de792d45dd88d87)
+ */
+function getFromGlobal() {
+    const ctor = globals === null || globals === void 0 ? void 0 : globals.DOMException;
+    return isDOMExceptionConstructor(ctor) ? ctor : undefined;
+}
+/**
+ * Support:
+ * - All platforms
+ */
+function createPolyfill() {
+    // eslint-disable-next-line @typescript-eslint/no-shadow
     const ctor = function DOMException(message, name) {
         this.message = message || '';
         this.name = name || 'Error';
@@ -2575,12 +2935,13 @@ function createDOMExceptionPolyfill() {
             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;
 }
-// eslint-disable-next-line no-redeclare
-const DOMException$1 = isDOMExceptionConstructor(NativeDOMException) ? NativeDOMException : createDOMExceptionPolyfill();
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+const DOMException = getFromGlobal() || createPolyfill();
 
 function ReadableStreamPipeTo(source, dest, preventClose, preventAbort, preventCancel, signal) {
     const reader = AcquireReadableStreamDefaultReader(source);
@@ -2593,7 +2954,7 @@ function ReadableStreamPipeTo(source, dest, preventClose, preventAbort, preventC
         let abortAlgorithm;
         if (signal !== undefined) {
             abortAlgorithm = () => {
-                const error = new DOMException$1('Aborted', 'AbortError');
+                const error = signal.reason !== undefined ? signal.reason : new DOMException('Aborted', 'AbortError');
                 const actions = [];
                 if (!preventAbort) {
                     actions.push(() => {
@@ -2662,6 +3023,7 @@ function ReadableStreamPipeTo(source, dest, preventClose, preventAbort, preventC
             else {
                 shutdown(true, storedError);
             }
+            return null;
         });
         // Errors must be propagated backward
         isOrBecomesErrored(dest, writer._closedPromise, storedError => {
@@ -2671,6 +3033,7 @@ function ReadableStreamPipeTo(source, dest, preventClose, preventAbort, preventC
             else {
                 shutdown(true, storedError);
             }
+            return null;
         });
         // Closing must be propagated forward
         isOrBecomesClosed(source, reader._closedPromise, () => {
@@ -2680,6 +3043,7 @@ function ReadableStreamPipeTo(source, dest, preventClose, preventAbort, preventC
             else {
                 shutdown();
             }
+            return null;
         });
         // Closing must be propagated backward
         if (WritableStreamCloseQueuedOrInFlight(dest) || dest._state === 'closed') {
@@ -2727,6 +3091,7 @@ function ReadableStreamPipeTo(source, dest, preventClose, preventAbort, preventC
             }
             function doTheRest() {
                 uponPromise(action(), () => finalize(originalIsError, originalError), newError => finalize(true, newError));
+                return null;
             }
         }
         function shutdown(isError, error) {
@@ -2753,6 +3118,7 @@ function ReadableStreamPipeTo(source, dest, preventClose, preventAbort, preventC
             else {
                 resolve(undefined);
             }
+            return null;
         }
     });
 }
@@ -2833,6 +3199,10 @@ class ReadableStreamDefaultController {
             ReadableStreamDefaultControllerCallPullIfNeeded(this);
         }
     }
+    /** @internal */
+    [ReleaseSteps]() {
+        // Do nothing.
+    }
 }
 Object.defineProperties(ReadableStreamDefaultController.prototype, {
     close: { enumerable: true },
@@ -2840,6 +3210,9 @@ Object.defineProperties(ReadableStreamDefaultController.prototype, {
     error: { enumerable: true },
     desiredSize: { enumerable: true }
 });
+setFunctionName(ReadableStreamDefaultController.prototype.close, 'close');
+setFunctionName(ReadableStreamDefaultController.prototype.enqueue, 'enqueue');
+setFunctionName(ReadableStreamDefaultController.prototype.error, 'error');
 if (typeof SymbolPolyfill.toStringTag === 'symbol') {
     Object.defineProperty(ReadableStreamDefaultController.prototype, SymbolPolyfill.toStringTag, {
         value: 'ReadableStreamDefaultController',
@@ -2873,8 +3246,10 @@ function ReadableStreamDefaultControllerCallPullIfNeeded(controller) {
             controller._pullAgain = false;
             ReadableStreamDefaultControllerCallPullIfNeeded(controller);
         }
+        return null;
     }, e => {
         ReadableStreamDefaultControllerError(controller, e);
+        return null;
     });
 }
 function ReadableStreamDefaultControllerShouldCallPull(controller) {
@@ -2989,24 +3364,35 @@ function SetUpReadableStreamDefaultController(stream, controller, startAlgorithm
     uponPromise(promiseResolvedWith(startResult), () => {
         controller._started = true;
         ReadableStreamDefaultControllerCallPullIfNeeded(controller);
+        return null;
     }, r => {
         ReadableStreamDefaultControllerError(controller, r);
+        return null;
     });
 }
 function SetUpReadableStreamDefaultControllerFromUnderlyingSource(stream, underlyingSource, highWaterMark, sizeAlgorithm) {
     const controller = Object.create(ReadableStreamDefaultController.prototype);
-    let startAlgorithm = () => undefined;
-    let pullAlgorithm = () => promiseResolvedWith(undefined);
-    let cancelAlgorithm = () => promiseResolvedWith(undefined);
+    let startAlgorithm;
+    let pullAlgorithm;
+    let cancelAlgorithm;
     if (underlyingSource.start !== undefined) {
         startAlgorithm = () => underlyingSource.start(controller);
     }
+    else {
+        startAlgorithm = () => undefined;
+    }
     if (underlyingSource.pull !== undefined) {
         pullAlgorithm = () => underlyingSource.pull(controller);
     }
+    else {
+        pullAlgorithm = () => promiseResolvedWith(undefined);
+    }
     if (underlyingSource.cancel !== undefined) {
         cancelAlgorithm = reason => underlyingSource.cancel(reason);
     }
+    else {
+        cancelAlgorithm = () => promiseResolvedWith(undefined);
+    }
     SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm);
 }
 // Helper functions for the ReadableStreamDefaultController.
@@ -3045,7 +3431,7 @@ function ReadableStreamDefaultTee(stream, cloneForBranch2) {
                 // This needs to be delayed a microtask because it takes at least a microtask to detect errors (using
                 // reader._closedPromise below), and we want errors in stream to error both branches immediately. We cannot let
                 // successful synchronously-available reads get ahead of asynchronously-available errors.
-                queueMicrotask(() => {
+                _queueMicrotask(() => {
                     readAgain = false;
                     const chunk1 = chunk;
                     const chunk2 = chunk;
@@ -3116,6 +3502,7 @@ function ReadableStreamDefaultTee(stream, cloneForBranch2) {
         if (!canceled1 || !canceled2) {
             resolveCancelPromise(undefined);
         }
+        return null;
     });
     return [branch1, branch2];
 }
@@ -3137,13 +3524,14 @@ function ReadableByteStreamTee(stream) {
     function forwardReaderError(thisReader) {
         uponRejection(thisReader._closedPromise, r => {
             if (thisReader !== reader) {
-                return;
+                return null;
             }
             ReadableByteStreamControllerError(branch1._readableStreamController, r);
             ReadableByteStreamControllerError(branch2._readableStreamController, r);
             if (!canceled1 || !canceled2) {
                 resolveCancelPromise(undefined);
             }
+            return null;
         });
     }
     function pullWithDefaultReader() {
@@ -3157,7 +3545,7 @@ function ReadableByteStreamTee(stream) {
                 // This needs to be delayed a microtask because it takes at least a microtask to detect errors (using
                 // reader._closedPromise below), and we want errors in stream to error both branches immediately. We cannot let
                 // successful synchronously-available reads get ahead of asynchronously-available errors.
-                queueMicrotask(() => {
+                _queueMicrotask(() => {
                     readAgainForBranch1 = false;
                     readAgainForBranch2 = false;
                     const chunk1 = chunk;
@@ -3225,7 +3613,7 @@ function ReadableByteStreamTee(stream) {
                 // This needs to be delayed a microtask because it takes at least a microtask to detect errors (using
                 // reader._closedPromise below), and we want errors in stream to error both branches immediately. We cannot let
                 // successful synchronously-available reads get ahead of asynchronously-available errors.
-                queueMicrotask(() => {
+                _queueMicrotask(() => {
                     readAgainForBranch1 = false;
                     readAgainForBranch2 = false;
                     const byobCanceled = forBranch2 ? canceled2 : canceled1;
@@ -3284,7 +3672,7 @@ function ReadableByteStreamTee(stream) {
                 reading = false;
             }
         };
-        ReadableStreamBYOBReaderRead(reader, view, readIntoRequest);
+        ReadableStreamBYOBReaderRead(reader, view, 1, readIntoRequest);
     }
     function pull1Algorithm() {
         if (reading) {
@@ -3345,6 +3733,109 @@ function ReadableByteStreamTee(stream) {
     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 (e) {
+            return promiseRejectedWith(e);
+        }
+        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 (e) {
+            return promiseRejectedWith(e);
+        }
+        if (returnMethod === undefined) {
+            return promiseResolvedWith(undefined);
+        }
+        let returnResult;
+        try {
+            returnResult = reflectCall(returnMethod, iterator, [reason]);
+        }
+        catch (e) {
+            return promiseRejectedWith(e);
+        }
+        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 undefined;
+        });
+    }
+    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 (e) {
+            return promiseRejectedWith(e);
+        }
+        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 (e) {
+            return promiseRejectedWith(e);
+        }
+    }
+    stream = CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, 0);
+    return stream;
+}
+
 function convertUnderlyingDefaultOrByteSource(source, context) {
     assertDictionary(source, context);
     const original = source;
@@ -3389,21 +3880,6 @@ function convertReadableStreamType(type, context) {
     return type;
 }
 
-function convertReaderOptions(options, context) {
-    assertDictionary(options, context);
-    const mode = options === null || options === void 0 ? void 0 : options.mode;
-    return {
-        mode: mode === undefined ? undefined : 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;
@@ -3573,7 +4049,19 @@ class ReadableStream {
         const options = convertIteratorOptions(rawOptions, 'First parameter');
         return AcquireReadableStreamAsyncIterator(this, options.preventCancel);
     }
+    /**
+     * 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(ReadableStream, {
+    from: { enumerable: true }
+});
 Object.defineProperties(ReadableStream.prototype, {
     cancel: { enumerable: true },
     getReader: { enumerable: true },
@@ -3583,6 +4071,13 @@ Object.defineProperties(ReadableStream.prototype, {
     values: { enumerable: true },
     locked: { enumerable: true }
 });
+setFunctionName(ReadableStream.from, 'from');
+setFunctionName(ReadableStream.prototype.cancel, 'cancel');
+setFunctionName(ReadableStream.prototype.getReader, 'getReader');
+setFunctionName(ReadableStream.prototype.pipeThrough, 'pipeThrough');
+setFunctionName(ReadableStream.prototype.pipeTo, 'pipeTo');
+setFunctionName(ReadableStream.prototype.tee, 'tee');
+setFunctionName(ReadableStream.prototype.values, 'values');
 if (typeof SymbolPolyfill.toStringTag === 'symbol') {
     Object.defineProperty(ReadableStream.prototype, SymbolPolyfill.toStringTag, {
         value: 'ReadableStream',
@@ -3646,10 +4141,11 @@ function ReadableStreamCancel(stream, reason) {
     ReadableStreamClose(stream);
     const reader = stream._reader;
     if (reader !== undefined && IsReadableStreamBYOBReader(reader)) {
-        reader._readIntoRequests.forEach(readIntoRequest => {
+        const readIntoRequests = reader._readIntoRequests;
+        reader._readIntoRequests = new SimpleQueue();
+        readIntoRequests.forEach(readIntoRequest => {
             readIntoRequest._closeSteps(undefined);
         });
-        reader._readIntoRequests = new SimpleQueue();
     }
     const sourceCancelPromise = stream._readableStreamController[CancelSteps](reason);
     return transformPromiseWith(sourceCancelPromise, noop);
@@ -3662,10 +4158,11 @@ function ReadableStreamClose(stream) {
     }
     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, e) {
@@ -3677,16 +4174,10 @@ function ReadableStreamError(stream, e) {
     }
     defaultReaderClosedPromiseReject(reader, e);
     if (IsReadableStreamDefaultReader(reader)) {
-        reader._readRequests.forEach(readRequest => {
-            readRequest._errorSteps(e);
-        });
-        reader._readRequests = new SimpleQueue();
+        ReadableStreamDefaultReaderErrorReadRequests(reader, e);
     }
     else {
-        reader._readIntoRequests.forEach(readIntoRequest => {
-            readIntoRequest._errorSteps(e);
-        });
-        reader._readIntoRequests = new SimpleQueue();
+        ReadableStreamBYOBReaderErrorReadIntoRequests(reader, e);
     }
 }
 // Helper functions for the ReadableStream.
@@ -3707,10 +4198,7 @@ function convertQueuingStrategyInit(init, context) {
 const byteLengthSizeFunction = (chunk) => {
     return chunk.byteLength;
 };
-Object.defineProperty(byteLengthSizeFunction, 'name', {
-    value: 'size',
-    configurable: true
-});
+setFunctionName(byteLengthSizeFunction, 'size');
 /**
  * A queuing strategy that counts the number of bytes in each chunk.
  *
@@ -3769,10 +4257,7 @@ function IsByteLengthQueuingStrategy(x) {
 const countSizeFunction = () => {
     return 1;
 };
-Object.defineProperty(countSizeFunction, 'name', {
-    value: 'size',
-    configurable: true
-});
+setFunctionName(countSizeFunction, 'size');
 /**
  * A queuing strategy that counts the number of chunks.
  *
@@ -3830,12 +4315,16 @@ function IsCountQueuingStrategy(x) {
 
 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 === undefined ?
+            undefined :
+            convertTransformerCancelCallback(cancel, original, `${context} has member 'cancel' that`),
         flush: flush === undefined ?
             undefined :
             convertTransformerFlushCallback(flush, original, `${context} has member 'flush' that`),
@@ -3861,6 +4350,10 @@ function convertTransformerTransformCallback(fn, original, context) {
     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
 /**
@@ -3949,8 +4442,7 @@ function InitializeTransformStream(stream, startPromise, writableHighWaterMark,
         return TransformStreamDefaultSourcePullAlgorithm(stream);
     }
     function cancelAlgorithm(reason) {
-        TransformStreamErrorWritableAndUnblockWrite(stream, reason);
-        return promiseResolvedWith(undefined);
+        return TransformStreamDefaultSourceCancelAlgorithm(stream, reason);
     }
     stream._readable = CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, readableHighWaterMark, readableSizeAlgorithm);
     // The [[backpressure]] slot is set to undefined so that it can be initialised by TransformStreamSetBackpressure.
@@ -3977,6 +4469,9 @@ function TransformStreamError(stream, e) {
 function TransformStreamErrorWritableAndUnblockWrite(stream, e) {
     TransformStreamDefaultControllerClearAlgorithms(stream._transformStreamController);
     WritableStreamDefaultControllerErrorIfNeeded(stream._writable._writableStreamController, e);
+    TransformStreamUnblockWrite(stream);
+}
+function TransformStreamUnblockWrite(stream) {
     if (stream._backpressure) {
         // Pretend that pull() was called to permit any pending write() calls to complete. TransformStreamSetBackpressure()
         // cannot be called from enqueue() or pull() once the ReadableStream is errored, so this will will be the final time
@@ -4047,6 +4542,9 @@ Object.defineProperties(TransformStreamDefaultController.prototype, {
     terminate: { enumerable: true },
     desiredSize: { enumerable: true }
 });
+setFunctionName(TransformStreamDefaultController.prototype.enqueue, 'enqueue');
+setFunctionName(TransformStreamDefaultController.prototype.error, 'error');
+setFunctionName(TransformStreamDefaultController.prototype.terminate, 'terminate');
 if (typeof SymbolPolyfill.toStringTag === 'symbol') {
     Object.defineProperty(TransformStreamDefaultController.prototype, SymbolPolyfill.toStringTag, {
         value: 'TransformStreamDefaultController',
@@ -4063,35 +4561,53 @@ function IsTransformStreamDefaultController(x) {
     }
     return x 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 = undefined;
+    controller._finishPromise_resolve = undefined;
+    controller._finishPromise_reject = undefined;
 }
 function SetUpTransformStreamDefaultControllerFromTransformer(stream, transformer) {
     const controller = Object.create(TransformStreamDefaultController.prototype);
-    let transformAlgorithm = (chunk) => {
-        try {
-            TransformStreamDefaultControllerEnqueue(controller, chunk);
-            return promiseResolvedWith(undefined);
-        }
-        catch (transformResultE) {
-            return promiseRejectedWith(transformResultE);
-        }
-    };
-    let flushAlgorithm = () => promiseResolvedWith(undefined);
+    let transformAlgorithm;
+    let flushAlgorithm;
+    let cancelAlgorithm;
     if (transformer.transform !== undefined) {
         transformAlgorithm = chunk => transformer.transform(chunk, controller);
     }
+    else {
+        transformAlgorithm = chunk => {
+            try {
+                TransformStreamDefaultControllerEnqueue(controller, chunk);
+                return promiseResolvedWith(undefined);
+            }
+            catch (transformResultE) {
+                return promiseRejectedWith(transformResultE);
+            }
+        };
+    }
     if (transformer.flush !== undefined) {
         flushAlgorithm = () => transformer.flush(controller);
     }
-    SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm);
+    else {
+        flushAlgorithm = () => promiseResolvedWith(undefined);
+    }
+    if (transformer.cancel !== undefined) {
+        cancelAlgorithm = reason => transformer.cancel(reason);
+    }
+    else {
+        cancelAlgorithm = () => promiseResolvedWith(undefined);
+    }
+    SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm, cancelAlgorithm);
 }
 function TransformStreamDefaultControllerClearAlgorithms(controller) {
     controller._transformAlgorithm = undefined;
     controller._flushAlgorithm = undefined;
+    controller._cancelAlgorithm = undefined;
 }
 function TransformStreamDefaultControllerEnqueue(controller, chunk) {
     const stream = controller._controlledTransformStream;
@@ -4148,27 +4664,66 @@ function TransformStreamDefaultSinkWriteAlgorithm(stream, chunk) {
     return TransformStreamDefaultControllerPerformTransform(controller, chunk);
 }
 function TransformStreamDefaultSinkAbortAlgorithm(stream, reason) {
-    // abort() is not called synchronously, so it is possible for abort() to be called when the stream is already
-    // errored.
-    TransformStreamError(stream, reason);
-    return promiseResolvedWith(undefined);
+    const controller = stream._transformStreamController;
+    if (controller._finishPromise !== undefined) {
+        return controller._finishPromise;
+    }
+    // stream._readable cannot change after construction, so caching it across a call to user code is safe.
+    const readable = stream._readable;
+    // Assign the _finishPromise now so that if _cancelAlgorithm calls readable.cancel() internally,
+    // we don't run the _cancelAlgorithm again.
+    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;
+    }, r => {
+        ReadableStreamDefaultControllerError(readable._readableStreamController, r);
+        defaultControllerFinishPromiseReject(controller, r);
+        return null;
+    });
+    return controller._finishPromise;
 }
 function TransformStreamDefaultSinkCloseAlgorithm(stream) {
+    const controller = stream._transformStreamController;
+    if (controller._finishPromise !== undefined) {
+        return controller._finishPromise;
+    }
     // stream._readable cannot change after construction, so caching it across a call to user code is safe.
     const readable = stream._readable;
-    const controller = stream._transformStreamController;
+    // Assign the _finishPromise now so that if _flushAlgorithm calls readable.cancel() internally,
+    // we don't also run the _cancelAlgorithm.
+    controller._finishPromise = newPromise((resolve, reject) => {
+        controller._finishPromise_resolve = resolve;
+        controller._finishPromise_reject = reject;
+    });
     const flushPromise = controller._flushAlgorithm();
     TransformStreamDefaultControllerClearAlgorithms(controller);
-    // Return a promise that is fulfilled with undefined on success.
-    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;
     }, r => {
-        TransformStreamError(stream, r);
-        throw readable._storedError;
+        ReadableStreamDefaultControllerError(readable._readableStreamController, r);
+        defaultControllerFinishPromiseReject(controller, r);
+        return null;
     });
+    return controller._finishPromise;
 }
 // TransformStreamDefaultSource Algorithms
 function TransformStreamDefaultSourcePullAlgorithm(stream) {
@@ -4177,10 +4732,61 @@ function TransformStreamDefaultSourcePullAlgorithm(stream) {
     // Prevent the next pull() call until there is backpressure.
     return stream._backpressureChangePromise;
 }
+function TransformStreamDefaultSourceCancelAlgorithm(stream, reason) {
+    const controller = stream._transformStreamController;
+    if (controller._finishPromise !== undefined) {
+        return controller._finishPromise;
+    }
+    // stream._writable cannot change after construction, so caching it across a call to user code is safe.
+    const writable = stream._writable;
+    // Assign the _finishPromise now so that if _flushAlgorithm calls writable.abort() or
+    // writable.cancel() internally, we don't run the _cancelAlgorithm again, or also run the
+    // _flushAlgorithm.
+    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;
+    }, r => {
+        WritableStreamDefaultControllerErrorIfNeeded(writable._writableStreamController, r);
+        TransformStreamUnblockWrite(stream);
+        defaultControllerFinishPromiseReject(controller, r);
+        return null;
+    });
+    return controller._finishPromise;
+}
 // Helper functions for the TransformStreamDefaultController.
 function defaultControllerBrandCheckException(name) {
     return new TypeError(`TransformStreamDefaultController.prototype.${name} can only be used on a TransformStreamDefaultController`);
 }
+function defaultControllerFinishPromiseResolve(controller) {
+    if (controller._finishPromise_resolve === undefined) {
+        return;
+    }
+    controller._finishPromise_resolve();
+    controller._finishPromise_resolve = undefined;
+    controller._finishPromise_reject = undefined;
+}
+function defaultControllerFinishPromiseReject(controller, reason) {
+    if (controller._finishPromise_reject === undefined) {
+        return;
+    }
+    setPromiseIsHandledToTrue(controller._finishPromise);
+    controller._finishPromise_reject(reason);
+    controller._finishPromise_resolve = undefined;
+    controller._finishPromise_reject = undefined;
+}
 // Helper functions for the TransformStream.
 function streamBrandCheckException(name) {
     return new TypeError(`TransformStream.prototype.${name} can only be used on a TransformStream`);