web-streams-polyfill 3.0.3 → 3.1.0

package/dist/polyfill.es6.js

@@ -1,5 +1,5 @@
 /**
- * web-streams-polyfill v3.0.3
+ * web-streams-polyfill v3.1.0
  */
 (function (global, factory) {
     typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
@@ -494,7 +494,7 @@
         if (!Object.prototype.hasOwnProperty.call(x, '_readRequests')) {
             return false;
         }
-        return true;
+        return x instanceof ReadableStreamDefaultReader;
     }
     function ReadableStreamDefaultReaderRead(reader, readRequest) {
         const stream = reader._ownerReadableStream;
@@ -637,7 +637,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) {
@@ -651,15 +658,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;
+        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;
@@ -672,6 +699,10 @@
         }
         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();
@@ -682,8 +713,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, size });
@@ -698,23 +728,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}.
      *
@@ -753,15 +766,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);
         }
     }
@@ -792,14 +800,7 @@
             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
@@ -862,10 +863,7 @@
         }
         /** @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);
@@ -894,6 +892,7 @@
                 }
                 const pullIntoDescriptor = {
                     buffer,
+                    bufferByteLength: autoAllocateChunkSize,
                     byteOffset: 0,
                     byteLength: autoAllocateChunkSize,
                     bytesFilled: 0,
@@ -928,7 +927,7 @@
         if (!Object.prototype.hasOwnProperty.call(x, '_controlledReadableByteStream')) {
             return false;
         }
-        return true;
+        return x instanceof ReadableByteStreamController;
     }
     function IsReadableStreamBYOBRequest(x) {
         if (!typeIsObject(x)) {
@@ -937,7 +936,7 @@
         if (!Object.prototype.hasOwnProperty.call(x, '_associatedReadableByteStreamController')) {
             return false;
         }
-        return true;
+        return x instanceof ReadableStreamBYOBRequest;
     }
     function ReadableByteStreamControllerCallPullIfNeeded(controller) {
         const shouldPull = ReadableByteStreamControllerShouldCallPull(controller);
@@ -1019,7 +1018,6 @@
         return ready;
     }
     function ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, size, pullIntoDescriptor) {
-        ReadableByteStreamControllerInvalidateBYOBRequest(controller);
         pullIntoDescriptor.bytesFilled += size;
     }
     function ReadableByteStreamControllerHandleQueueDrain(controller) {
@@ -1058,9 +1056,15 @@
             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,
@@ -1100,7 +1104,6 @@
         ReadableByteStreamControllerCallPullIfNeeded(controller);
     }
     function ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor) {
-        firstDescriptor.buffer = TransferArrayBuffer(firstDescriptor.buffer);
         const stream = controller._controlledReadableByteStream;
         if (ReadableStreamHasBYOBReader(stream)) {
             while (ReadableStreamGetNumReadIntoRequests(stream) > 0) {
@@ -1110,34 +1113,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);
         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();
+        ReadableByteStreamControllerInvalidateBYOBRequest(controller);
         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');
-            }
-            ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor);
+            ReadableByteStreamControllerRespondInClosedState(controller);
         }
         else {
             ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, firstDescriptor);
@@ -1146,7 +1142,6 @@
     }
     function ReadableByteStreamControllerShiftPendingPullInto(controller) {
         const descriptor = controller._pendingPullIntos.shift();
-        ReadableByteStreamControllerInvalidateBYOBRequest(controller);
         return descriptor;
     }
     function ReadableByteStreamControllerShouldCallPull(controller) {
@@ -1206,6 +1201,12 @@
         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);
@@ -1235,6 +1236,16 @@
         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 state = controller._controlledReadableByteStream._state;
         if (state === 'errored') {
@@ -1246,21 +1257,47 @@
         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) {
@@ -1410,6 +1447,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'));
             }
@@ -1469,7 +1507,7 @@
         if (!Object.prototype.hasOwnProperty.call(x, '_readIntoRequests')) {
             return false;
         }
-        return true;
+        return x instanceof ReadableStreamBYOBReader;
     }
     function ReadableStreamBYOBReaderRead(reader, view, readIntoRequest) {
         const stream = reader._ownerReadableStream;
@@ -1564,6 +1602,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;
+        }
+    }
+    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.
      *
@@ -1707,7 +1770,7 @@
         if (!Object.prototype.hasOwnProperty.call(x, '_writableStreamController')) {
             return false;
         }
-        return true;
+        return x instanceof WritableStream;
     }
     function IsWritableStreamLocked(stream) {
         if (stream._writer === undefined) {
@@ -1716,6 +1779,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.
         const state = stream._state;
         if (state === 'closed' || state === 'errored') {
             return promiseResolvedWith(undefined);
@@ -2061,7 +2133,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) {
@@ -2151,6 +2223,30 @@
         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`.
          *
@@ -2160,7 +2256,7 @@
          */
         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') {
@@ -2198,7 +2294,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;
@@ -2207,6 +2303,8 @@
         controller._queue = undefined;
         controller._queueTotalSize = undefined;
         ResetQueue(controller);
+        controller._abortReason = undefined;
+        controller._abortController = createAbortController();
         controller._started = false;
         controller._strategySizeAlgorithm = sizeAlgorithm;
         controller._strategyHWM = highWaterMark;
@@ -2359,6 +2457,10 @@
     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`);
@@ -2444,19 +2546,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" />
     const NativeDOMException = typeof DOMException !== 'undefined' ? DOMException : undefined;
 
@@ -2761,7 +2850,7 @@
         if (!Object.prototype.hasOwnProperty.call(x, '_controlledReadableStream')) {
             return false;
         }
-        return true;
+        return x instanceof ReadableStreamDefaultController;
     }
     function ReadableStreamDefaultControllerCallPullIfNeeded(controller) {
         const shouldPull = ReadableStreamDefaultControllerShouldCallPull(controller);
@@ -2922,6 +3011,12 @@
     }
 
     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;
@@ -2940,24 +3035,24 @@
             }
             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);
                         }
                     });
                 },
@@ -3014,6 +3109,211 @@
         });
         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);
@@ -3275,6 +3575,14 @@
         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;
@@ -3288,7 +3596,7 @@
         if (!Object.prototype.hasOwnProperty.call(x, '_readableStreamController')) {
             return false;
         }
-        return true;
+        return x instanceof ReadableStream;
     }
     function IsReadableStreamLocked(stream) {
         if (stream._reader === undefined) {
@@ -3306,6 +3614,13 @@
             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);
     }
@@ -3358,9 +3673,14 @@
         };
     }
 
-    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.
      *
@@ -3412,12 +3732,17 @@
         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.
      *
@@ -3470,7 +3795,7 @@
         if (!Object.prototype.hasOwnProperty.call(x, '_countQueuingStrategyHighWaterMark')) {
             return false;
         }
-        return true;
+        return x instanceof CountQueuingStrategy;
     }
 
     function convertTransformer(original, context) {
@@ -3612,7 +3937,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) {
@@ -3706,7 +4031,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;