web-streams-polyfill 3.0.2 → 3.2.0

package/dist/polyfill.js

@@ -1,10 +1,10 @@
 /**
- * web-streams-polyfill v3.0.2
+ * web-streams-polyfill v3.2.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;
@@ -505,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;
@@ -653,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) {
@@ -667,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;
@@ -688,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();
@@ -698,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 });
@@ -714,23 +744,6 @@
         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}.
      *
@@ -773,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;
@@ -814,14 +822,7 @@
                 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
@@ -892,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);
@@ -924,6 +922,7 @@
                 }
                 var pullIntoDescriptor = {
                     buffer: buffer,
+                    bufferByteLength: autoAllocateChunkSize,
                     byteOffset: 0,
                     byteLength: autoAllocateChunkSize,
                     bytesFilled: 0,
@@ -959,7 +958,7 @@
         if (!Object.prototype.hasOwnProperty.call(x, '_controlledReadableByteStream')) {
             return false;
         }
-        return true;
+        return x instanceof ReadableByteStreamController;
     }
     function IsReadableStreamBYOBRequest(x) {
         if (!typeIsObject(x)) {
@@ -968,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);
@@ -1050,7 +1049,6 @@
         return ready;
     }
     function ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, size, pullIntoDescriptor) {
-        ReadableByteStreamControllerInvalidateBYOBRequest(controller);
         pullIntoDescriptor.bytesFilled += size;
     }
     function ReadableByteStreamControllerHandleQueueDrain(controller) {
@@ -1089,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,
@@ -1131,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) {
@@ -1141,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();
+        ReadableByteStreamControllerInvalidateBYOBRequest(controller);
         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');
-            }
-            ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor);
+            ReadableByteStreamControllerRespondInClosedState(controller);
         }
         else {
             ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, firstDescriptor);
@@ -1177,7 +1173,6 @@
     }
     function ReadableByteStreamControllerShiftPendingPullInto(controller) {
         var descriptor = controller._pendingPullIntos.shift();
-        ReadableByteStreamControllerInvalidateBYOBRequest(controller);
         return descriptor;
     }
     function ReadableByteStreamControllerShouldCallPull(controller) {
@@ -1237,11 +1232,20 @@
         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);
             }
             else {
+                if (controller._pendingPullIntos.length > 0) {
+                    ReadableByteStreamControllerShiftPendingPullInto(controller);
+                }
                 var transferredView = new Uint8Array(transferredBuffer, byteOffset, byteLength);
                 ReadableStreamFulfillReadRequest(stream, transferredView, false);
             }
@@ -1266,6 +1270,16 @@
         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 state = controller._controlledReadableByteStream._state;
         if (state === 'errored') {
@@ -1277,22 +1291,49 @@
         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;
-        ReadableByteStreamControllerRespondInternal(controller, view.byteLength);
+        if (firstDescriptor.bytesFilled + view.byteLength > firstDescriptor.byteLength) {
+            throw new RangeError('The region specified by view is larger than byobRequest');
+        }
+        var viewByteLength = view.byteLength;
+        firstDescriptor.buffer = TransferArrayBuffer(view.buffer);
+        ReadableByteStreamControllerRespondInternal(controller, viewByteLength);
     }
     function SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, autoAllocateChunkSize) {
         controller._controlledReadableByteStream = stream;
@@ -1446,6 +1487,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'));
             }
@@ -1506,7 +1548,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;
@@ -1601,6 +1643,31 @@
         }
     }
 
+    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.
      *
@@ -1633,7 +1700,7 @@
              */
             get: function () {
                 if (!IsWritableStream(this)) {
-                    throw streamBrandCheckException('locked');
+                    throw streamBrandCheckException$2('locked');
                 }
                 return IsWritableStreamLocked(this);
             },
@@ -1652,7 +1719,7 @@
         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'));
@@ -1669,7 +1736,7 @@
          */
         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'));
@@ -1689,7 +1756,7 @@
          */
         WritableStream.prototype.getWriter = function () {
             if (!IsWritableStream(this)) {
-                throw streamBrandCheckException('getWriter');
+                throw streamBrandCheckException$2('getWriter');
             }
             return AcquireWritableStreamDefaultWriter(this);
         };
@@ -1754,7 +1821,7 @@
         if (!Object.prototype.hasOwnProperty.call(x, '_writableStreamController')) {
             return false;
         }
-        return true;
+        return x instanceof WritableStream;
     }
     function IsWritableStreamLocked(stream) {
         if (stream._writer === undefined) {
@@ -1763,6 +1830,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);
@@ -2123,7 +2199,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) {
@@ -2213,6 +2289,42 @@
         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.
+             *
+             * @deprecated
+             *  This property has been removed from the specification, see https://github.com/whatwg/streams/pull/1177.
+             *  Use {@link WritableStreamDefaultController.signal}'s `reason` instead.
+             */
+            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`.
          *
@@ -2223,7 +2335,7 @@
         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') {
@@ -2246,6 +2358,8 @@
         return WritableStreamDefaultController;
     }());
     Object.defineProperties(WritableStreamDefaultController.prototype, {
+        abortReason: { enumerable: true },
+        signal: { enumerable: true },
         error: { enumerable: true }
     });
     if (typeof SymbolPolyfill.toStringTag === 'symbol') {
@@ -2262,7 +2376,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;
@@ -2271,6 +2385,8 @@
         controller._queue = undefined;
         controller._queueTotalSize = undefined;
         ResetQueue(controller);
+        controller._abortReason = undefined;
+        controller._abortController = createAbortController();
         controller._started = false;
         controller._strategySizeAlgorithm = sizeAlgorithm;
         controller._strategyHWM = highWaterMark;
@@ -2420,9 +2536,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");
@@ -2508,19 +2628,6 @@
         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;
 
@@ -2538,6 +2645,7 @@
         }
     }
     function createDOMExceptionPolyfill() {
+        // eslint-disable-next-line no-shadow
         var ctor = function DOMException(message, name) {
             this.message = message || '';
             this.name = name || 'Error';
@@ -2549,6 +2657,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) {
@@ -2742,7 +2851,7 @@
              */
             get: function () {
                 if (!IsReadableStreamDefaultController(this)) {
-                    throw defaultControllerBrandCheckException('desiredSize');
+                    throw defaultControllerBrandCheckException$1('desiredSize');
                 }
                 return ReadableStreamDefaultControllerGetDesiredSize(this);
             },
@@ -2755,7 +2864,7 @@
          */
         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');
@@ -2765,7 +2874,7 @@
         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');
@@ -2778,7 +2887,7 @@
         ReadableStreamDefaultController.prototype.error = function (e) {
             if (e === void 0) { e = undefined; }
             if (!IsReadableStreamDefaultController(this)) {
-                throw defaultControllerBrandCheckException('error');
+                throw defaultControllerBrandCheckException$1('error');
             }
             ReadableStreamDefaultControllerError(this, e);
         };
@@ -2830,7 +2939,7 @@
         if (!Object.prototype.hasOwnProperty.call(x, '_controlledReadableStream')) {
             return false;
         }
-        return true;
+        return x instanceof ReadableStreamDefaultController;
     }
     function ReadableStreamDefaultControllerCallPullIfNeeded(controller) {
         var shouldPull = ReadableStreamDefaultControllerShouldCallPull(controller);
@@ -2986,13 +3095,20 @@
         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 readAgain = false;
         var canceled1 = false;
         var canceled2 = false;
         var reason1;
@@ -3005,30 +3121,34 @@
         });
         function pullAlgorithm() {
             if (reading) {
+                readAgain = true;
                 return promiseResolvedWith(undefined);
             }
             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;
+                        readAgain = false;
+                        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);
+                        }
+                        reading = false;
+                        if (readAgain) {
+                            pullAlgorithm();
                         }
-                        resolveCancelPromise(undefined);
                     });
                 },
                 _closeSteps: function () {
@@ -3039,6 +3159,9 @@
                     if (!canceled2) {
                         ReadableStreamDefaultControllerClose(branch2._readableStreamController);
                     }
+                    if (!canceled1 || !canceled2) {
+                        resolveCancelPromise(undefined);
+                    }
                 },
                 _errorSteps: function () {
                     reading = false;
@@ -3075,10 +3198,237 @@
         uponRejection(reader._closedPromise, function (r) {
             ReadableStreamDefaultControllerError(branch1._readableStreamController, r);
             ReadableStreamDefaultControllerError(branch2._readableStreamController, r);
-            resolveCancelPromise(undefined);
+            if (!canceled1 || !canceled2) {
+                resolveCancelPromise(undefined);
+            }
         });
         return [branch1, branch2];
     }
+    function ReadableByteStreamTee(stream) {
+        var reader = AcquireReadableStreamDefaultReader(stream);
+        var reading = false;
+        var readAgainForBranch1 = false;
+        var readAgainForBranch2 = 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 () {
+                        readAgainForBranch1 = false;
+                        readAgainForBranch2 = 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);
+                        }
+                        reading = false;
+                        if (readAgainForBranch1) {
+                            pull1Algorithm();
+                        }
+                        else if (readAgainForBranch2) {
+                            pull2Algorithm();
+                        }
+                    });
+                },
+                _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 () {
+                        readAgainForBranch1 = false;
+                        readAgainForBranch2 = 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);
+                        }
+                        reading = false;
+                        if (readAgainForBranch1) {
+                            pull1Algorithm();
+                        }
+                        else if (readAgainForBranch2) {
+                            pull2Algorithm();
+                        }
+                    });
+                },
+                _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) {
+                readAgainForBranch1 = true;
+                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) {
+                readAgainForBranch2 = true;
+                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);
@@ -3354,6 +3704,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;
@@ -3367,7 +3725,7 @@
         if (!Object.prototype.hasOwnProperty.call(x, '_readableStreamController')) {
             return false;
         }
-        return true;
+        return x instanceof ReadableStream;
     }
     function IsReadableStreamLocked(stream) {
         if (stream._reader === undefined) {
@@ -3385,6 +3743,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);
     }
@@ -3437,9 +3802,14 @@
         };
     }
 
-    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.
      *
@@ -3500,12 +3870,17 @@
         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.
      *
@@ -3567,7 +3942,7 @@
         if (!Object.prototype.hasOwnProperty.call(x, '_countQueuingStrategyHighWaterMark')) {
             return false;
         }
-        return true;
+        return x instanceof CountQueuingStrategy;
     }
 
     function convertTransformer(original, context) {
@@ -3653,7 +4028,7 @@
              */
             get: function () {
                 if (!IsTransformStream(this)) {
-                    throw streamBrandCheckException$2('readable');
+                    throw streamBrandCheckException('readable');
                 }
                 return this._readable;
             },
@@ -3666,7 +4041,7 @@
              */
             get: function () {
                 if (!IsTransformStream(this)) {
-                    throw streamBrandCheckException$2('writable');
+                    throw streamBrandCheckException('writable');
                 }
                 return this._writable;
             },
@@ -3721,7 +4096,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) {
@@ -3764,7 +4139,7 @@
              */
             get: function () {
                 if (!IsTransformStreamDefaultController(this)) {
-                    throw defaultControllerBrandCheckException$1('desiredSize');
+                    throw defaultControllerBrandCheckException('desiredSize');
                 }
                 var readableController = this._controlledTransformStream._readable._readableStreamController;
                 return ReadableStreamDefaultControllerGetDesiredSize(readableController);
@@ -3775,7 +4150,7 @@
         TransformStreamDefaultController.prototype.enqueue = function (chunk) {
             if (chunk === void 0) { chunk = undefined; }
             if (!IsTransformStreamDefaultController(this)) {
-                throw defaultControllerBrandCheckException$1('enqueue');
+                throw defaultControllerBrandCheckException('enqueue');
             }
             TransformStreamDefaultControllerEnqueue(this, chunk);
         };
@@ -3786,7 +4161,7 @@
         TransformStreamDefaultController.prototype.error = function (reason) {
             if (reason === void 0) { reason = undefined; }
             if (!IsTransformStreamDefaultController(this)) {
-                throw defaultControllerBrandCheckException$1('error');
+                throw defaultControllerBrandCheckException('error');
             }
             TransformStreamDefaultControllerError(this, reason);
         };
@@ -3796,7 +4171,7 @@
          */
         TransformStreamDefaultController.prototype.terminate = function () {
             if (!IsTransformStreamDefaultController(this)) {
-                throw defaultControllerBrandCheckException$1('terminate');
+                throw defaultControllerBrandCheckException('terminate');
             }
             TransformStreamDefaultControllerTerminate(this);
         };
@@ -3822,7 +4197,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;
@@ -3939,11 +4314,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");
     }