web-streams-polyfill 3.0.0 → 3.1.0

package/dist/polyfill.mjs

@@ -1,5 +1,5 @@
 /**
- * web-streams-polyfill v3.0.0
+ * web-streams-polyfill v3.1.0
  */
 /// <reference lib="es2015.symbol" />
 var SymbolPolyfill = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol' ?
@@ -8,7 +8,7 @@ var SymbolPolyfill = typeof Symbol === 'function' && typeof Symbol.iterator ===
 
 /// <reference lib="dom" />
 function noop() {
-    // do nothing
+    return undefined;
 }
 function getGlobals() {
     if (typeof self !== 'undefined') {
@@ -27,7 +27,7 @@ var globals = getGlobals();
 function typeIsObject(x) {
     return (typeof x === 'object' && x !== null) || typeof x === 'function';
 }
-var rethrowAssertionErrorRejection =  noop;
+var rethrowAssertionErrorRejection = noop;
 
 var originalPromise = Promise;
 var originalPromiseThen = Promise.prototype.then;
@@ -247,6 +247,9 @@ function defaultReaderClosedPromiseInitializeAsResolved(reader) {
     defaultReaderClosedPromiseResolve(reader);
 }
 function defaultReaderClosedPromiseReject(reader, reason) {
+    if (reader._closedPromise_reject === undefined) {
+        return;
+    }
     setPromiseIsHandledToTrue(reader._closedPromise);
     reader._closedPromise_reject(reason);
     reader._closedPromise_resolve = undefined;
@@ -256,6 +259,9 @@ function defaultReaderClosedPromiseResetToRejected(reader, reason) {
     defaultReaderClosedPromiseInitializeAsRejected(reader, reason);
 }
 function defaultReaderClosedPromiseResolve(reader) {
+    if (reader._closedPromise_resolve === undefined) {
+        return;
+    }
     reader._closedPromise_resolve(undefined);
     reader._closedPromise_resolve = undefined;
     reader._closedPromise_reject = undefined;
@@ -382,6 +388,11 @@ function ReadableStreamHasDefaultReader(stream) {
     }
     return true;
 }
+/**
+ * A default reader vended by a {@link ReadableStream}.
+ *
+ * @public
+ */
 var ReadableStreamDefaultReader = /** @class */ (function () {
     function ReadableStreamDefaultReader(stream) {
         assertRequiredArgument(stream, 1, 'ReadableStreamDefaultReader');
@@ -393,6 +404,10 @@ var ReadableStreamDefaultReader = /** @class */ (function () {
         this._readRequests = new SimpleQueue();
     }
     Object.defineProperty(ReadableStreamDefaultReader.prototype, "closed", {
+        /**
+         * Returns a promise that will be fulfilled when the stream becomes closed,
+         * or rejected if the stream ever errors or the reader's lock is released before the stream finishes closing.
+         */
         get: function () {
             if (!IsReadableStreamDefaultReader(this)) {
                 return promiseRejectedWith(defaultReaderBrandCheckException('closed'));
@@ -402,6 +417,9 @@ var ReadableStreamDefaultReader = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    /**
+     * If the reader is active, behaves the same as {@link ReadableStream.cancel | stream.cancel(reason)}.
+     */
     ReadableStreamDefaultReader.prototype.cancel = function (reason) {
         if (reason === void 0) { reason = undefined; }
         if (!IsReadableStreamDefaultReader(this)) {
@@ -412,6 +430,11 @@ var ReadableStreamDefaultReader = /** @class */ (function () {
         }
         return ReadableStreamReaderGenericCancel(this, reason);
     };
+    /**
+     * Returns a promise that allows access to the next chunk from the stream's internal queue, if available.
+     *
+     * If reading a chunk causes the queue to become empty, more data will be pulled from the underlying source.
+     */
     ReadableStreamDefaultReader.prototype.read = function () {
         if (!IsReadableStreamDefaultReader(this)) {
             return promiseRejectedWith(defaultReaderBrandCheckException('read'));
@@ -433,6 +456,15 @@ var ReadableStreamDefaultReader = /** @class */ (function () {
         ReadableStreamDefaultReaderRead(this, readRequest);
         return promise;
     };
+    /**
+     * Releases the reader's lock on the corresponding stream. After the lock is released, the reader is no longer active.
+     * If the associated stream is errored when the lock is released, the reader will appear errored in the same way
+     * from now on; otherwise, the reader will appear closed.
+     *
+     * A reader's lock cannot be released while it still has a pending read request, i.e., if a promise returned by
+     * the reader's {@link ReadableStreamDefaultReader.read | read()} method has not yet been settled. Attempting to
+     * do so will throw a `TypeError` and leave the reader locked to the stream.
+     */
     ReadableStreamDefaultReader.prototype.releaseLock = function () {
         if (!IsReadableStreamDefaultReader(this)) {
             throw defaultReaderBrandCheckException('releaseLock');
@@ -467,7 +499,7 @@ function IsReadableStreamDefaultReader(x) {
     if (!Object.prototype.hasOwnProperty.call(x, '_readRequests')) {
         return false;
     }
-    return true;
+    return x instanceof ReadableStreamDefaultReader;
 }
 function ReadableStreamDefaultReaderRead(reader, readRequest) {
     var stream = reader._ownerReadableStream;
@@ -615,7 +647,14 @@ function IsReadableStreamAsyncIterator(x) {
     if (!Object.prototype.hasOwnProperty.call(x, '_asyncIteratorImpl')) {
         return false;
     }
-    return true;
+    try {
+        // noinspection SuspiciousTypeOfGuard
+        return x._asyncIteratorImpl instanceof
+            ReadableStreamAsyncIteratorImpl;
+    }
+    catch (_a) {
+        return false;
+    }
 }
 // Helper functions for the ReadableStream.
 function streamAsyncIteratorBrandCheckException(name) {
@@ -629,15 +668,35 @@ var NumberIsNaN = Number.isNaN || function (x) {
     return x !== x;
 };
 
-function IsFiniteNonNegativeNumber(v) {
-    if (!IsNonNegativeNumber(v)) {
-        return false;
-    }
-    if (v === Infinity) {
-        return false;
+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.
+    return elements.slice();
+}
+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;
+}
+function ArrayBufferSlice(buffer, begin, end) {
+    // ArrayBuffer.prototype.slice is not available on IE10
+    // https://www.caniuse.com/mdn-javascript_builtins_arraybuffer_slice
+    if (buffer.slice) {
+        return buffer.slice(begin, end);
     }
-    return true;
+    var length = end - begin;
+    var slice = new ArrayBuffer(length);
+    CopyDataBlockBytes(slice, 0, buffer, begin, length);
+    return slice;
 }
+
 function IsNonNegativeNumber(v) {
     if (typeof v !== 'number') {
         return false;
@@ -650,6 +709,10 @@ function IsNonNegativeNumber(v) {
     }
     return true;
 }
+function CloneAsUint8Array(O) {
+    var buffer = ArrayBufferSlice(O.buffer, O.byteOffset, O.byteOffset + O.byteLength);
+    return new Uint8Array(buffer);
+}
 
 function DequeueValue(container) {
     var pair = container._queue.shift();
@@ -660,8 +723,7 @@ function DequeueValue(container) {
     return pair.value;
 }
 function EnqueueValueWithSize(container, value, size) {
-    size = Number(size);
-    if (!IsFiniteNonNegativeNumber(size)) {
+    if (!IsNonNegativeNumber(size) || size === Infinity) {
         throw new RangeError('Size must be a finite, non-NaN, non-negative number.');
     }
     container._queue.push({ value: value, size: size });
@@ -676,28 +738,19 @@ function ResetQueue(container) {
     container._queueTotalSize = 0;
 }
 
-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.
-    return elements.slice();
-}
-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
-function IsDetachedBuffer(O) {
-    return false;
-}
-
+/**
+ * A pull-into request in a {@link ReadableByteStreamController}.
+ *
+ * @public
+ */
 var ReadableStreamBYOBRequest = /** @class */ (function () {
     function ReadableStreamBYOBRequest() {
         throw new TypeError('Illegal constructor');
     }
     Object.defineProperty(ReadableStreamBYOBRequest.prototype, "view", {
+        /**
+         * Returns the view for writing in to, or `null` if the BYOB request has already been responded to.
+         */
         get: function () {
             if (!IsReadableStreamBYOBRequest(this)) {
                 throw byobRequestBrandCheckException('view');
@@ -727,15 +780,10 @@ var ReadableStreamBYOBRequest = /** @class */ (function () {
         if (!ArrayBuffer.isView(view)) {
             throw new TypeError('You can only respond with array buffer views');
         }
-        if (view.byteLength === 0) {
-            throw new TypeError('chunk must have non-zero byteLength');
-        }
-        if (view.buffer.byteLength === 0) {
-            throw new TypeError("chunk's buffer must have non-zero byteLength");
-        }
         if (this._associatedReadableByteStreamController === undefined) {
             throw new TypeError('This BYOB request has been invalidated');
         }
+        if (IsDetachedBuffer(view.buffer)) ;
         ReadableByteStreamControllerRespondWithNewView(this._associatedReadableByteStreamController, view);
     };
     return ReadableStreamBYOBRequest;
@@ -751,28 +799,33 @@ if (typeof SymbolPolyfill.toStringTag === 'symbol') {
         configurable: true
     });
 }
+/**
+ * Allows control of a {@link ReadableStream | readable byte stream}'s state and internal queue.
+ *
+ * @public
+ */
 var ReadableByteStreamController = /** @class */ (function () {
     function ReadableByteStreamController() {
         throw new TypeError('Illegal constructor');
     }
     Object.defineProperty(ReadableByteStreamController.prototype, "byobRequest", {
+        /**
+         * Returns the current BYOB pull request, or `null` if there isn't one.
+         */
         get: function () {
             if (!IsReadableByteStreamController(this)) {
                 throw byteStreamControllerBrandCheckException('byobRequest');
             }
-            if (this._byobRequest === null && this._pendingPullIntos.length > 0) {
-                var firstDescriptor = this._pendingPullIntos.peek();
-                var view = new Uint8Array(firstDescriptor.buffer, firstDescriptor.byteOffset + firstDescriptor.bytesFilled, firstDescriptor.byteLength - firstDescriptor.bytesFilled);
-                var byobRequest = Object.create(ReadableStreamBYOBRequest.prototype);
-                SetUpReadableStreamBYOBRequest(byobRequest, this, view);
-                this._byobRequest = byobRequest;
-            }
-            return this._byobRequest;
+            return ReadableByteStreamControllerGetBYOBRequest(this);
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(ReadableByteStreamController.prototype, "desiredSize", {
+        /**
+         * Returns the desired size to fill the controlled stream's internal queue. It can be negative, if the queue is
+         * over-full. An underlying byte source ought to use this information to determine when and how to apply backpressure.
+         */
         get: function () {
             if (!IsReadableByteStreamController(this)) {
                 throw byteStreamControllerBrandCheckException('desiredSize');
@@ -782,6 +835,10 @@ var ReadableByteStreamController = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    /**
+     * Closes the controlled readable stream. Consumers will still be able to read any previously-enqueued chunks from
+     * the stream, but once those are read, the stream will become closed.
+     */
     ReadableByteStreamController.prototype.close = function () {
         if (!IsReadableByteStreamController(this)) {
             throw byteStreamControllerBrandCheckException('close');
@@ -818,6 +875,9 @@ var ReadableByteStreamController = /** @class */ (function () {
         }
         ReadableByteStreamControllerEnqueue(this, chunk);
     };
+    /**
+     * Errors the controlled readable stream, making all future interactions with it fail with the given error `e`.
+     */
     ReadableByteStreamController.prototype.error = function (e) {
         if (e === void 0) { e = undefined; }
         if (!IsReadableByteStreamController(this)) {
@@ -827,10 +887,7 @@ var ReadableByteStreamController = /** @class */ (function () {
     };
     /** @internal */
     ReadableByteStreamController.prototype[CancelSteps] = function (reason) {
-        if (this._pendingPullIntos.length > 0) {
-            var firstDescriptor = this._pendingPullIntos.peek();
-            firstDescriptor.bytesFilled = 0;
-        }
+        ReadableByteStreamControllerClearPendingPullIntos(this);
         ResetQueue(this);
         var result = this._cancelAlgorithm(reason);
         ReadableByteStreamControllerClearAlgorithms(this);
@@ -859,6 +916,7 @@ var ReadableByteStreamController = /** @class */ (function () {
             }
             var pullIntoDescriptor = {
                 buffer: buffer,
+                bufferByteLength: autoAllocateChunkSize,
                 byteOffset: 0,
                 byteLength: autoAllocateChunkSize,
                 bytesFilled: 0,
@@ -894,7 +952,7 @@ function IsReadableByteStreamController(x) {
     if (!Object.prototype.hasOwnProperty.call(x, '_controlledReadableByteStream')) {
         return false;
     }
-    return true;
+    return x instanceof ReadableByteStreamController;
 }
 function IsReadableStreamBYOBRequest(x) {
     if (!typeIsObject(x)) {
@@ -903,7 +961,7 @@ function IsReadableStreamBYOBRequest(x) {
     if (!Object.prototype.hasOwnProperty.call(x, '_associatedReadableByteStreamController')) {
         return false;
     }
-    return true;
+    return x instanceof ReadableStreamBYOBRequest;
 }
 function ReadableByteStreamControllerCallPullIfNeeded(controller) {
     var shouldPull = ReadableByteStreamControllerShouldCallPull(controller);
@@ -985,7 +1043,6 @@ function ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller,
     return ready;
 }
 function ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, size, pullIntoDescriptor) {
-    ReadableByteStreamControllerInvalidateBYOBRequest(controller);
     pullIntoDescriptor.bytesFilled += size;
 }
 function ReadableByteStreamControllerHandleQueueDrain(controller) {
@@ -1024,9 +1081,15 @@ function ReadableByteStreamControllerPullInto(controller, view, readIntoRequest)
         elementSize = view.constructor.BYTES_PER_ELEMENT;
     }
     var ctor = view.constructor;
+    // try {
     var buffer = TransferArrayBuffer(view.buffer);
+    // } catch (e) {
+    //   readIntoRequest._errorSteps(e);
+    //   return;
+    // }
     var pullIntoDescriptor = {
         buffer: buffer,
+        bufferByteLength: buffer.byteLength,
         byteOffset: view.byteOffset,
         byteLength: view.byteLength,
         bytesFilled: 0,
@@ -1066,7 +1129,6 @@ function ReadableByteStreamControllerPullInto(controller, view, readIntoRequest)
     ReadableByteStreamControllerCallPullIfNeeded(controller);
 }
 function ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor) {
-    firstDescriptor.buffer = TransferArrayBuffer(firstDescriptor.buffer);
     var stream = controller._controlledReadableByteStream;
     if (ReadableStreamHasBYOBReader(stream)) {
         while (ReadableStreamGetNumReadIntoRequests(stream) > 0) {
@@ -1076,34 +1138,27 @@ function ReadableByteStreamControllerRespondInClosedState(controller, firstDescr
     }
 }
 function ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, pullIntoDescriptor) {
-    if (pullIntoDescriptor.bytesFilled + bytesWritten > pullIntoDescriptor.byteLength) {
-        throw new RangeError('bytesWritten out of range');
-    }
     ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesWritten, pullIntoDescriptor);
     if (pullIntoDescriptor.bytesFilled < pullIntoDescriptor.elementSize) {
-        // TODO: Figure out whether we should detach the buffer or not here.
         return;
     }
     ReadableByteStreamControllerShiftPendingPullInto(controller);
     var remainderSize = pullIntoDescriptor.bytesFilled % pullIntoDescriptor.elementSize;
     if (remainderSize > 0) {
         var end = pullIntoDescriptor.byteOffset + pullIntoDescriptor.bytesFilled;
-        var remainder = pullIntoDescriptor.buffer.slice(end - remainderSize, end);
+        var remainder = ArrayBufferSlice(pullIntoDescriptor.buffer, end - remainderSize, end);
         ReadableByteStreamControllerEnqueueChunkToQueue(controller, remainder, 0, remainder.byteLength);
     }
-    pullIntoDescriptor.buffer = TransferArrayBuffer(pullIntoDescriptor.buffer);
     pullIntoDescriptor.bytesFilled -= remainderSize;
     ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableByteStream, pullIntoDescriptor);
     ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);
 }
 function ReadableByteStreamControllerRespondInternal(controller, bytesWritten) {
     var firstDescriptor = controller._pendingPullIntos.peek();
-    var stream = controller._controlledReadableByteStream;
-    if (stream._state === 'closed') {
-        if (bytesWritten !== 0) {
-            throw new TypeError('bytesWritten must be 0 when calling respond() on a closed stream');
-        }
-        ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor);
+    ReadableByteStreamControllerInvalidateBYOBRequest(controller);
+    var state = controller._controlledReadableByteStream._state;
+    if (state === 'closed') {
+        ReadableByteStreamControllerRespondInClosedState(controller);
     }
     else {
         ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, firstDescriptor);
@@ -1112,7 +1167,6 @@ function ReadableByteStreamControllerRespondInternal(controller, bytesWritten) {
 }
 function ReadableByteStreamControllerShiftPendingPullInto(controller) {
     var descriptor = controller._pendingPullIntos.shift();
-    ReadableByteStreamControllerInvalidateBYOBRequest(controller);
     return descriptor;
 }
 function ReadableByteStreamControllerShouldCallPull(controller) {
@@ -1172,6 +1226,12 @@ function ReadableByteStreamControllerEnqueue(controller, chunk) {
     var byteOffset = chunk.byteOffset;
     var byteLength = chunk.byteLength;
     var transferredBuffer = TransferArrayBuffer(buffer);
+    if (controller._pendingPullIntos.length > 0) {
+        var firstPendingPullInto = controller._pendingPullIntos.peek();
+        if (IsDetachedBuffer(firstPendingPullInto.buffer)) ;
+        firstPendingPullInto.buffer = TransferArrayBuffer(firstPendingPullInto.buffer);
+    }
+    ReadableByteStreamControllerInvalidateBYOBRequest(controller);
     if (ReadableStreamHasDefaultReader(stream)) {
         if (ReadableStreamGetNumReadRequests(stream) === 0) {
             ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);
@@ -1201,9 +1261,18 @@ function ReadableByteStreamControllerError(controller, e) {
     ReadableByteStreamControllerClearAlgorithms(controller);
     ReadableStreamError(stream, e);
 }
+function ReadableByteStreamControllerGetBYOBRequest(controller) {
+    if (controller._byobRequest === null && controller._pendingPullIntos.length > 0) {
+        var firstDescriptor = controller._pendingPullIntos.peek();
+        var view = new Uint8Array(firstDescriptor.buffer, firstDescriptor.byteOffset + firstDescriptor.bytesFilled, firstDescriptor.byteLength - firstDescriptor.bytesFilled);
+        var byobRequest = Object.create(ReadableStreamBYOBRequest.prototype);
+        SetUpReadableStreamBYOBRequest(byobRequest, controller, view);
+        controller._byobRequest = byobRequest;
+    }
+    return controller._byobRequest;
+}
 function ReadableByteStreamControllerGetDesiredSize(controller) {
-    var stream = controller._controlledReadableByteStream;
-    var state = stream._state;
+    var state = controller._controlledReadableByteStream._state;
     if (state === 'errored') {
         return null;
     }
@@ -1213,21 +1282,47 @@ function ReadableByteStreamControllerGetDesiredSize(controller) {
     return controller._strategyHWM - controller._queueTotalSize;
 }
 function ReadableByteStreamControllerRespond(controller, bytesWritten) {
-    bytesWritten = Number(bytesWritten);
-    if (!IsFiniteNonNegativeNumber(bytesWritten)) {
-        throw new RangeError('bytesWritten must be a finite');
+    var firstDescriptor = controller._pendingPullIntos.peek();
+    var state = controller._controlledReadableByteStream._state;
+    if (state === 'closed') {
+        if (bytesWritten !== 0) {
+            throw new TypeError('bytesWritten must be 0 when calling respond() on a closed stream');
+        }
+    }
+    else {
+        if (bytesWritten === 0) {
+            throw new TypeError('bytesWritten must be greater than 0 when calling respond() on a readable stream');
+        }
+        if (firstDescriptor.bytesFilled + bytesWritten > firstDescriptor.byteLength) {
+            throw new RangeError('bytesWritten out of range');
+        }
     }
+    firstDescriptor.buffer = TransferArrayBuffer(firstDescriptor.buffer);
     ReadableByteStreamControllerRespondInternal(controller, bytesWritten);
 }
 function ReadableByteStreamControllerRespondWithNewView(controller, view) {
     var firstDescriptor = controller._pendingPullIntos.peek();
+    var state = controller._controlledReadableByteStream._state;
+    if (state === 'closed') {
+        if (view.byteLength !== 0) {
+            throw new TypeError('The view\'s length must be 0 when calling respondWithNewView() on a closed stream');
+        }
+    }
+    else {
+        if (view.byteLength === 0) {
+            throw new TypeError('The view\'s length must be greater than 0 when calling respondWithNewView() on a readable stream');
+        }
+    }
     if (firstDescriptor.byteOffset + firstDescriptor.bytesFilled !== view.byteOffset) {
         throw new RangeError('The region specified by view does not match byobRequest');
     }
-    if (firstDescriptor.byteLength !== view.byteLength) {
+    if (firstDescriptor.bufferByteLength !== view.buffer.byteLength) {
         throw new RangeError('The buffer of view has different capacity than byobRequest');
     }
-    firstDescriptor.buffer = view.buffer;
+    if (firstDescriptor.bytesFilled + view.byteLength > firstDescriptor.byteLength) {
+        throw new RangeError('The region specified by view is larger than byobRequest');
+    }
+    firstDescriptor.buffer = TransferArrayBuffer(view.buffer);
     ReadableByteStreamControllerRespondInternal(controller, view.byteLength);
 }
 function SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, autoAllocateChunkSize) {
@@ -1269,6 +1364,9 @@ function SetUpReadableByteStreamControllerFromUnderlyingSource(stream, underlyin
         cancelAlgorithm = function (reason) { return underlyingByteSource.cancel(reason); };
     }
     var autoAllocateChunkSize = underlyingByteSource.autoAllocateChunkSize;
+    if (autoAllocateChunkSize === 0) {
+        throw new TypeError('autoAllocateChunkSize must be greater than 0');
+    }
     SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, autoAllocateChunkSize);
 }
 function SetUpReadableStreamBYOBRequest(request, controller, view) {
@@ -1315,6 +1413,11 @@ function ReadableStreamHasBYOBReader(stream) {
     }
     return true;
 }
+/**
+ * A BYOB reader vended by a {@link ReadableStream}.
+ *
+ * @public
+ */
 var ReadableStreamBYOBReader = /** @class */ (function () {
     function ReadableStreamBYOBReader(stream) {
         assertRequiredArgument(stream, 1, 'ReadableStreamBYOBReader');
@@ -1330,6 +1433,10 @@ var ReadableStreamBYOBReader = /** @class */ (function () {
         this._readIntoRequests = new SimpleQueue();
     }
     Object.defineProperty(ReadableStreamBYOBReader.prototype, "closed", {
+        /**
+         * Returns a promise that will be fulfilled when the stream becomes closed, or rejected if the stream ever errors or
+         * the reader's lock is released before the stream finishes closing.
+         */
         get: function () {
             if (!IsReadableStreamBYOBReader(this)) {
                 return promiseRejectedWith(byobReaderBrandCheckException('closed'));
@@ -1339,6 +1446,9 @@ var ReadableStreamBYOBReader = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    /**
+     * If the reader is active, behaves the same as {@link ReadableStream.cancel | stream.cancel(reason)}.
+     */
     ReadableStreamBYOBReader.prototype.cancel = function (reason) {
         if (reason === void 0) { reason = undefined; }
         if (!IsReadableStreamBYOBReader(this)) {
@@ -1349,6 +1459,11 @@ var ReadableStreamBYOBReader = /** @class */ (function () {
         }
         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.
+     */
     ReadableStreamBYOBReader.prototype.read = function (view) {
         if (!IsReadableStreamBYOBReader(this)) {
             return promiseRejectedWith(byobReaderBrandCheckException('read'));
@@ -1362,6 +1477,7 @@ var ReadableStreamBYOBReader = /** @class */ (function () {
         if (view.buffer.byteLength === 0) {
             return promiseRejectedWith(new TypeError("view's buffer must have non-zero byteLength"));
         }
+        if (IsDetachedBuffer(view.buffer)) ;
         if (this._ownerReadableStream === undefined) {
             return promiseRejectedWith(readerLockException('read from'));
         }
@@ -1379,6 +1495,15 @@ var ReadableStreamBYOBReader = /** @class */ (function () {
         ReadableStreamBYOBReaderRead(this, view, readIntoRequest);
         return promise;
     };
+    /**
+     * Releases the reader's lock on the corresponding stream. After the lock is released, the reader is no longer active.
+     * If the associated stream is errored when the lock is released, the reader will appear errored in the same way
+     * from now on; otherwise, the reader will appear closed.
+     *
+     * A reader's lock cannot be released while it still has a pending read request, i.e., if a promise returned by
+     * the reader's {@link ReadableStreamBYOBReader.read | read()} method has not yet been settled. Attempting to
+     * do so will throw a `TypeError` and leave the reader locked to the stream.
+     */
     ReadableStreamBYOBReader.prototype.releaseLock = function () {
         if (!IsReadableStreamBYOBReader(this)) {
             throw byobReaderBrandCheckException('releaseLock');
@@ -1413,7 +1538,7 @@ function IsReadableStreamBYOBReader(x) {
     if (!Object.prototype.hasOwnProperty.call(x, '_readIntoRequests')) {
         return false;
     }
-    return true;
+    return x instanceof ReadableStreamBYOBReader;
 }
 function ReadableStreamBYOBReaderRead(reader, view, readIntoRequest) {
     var stream = reader._ownerReadableStream;
@@ -1508,6 +1633,36 @@ function assertWritableStream(x, context) {
     }
 }
 
+function isAbortSignal(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    try {
+        return typeof value.aborted === 'boolean';
+    }
+    catch (_a) {
+        // AbortSignal.prototype.aborted throws if its brand check fails
+        return false;
+    }
+}
+var supportsAbortController = typeof AbortController === 'function';
+/**
+ * Construct a new AbortController, if supported by the platform.
+ *
+ * @internal
+ */
+function createAbortController() {
+    if (supportsAbortController) {
+        return new AbortController();
+    }
+    return undefined;
+}
+
+/**
+ * A writable stream represents a destination for data, into which you can write.
+ *
+ * @public
+ */
 var WritableStream = /** @class */ (function () {
     function WritableStream(rawUnderlyingSink, rawStrategy) {
         if (rawUnderlyingSink === void 0) { rawUnderlyingSink = {}; }
@@ -1530,28 +1685,48 @@ var WritableStream = /** @class */ (function () {
         SetUpWritableStreamDefaultControllerFromUnderlyingSink(this, underlyingSink, highWaterMark, sizeAlgorithm);
     }
     Object.defineProperty(WritableStream.prototype, "locked", {
+        /**
+         * Returns whether or not the writable stream is locked to a writer.
+         */
         get: function () {
             if (!IsWritableStream(this)) {
-                throw streamBrandCheckException('locked');
+                throw streamBrandCheckException$2('locked');
             }
             return IsWritableStreamLocked(this);
         },
         enumerable: false,
         configurable: true
     });
+    /**
+     * Aborts the stream, signaling that the producer can no longer successfully write to the stream and it is to be
+     * immediately moved to an errored state, with any queued-up writes discarded. This will also execute any abort
+     * mechanism of the underlying sink.
+     *
+     * The returned promise will fulfill if the stream shuts down successfully, or reject if the underlying sink signaled
+     * that there was an error doing so. Additionally, it will reject with a `TypeError` (without attempting to cancel
+     * the stream) if the stream is currently locked.
+     */
     WritableStream.prototype.abort = function (reason) {
         if (reason === void 0) { reason = undefined; }
         if (!IsWritableStream(this)) {
-            return promiseRejectedWith(streamBrandCheckException('abort'));
+            return promiseRejectedWith(streamBrandCheckException$2('abort'));
         }
         if (IsWritableStreamLocked(this)) {
             return promiseRejectedWith(new TypeError('Cannot abort a stream that already has a writer'));
         }
         return WritableStreamAbort(this, reason);
     };
+    /**
+     * Closes the stream. The underlying sink will finish processing any previously-written chunks, before invoking its
+     * close behavior. During this time any further attempts to write will fail (without erroring the stream).
+     *
+     * The method returns a promise that will fulfill if all remaining chunks are successfully written and the stream
+     * successfully closes, or rejects if an error is encountered during this process. Additionally, it will reject with
+     * a `TypeError` (without attempting to cancel the stream) if the stream is currently locked.
+     */
     WritableStream.prototype.close = function () {
         if (!IsWritableStream(this)) {
-            return promiseRejectedWith(streamBrandCheckException('close'));
+            return promiseRejectedWith(streamBrandCheckException$2('close'));
         }
         if (IsWritableStreamLocked(this)) {
             return promiseRejectedWith(new TypeError('Cannot close a stream that already has a writer'));
@@ -1561,9 +1736,17 @@ var WritableStream = /** @class */ (function () {
         }
         return WritableStreamClose(this);
     };
+    /**
+     * Creates a {@link WritableStreamDefaultWriter | writer} and locks the stream to the new writer. While the stream
+     * is locked, no other writer can be acquired until this one is released.
+     *
+     * This functionality is especially useful for creating abstractions that desire the ability to write to a stream
+     * without interruption or interleaving. By getting a writer for the stream, you can ensure nobody else can write at
+     * the same time, which would cause the resulting written data to be unpredictable and probably useless.
+     */
     WritableStream.prototype.getWriter = function () {
         if (!IsWritableStream(this)) {
-            throw streamBrandCheckException('getWriter');
+            throw streamBrandCheckException$2('getWriter');
         }
         return AcquireWritableStreamDefaultWriter(this);
     };
@@ -1628,7 +1811,7 @@ function IsWritableStream(x) {
     if (!Object.prototype.hasOwnProperty.call(x, '_writableStreamController')) {
         return false;
     }
-    return true;
+    return x instanceof WritableStream;
 }
 function IsWritableStreamLocked(stream) {
     if (stream._writer === undefined) {
@@ -1637,6 +1820,15 @@ function IsWritableStreamLocked(stream) {
     return true;
 }
 function WritableStreamAbort(stream, reason) {
+    var _a;
+    if (stream._state === 'closed' || stream._state === 'errored') {
+        return promiseResolvedWith(undefined);
+    }
+    stream._writableStreamController._abortReason = reason;
+    (_a = stream._writableStreamController._abortController) === null || _a === void 0 ? void 0 : _a.abort();
+    // 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.
     var state = stream._state;
     if (state === 'closed' || state === 'errored') {
         return promiseResolvedWith(undefined);
@@ -1822,6 +2014,11 @@ function WritableStreamUpdateBackpressure(stream, backpressure) {
     }
     stream._backpressure = backpressure;
 }
+/**
+ * A default writer vended by a {@link WritableStream}.
+ *
+ * @public
+ */
 var WritableStreamDefaultWriter = /** @class */ (function () {
     function WritableStreamDefaultWriter(stream) {
         assertRequiredArgument(stream, 1, 'WritableStreamDefaultWriter');
@@ -1856,6 +2053,10 @@ var WritableStreamDefaultWriter = /** @class */ (function () {
         }
     }
     Object.defineProperty(WritableStreamDefaultWriter.prototype, "closed", {
+        /**
+         * Returns a promise that will be fulfilled when the stream becomes closed, or rejected if the stream ever errors or
+         * the writer’s lock is released before the stream finishes closing.
+         */
         get: function () {
             if (!IsWritableStreamDefaultWriter(this)) {
                 return promiseRejectedWith(defaultWriterBrandCheckException('closed'));
@@ -1866,6 +2067,14 @@ var WritableStreamDefaultWriter = /** @class */ (function () {
         configurable: true
     });
     Object.defineProperty(WritableStreamDefaultWriter.prototype, "desiredSize", {
+        /**
+         * Returns the desired size to fill the stream’s internal queue. It can be negative, if the queue is over-full.
+         * A producer can use this information to determine the right amount of data to write.
+         *
+         * It will be `null` if the stream cannot be successfully written to (due to either being errored, or having an abort
+         * queued up). It will return zero if the stream is closed. And the getter will throw an exception if invoked when
+         * the writer’s lock is released.
+         */
         get: function () {
             if (!IsWritableStreamDefaultWriter(this)) {
                 throw defaultWriterBrandCheckException('desiredSize');
@@ -1879,6 +2088,14 @@ var WritableStreamDefaultWriter = /** @class */ (function () {
         configurable: true
     });
     Object.defineProperty(WritableStreamDefaultWriter.prototype, "ready", {
+        /**
+         * Returns a promise that will be fulfilled when the desired size to fill the stream’s internal queue transitions
+         * from non-positive to positive, signaling that it is no longer applying backpressure. Once the desired size dips
+         * back to zero or below, the getter will return a new promise that stays pending until the next transition.
+         *
+         * If the stream becomes errored or aborted, or the writer’s lock is released, the returned promise will become
+         * rejected.
+         */
         get: function () {
             if (!IsWritableStreamDefaultWriter(this)) {
                 return promiseRejectedWith(defaultWriterBrandCheckException('ready'));
@@ -1888,6 +2105,9 @@ var WritableStreamDefaultWriter = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    /**
+     * If the reader is active, behaves the same as {@link WritableStream.abort | stream.abort(reason)}.
+     */
     WritableStreamDefaultWriter.prototype.abort = function (reason) {
         if (reason === void 0) { reason = undefined; }
         if (!IsWritableStreamDefaultWriter(this)) {
@@ -1898,6 +2118,9 @@ var WritableStreamDefaultWriter = /** @class */ (function () {
         }
         return WritableStreamDefaultWriterAbort(this, reason);
     };
+    /**
+     * If the reader is active, behaves the same as {@link WritableStream.close | stream.close()}.
+     */
     WritableStreamDefaultWriter.prototype.close = function () {
         if (!IsWritableStreamDefaultWriter(this)) {
             return promiseRejectedWith(defaultWriterBrandCheckException('close'));
@@ -1911,6 +2134,16 @@ var WritableStreamDefaultWriter = /** @class */ (function () {
         }
         return WritableStreamDefaultWriterClose(this);
     };
+    /**
+     * Releases the writer’s lock on the corresponding stream. After the lock is released, the writer is no longer active.
+     * If the associated stream is errored when the lock is released, the writer will appear errored in the same way from
+     * now on; otherwise, the writer will appear closed.
+     *
+     * Note that the lock can still be released even if some ongoing writes have not yet finished (i.e. even if the
+     * promises returned from previous calls to {@link WritableStreamDefaultWriter.write | write()} have not yet settled).
+     * It’s not necessary to hold the lock on the writer for the duration of the write; the lock instead simply prevents
+     * other producers from writing in an interleaved manner.
+     */
     WritableStreamDefaultWriter.prototype.releaseLock = function () {
         if (!IsWritableStreamDefaultWriter(this)) {
             throw defaultWriterBrandCheckException('releaseLock');
@@ -1956,7 +2189,7 @@ function IsWritableStreamDefaultWriter(x) {
     if (!Object.prototype.hasOwnProperty.call(x, '_ownerWritableStream')) {
         return false;
     }
-    return true;
+    return x instanceof WritableStreamDefaultWriter;
 }
 // A client of WritableStreamDefaultWriter may use these functions directly to bypass state check.
 function WritableStreamDefaultWriterAbort(writer, reason) {
@@ -2037,14 +2270,58 @@ function WritableStreamDefaultWriterWrite(writer, chunk) {
     return promise;
 }
 var closeSentinel = {};
+/**
+ * Allows control of a {@link WritableStream | writable stream}'s state and internal queue.
+ *
+ * @public
+ */
 var WritableStreamDefaultController = /** @class */ (function () {
     function WritableStreamDefaultController() {
         throw new TypeError('Illegal constructor');
     }
+    Object.defineProperty(WritableStreamDefaultController.prototype, "abortReason", {
+        /**
+         * The reason which was passed to `WritableStream.abort(reason)` when the stream was aborted.
+         */
+        get: function () {
+            if (!IsWritableStreamDefaultController(this)) {
+                throw defaultControllerBrandCheckException$2('abortReason');
+            }
+            return this._abortReason;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(WritableStreamDefaultController.prototype, "signal", {
+        /**
+         * An `AbortSignal` that can be used to abort the pending write or close operation when the stream is aborted.
+         */
+        get: function () {
+            if (!IsWritableStreamDefaultController(this)) {
+                throw defaultControllerBrandCheckException$2('signal');
+            }
+            if (this._abortController === undefined) {
+                // Older browsers or older Node versions may not support `AbortController` or `AbortSignal`.
+                // We don't want to bundle and ship an `AbortController` polyfill together with our polyfill,
+                // so instead we only implement support for `signal` if we find a global `AbortController` constructor.
+                throw new TypeError('WritableStreamDefaultController.prototype.signal is not supported');
+            }
+            return this._abortController.signal;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Closes the controlled writable stream, making all future interactions with it fail with the given error `e`.
+     *
+     * This method is rarely used, since usually it suffices to return a rejected promise from one of the underlying
+     * sink's methods. However, it can be useful for suddenly shutting down a stream in response to an event outside the
+     * normal lifecycle of interactions with the underlying sink.
+     */
     WritableStreamDefaultController.prototype.error = function (e) {
         if (e === void 0) { e = undefined; }
         if (!IsWritableStreamDefaultController(this)) {
-            throw new TypeError('WritableStreamDefaultController.prototype.error can only be used on a WritableStreamDefaultController');
+            throw defaultControllerBrandCheckException$2('error');
         }
         var state = this._controlledWritableStream._state;
         if (state !== 'writable') {
@@ -2083,7 +2360,7 @@ function IsWritableStreamDefaultController(x) {
     if (!Object.prototype.hasOwnProperty.call(x, '_controlledWritableStream')) {
         return false;
     }
-    return true;
+    return x instanceof WritableStreamDefaultController;
 }
 function SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm) {
     controller._controlledWritableStream = stream;
@@ -2092,6 +2369,8 @@ function SetUpWritableStreamDefaultController(stream, controller, startAlgorithm
     controller._queue = undefined;
     controller._queueTotalSize = undefined;
     ResetQueue(controller);
+    controller._abortReason = undefined;
+    controller._abortController = createAbortController();
     controller._started = false;
     controller._strategySizeAlgorithm = sizeAlgorithm;
     controller._strategyHWM = highWaterMark;
@@ -2241,9 +2520,13 @@ function WritableStreamDefaultControllerError(controller, error) {
     WritableStreamStartErroring(stream, error);
 }
 // Helper functions for the WritableStream.
-function streamBrandCheckException(name) {
+function streamBrandCheckException$2(name) {
     return new TypeError("WritableStream.prototype." + name + " can only be used on a WritableStream");
 }
+// Helper functions for the WritableStreamDefaultController.
+function defaultControllerBrandCheckException$2(name) {
+    return new TypeError("WritableStreamDefaultController.prototype." + name + " can only be used on a WritableStreamDefaultController");
+}
 // Helper functions for the WritableStreamDefaultWriter.
 function defaultWriterBrandCheckException(name) {
     return new TypeError("WritableStreamDefaultWriter.prototype." + name + " can only be used on a WritableStreamDefaultWriter");
@@ -2267,6 +2550,9 @@ function defaultWriterClosedPromiseInitializeAsResolved(writer) {
     defaultWriterClosedPromiseResolve(writer);
 }
 function defaultWriterClosedPromiseReject(writer, reason) {
+    if (writer._closedPromise_reject === undefined) {
+        return;
+    }
     setPromiseIsHandledToTrue(writer._closedPromise);
     writer._closedPromise_reject(reason);
     writer._closedPromise_resolve = undefined;
@@ -2277,6 +2563,9 @@ function defaultWriterClosedPromiseResetToRejected(writer, reason) {
     defaultWriterClosedPromiseInitializeAsRejected(writer, reason);
 }
 function defaultWriterClosedPromiseResolve(writer) {
+    if (writer._closedPromise_resolve === undefined) {
+        return;
+    }
     writer._closedPromise_resolve(undefined);
     writer._closedPromise_resolve = undefined;
     writer._closedPromise_reject = undefined;
@@ -2298,6 +2587,9 @@ function defaultWriterReadyPromiseInitializeAsResolved(writer) {
     defaultWriterReadyPromiseResolve(writer);
 }
 function defaultWriterReadyPromiseReject(writer, reason) {
+    if (writer._readyPromise_reject === undefined) {
+        return;
+    }
     setPromiseIsHandledToTrue(writer._readyPromise);
     writer._readyPromise_reject(reason);
     writer._readyPromise_resolve = undefined;
@@ -2311,25 +2603,15 @@ function defaultWriterReadyPromiseResetToRejected(writer, reason) {
     defaultWriterReadyPromiseInitializeAsRejected(writer, reason);
 }
 function defaultWriterReadyPromiseResolve(writer) {
+    if (writer._readyPromise_resolve === undefined) {
+        return;
+    }
     writer._readyPromise_resolve(undefined);
     writer._readyPromise_resolve = undefined;
     writer._readyPromise_reject = undefined;
     writer._readyPromiseState = 'fulfilled';
 }
 
-function isAbortSignal(value) {
-    if (typeof value !== 'object' || value === null) {
-        return false;
-    }
-    try {
-        return typeof value.aborted === 'boolean';
-    }
-    catch (_a) {
-        // AbortSignal.prototype.aborted throws if its brand check fails
-        return false;
-    }
-}
-
 /// <reference lib="dom" />
 var NativeDOMException = typeof DOMException !== 'undefined' ? DOMException : undefined;
 
@@ -2347,6 +2629,7 @@ function isDOMExceptionConstructor(ctor) {
     }
 }
 function createDOMExceptionPolyfill() {
+    // eslint-disable-next-line no-shadow
     var ctor = function DOMException(message, name) {
         this.message = message || '';
         this.name = name || 'Error';
@@ -2358,6 +2641,7 @@ function createDOMExceptionPolyfill() {
     Object.defineProperty(ctor.prototype, 'constructor', { value: ctor, writable: true, configurable: true });
     return ctor;
 }
+// eslint-disable-next-line no-redeclare
 var DOMException$1 = isDOMExceptionConstructor(NativeDOMException) ? NativeDOMException : createDOMExceptionPolyfill();
 
 function ReadableStreamPipeTo(source, dest, preventClose, preventAbort, preventCancel, signal) {
@@ -2535,23 +2819,36 @@ function ReadableStreamPipeTo(source, dest, preventClose, preventAbort, preventC
     });
 }
 
+/**
+ * Allows control of a {@link ReadableStream | readable stream}'s state and internal queue.
+ *
+ * @public
+ */
 var ReadableStreamDefaultController = /** @class */ (function () {
     function ReadableStreamDefaultController() {
         throw new TypeError('Illegal constructor');
     }
     Object.defineProperty(ReadableStreamDefaultController.prototype, "desiredSize", {
+        /**
+         * Returns the desired size to fill the controlled stream's internal queue. It can be negative, if the queue is
+         * over-full. An underlying source ought to use this information to determine when and how to apply backpressure.
+         */
         get: function () {
             if (!IsReadableStreamDefaultController(this)) {
-                throw defaultControllerBrandCheckException('desiredSize');
+                throw defaultControllerBrandCheckException$1('desiredSize');
             }
             return ReadableStreamDefaultControllerGetDesiredSize(this);
         },
         enumerable: false,
         configurable: true
     });
+    /**
+     * Closes the controlled readable stream. Consumers will still be able to read any previously-enqueued chunks from
+     * the stream, but once those are read, the stream will become closed.
+     */
     ReadableStreamDefaultController.prototype.close = function () {
         if (!IsReadableStreamDefaultController(this)) {
-            throw defaultControllerBrandCheckException('close');
+            throw defaultControllerBrandCheckException$1('close');
         }
         if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(this)) {
             throw new TypeError('The stream is not in a state that permits close');
@@ -2561,17 +2858,20 @@ var ReadableStreamDefaultController = /** @class */ (function () {
     ReadableStreamDefaultController.prototype.enqueue = function (chunk) {
         if (chunk === void 0) { chunk = undefined; }
         if (!IsReadableStreamDefaultController(this)) {
-            throw defaultControllerBrandCheckException('enqueue');
+            throw defaultControllerBrandCheckException$1('enqueue');
         }
         if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(this)) {
             throw new TypeError('The stream is not in a state that permits enqueue');
         }
         return ReadableStreamDefaultControllerEnqueue(this, chunk);
     };
+    /**
+     * Errors the controlled readable stream, making all future interactions with it fail with the given error `e`.
+     */
     ReadableStreamDefaultController.prototype.error = function (e) {
         if (e === void 0) { e = undefined; }
         if (!IsReadableStreamDefaultController(this)) {
-            throw defaultControllerBrandCheckException('error');
+            throw defaultControllerBrandCheckException$1('error');
         }
         ReadableStreamDefaultControllerError(this, e);
     };
@@ -2623,7 +2923,7 @@ function IsReadableStreamDefaultController(x) {
     if (!Object.prototype.hasOwnProperty.call(x, '_controlledReadableStream')) {
         return false;
     }
-    return true;
+    return x instanceof ReadableStreamDefaultController;
 }
 function ReadableStreamDefaultControllerCallPullIfNeeded(controller) {
     var shouldPull = ReadableStreamDefaultControllerShouldCallPull(controller);
@@ -2717,8 +3017,7 @@ function ReadableStreamDefaultControllerError(controller, e) {
     ReadableStreamError(stream, e);
 }
 function ReadableStreamDefaultControllerGetDesiredSize(controller) {
-    var stream = controller._controlledReadableStream;
-    var state = stream._state;
+    var state = controller._controlledReadableStream._state;
     if (state === 'errored') {
         return null;
     }
@@ -2780,11 +3079,17 @@ function SetUpReadableStreamDefaultControllerFromUnderlyingSource(stream, underl
     SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm);
 }
 // Helper functions for the ReadableStreamDefaultController.
-function defaultControllerBrandCheckException(name) {
+function defaultControllerBrandCheckException$1(name) {
     return new TypeError("ReadableStreamDefaultController.prototype." + name + " can only be used on a ReadableStreamDefaultController");
 }
 
 function ReadableStreamTee(stream, cloneForBranch2) {
+    if (IsReadableByteStreamController(stream._readableStreamController)) {
+        return ReadableByteStreamTee(stream);
+    }
+    return ReadableStreamDefaultTee(stream);
+}
+function ReadableStreamDefaultTee(stream, cloneForBranch2) {
     var reader = AcquireReadableStreamDefaultReader(stream);
     var reading = false;
     var canceled1 = false;
@@ -2803,24 +3108,24 @@ function ReadableStreamTee(stream, cloneForBranch2) {
         }
         reading = true;
         var readRequest = {
-            _chunkSteps: function (value) {
+            _chunkSteps: function (chunk) {
                 // 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(function () {
                     reading = false;
-                    var value1 = value;
-                    var value2 = value;
+                    var chunk1 = chunk;
+                    var chunk2 = chunk;
                     // There is no way to access the cloning code right now in the reference implementation.
                     // If we add one then we'll need an implementation for serializable objects.
                     // if (!canceled2 && cloneForBranch2) {
-                    //   value2 = StructuredDeserialize(StructuredSerialize(value2));
+                    //   chunk2 = StructuredDeserialize(StructuredSerialize(chunk2));
                     // }
                     if (!canceled1) {
-                        ReadableStreamDefaultControllerEnqueue(branch1._readableStreamController, value1);
+                        ReadableStreamDefaultControllerEnqueue(branch1._readableStreamController, chunk1);
                     }
                     if (!canceled2) {
-                        ReadableStreamDefaultControllerEnqueue(branch2._readableStreamController, value2);
+                        ReadableStreamDefaultControllerEnqueue(branch2._readableStreamController, chunk2);
                     }
                 });
             },
@@ -2832,6 +3137,9 @@ function ReadableStreamTee(stream, cloneForBranch2) {
                 if (!canceled2) {
                     ReadableStreamDefaultControllerClose(branch2._readableStreamController);
                 }
+                if (!canceled1 || !canceled2) {
+                    resolveCancelPromise(undefined);
+                }
             },
             _errorSteps: function () {
                 reading = false;
@@ -2868,9 +3176,217 @@ function ReadableStreamTee(stream, cloneForBranch2) {
     uponRejection(reader._closedPromise, function (r) {
         ReadableStreamDefaultControllerError(branch1._readableStreamController, r);
         ReadableStreamDefaultControllerError(branch2._readableStreamController, r);
+        if (!canceled1 || !canceled2) {
+            resolveCancelPromise(undefined);
+        }
     });
     return [branch1, branch2];
 }
+function ReadableByteStreamTee(stream) {
+    var reader = AcquireReadableStreamDefaultReader(stream);
+    var reading = false;
+    var canceled1 = false;
+    var canceled2 = false;
+    var reason1;
+    var reason2;
+    var branch1;
+    var branch2;
+    var resolveCancelPromise;
+    var cancelPromise = newPromise(function (resolve) {
+        resolveCancelPromise = resolve;
+    });
+    function forwardReaderError(thisReader) {
+        uponRejection(thisReader._closedPromise, function (r) {
+            if (thisReader !== reader) {
+                return;
+            }
+            ReadableByteStreamControllerError(branch1._readableStreamController, r);
+            ReadableByteStreamControllerError(branch2._readableStreamController, r);
+            if (!canceled1 || !canceled2) {
+                resolveCancelPromise(undefined);
+            }
+        });
+    }
+    function pullWithDefaultReader() {
+        if (IsReadableStreamBYOBReader(reader)) {
+            ReadableStreamReaderGenericRelease(reader);
+            reader = AcquireReadableStreamDefaultReader(stream);
+            forwardReaderError(reader);
+        }
+        var readRequest = {
+            _chunkSteps: function (chunk) {
+                // 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(function () {
+                    reading = false;
+                    var chunk1 = chunk;
+                    var chunk2 = chunk;
+                    if (!canceled1 && !canceled2) {
+                        try {
+                            chunk2 = CloneAsUint8Array(chunk);
+                        }
+                        catch (cloneE) {
+                            ReadableByteStreamControllerError(branch1._readableStreamController, cloneE);
+                            ReadableByteStreamControllerError(branch2._readableStreamController, cloneE);
+                            resolveCancelPromise(ReadableStreamCancel(stream, cloneE));
+                            return;
+                        }
+                    }
+                    if (!canceled1) {
+                        ReadableByteStreamControllerEnqueue(branch1._readableStreamController, chunk1);
+                    }
+                    if (!canceled2) {
+                        ReadableByteStreamControllerEnqueue(branch2._readableStreamController, chunk2);
+                    }
+                });
+            },
+            _closeSteps: function () {
+                reading = false;
+                if (!canceled1) {
+                    ReadableByteStreamControllerClose(branch1._readableStreamController);
+                }
+                if (!canceled2) {
+                    ReadableByteStreamControllerClose(branch2._readableStreamController);
+                }
+                if (branch1._readableStreamController._pendingPullIntos.length > 0) {
+                    ReadableByteStreamControllerRespond(branch1._readableStreamController, 0);
+                }
+                if (branch2._readableStreamController._pendingPullIntos.length > 0) {
+                    ReadableByteStreamControllerRespond(branch2._readableStreamController, 0);
+                }
+                if (!canceled1 || !canceled2) {
+                    resolveCancelPromise(undefined);
+                }
+            },
+            _errorSteps: function () {
+                reading = false;
+            }
+        };
+        ReadableStreamDefaultReaderRead(reader, readRequest);
+    }
+    function pullWithBYOBReader(view, forBranch2) {
+        if (IsReadableStreamDefaultReader(reader)) {
+            ReadableStreamReaderGenericRelease(reader);
+            reader = AcquireReadableStreamBYOBReader(stream);
+            forwardReaderError(reader);
+        }
+        var byobBranch = forBranch2 ? branch2 : branch1;
+        var otherBranch = forBranch2 ? branch1 : branch2;
+        var readIntoRequest = {
+            _chunkSteps: function (chunk) {
+                // 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(function () {
+                    reading = false;
+                    var byobCanceled = forBranch2 ? canceled2 : canceled1;
+                    var otherCanceled = forBranch2 ? canceled1 : canceled2;
+                    if (!otherCanceled) {
+                        var clonedChunk = void 0;
+                        try {
+                            clonedChunk = CloneAsUint8Array(chunk);
+                        }
+                        catch (cloneE) {
+                            ReadableByteStreamControllerError(byobBranch._readableStreamController, cloneE);
+                            ReadableByteStreamControllerError(otherBranch._readableStreamController, cloneE);
+                            resolveCancelPromise(ReadableStreamCancel(stream, cloneE));
+                            return;
+                        }
+                        if (!byobCanceled) {
+                            ReadableByteStreamControllerRespondWithNewView(byobBranch._readableStreamController, chunk);
+                        }
+                        ReadableByteStreamControllerEnqueue(otherBranch._readableStreamController, clonedChunk);
+                    }
+                    else if (!byobCanceled) {
+                        ReadableByteStreamControllerRespondWithNewView(byobBranch._readableStreamController, chunk);
+                    }
+                });
+            },
+            _closeSteps: function (chunk) {
+                reading = false;
+                var byobCanceled = forBranch2 ? canceled2 : canceled1;
+                var otherCanceled = forBranch2 ? canceled1 : canceled2;
+                if (!byobCanceled) {
+                    ReadableByteStreamControllerClose(byobBranch._readableStreamController);
+                }
+                if (!otherCanceled) {
+                    ReadableByteStreamControllerClose(otherBranch._readableStreamController);
+                }
+                if (chunk !== undefined) {
+                    if (!byobCanceled) {
+                        ReadableByteStreamControllerRespondWithNewView(byobBranch._readableStreamController, chunk);
+                    }
+                    if (!otherCanceled && otherBranch._readableStreamController._pendingPullIntos.length > 0) {
+                        ReadableByteStreamControllerRespond(otherBranch._readableStreamController, 0);
+                    }
+                }
+                if (!byobCanceled || !otherCanceled) {
+                    resolveCancelPromise(undefined);
+                }
+            },
+            _errorSteps: function () {
+                reading = false;
+            }
+        };
+        ReadableStreamBYOBReaderRead(reader, view, readIntoRequest);
+    }
+    function pull1Algorithm() {
+        if (reading) {
+            return promiseResolvedWith(undefined);
+        }
+        reading = true;
+        var byobRequest = ReadableByteStreamControllerGetBYOBRequest(branch1._readableStreamController);
+        if (byobRequest === null) {
+            pullWithDefaultReader();
+        }
+        else {
+            pullWithBYOBReader(byobRequest._view, false);
+        }
+        return promiseResolvedWith(undefined);
+    }
+    function pull2Algorithm() {
+        if (reading) {
+            return promiseResolvedWith(undefined);
+        }
+        reading = true;
+        var byobRequest = ReadableByteStreamControllerGetBYOBRequest(branch2._readableStreamController);
+        if (byobRequest === null) {
+            pullWithDefaultReader();
+        }
+        else {
+            pullWithBYOBReader(byobRequest._view, true);
+        }
+        return promiseResolvedWith(undefined);
+    }
+    function cancel1Algorithm(reason) {
+        canceled1 = true;
+        reason1 = reason;
+        if (canceled2) {
+            var compositeReason = CreateArrayFromList([reason1, reason2]);
+            var cancelResult = ReadableStreamCancel(stream, compositeReason);
+            resolveCancelPromise(cancelResult);
+        }
+        return cancelPromise;
+    }
+    function cancel2Algorithm(reason) {
+        canceled2 = true;
+        reason2 = reason;
+        if (canceled1) {
+            var compositeReason = CreateArrayFromList([reason1, reason2]);
+            var cancelResult = ReadableStreamCancel(stream, compositeReason);
+            resolveCancelPromise(cancelResult);
+        }
+        return cancelPromise;
+    }
+    function startAlgorithm() {
+        return;
+    }
+    branch1 = CreateReadableByteStream(startAlgorithm, pull1Algorithm, cancel1Algorithm);
+    branch2 = CreateReadableByteStream(startAlgorithm, pull2Algorithm, cancel2Algorithm);
+    forwardReaderError(reader);
+    return [branch1, branch2];
+}
 
 function convertUnderlyingDefaultOrByteSource(source, context) {
     assertDictionary(source, context);
@@ -2970,6 +3486,11 @@ function convertReadableWritablePair(pair, context) {
     return { readable: readable, writable: writable };
 }
 
+/**
+ * A readable stream represents a source of data, from which you can read.
+ *
+ * @public
+ */
 var ReadableStream = /** @class */ (function () {
     function ReadableStream(rawUnderlyingSource, rawStrategy) {
         if (rawUnderlyingSource === void 0) { rawUnderlyingSource = {}; }
@@ -2997,6 +3518,9 @@ var ReadableStream = /** @class */ (function () {
         }
     }
     Object.defineProperty(ReadableStream.prototype, "locked", {
+        /**
+         * Whether or not the readable stream is locked to a {@link ReadableStreamDefaultReader | reader}.
+         */
         get: function () {
             if (!IsReadableStream(this)) {
                 throw streamBrandCheckException$1('locked');
@@ -3006,6 +3530,12 @@ var ReadableStream = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    /**
+     * Cancels the stream, signaling a loss of interest in the stream by a consumer.
+     *
+     * The supplied `reason` argument will be given to the underlying source's {@link UnderlyingSource.cancel | cancel()}
+     * method, which might or might not use it.
+     */
     ReadableStream.prototype.cancel = function (reason) {
         if (reason === void 0) { reason = undefined; }
         if (!IsReadableStream(this)) {
@@ -3071,6 +3601,17 @@ var ReadableStream = /** @class */ (function () {
         }
         return ReadableStreamPipeTo(this, destination, options.preventClose, options.preventAbort, options.preventCancel, options.signal);
     };
+    /**
+     * Tees this readable stream, returning a two-element array containing the two resulting branches as
+     * new {@link ReadableStream} instances.
+     *
+     * Teeing a stream will lock it, preventing any other consumer from acquiring a reader.
+     * To cancel the stream, cancel both of the resulting branches; a composite cancellation reason will then be
+     * propagated to the stream's underlying source.
+     *
+     * Note that the chunks seen in each branch will be the same object. If the chunks are not immutable,
+     * this could allow interference between the two branches.
+     */
     ReadableStream.prototype.tee = function () {
         if (!IsReadableStream(this)) {
             throw streamBrandCheckException$1('tee');
@@ -3121,6 +3662,14 @@ function CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, hi
     SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm);
     return stream;
 }
+// Throws if and only if startAlgorithm throws.
+function CreateReadableByteStream(startAlgorithm, pullAlgorithm, cancelAlgorithm) {
+    var stream = Object.create(ReadableStream.prototype);
+    InitializeReadableStream(stream);
+    var controller = Object.create(ReadableByteStreamController.prototype);
+    SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, 0, undefined);
+    return stream;
+}
 function InitializeReadableStream(stream) {
     stream._state = 'readable';
     stream._reader = undefined;
@@ -3134,7 +3683,7 @@ function IsReadableStream(x) {
     if (!Object.prototype.hasOwnProperty.call(x, '_readableStreamController')) {
         return false;
     }
-    return true;
+    return x instanceof ReadableStream;
 }
 function IsReadableStreamLocked(stream) {
     if (stream._reader === undefined) {
@@ -3152,6 +3701,13 @@ function ReadableStreamCancel(stream, reason) {
         return promiseRejectedWith(stream._storedError);
     }
     ReadableStreamClose(stream);
+    var reader = stream._reader;
+    if (reader !== undefined && IsReadableStreamBYOBReader(reader)) {
+        reader._readIntoRequests.forEach(function (readIntoRequest) {
+            readIntoRequest._closeSteps(undefined);
+        });
+        reader._readIntoRequests = new SimpleQueue();
+    }
     var sourceCancelPromise = stream._readableStreamController[CancelSteps](reason);
     return transformPromiseWith(sourceCancelPromise, noop);
 }
@@ -3161,13 +3717,13 @@ function ReadableStreamClose(stream) {
     if (reader === undefined) {
         return;
     }
+    defaultReaderClosedPromiseResolve(reader);
     if (IsReadableStreamDefaultReader(reader)) {
         reader._readRequests.forEach(function (readRequest) {
             readRequest._closeSteps();
         });
         reader._readRequests = new SimpleQueue();
     }
-    defaultReaderClosedPromiseResolve(reader);
 }
 function ReadableStreamError(stream, e) {
     stream._state = 'errored';
@@ -3176,6 +3732,7 @@ function ReadableStreamError(stream, e) {
     if (reader === undefined) {
         return;
     }
+    defaultReaderClosedPromiseReject(reader, e);
     if (IsReadableStreamDefaultReader(reader)) {
         reader._readRequests.forEach(function (readRequest) {
             readRequest._errorSteps(e);
@@ -3188,7 +3745,6 @@ function ReadableStreamError(stream, e) {
         });
         reader._readIntoRequests = new SimpleQueue();
     }
-    defaultReaderClosedPromiseReject(reader, e);
 }
 // Helper functions for the ReadableStream.
 function streamBrandCheckException$1(name) {
@@ -3204,9 +3760,19 @@ function convertQueuingStrategyInit(init, context) {
     };
 }
 
-var byteLengthSizeFunction = function size(chunk) {
+// The size function must not have a prototype property nor be a constructor
+var byteLengthSizeFunction = function (chunk) {
     return chunk.byteLength;
 };
+Object.defineProperty(byteLengthSizeFunction, 'name', {
+    value: 'size',
+    configurable: true
+});
+/**
+ * A queuing strategy that counts the number of bytes in each chunk.
+ *
+ * @public
+ */
 var ByteLengthQueuingStrategy = /** @class */ (function () {
     function ByteLengthQueuingStrategy(options) {
         assertRequiredArgument(options, 1, 'ByteLengthQueuingStrategy');
@@ -3214,6 +3780,9 @@ var ByteLengthQueuingStrategy = /** @class */ (function () {
         this._byteLengthQueuingStrategyHighWaterMark = options.highWaterMark;
     }
     Object.defineProperty(ByteLengthQueuingStrategy.prototype, "highWaterMark", {
+        /**
+         * Returns the high water mark provided to the constructor.
+         */
         get: function () {
             if (!IsByteLengthQueuingStrategy(this)) {
                 throw byteLengthBrandCheckException('highWaterMark');
@@ -3224,6 +3793,9 @@ var ByteLengthQueuingStrategy = /** @class */ (function () {
         configurable: true
     });
     Object.defineProperty(ByteLengthQueuingStrategy.prototype, "size", {
+        /**
+         * Measures the size of `chunk` by returning the value of its `byteLength` property.
+         */
         get: function () {
             if (!IsByteLengthQueuingStrategy(this)) {
                 throw byteLengthBrandCheckException('size');
@@ -3256,12 +3828,22 @@ function IsByteLengthQueuingStrategy(x) {
     if (!Object.prototype.hasOwnProperty.call(x, '_byteLengthQueuingStrategyHighWaterMark')) {
         return false;
     }
-    return true;
+    return x instanceof ByteLengthQueuingStrategy;
 }
 
-var countSizeFunction = function size() {
+// The size function must not have a prototype property nor be a constructor
+var countSizeFunction = function () {
     return 1;
 };
+Object.defineProperty(countSizeFunction, 'name', {
+    value: 'size',
+    configurable: true
+});
+/**
+ * A queuing strategy that counts the number of chunks.
+ *
+ * @public
+ */
 var CountQueuingStrategy = /** @class */ (function () {
     function CountQueuingStrategy(options) {
         assertRequiredArgument(options, 1, 'CountQueuingStrategy');
@@ -3269,6 +3851,9 @@ var CountQueuingStrategy = /** @class */ (function () {
         this._countQueuingStrategyHighWaterMark = options.highWaterMark;
     }
     Object.defineProperty(CountQueuingStrategy.prototype, "highWaterMark", {
+        /**
+         * Returns the high water mark provided to the constructor.
+         */
         get: function () {
             if (!IsCountQueuingStrategy(this)) {
                 throw countBrandCheckException('highWaterMark');
@@ -3279,6 +3864,10 @@ var CountQueuingStrategy = /** @class */ (function () {
         configurable: true
     });
     Object.defineProperty(CountQueuingStrategy.prototype, "size", {
+        /**
+         * Measures the size of `chunk` by always returning 1.
+         * This ensures that the total queue size is a count of the number of chunks in the queue.
+         */
         get: function () {
             if (!IsCountQueuingStrategy(this)) {
                 throw countBrandCheckException('size');
@@ -3311,7 +3900,7 @@ function IsCountQueuingStrategy(x) {
     if (!Object.prototype.hasOwnProperty.call(x, '_countQueuingStrategyHighWaterMark')) {
         return false;
     }
-    return true;
+    return x instanceof CountQueuingStrategy;
 }
 
 function convertTransformer(original, context) {
@@ -3349,6 +3938,14 @@ function convertTransformerTransformCallback(fn, original, context) {
 }
 
 // Class TransformStream
+/**
+ * A transform stream consists of a pair of streams: a {@link WritableStream | writable stream},
+ * known as its writable side, and a {@link ReadableStream | readable stream}, known as its readable side.
+ * In a manner specific to the transform stream in question, writes to the writable side result in new data being
+ * made available for reading from the readable side.
+ *
+ * @public
+ */
 var TransformStream = /** @class */ (function () {
     function TransformStream(rawTransformer, rawWritableStrategy, rawReadableStrategy) {
         if (rawTransformer === void 0) { rawTransformer = {}; }
@@ -3384,9 +3981,12 @@ var TransformStream = /** @class */ (function () {
         }
     }
     Object.defineProperty(TransformStream.prototype, "readable", {
+        /**
+         * The readable side of the transform stream.
+         */
         get: function () {
             if (!IsTransformStream(this)) {
-                throw streamBrandCheckException$2('readable');
+                throw streamBrandCheckException('readable');
             }
             return this._readable;
         },
@@ -3394,9 +3994,12 @@ var TransformStream = /** @class */ (function () {
         configurable: true
     });
     Object.defineProperty(TransformStream.prototype, "writable", {
+        /**
+         * The writable side of the transform stream.
+         */
         get: function () {
             if (!IsTransformStream(this)) {
-                throw streamBrandCheckException$2('writable');
+                throw streamBrandCheckException('writable');
             }
             return this._writable;
         },
@@ -3451,7 +4054,7 @@ function IsTransformStream(x) {
     if (!Object.prototype.hasOwnProperty.call(x, '_transformStreamController')) {
         return false;
     }
-    return true;
+    return x instanceof TransformStream;
 }
 // This is a no-op if both sides are already errored.
 function TransformStreamError(stream, e) {
@@ -3479,14 +4082,22 @@ function TransformStreamSetBackpressure(stream, backpressure) {
     stream._backpressure = backpressure;
 }
 // Class TransformStreamDefaultController
+/**
+ * Allows control of the {@link ReadableStream} and {@link WritableStream} of the associated {@link TransformStream}.
+ *
+ * @public
+ */
 var TransformStreamDefaultController = /** @class */ (function () {
     function TransformStreamDefaultController() {
         throw new TypeError('Illegal constructor');
     }
     Object.defineProperty(TransformStreamDefaultController.prototype, "desiredSize", {
+        /**
+         * Returns the desired size to fill the readable side’s internal queue. It can be negative, if the queue is over-full.
+         */
         get: function () {
             if (!IsTransformStreamDefaultController(this)) {
-                throw defaultControllerBrandCheckException$1('desiredSize');
+                throw defaultControllerBrandCheckException('desiredSize');
             }
             var readableController = this._controlledTransformStream._readable._readableStreamController;
             return ReadableStreamDefaultControllerGetDesiredSize(readableController);
@@ -3497,20 +4108,28 @@ var TransformStreamDefaultController = /** @class */ (function () {
     TransformStreamDefaultController.prototype.enqueue = function (chunk) {
         if (chunk === void 0) { chunk = undefined; }
         if (!IsTransformStreamDefaultController(this)) {
-            throw defaultControllerBrandCheckException$1('enqueue');
+            throw defaultControllerBrandCheckException('enqueue');
         }
         TransformStreamDefaultControllerEnqueue(this, chunk);
     };
+    /**
+     * Errors both the readable side and the writable side of the controlled transform stream, making all future
+     * interactions with it fail with the given error `e`. Any chunks queued for transformation will be discarded.
+     */
     TransformStreamDefaultController.prototype.error = function (reason) {
         if (reason === void 0) { reason = undefined; }
         if (!IsTransformStreamDefaultController(this)) {
-            throw defaultControllerBrandCheckException$1('error');
+            throw defaultControllerBrandCheckException('error');
         }
         TransformStreamDefaultControllerError(this, reason);
     };
+    /**
+     * Closes the readable side and errors the writable side of the controlled transform stream. This is useful when the
+     * transformer only needs to consume a portion of the chunks written to the writable side.
+     */
     TransformStreamDefaultController.prototype.terminate = function () {
         if (!IsTransformStreamDefaultController(this)) {
-            throw defaultControllerBrandCheckException$1('terminate');
+            throw defaultControllerBrandCheckException('terminate');
         }
         TransformStreamDefaultControllerTerminate(this);
     };
@@ -3536,7 +4155,7 @@ function IsTransformStreamDefaultController(x) {
     if (!Object.prototype.hasOwnProperty.call(x, '_controlledTransformStream')) {
         return false;
     }
-    return true;
+    return x instanceof TransformStreamDefaultController;
 }
 function SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm) {
     controller._controlledTransformStream = stream;
@@ -3653,11 +4272,11 @@ function TransformStreamDefaultSourcePullAlgorithm(stream) {
     return stream._backpressureChangePromise;
 }
 // Helper functions for the TransformStreamDefaultController.
-function defaultControllerBrandCheckException$1(name) {
+function defaultControllerBrandCheckException(name) {
     return new TypeError("TransformStreamDefaultController.prototype." + name + " can only be used on a TransformStreamDefaultController");
 }
 // Helper functions for the TransformStream.
-function streamBrandCheckException$2(name) {
+function streamBrandCheckException(name) {
     return new TypeError("TransformStream.prototype." + name + " can only be used on a TransformStream");
 }