web-streams-polyfill 3.0.0 → 3.1.0

package/dist/polyfill.js

@@ -1,10 +1,10 @@
 /**
- * web-streams-polyfill v3.0.0
+ * web-streams-polyfill v3.1.0
  */
 (function (global, factory) {
     typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
     typeof define === 'function' && define.amd ? define(['exports'], factory) :
-    (global = global || self, factory(global.WebStreamsPolyfill = {}));
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.WebStreamsPolyfill = {}));
 }(this, (function (exports) { 'use strict';
 
     /// <reference lib="es2015.symbol" />
@@ -14,7 +14,7 @@
 
     /// <reference lib="dom" />
     function noop() {
-        // do nothing
+        return undefined;
     }
     function getGlobals() {
         if (typeof self !== 'undefined') {
@@ -33,7 +33,7 @@
     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;
@@ -253,6 +253,9 @@
         defaultReaderClosedPromiseResolve(reader);
     }
     function defaultReaderClosedPromiseReject(reader, reason) {
+        if (reader._closedPromise_reject === undefined) {
+            return;
+        }
         setPromiseIsHandledToTrue(reader._closedPromise);
         reader._closedPromise_reject(reason);
         reader._closedPromise_resolve = undefined;
@@ -262,6 +265,9 @@
         defaultReaderClosedPromiseInitializeAsRejected(reader, reason);
     }
     function defaultReaderClosedPromiseResolve(reader) {
+        if (reader._closedPromise_resolve === undefined) {
+            return;
+        }
         reader._closedPromise_resolve(undefined);
         reader._closedPromise_resolve = undefined;
         reader._closedPromise_reject = undefined;
@@ -388,6 +394,11 @@
         }
         return true;
     }
+    /**
+     * A default reader vended by a {@link ReadableStream}.
+     *
+     * @public
+     */
     var ReadableStreamDefaultReader = /** @class */ (function () {
         function ReadableStreamDefaultReader(stream) {
             assertRequiredArgument(stream, 1, 'ReadableStreamDefaultReader');
@@ -399,6 +410,10 @@
             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'));
@@ -408,6 +423,9 @@
             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)) {
@@ -418,6 +436,11 @@
             }
             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'));
@@ -439,6 +462,15 @@
             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');
@@ -473,7 +505,7 @@
         if (!Object.prototype.hasOwnProperty.call(x, '_readRequests')) {
             return false;
         }
-        return true;
+        return x instanceof ReadableStreamDefaultReader;
     }
     function ReadableStreamDefaultReaderRead(reader, readRequest) {
         var stream = reader._ownerReadableStream;
@@ -621,7 +653,14 @@
         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) {
@@ -635,15 +674,35 @@
         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;
@@ -656,6 +715,10 @@
         }
         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();
@@ -666,8 +729,7 @@
         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 });
@@ -682,28 +744,19 @@
         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');
@@ -733,15 +786,10 @@
             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;
@@ -757,28 +805,33 @@
             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');
@@ -788,6 +841,10 @@
             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');
@@ -824,6 +881,9 @@
             }
             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)) {
@@ -833,10 +893,7 @@
         };
         /** @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);
@@ -865,6 +922,7 @@
                 }
                 var pullIntoDescriptor = {
                     buffer: buffer,
+                    bufferByteLength: autoAllocateChunkSize,
                     byteOffset: 0,
                     byteLength: autoAllocateChunkSize,
                     bytesFilled: 0,
@@ -900,7 +958,7 @@
         if (!Object.prototype.hasOwnProperty.call(x, '_controlledReadableByteStream')) {
             return false;
         }
-        return true;
+        return x instanceof ReadableByteStreamController;
     }
     function IsReadableStreamBYOBRequest(x) {
         if (!typeIsObject(x)) {
@@ -909,7 +967,7 @@
         if (!Object.prototype.hasOwnProperty.call(x, '_associatedReadableByteStreamController')) {
             return false;
         }
-        return true;
+        return x instanceof ReadableStreamBYOBRequest;
     }
     function ReadableByteStreamControllerCallPullIfNeeded(controller) {
         var shouldPull = ReadableByteStreamControllerShouldCallPull(controller);
@@ -991,7 +1049,6 @@
         return ready;
     }
     function ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, size, pullIntoDescriptor) {
-        ReadableByteStreamControllerInvalidateBYOBRequest(controller);
         pullIntoDescriptor.bytesFilled += size;
     }
     function ReadableByteStreamControllerHandleQueueDrain(controller) {
@@ -1030,9 +1087,15 @@
             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,
@@ -1072,7 +1135,6 @@
         ReadableByteStreamControllerCallPullIfNeeded(controller);
     }
     function ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor) {
-        firstDescriptor.buffer = TransferArrayBuffer(firstDescriptor.buffer);
         var stream = controller._controlledReadableByteStream;
         if (ReadableStreamHasBYOBReader(stream)) {
             while (ReadableStreamGetNumReadIntoRequests(stream) > 0) {
@@ -1082,34 +1144,27 @@
         }
     }
     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);
@@ -1118,7 +1173,6 @@
     }
     function ReadableByteStreamControllerShiftPendingPullInto(controller) {
         var descriptor = controller._pendingPullIntos.shift();
-        ReadableByteStreamControllerInvalidateBYOBRequest(controller);
         return descriptor;
     }
     function ReadableByteStreamControllerShouldCallPull(controller) {
@@ -1178,6 +1232,12 @@
         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);
@@ -1207,9 +1267,18 @@
         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;
         }
@@ -1219,21 +1288,47 @@
         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) {
@@ -1275,6 +1370,9 @@
             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) {
@@ -1321,6 +1419,11 @@
         }
         return true;
     }
+    /**
+     * A BYOB reader vended by a {@link ReadableStream}.
+     *
+     * @public
+     */
     var ReadableStreamBYOBReader = /** @class */ (function () {
         function ReadableStreamBYOBReader(stream) {
             assertRequiredArgument(stream, 1, 'ReadableStreamBYOBReader');
@@ -1336,6 +1439,10 @@
             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'));
@@ -1345,6 +1452,9 @@
             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)) {
@@ -1355,6 +1465,11 @@
             }
             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'));
@@ -1368,6 +1483,7 @@
             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'));
             }
@@ -1385,6 +1501,15 @@
             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');
@@ -1419,7 +1544,7 @@
         if (!Object.prototype.hasOwnProperty.call(x, '_readIntoRequests')) {
             return false;
         }
-        return true;
+        return x instanceof ReadableStreamBYOBReader;
     }
     function ReadableStreamBYOBReaderRead(reader, view, readIntoRequest) {
         var stream = reader._ownerReadableStream;
@@ -1514,6 +1639,36 @@
         }
     }
 
+    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 = {}; }
@@ -1536,28 +1691,48 @@
             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'));
@@ -1567,9 +1742,17 @@
             }
             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);
         };
@@ -1634,7 +1817,7 @@
         if (!Object.prototype.hasOwnProperty.call(x, '_writableStreamController')) {
             return false;
         }
-        return true;
+        return x instanceof WritableStream;
     }
     function IsWritableStreamLocked(stream) {
         if (stream._writer === undefined) {
@@ -1643,6 +1826,15 @@
         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);
@@ -1828,6 +2020,11 @@
         }
         stream._backpressure = backpressure;
     }
+    /**
+     * A default writer vended by a {@link WritableStream}.
+     *
+     * @public
+     */
     var WritableStreamDefaultWriter = /** @class */ (function () {
         function WritableStreamDefaultWriter(stream) {
             assertRequiredArgument(stream, 1, 'WritableStreamDefaultWriter');
@@ -1862,6 +2059,10 @@
             }
         }
         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'));
@@ -1872,6 +2073,14 @@
             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');
@@ -1885,6 +2094,14 @@
             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'));
@@ -1894,6 +2111,9 @@
             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)) {
@@ -1904,6 +2124,9 @@
             }
             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'));
@@ -1917,6 +2140,16 @@
             }
             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');
@@ -1962,7 +2195,7 @@
         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) {
@@ -2043,14 +2276,58 @@
         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') {
@@ -2089,7 +2366,7 @@
         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;
@@ -2098,6 +2375,8 @@
         controller._queue = undefined;
         controller._queueTotalSize = undefined;
         ResetQueue(controller);
+        controller._abortReason = undefined;
+        controller._abortController = createAbortController();
         controller._started = false;
         controller._strategySizeAlgorithm = sizeAlgorithm;
         controller._strategyHWM = highWaterMark;
@@ -2247,9 +2526,13 @@
         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");
@@ -2273,6 +2556,9 @@
         defaultWriterClosedPromiseResolve(writer);
     }
     function defaultWriterClosedPromiseReject(writer, reason) {
+        if (writer._closedPromise_reject === undefined) {
+            return;
+        }
         setPromiseIsHandledToTrue(writer._closedPromise);
         writer._closedPromise_reject(reason);
         writer._closedPromise_resolve = undefined;
@@ -2283,6 +2569,9 @@
         defaultWriterClosedPromiseInitializeAsRejected(writer, reason);
     }
     function defaultWriterClosedPromiseResolve(writer) {
+        if (writer._closedPromise_resolve === undefined) {
+            return;
+        }
         writer._closedPromise_resolve(undefined);
         writer._closedPromise_resolve = undefined;
         writer._closedPromise_reject = undefined;
@@ -2304,6 +2593,9 @@
         defaultWriterReadyPromiseResolve(writer);
     }
     function defaultWriterReadyPromiseReject(writer, reason) {
+        if (writer._readyPromise_reject === undefined) {
+            return;
+        }
         setPromiseIsHandledToTrue(writer._readyPromise);
         writer._readyPromise_reject(reason);
         writer._readyPromise_resolve = undefined;
@@ -2317,25 +2609,15 @@
         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;
 
@@ -2353,6 +2635,7 @@
         }
     }
     function createDOMExceptionPolyfill() {
+        // eslint-disable-next-line no-shadow
         var ctor = function DOMException(message, name) {
             this.message = message || '';
             this.name = name || 'Error';
@@ -2364,6 +2647,7 @@
         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) {
@@ -2541,23 +2825,36 @@
         });
     }
 
+    /**
+     * 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');
@@ -2567,17 +2864,20 @@
         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);
         };
@@ -2629,7 +2929,7 @@
         if (!Object.prototype.hasOwnProperty.call(x, '_controlledReadableStream')) {
             return false;
         }
-        return true;
+        return x instanceof ReadableStreamDefaultController;
     }
     function ReadableStreamDefaultControllerCallPullIfNeeded(controller) {
         var shouldPull = ReadableStreamDefaultControllerShouldCallPull(controller);
@@ -2723,8 +3023,7 @@
         ReadableStreamError(stream, e);
     }
     function ReadableStreamDefaultControllerGetDesiredSize(controller) {
-        var stream = controller._controlledReadableStream;
-        var state = stream._state;
+        var state = controller._controlledReadableStream._state;
         if (state === 'errored') {
             return null;
         }
@@ -2786,11 +3085,17 @@
         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;
@@ -2809,24 +3114,24 @@
             }
             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);
                         }
                     });
                 },
@@ -2838,6 +3143,9 @@
                     if (!canceled2) {
                         ReadableStreamDefaultControllerClose(branch2._readableStreamController);
                     }
+                    if (!canceled1 || !canceled2) {
+                        resolveCancelPromise(undefined);
+                    }
                 },
                 _errorSteps: function () {
                     reading = false;
@@ -2874,9 +3182,217 @@
         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);
@@ -2976,6 +3492,11 @@
         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 = {}; }
@@ -3003,6 +3524,9 @@
             }
         }
         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');
@@ -3012,6 +3536,12 @@
             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)) {
@@ -3077,6 +3607,17 @@
             }
             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');
@@ -3127,6 +3668,14 @@
         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;
@@ -3140,7 +3689,7 @@
         if (!Object.prototype.hasOwnProperty.call(x, '_readableStreamController')) {
             return false;
         }
-        return true;
+        return x instanceof ReadableStream;
     }
     function IsReadableStreamLocked(stream) {
         if (stream._reader === undefined) {
@@ -3158,6 +3707,13 @@
             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);
     }
@@ -3167,13 +3723,13 @@
         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';
@@ -3182,6 +3738,7 @@
         if (reader === undefined) {
             return;
         }
+        defaultReaderClosedPromiseReject(reader, e);
         if (IsReadableStreamDefaultReader(reader)) {
             reader._readRequests.forEach(function (readRequest) {
                 readRequest._errorSteps(e);
@@ -3194,7 +3751,6 @@
             });
             reader._readIntoRequests = new SimpleQueue();
         }
-        defaultReaderClosedPromiseReject(reader, e);
     }
     // Helper functions for the ReadableStream.
     function streamBrandCheckException$1(name) {
@@ -3210,9 +3766,19 @@
         };
     }
 
-    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');
@@ -3220,6 +3786,9 @@
             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');
@@ -3230,6 +3799,9 @@
             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');
@@ -3262,12 +3834,22 @@
         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');
@@ -3275,6 +3857,9 @@
             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');
@@ -3285,6 +3870,10 @@
             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');
@@ -3317,7 +3906,7 @@
         if (!Object.prototype.hasOwnProperty.call(x, '_countQueuingStrategyHighWaterMark')) {
             return false;
         }
-        return true;
+        return x instanceof CountQueuingStrategy;
     }
 
     function convertTransformer(original, context) {
@@ -3355,6 +3944,14 @@
     }
 
     // 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 = {}; }
@@ -3390,9 +3987,12 @@
             }
         }
         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;
             },
@@ -3400,9 +4000,12 @@
             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;
             },
@@ -3457,7 +4060,7 @@
         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) {
@@ -3485,14 +4088,22 @@
         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);
@@ -3503,20 +4114,28 @@
         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);
         };
@@ -3542,7 +4161,7 @@
         if (!Object.prototype.hasOwnProperty.call(x, '_controlledTransformStream')) {
             return false;
         }
-        return true;
+        return x instanceof TransformStreamDefaultController;
     }
     function SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm) {
         controller._controlledTransformStream = stream;
@@ -3659,11 +4278,11 @@
         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");
     }