web-streams-polyfill 3.0.0 → 3.1.0

package/dist/polyfill.es6.mjs

@@ -1,5 +1,5 @@
 /**
- * web-streams-polyfill v3.0.0
+ * web-streams-polyfill v3.1.0
  */
 /// <reference lib="es2015.symbol" />
 const SymbolPolyfill = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol' ?
@@ -8,7 +8,7 @@ const 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 @@ const globals = getGlobals();
 function typeIsObject(x) {
     return (typeof x === 'object' && x !== null) || typeof x === 'function';
 }
-const rethrowAssertionErrorRejection =  noop;
+const rethrowAssertionErrorRejection = noop;
 
 const originalPromise = Promise;
 const originalPromiseThen = Promise.prototype.then;
@@ -242,6 +242,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;
@@ -251,6 +254,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;
@@ -377,6 +383,11 @@ function ReadableStreamHasDefaultReader(stream) {
     }
     return true;
 }
+/**
+ * A default reader vended by a {@link ReadableStream}.
+ *
+ * @public
+ */
 class ReadableStreamDefaultReader {
     constructor(stream) {
         assertRequiredArgument(stream, 1, 'ReadableStreamDefaultReader');
@@ -387,12 +398,19 @@ class ReadableStreamDefaultReader {
         ReadableStreamReaderGenericInitialize(this, stream);
         this._readRequests = new SimpleQueue();
     }
+    /**
+     * 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 closed() {
         if (!IsReadableStreamDefaultReader(this)) {
             return promiseRejectedWith(defaultReaderBrandCheckException('closed'));
         }
         return this._closedPromise;
     }
+    /**
+     * If the reader is active, behaves the same as {@link ReadableStream.cancel | stream.cancel(reason)}.
+     */
     cancel(reason = undefined) {
         if (!IsReadableStreamDefaultReader(this)) {
             return promiseRejectedWith(defaultReaderBrandCheckException('cancel'));
@@ -402,6 +420,11 @@ class ReadableStreamDefaultReader {
         }
         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.
+     */
     read() {
         if (!IsReadableStreamDefaultReader(this)) {
             return promiseRejectedWith(defaultReaderBrandCheckException('read'));
@@ -423,6 +446,15 @@ class ReadableStreamDefaultReader {
         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.
+     */
     releaseLock() {
         if (!IsReadableStreamDefaultReader(this)) {
             throw defaultReaderBrandCheckException('releaseLock');
@@ -456,7 +488,7 @@ function IsReadableStreamDefaultReader(x) {
     if (!Object.prototype.hasOwnProperty.call(x, '_readRequests')) {
         return false;
     }
-    return true;
+    return x instanceof ReadableStreamDefaultReader;
 }
 function ReadableStreamDefaultReaderRead(reader, readRequest) {
     const stream = reader._ownerReadableStream;
@@ -599,7 +631,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) {
@@ -613,15 +652,35 @@ const 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;
+    const length = end - begin;
+    const slice = new ArrayBuffer(length);
+    CopyDataBlockBytes(slice, 0, buffer, begin, length);
+    return slice;
 }
+
 function IsNonNegativeNumber(v) {
     if (typeof v !== 'number') {
         return false;
@@ -634,6 +693,10 @@ function IsNonNegativeNumber(v) {
     }
     return true;
 }
+function CloneAsUint8Array(O) {
+    const buffer = ArrayBufferSlice(O.buffer, O.byteOffset, O.byteOffset + O.byteLength);
+    return new Uint8Array(buffer);
+}
 
 function DequeueValue(container) {
     const pair = container._queue.shift();
@@ -644,8 +707,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, size });
@@ -660,27 +722,18 @@ 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
+ */
 class ReadableStreamBYOBRequest {
     constructor() {
         throw new TypeError('Illegal constructor');
     }
+    /**
+     * Returns the view for writing in to, or `null` if the BYOB request has already been responded to.
+     */
     get view() {
         if (!IsReadableStreamBYOBRequest(this)) {
             throw byobRequestBrandCheckException('view');
@@ -707,15 +760,10 @@ class ReadableStreamBYOBRequest {
         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);
     }
 }
@@ -730,29 +778,38 @@ if (typeof SymbolPolyfill.toStringTag === 'symbol') {
         configurable: true
     });
 }
+/**
+ * Allows control of a {@link ReadableStream | readable byte stream}'s state and internal queue.
+ *
+ * @public
+ */
 class ReadableByteStreamController {
     constructor() {
         throw new TypeError('Illegal constructor');
     }
+    /**
+     * Returns the current BYOB pull request, or `null` if there isn't one.
+     */
     get byobRequest() {
         if (!IsReadableByteStreamController(this)) {
             throw byteStreamControllerBrandCheckException('byobRequest');
         }
-        if (this._byobRequest === null && this._pendingPullIntos.length > 0) {
-            const firstDescriptor = this._pendingPullIntos.peek();
-            const view = new Uint8Array(firstDescriptor.buffer, firstDescriptor.byteOffset + firstDescriptor.bytesFilled, firstDescriptor.byteLength - firstDescriptor.bytesFilled);
-            const byobRequest = Object.create(ReadableStreamBYOBRequest.prototype);
-            SetUpReadableStreamBYOBRequest(byobRequest, this, view);
-            this._byobRequest = byobRequest;
-        }
-        return this._byobRequest;
+        return ReadableByteStreamControllerGetBYOBRequest(this);
     }
+    /**
+     * 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 desiredSize() {
         if (!IsReadableByteStreamController(this)) {
             throw byteStreamControllerBrandCheckException('desiredSize');
         }
         return ReadableByteStreamControllerGetDesiredSize(this);
     }
+    /**
+     * 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.
+     */
     close() {
         if (!IsReadableByteStreamController(this)) {
             throw byteStreamControllerBrandCheckException('close');
@@ -789,6 +846,9 @@ class ReadableByteStreamController {
         }
         ReadableByteStreamControllerEnqueue(this, chunk);
     }
+    /**
+     * Errors the controlled readable stream, making all future interactions with it fail with the given error `e`.
+     */
     error(e = undefined) {
         if (!IsReadableByteStreamController(this)) {
             throw byteStreamControllerBrandCheckException('error');
@@ -797,10 +857,7 @@ class ReadableByteStreamController {
     }
     /** @internal */
     [CancelSteps](reason) {
-        if (this._pendingPullIntos.length > 0) {
-            const firstDescriptor = this._pendingPullIntos.peek();
-            firstDescriptor.bytesFilled = 0;
-        }
+        ReadableByteStreamControllerClearPendingPullIntos(this);
         ResetQueue(this);
         const result = this._cancelAlgorithm(reason);
         ReadableByteStreamControllerClearAlgorithms(this);
@@ -829,6 +886,7 @@ class ReadableByteStreamController {
             }
             const pullIntoDescriptor = {
                 buffer,
+                bufferByteLength: autoAllocateChunkSize,
                 byteOffset: 0,
                 byteLength: autoAllocateChunkSize,
                 bytesFilled: 0,
@@ -863,7 +921,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)) {
@@ -872,7 +930,7 @@ function IsReadableStreamBYOBRequest(x) {
     if (!Object.prototype.hasOwnProperty.call(x, '_associatedReadableByteStreamController')) {
         return false;
     }
-    return true;
+    return x instanceof ReadableStreamBYOBRequest;
 }
 function ReadableByteStreamControllerCallPullIfNeeded(controller) {
     const shouldPull = ReadableByteStreamControllerShouldCallPull(controller);
@@ -954,7 +1012,6 @@ function ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller,
     return ready;
 }
 function ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, size, pullIntoDescriptor) {
-    ReadableByteStreamControllerInvalidateBYOBRequest(controller);
     pullIntoDescriptor.bytesFilled += size;
 }
 function ReadableByteStreamControllerHandleQueueDrain(controller) {
@@ -993,9 +1050,15 @@ function ReadableByteStreamControllerPullInto(controller, view, readIntoRequest)
         elementSize = view.constructor.BYTES_PER_ELEMENT;
     }
     const ctor = view.constructor;
+    // try {
     const buffer = TransferArrayBuffer(view.buffer);
+    // } catch (e) {
+    //   readIntoRequest._errorSteps(e);
+    //   return;
+    // }
     const pullIntoDescriptor = {
         buffer,
+        bufferByteLength: buffer.byteLength,
         byteOffset: view.byteOffset,
         byteLength: view.byteLength,
         bytesFilled: 0,
@@ -1035,7 +1098,6 @@ function ReadableByteStreamControllerPullInto(controller, view, readIntoRequest)
     ReadableByteStreamControllerCallPullIfNeeded(controller);
 }
 function ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor) {
-    firstDescriptor.buffer = TransferArrayBuffer(firstDescriptor.buffer);
     const stream = controller._controlledReadableByteStream;
     if (ReadableStreamHasBYOBReader(stream)) {
         while (ReadableStreamGetNumReadIntoRequests(stream) > 0) {
@@ -1045,34 +1107,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);
     const remainderSize = pullIntoDescriptor.bytesFilled % pullIntoDescriptor.elementSize;
     if (remainderSize > 0) {
         const end = pullIntoDescriptor.byteOffset + pullIntoDescriptor.bytesFilled;
-        const remainder = pullIntoDescriptor.buffer.slice(end - remainderSize, end);
+        const 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) {
     const firstDescriptor = controller._pendingPullIntos.peek();
-    const 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);
+    const state = controller._controlledReadableByteStream._state;
+    if (state === 'closed') {
+        ReadableByteStreamControllerRespondInClosedState(controller);
     }
     else {
         ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, firstDescriptor);
@@ -1081,7 +1136,6 @@ function ReadableByteStreamControllerRespondInternal(controller, bytesWritten) {
 }
 function ReadableByteStreamControllerShiftPendingPullInto(controller) {
     const descriptor = controller._pendingPullIntos.shift();
-    ReadableByteStreamControllerInvalidateBYOBRequest(controller);
     return descriptor;
 }
 function ReadableByteStreamControllerShouldCallPull(controller) {
@@ -1141,6 +1195,12 @@ function ReadableByteStreamControllerEnqueue(controller, chunk) {
     const byteOffset = chunk.byteOffset;
     const byteLength = chunk.byteLength;
     const transferredBuffer = TransferArrayBuffer(buffer);
+    if (controller._pendingPullIntos.length > 0) {
+        const 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);
@@ -1170,9 +1230,18 @@ function ReadableByteStreamControllerError(controller, e) {
     ReadableByteStreamControllerClearAlgorithms(controller);
     ReadableStreamError(stream, e);
 }
+function ReadableByteStreamControllerGetBYOBRequest(controller) {
+    if (controller._byobRequest === null && controller._pendingPullIntos.length > 0) {
+        const firstDescriptor = controller._pendingPullIntos.peek();
+        const view = new Uint8Array(firstDescriptor.buffer, firstDescriptor.byteOffset + firstDescriptor.bytesFilled, firstDescriptor.byteLength - firstDescriptor.bytesFilled);
+        const byobRequest = Object.create(ReadableStreamBYOBRequest.prototype);
+        SetUpReadableStreamBYOBRequest(byobRequest, controller, view);
+        controller._byobRequest = byobRequest;
+    }
+    return controller._byobRequest;
+}
 function ReadableByteStreamControllerGetDesiredSize(controller) {
-    const stream = controller._controlledReadableByteStream;
-    const state = stream._state;
+    const state = controller._controlledReadableByteStream._state;
     if (state === 'errored') {
         return null;
     }
@@ -1182,21 +1251,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');
+    const firstDescriptor = controller._pendingPullIntos.peek();
+    const 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) {
     const firstDescriptor = controller._pendingPullIntos.peek();
+    const 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) {
@@ -1238,6 +1333,9 @@ function SetUpReadableByteStreamControllerFromUnderlyingSource(stream, underlyin
         cancelAlgorithm = reason => underlyingByteSource.cancel(reason);
     }
     const 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) {
@@ -1284,6 +1382,11 @@ function ReadableStreamHasBYOBReader(stream) {
     }
     return true;
 }
+/**
+ * A BYOB reader vended by a {@link ReadableStream}.
+ *
+ * @public
+ */
 class ReadableStreamBYOBReader {
     constructor(stream) {
         assertRequiredArgument(stream, 1, 'ReadableStreamBYOBReader');
@@ -1298,12 +1401,19 @@ class ReadableStreamBYOBReader {
         ReadableStreamReaderGenericInitialize(this, stream);
         this._readIntoRequests = new SimpleQueue();
     }
+    /**
+     * 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 closed() {
         if (!IsReadableStreamBYOBReader(this)) {
             return promiseRejectedWith(byobReaderBrandCheckException('closed'));
         }
         return this._closedPromise;
     }
+    /**
+     * If the reader is active, behaves the same as {@link ReadableStream.cancel | stream.cancel(reason)}.
+     */
     cancel(reason = undefined) {
         if (!IsReadableStreamBYOBReader(this)) {
             return promiseRejectedWith(byobReaderBrandCheckException('cancel'));
@@ -1313,6 +1423,11 @@ class ReadableStreamBYOBReader {
         }
         return ReadableStreamReaderGenericCancel(this, reason);
     }
+    /**
+     * Attempts to reads bytes into view, and returns a promise resolved with the result.
+     *
+     * If reading a chunk causes the queue to become empty, more data will be pulled from the underlying source.
+     */
     read(view) {
         if (!IsReadableStreamBYOBReader(this)) {
             return promiseRejectedWith(byobReaderBrandCheckException('read'));
@@ -1326,6 +1441,7 @@ class ReadableStreamBYOBReader {
         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'));
         }
@@ -1343,6 +1459,15 @@ class ReadableStreamBYOBReader {
         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.
+     */
     releaseLock() {
         if (!IsReadableStreamBYOBReader(this)) {
             throw byobReaderBrandCheckException('releaseLock');
@@ -1376,7 +1501,7 @@ function IsReadableStreamBYOBReader(x) {
     if (!Object.prototype.hasOwnProperty.call(x, '_readIntoRequests')) {
         return false;
     }
-    return true;
+    return x instanceof ReadableStreamBYOBReader;
 }
 function ReadableStreamBYOBReaderRead(reader, view, readIntoRequest) {
     const stream = reader._ownerReadableStream;
@@ -1471,6 +1596,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;
+    }
+}
+const 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
+ */
 class WritableStream {
     constructor(rawUnderlyingSink = {}, rawStrategy = {}) {
         if (rawUnderlyingSink === undefined) {
@@ -1490,24 +1645,44 @@ class WritableStream {
         const highWaterMark = ExtractHighWaterMark(strategy, 1);
         SetUpWritableStreamDefaultControllerFromUnderlyingSink(this, underlyingSink, highWaterMark, sizeAlgorithm);
     }
+    /**
+     * Returns whether or not the writable stream is locked to a writer.
+     */
     get locked() {
         if (!IsWritableStream(this)) {
-            throw streamBrandCheckException('locked');
+            throw streamBrandCheckException$2('locked');
         }
         return IsWritableStreamLocked(this);
     }
+    /**
+     * 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.
+     */
     abort(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.
+     */
     close() {
         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'));
@@ -1517,9 +1692,17 @@ class WritableStream {
         }
         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.
+     */
     getWriter() {
         if (!IsWritableStream(this)) {
-            throw streamBrandCheckException('getWriter');
+            throw streamBrandCheckException$2('getWriter');
         }
         return AcquireWritableStreamDefaultWriter(this);
     }
@@ -1581,7 +1764,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) {
@@ -1590,6 +1773,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.
     const state = stream._state;
     if (state === 'closed' || state === 'errored') {
         return promiseResolvedWith(undefined);
@@ -1775,6 +1967,11 @@ function WritableStreamUpdateBackpressure(stream, backpressure) {
     }
     stream._backpressure = backpressure;
 }
+/**
+ * A default writer vended by a {@link WritableStream}.
+ *
+ * @public
+ */
 class WritableStreamDefaultWriter {
     constructor(stream) {
         assertRequiredArgument(stream, 1, 'WritableStreamDefaultWriter');
@@ -1808,12 +2005,24 @@ class WritableStreamDefaultWriter {
             defaultWriterClosedPromiseInitializeAsRejected(this, storedError);
         }
     }
+    /**
+     * 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 closed() {
         if (!IsWritableStreamDefaultWriter(this)) {
             return promiseRejectedWith(defaultWriterBrandCheckException('closed'));
         }
         return this._closedPromise;
     }
+    /**
+     * 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 desiredSize() {
         if (!IsWritableStreamDefaultWriter(this)) {
             throw defaultWriterBrandCheckException('desiredSize');
@@ -1823,12 +2032,23 @@ class WritableStreamDefaultWriter {
         }
         return WritableStreamDefaultWriterGetDesiredSize(this);
     }
+    /**
+     * 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 ready() {
         if (!IsWritableStreamDefaultWriter(this)) {
             return promiseRejectedWith(defaultWriterBrandCheckException('ready'));
         }
         return this._readyPromise;
     }
+    /**
+     * If the reader is active, behaves the same as {@link WritableStream.abort | stream.abort(reason)}.
+     */
     abort(reason = undefined) {
         if (!IsWritableStreamDefaultWriter(this)) {
             return promiseRejectedWith(defaultWriterBrandCheckException('abort'));
@@ -1838,6 +2058,9 @@ class WritableStreamDefaultWriter {
         }
         return WritableStreamDefaultWriterAbort(this, reason);
     }
+    /**
+     * If the reader is active, behaves the same as {@link WritableStream.close | stream.close()}.
+     */
     close() {
         if (!IsWritableStreamDefaultWriter(this)) {
             return promiseRejectedWith(defaultWriterBrandCheckException('close'));
@@ -1851,6 +2074,16 @@ class WritableStreamDefaultWriter {
         }
         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.
+     */
     releaseLock() {
         if (!IsWritableStreamDefaultWriter(this)) {
             throw defaultWriterBrandCheckException('releaseLock');
@@ -1894,7 +2127,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) {
@@ -1975,13 +2208,49 @@ function WritableStreamDefaultWriterWrite(writer, chunk) {
     return promise;
 }
 const closeSentinel = {};
+/**
+ * Allows control of a {@link WritableStream | writable stream}'s state and internal queue.
+ *
+ * @public
+ */
 class WritableStreamDefaultController {
     constructor() {
         throw new TypeError('Illegal constructor');
     }
+    /**
+     * The reason which was passed to `WritableStream.abort(reason)` when the stream was aborted.
+     */
+    get abortReason() {
+        if (!IsWritableStreamDefaultController(this)) {
+            throw defaultControllerBrandCheckException$2('abortReason');
+        }
+        return this._abortReason;
+    }
+    /**
+     * An `AbortSignal` that can be used to abort the pending write or close operation when the stream is aborted.
+     */
+    get signal() {
+        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;
+    }
+    /**
+     * 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.
+     */
     error(e = undefined) {
         if (!IsWritableStreamDefaultController(this)) {
-            throw new TypeError('WritableStreamDefaultController.prototype.error can only be used on a WritableStreamDefaultController');
+            throw defaultControllerBrandCheckException$2('error');
         }
         const state = this._controlledWritableStream._state;
         if (state !== 'writable') {
@@ -2019,7 +2288,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;
@@ -2028,6 +2297,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;
@@ -2177,9 +2448,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`);
@@ -2203,6 +2478,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;
@@ -2213,6 +2491,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;
@@ -2234,6 +2515,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;
@@ -2247,25 +2531,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" />
 const NativeDOMException = typeof DOMException !== 'undefined' ? DOMException : undefined;
 
@@ -2283,6 +2557,7 @@ function isDOMExceptionConstructor(ctor) {
     }
 }
 function createDOMExceptionPolyfill() {
+    // eslint-disable-next-line no-shadow
     const ctor = function DOMException(message, name) {
         this.message = message || '';
         this.name = name || 'Error';
@@ -2294,6 +2569,7 @@ function createDOMExceptionPolyfill() {
     Object.defineProperty(ctor.prototype, 'constructor', { value: ctor, writable: true, configurable: true });
     return ctor;
 }
+// eslint-disable-next-line no-redeclare
 const DOMException$1 = isDOMExceptionConstructor(NativeDOMException) ? NativeDOMException : createDOMExceptionPolyfill();
 
 function ReadableStreamPipeTo(source, dest, preventClose, preventAbort, preventCancel, signal) {
@@ -2471,19 +2747,32 @@ function ReadableStreamPipeTo(source, dest, preventClose, preventAbort, preventC
     });
 }
 
+/**
+ * Allows control of a {@link ReadableStream | readable stream}'s state and internal queue.
+ *
+ * @public
+ */
 class ReadableStreamDefaultController {
     constructor() {
         throw new TypeError('Illegal constructor');
     }
+    /**
+     * 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 desiredSize() {
         if (!IsReadableStreamDefaultController(this)) {
-            throw defaultControllerBrandCheckException('desiredSize');
+            throw defaultControllerBrandCheckException$1('desiredSize');
         }
         return ReadableStreamDefaultControllerGetDesiredSize(this);
     }
+    /**
+     * 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.
+     */
     close() {
         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');
@@ -2492,16 +2781,19 @@ class ReadableStreamDefaultController {
     }
     enqueue(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`.
+     */
     error(e = undefined) {
         if (!IsReadableStreamDefaultController(this)) {
-            throw defaultControllerBrandCheckException('error');
+            throw defaultControllerBrandCheckException$1('error');
         }
         ReadableStreamDefaultControllerError(this, e);
     }
@@ -2552,7 +2844,7 @@ function IsReadableStreamDefaultController(x) {
     if (!Object.prototype.hasOwnProperty.call(x, '_controlledReadableStream')) {
         return false;
     }
-    return true;
+    return x instanceof ReadableStreamDefaultController;
 }
 function ReadableStreamDefaultControllerCallPullIfNeeded(controller) {
     const shouldPull = ReadableStreamDefaultControllerShouldCallPull(controller);
@@ -2646,8 +2938,7 @@ function ReadableStreamDefaultControllerError(controller, e) {
     ReadableStreamError(stream, e);
 }
 function ReadableStreamDefaultControllerGetDesiredSize(controller) {
-    const stream = controller._controlledReadableStream;
-    const state = stream._state;
+    const state = controller._controlledReadableStream._state;
     if (state === 'errored') {
         return null;
     }
@@ -2709,11 +3000,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) {
     const reader = AcquireReadableStreamDefaultReader(stream);
     let reading = false;
     let canceled1 = false;
@@ -2732,24 +3029,24 @@ function ReadableStreamTee(stream, cloneForBranch2) {
         }
         reading = true;
         const readRequest = {
-            _chunkSteps: value => {
+            _chunkSteps: 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(() => {
                     reading = false;
-                    const value1 = value;
-                    const value2 = value;
+                    const chunk1 = chunk;
+                    const 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);
                     }
                 });
             },
@@ -2761,6 +3058,9 @@ function ReadableStreamTee(stream, cloneForBranch2) {
                 if (!canceled2) {
                     ReadableStreamDefaultControllerClose(branch2._readableStreamController);
                 }
+                if (!canceled1 || !canceled2) {
+                    resolveCancelPromise(undefined);
+                }
             },
             _errorSteps: () => {
                 reading = false;
@@ -2797,9 +3097,217 @@ function ReadableStreamTee(stream, cloneForBranch2) {
     uponRejection(reader._closedPromise, (r) => {
         ReadableStreamDefaultControllerError(branch1._readableStreamController, r);
         ReadableStreamDefaultControllerError(branch2._readableStreamController, r);
+        if (!canceled1 || !canceled2) {
+            resolveCancelPromise(undefined);
+        }
     });
     return [branch1, branch2];
 }
+function ReadableByteStreamTee(stream) {
+    let reader = AcquireReadableStreamDefaultReader(stream);
+    let reading = false;
+    let canceled1 = false;
+    let canceled2 = false;
+    let reason1;
+    let reason2;
+    let branch1;
+    let branch2;
+    let resolveCancelPromise;
+    const cancelPromise = newPromise(resolve => {
+        resolveCancelPromise = resolve;
+    });
+    function forwardReaderError(thisReader) {
+        uponRejection(thisReader._closedPromise, 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);
+        }
+        const readRequest = {
+            _chunkSteps: 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(() => {
+                    reading = false;
+                    const chunk1 = chunk;
+                    let 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: () => {
+                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: () => {
+                reading = false;
+            }
+        };
+        ReadableStreamDefaultReaderRead(reader, readRequest);
+    }
+    function pullWithBYOBReader(view, forBranch2) {
+        if (IsReadableStreamDefaultReader(reader)) {
+            ReadableStreamReaderGenericRelease(reader);
+            reader = AcquireReadableStreamBYOBReader(stream);
+            forwardReaderError(reader);
+        }
+        const byobBranch = forBranch2 ? branch2 : branch1;
+        const otherBranch = forBranch2 ? branch1 : branch2;
+        const readIntoRequest = {
+            _chunkSteps: 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(() => {
+                    reading = false;
+                    const byobCanceled = forBranch2 ? canceled2 : canceled1;
+                    const otherCanceled = forBranch2 ? canceled1 : canceled2;
+                    if (!otherCanceled) {
+                        let clonedChunk;
+                        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: chunk => {
+                reading = false;
+                const byobCanceled = forBranch2 ? canceled2 : canceled1;
+                const 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: () => {
+                reading = false;
+            }
+        };
+        ReadableStreamBYOBReaderRead(reader, view, readIntoRequest);
+    }
+    function pull1Algorithm() {
+        if (reading) {
+            return promiseResolvedWith(undefined);
+        }
+        reading = true;
+        const 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;
+        const 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) {
+            const compositeReason = CreateArrayFromList([reason1, reason2]);
+            const cancelResult = ReadableStreamCancel(stream, compositeReason);
+            resolveCancelPromise(cancelResult);
+        }
+        return cancelPromise;
+    }
+    function cancel2Algorithm(reason) {
+        canceled2 = true;
+        reason2 = reason;
+        if (canceled1) {
+            const compositeReason = CreateArrayFromList([reason1, reason2]);
+            const 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);
@@ -2899,6 +3407,11 @@ function convertReadableWritablePair(pair, context) {
     return { readable, writable };
 }
 
+/**
+ * A readable stream represents a source of data, from which you can read.
+ *
+ * @public
+ */
 class ReadableStream {
     constructor(rawUnderlyingSource = {}, rawStrategy = {}) {
         if (rawUnderlyingSource === undefined) {
@@ -2923,12 +3436,21 @@ class ReadableStream {
             SetUpReadableStreamDefaultControllerFromUnderlyingSource(this, underlyingSource, highWaterMark, sizeAlgorithm);
         }
     }
+    /**
+     * Whether or not the readable stream is locked to a {@link ReadableStreamDefaultReader | reader}.
+     */
     get locked() {
         if (!IsReadableStream(this)) {
             throw streamBrandCheckException$1('locked');
         }
         return IsReadableStreamLocked(this);
     }
+    /**
+     * 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.
+     */
     cancel(reason = undefined) {
         if (!IsReadableStream(this)) {
             return promiseRejectedWith(streamBrandCheckException$1('cancel'));
@@ -2990,6 +3512,17 @@ class ReadableStream {
         }
         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.
+     */
     tee() {
         if (!IsReadableStream(this)) {
             throw streamBrandCheckException$1('tee');
@@ -3036,6 +3569,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) {
+    const stream = Object.create(ReadableStream.prototype);
+    InitializeReadableStream(stream);
+    const controller = Object.create(ReadableByteStreamController.prototype);
+    SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, 0, undefined);
+    return stream;
+}
 function InitializeReadableStream(stream) {
     stream._state = 'readable';
     stream._reader = undefined;
@@ -3049,7 +3590,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) {
@@ -3067,6 +3608,13 @@ function ReadableStreamCancel(stream, reason) {
         return promiseRejectedWith(stream._storedError);
     }
     ReadableStreamClose(stream);
+    const reader = stream._reader;
+    if (reader !== undefined && IsReadableStreamBYOBReader(reader)) {
+        reader._readIntoRequests.forEach(readIntoRequest => {
+            readIntoRequest._closeSteps(undefined);
+        });
+        reader._readIntoRequests = new SimpleQueue();
+    }
     const sourceCancelPromise = stream._readableStreamController[CancelSteps](reason);
     return transformPromiseWith(sourceCancelPromise, noop);
 }
@@ -3076,13 +3624,13 @@ function ReadableStreamClose(stream) {
     if (reader === undefined) {
         return;
     }
+    defaultReaderClosedPromiseResolve(reader);
     if (IsReadableStreamDefaultReader(reader)) {
         reader._readRequests.forEach(readRequest => {
             readRequest._closeSteps();
         });
         reader._readRequests = new SimpleQueue();
     }
-    defaultReaderClosedPromiseResolve(reader);
 }
 function ReadableStreamError(stream, e) {
     stream._state = 'errored';
@@ -3091,6 +3639,7 @@ function ReadableStreamError(stream, e) {
     if (reader === undefined) {
         return;
     }
+    defaultReaderClosedPromiseReject(reader, e);
     if (IsReadableStreamDefaultReader(reader)) {
         reader._readRequests.forEach(readRequest => {
             readRequest._errorSteps(e);
@@ -3103,7 +3652,6 @@ function ReadableStreamError(stream, e) {
         });
         reader._readIntoRequests = new SimpleQueue();
     }
-    defaultReaderClosedPromiseReject(reader, e);
 }
 // Helper functions for the ReadableStream.
 function streamBrandCheckException$1(name) {
@@ -3119,21 +3667,37 @@ function convertQueuingStrategyInit(init, context) {
     };
 }
 
-const byteLengthSizeFunction = function size(chunk) {
+// The size function must not have a prototype property nor be a constructor
+const byteLengthSizeFunction = (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
+ */
 class ByteLengthQueuingStrategy {
     constructor(options) {
         assertRequiredArgument(options, 1, 'ByteLengthQueuingStrategy');
         options = convertQueuingStrategyInit(options, 'First parameter');
         this._byteLengthQueuingStrategyHighWaterMark = options.highWaterMark;
     }
+    /**
+     * Returns the high water mark provided to the constructor.
+     */
     get highWaterMark() {
         if (!IsByteLengthQueuingStrategy(this)) {
             throw byteLengthBrandCheckException('highWaterMark');
         }
         return this._byteLengthQueuingStrategyHighWaterMark;
     }
+    /**
+     * Measures the size of `chunk` by returning the value of its `byteLength` property.
+     */
     get size() {
         if (!IsByteLengthQueuingStrategy(this)) {
             throw byteLengthBrandCheckException('size');
@@ -3162,24 +3726,41 @@ function IsByteLengthQueuingStrategy(x) {
     if (!Object.prototype.hasOwnProperty.call(x, '_byteLengthQueuingStrategyHighWaterMark')) {
         return false;
     }
-    return true;
+    return x instanceof ByteLengthQueuingStrategy;
 }
 
-const countSizeFunction = function size() {
+// The size function must not have a prototype property nor be a constructor
+const countSizeFunction = () => {
     return 1;
 };
+Object.defineProperty(countSizeFunction, 'name', {
+    value: 'size',
+    configurable: true
+});
+/**
+ * A queuing strategy that counts the number of chunks.
+ *
+ * @public
+ */
 class CountQueuingStrategy {
     constructor(options) {
         assertRequiredArgument(options, 1, 'CountQueuingStrategy');
         options = convertQueuingStrategyInit(options, 'First parameter');
         this._countQueuingStrategyHighWaterMark = options.highWaterMark;
     }
+    /**
+     * Returns the high water mark provided to the constructor.
+     */
     get highWaterMark() {
         if (!IsCountQueuingStrategy(this)) {
             throw countBrandCheckException('highWaterMark');
         }
         return this._countQueuingStrategyHighWaterMark;
     }
+    /**
+     * 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 size() {
         if (!IsCountQueuingStrategy(this)) {
             throw countBrandCheckException('size');
@@ -3208,7 +3789,7 @@ function IsCountQueuingStrategy(x) {
     if (!Object.prototype.hasOwnProperty.call(x, '_countQueuingStrategyHighWaterMark')) {
         return false;
     }
-    return true;
+    return x instanceof CountQueuingStrategy;
 }
 
 function convertTransformer(original, context) {
@@ -3246,6 +3827,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
+ */
 class TransformStream {
     constructor(rawTransformer = {}, rawWritableStrategy = {}, rawReadableStrategy = {}) {
         if (rawTransformer === undefined) {
@@ -3277,15 +3866,21 @@ class TransformStream {
             startPromise_resolve(undefined);
         }
     }
+    /**
+     * The readable side of the transform stream.
+     */
     get readable() {
         if (!IsTransformStream(this)) {
-            throw streamBrandCheckException$2('readable');
+            throw streamBrandCheckException('readable');
         }
         return this._readable;
     }
+    /**
+     * The writable side of the transform stream.
+     */
     get writable() {
         if (!IsTransformStream(this)) {
-            throw streamBrandCheckException$2('writable');
+            throw streamBrandCheckException('writable');
         }
         return this._writable;
     }
@@ -3336,7 +3931,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) {
@@ -3364,32 +3959,48 @@ function TransformStreamSetBackpressure(stream, backpressure) {
     stream._backpressure = backpressure;
 }
 // Class TransformStreamDefaultController
+/**
+ * Allows control of the {@link ReadableStream} and {@link WritableStream} of the associated {@link TransformStream}.
+ *
+ * @public
+ */
 class TransformStreamDefaultController {
     constructor() {
         throw new TypeError('Illegal constructor');
     }
+    /**
+     * Returns the desired size to fill the readable side’s internal queue. It can be negative, if the queue is over-full.
+     */
     get desiredSize() {
         if (!IsTransformStreamDefaultController(this)) {
-            throw defaultControllerBrandCheckException$1('desiredSize');
+            throw defaultControllerBrandCheckException('desiredSize');
         }
         const readableController = this._controlledTransformStream._readable._readableStreamController;
         return ReadableStreamDefaultControllerGetDesiredSize(readableController);
     }
     enqueue(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.
+     */
     error(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.
+     */
     terminate() {
         if (!IsTransformStreamDefaultController(this)) {
-            throw defaultControllerBrandCheckException$1('terminate');
+            throw defaultControllerBrandCheckException('terminate');
         }
         TransformStreamDefaultControllerTerminate(this);
     }
@@ -3414,7 +4025,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;
@@ -3531,11 +4142,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`);
 }