web-streams-polyfill 3.0.3 → 3.1.0

package/dist/ponyfill.es6.mjs

@@ -1,5 +1,5 @@
 /**
- * web-streams-polyfill v3.0.3
+ * web-streams-polyfill v3.1.0
  */
 /// <reference lib="es2015.symbol" />
 const SymbolPolyfill = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol' ?
@@ -488,7 +488,7 @@ function IsReadableStreamDefaultReader(x) {
     if (!Object.prototype.hasOwnProperty.call(x, '_readRequests')) {
         return false;
     }
-    return true;
+    return x instanceof ReadableStreamDefaultReader;
 }
 function ReadableStreamDefaultReaderRead(reader, readRequest) {
     const stream = reader._ownerReadableStream;
@@ -631,7 +631,14 @@ function IsReadableStreamAsyncIterator(x) {
     if (!Object.prototype.hasOwnProperty.call(x, '_asyncIteratorImpl')) {
         return false;
     }
-    return true;
+    try {
+        // noinspection SuspiciousTypeOfGuard
+        return x._asyncIteratorImpl instanceof
+            ReadableStreamAsyncIteratorImpl;
+    }
+    catch (_a) {
+        return false;
+    }
 }
 // Helper functions for the ReadableStream.
 function streamAsyncIteratorBrandCheckException(name) {
@@ -645,15 +652,35 @@ const NumberIsNaN = Number.isNaN || function (x) {
     return x !== x;
 };
 
-function IsFiniteNonNegativeNumber(v) {
-    if (!IsNonNegativeNumber(v)) {
-        return false;
-    }
-    if (v === Infinity) {
-        return false;
+function CreateArrayFromList(elements) {
+    // We use arrays to represent lists, so this is basically a no-op.
+    // Do a slice though just in case we happen to depend on the unique-ness.
+    return elements.slice();
+}
+function CopyDataBlockBytes(dest, destOffset, src, srcOffset, n) {
+    new Uint8Array(dest).set(new Uint8Array(src, srcOffset, n), destOffset);
+}
+// Not implemented correctly
+function TransferArrayBuffer(O) {
+    return O;
+}
+// Not implemented correctly
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function IsDetachedBuffer(O) {
+    return false;
+}
+function ArrayBufferSlice(buffer, begin, end) {
+    // ArrayBuffer.prototype.slice is not available on IE10
+    // https://www.caniuse.com/mdn-javascript_builtins_arraybuffer_slice
+    if (buffer.slice) {
+        return buffer.slice(begin, end);
     }
-    return true;
+    const length = end - begin;
+    const slice = new ArrayBuffer(length);
+    CopyDataBlockBytes(slice, 0, buffer, begin, length);
+    return slice;
 }
+
 function IsNonNegativeNumber(v) {
     if (typeof v !== 'number') {
         return false;
@@ -666,6 +693,10 @@ function IsNonNegativeNumber(v) {
     }
     return true;
 }
+function CloneAsUint8Array(O) {
+    const buffer = ArrayBufferSlice(O.buffer, O.byteOffset, O.byteOffset + O.byteLength);
+    return new Uint8Array(buffer);
+}
 
 function DequeueValue(container) {
     const pair = container._queue.shift();
@@ -676,8 +707,7 @@ function DequeueValue(container) {
     return pair.value;
 }
 function EnqueueValueWithSize(container, value, size) {
-    size = Number(size);
-    if (!IsFiniteNonNegativeNumber(size)) {
+    if (!IsNonNegativeNumber(size) || size === Infinity) {
         throw new RangeError('Size must be a finite, non-NaN, non-negative number.');
     }
     container._queue.push({ value, size });
@@ -692,23 +722,6 @@ function ResetQueue(container) {
     container._queueTotalSize = 0;
 }
 
-function CreateArrayFromList(elements) {
-    // We use arrays to represent lists, so this is basically a no-op.
-    // Do a slice though just in case we happen to depend on the unique-ness.
-    return elements.slice();
-}
-function CopyDataBlockBytes(dest, destOffset, src, srcOffset, n) {
-    new Uint8Array(dest).set(new Uint8Array(src, srcOffset, n), destOffset);
-}
-// Not implemented correctly
-function TransferArrayBuffer(O) {
-    return O;
-}
-// Not implemented correctly
-function IsDetachedBuffer(O) {
-    return false;
-}
-
 /**
  * A pull-into request in a {@link ReadableByteStreamController}.
  *
@@ -747,15 +760,10 @@ class ReadableStreamBYOBRequest {
         if (!ArrayBuffer.isView(view)) {
             throw new TypeError('You can only respond with array buffer views');
         }
-        if (view.byteLength === 0) {
-            throw new TypeError('chunk must have non-zero byteLength');
-        }
-        if (view.buffer.byteLength === 0) {
-            throw new TypeError(`chunk's buffer must have non-zero byteLength`);
-        }
         if (this._associatedReadableByteStreamController === undefined) {
             throw new TypeError('This BYOB request has been invalidated');
         }
+        if (IsDetachedBuffer(view.buffer)) ;
         ReadableByteStreamControllerRespondWithNewView(this._associatedReadableByteStreamController, view);
     }
 }
@@ -786,14 +794,7 @@ class ReadableByteStreamController {
         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
@@ -856,10 +857,7 @@ class ReadableByteStreamController {
     }
     /** @internal */
     [CancelSteps](reason) {
-        if (this._pendingPullIntos.length > 0) {
-            const firstDescriptor = this._pendingPullIntos.peek();
-            firstDescriptor.bytesFilled = 0;
-        }
+        ReadableByteStreamControllerClearPendingPullIntos(this);
         ResetQueue(this);
         const result = this._cancelAlgorithm(reason);
         ReadableByteStreamControllerClearAlgorithms(this);
@@ -888,6 +886,7 @@ class ReadableByteStreamController {
             }
             const pullIntoDescriptor = {
                 buffer,
+                bufferByteLength: autoAllocateChunkSize,
                 byteOffset: 0,
                 byteLength: autoAllocateChunkSize,
                 bytesFilled: 0,
@@ -922,7 +921,7 @@ function IsReadableByteStreamController(x) {
     if (!Object.prototype.hasOwnProperty.call(x, '_controlledReadableByteStream')) {
         return false;
     }
-    return true;
+    return x instanceof ReadableByteStreamController;
 }
 function IsReadableStreamBYOBRequest(x) {
     if (!typeIsObject(x)) {
@@ -931,7 +930,7 @@ function IsReadableStreamBYOBRequest(x) {
     if (!Object.prototype.hasOwnProperty.call(x, '_associatedReadableByteStreamController')) {
         return false;
     }
-    return true;
+    return x instanceof ReadableStreamBYOBRequest;
 }
 function ReadableByteStreamControllerCallPullIfNeeded(controller) {
     const shouldPull = ReadableByteStreamControllerShouldCallPull(controller);
@@ -1013,7 +1012,6 @@ function ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller,
     return ready;
 }
 function ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, size, pullIntoDescriptor) {
-    ReadableByteStreamControllerInvalidateBYOBRequest(controller);
     pullIntoDescriptor.bytesFilled += size;
 }
 function ReadableByteStreamControllerHandleQueueDrain(controller) {
@@ -1052,9 +1050,15 @@ function ReadableByteStreamControllerPullInto(controller, view, readIntoRequest)
         elementSize = view.constructor.BYTES_PER_ELEMENT;
     }
     const ctor = view.constructor;
+    // try {
     const buffer = TransferArrayBuffer(view.buffer);
+    // } catch (e) {
+    //   readIntoRequest._errorSteps(e);
+    //   return;
+    // }
     const pullIntoDescriptor = {
         buffer,
+        bufferByteLength: buffer.byteLength,
         byteOffset: view.byteOffset,
         byteLength: view.byteLength,
         bytesFilled: 0,
@@ -1094,7 +1098,6 @@ function ReadableByteStreamControllerPullInto(controller, view, readIntoRequest)
     ReadableByteStreamControllerCallPullIfNeeded(controller);
 }
 function ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor) {
-    firstDescriptor.buffer = TransferArrayBuffer(firstDescriptor.buffer);
     const stream = controller._controlledReadableByteStream;
     if (ReadableStreamHasBYOBReader(stream)) {
         while (ReadableStreamGetNumReadIntoRequests(stream) > 0) {
@@ -1104,34 +1107,27 @@ function ReadableByteStreamControllerRespondInClosedState(controller, firstDescr
     }
 }
 function ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, pullIntoDescriptor) {
-    if (pullIntoDescriptor.bytesFilled + bytesWritten > pullIntoDescriptor.byteLength) {
-        throw new RangeError('bytesWritten out of range');
-    }
     ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesWritten, pullIntoDescriptor);
     if (pullIntoDescriptor.bytesFilled < pullIntoDescriptor.elementSize) {
-        // TODO: Figure out whether we should detach the buffer or not here.
         return;
     }
     ReadableByteStreamControllerShiftPendingPullInto(controller);
     const remainderSize = pullIntoDescriptor.bytesFilled % pullIntoDescriptor.elementSize;
     if (remainderSize > 0) {
         const end = pullIntoDescriptor.byteOffset + pullIntoDescriptor.bytesFilled;
-        const remainder = pullIntoDescriptor.buffer.slice(end - remainderSize, end);
+        const remainder = ArrayBufferSlice(pullIntoDescriptor.buffer, end - remainderSize, end);
         ReadableByteStreamControllerEnqueueChunkToQueue(controller, remainder, 0, remainder.byteLength);
     }
-    pullIntoDescriptor.buffer = TransferArrayBuffer(pullIntoDescriptor.buffer);
     pullIntoDescriptor.bytesFilled -= remainderSize;
     ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableByteStream, pullIntoDescriptor);
     ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);
 }
 function ReadableByteStreamControllerRespondInternal(controller, bytesWritten) {
     const firstDescriptor = controller._pendingPullIntos.peek();
+    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);
@@ -1140,7 +1136,6 @@ function ReadableByteStreamControllerRespondInternal(controller, bytesWritten) {
 }
 function ReadableByteStreamControllerShiftPendingPullInto(controller) {
     const descriptor = controller._pendingPullIntos.shift();
-    ReadableByteStreamControllerInvalidateBYOBRequest(controller);
     return descriptor;
 }
 function ReadableByteStreamControllerShouldCallPull(controller) {
@@ -1200,6 +1195,12 @@ function ReadableByteStreamControllerEnqueue(controller, chunk) {
     const byteOffset = chunk.byteOffset;
     const byteLength = chunk.byteLength;
     const transferredBuffer = TransferArrayBuffer(buffer);
+    if (controller._pendingPullIntos.length > 0) {
+        const firstPendingPullInto = controller._pendingPullIntos.peek();
+        if (IsDetachedBuffer(firstPendingPullInto.buffer)) ;
+        firstPendingPullInto.buffer = TransferArrayBuffer(firstPendingPullInto.buffer);
+    }
+    ReadableByteStreamControllerInvalidateBYOBRequest(controller);
     if (ReadableStreamHasDefaultReader(stream)) {
         if (ReadableStreamGetNumReadRequests(stream) === 0) {
             ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);
@@ -1229,6 +1230,16 @@ function ReadableByteStreamControllerError(controller, e) {
     ReadableByteStreamControllerClearAlgorithms(controller);
     ReadableStreamError(stream, e);
 }
+function ReadableByteStreamControllerGetBYOBRequest(controller) {
+    if (controller._byobRequest === null && controller._pendingPullIntos.length > 0) {
+        const firstDescriptor = controller._pendingPullIntos.peek();
+        const view = new Uint8Array(firstDescriptor.buffer, firstDescriptor.byteOffset + firstDescriptor.bytesFilled, firstDescriptor.byteLength - firstDescriptor.bytesFilled);
+        const byobRequest = Object.create(ReadableStreamBYOBRequest.prototype);
+        SetUpReadableStreamBYOBRequest(byobRequest, controller, view);
+        controller._byobRequest = byobRequest;
+    }
+    return controller._byobRequest;
+}
 function ReadableByteStreamControllerGetDesiredSize(controller) {
     const state = controller._controlledReadableByteStream._state;
     if (state === 'errored') {
@@ -1240,21 +1251,47 @@ function ReadableByteStreamControllerGetDesiredSize(controller) {
     return controller._strategyHWM - controller._queueTotalSize;
 }
 function ReadableByteStreamControllerRespond(controller, bytesWritten) {
-    bytesWritten = Number(bytesWritten);
-    if (!IsFiniteNonNegativeNumber(bytesWritten)) {
-        throw new RangeError('bytesWritten must be a finite');
+    const firstDescriptor = controller._pendingPullIntos.peek();
+    const state = controller._controlledReadableByteStream._state;
+    if (state === 'closed') {
+        if (bytesWritten !== 0) {
+            throw new TypeError('bytesWritten must be 0 when calling respond() on a closed stream');
+        }
     }
+    else {
+        if (bytesWritten === 0) {
+            throw new TypeError('bytesWritten must be greater than 0 when calling respond() on a readable stream');
+        }
+        if (firstDescriptor.bytesFilled + bytesWritten > firstDescriptor.byteLength) {
+            throw new RangeError('bytesWritten out of range');
+        }
+    }
+    firstDescriptor.buffer = TransferArrayBuffer(firstDescriptor.buffer);
     ReadableByteStreamControllerRespondInternal(controller, bytesWritten);
 }
 function ReadableByteStreamControllerRespondWithNewView(controller, view) {
     const firstDescriptor = controller._pendingPullIntos.peek();
+    const state = controller._controlledReadableByteStream._state;
+    if (state === 'closed') {
+        if (view.byteLength !== 0) {
+            throw new TypeError('The view\'s length must be 0 when calling respondWithNewView() on a closed stream');
+        }
+    }
+    else {
+        if (view.byteLength === 0) {
+            throw new TypeError('The view\'s length must be greater than 0 when calling respondWithNewView() on a readable stream');
+        }
+    }
     if (firstDescriptor.byteOffset + firstDescriptor.bytesFilled !== view.byteOffset) {
         throw new RangeError('The region specified by view does not match byobRequest');
     }
-    if (firstDescriptor.byteLength !== view.byteLength) {
+    if (firstDescriptor.bufferByteLength !== view.buffer.byteLength) {
         throw new RangeError('The buffer of view has different capacity than byobRequest');
     }
-    firstDescriptor.buffer = view.buffer;
+    if (firstDescriptor.bytesFilled + view.byteLength > firstDescriptor.byteLength) {
+        throw new RangeError('The region specified by view is larger than byobRequest');
+    }
+    firstDescriptor.buffer = TransferArrayBuffer(view.buffer);
     ReadableByteStreamControllerRespondInternal(controller, view.byteLength);
 }
 function SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, autoAllocateChunkSize) {
@@ -1404,6 +1441,7 @@ class ReadableStreamBYOBReader {
         if (view.buffer.byteLength === 0) {
             return promiseRejectedWith(new TypeError(`view's buffer must have non-zero byteLength`));
         }
+        if (IsDetachedBuffer(view.buffer)) ;
         if (this._ownerReadableStream === undefined) {
             return promiseRejectedWith(readerLockException('read from'));
         }
@@ -1463,7 +1501,7 @@ function IsReadableStreamBYOBReader(x) {
     if (!Object.prototype.hasOwnProperty.call(x, '_readIntoRequests')) {
         return false;
     }
-    return true;
+    return x instanceof ReadableStreamBYOBReader;
 }
 function ReadableStreamBYOBReaderRead(reader, view, readIntoRequest) {
     const stream = reader._ownerReadableStream;
@@ -1558,6 +1596,31 @@ function assertWritableStream(x, context) {
     }
 }
 
+function isAbortSignal(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    try {
+        return typeof value.aborted === 'boolean';
+    }
+    catch (_a) {
+        // AbortSignal.prototype.aborted throws if its brand check fails
+        return false;
+    }
+}
+const supportsAbortController = typeof AbortController === 'function';
+/**
+ * Construct a new AbortController, if supported by the platform.
+ *
+ * @internal
+ */
+function createAbortController() {
+    if (supportsAbortController) {
+        return new AbortController();
+    }
+    return undefined;
+}
+
 /**
  * A writable stream represents a destination for data, into which you can write.
  *
@@ -1701,7 +1764,7 @@ function IsWritableStream(x) {
     if (!Object.prototype.hasOwnProperty.call(x, '_writableStreamController')) {
         return false;
     }
-    return true;
+    return x instanceof WritableStream;
 }
 function IsWritableStreamLocked(stream) {
     if (stream._writer === undefined) {
@@ -1710,6 +1773,15 @@ function IsWritableStreamLocked(stream) {
     return true;
 }
 function WritableStreamAbort(stream, reason) {
+    var _a;
+    if (stream._state === 'closed' || stream._state === 'errored') {
+        return promiseResolvedWith(undefined);
+    }
+    stream._writableStreamController._abortReason = reason;
+    (_a = stream._writableStreamController._abortController) === null || _a === void 0 ? void 0 : _a.abort();
+    // TypeScript narrows the type of `stream._state` down to 'writable' | 'erroring',
+    // but it doesn't know that signaling abort runs author code that might have changed the state.
+    // Widen the type again by casting to WritableStreamState.
     const state = stream._state;
     if (state === 'closed' || state === 'errored') {
         return promiseResolvedWith(undefined);
@@ -2055,7 +2127,7 @@ function IsWritableStreamDefaultWriter(x) {
     if (!Object.prototype.hasOwnProperty.call(x, '_ownerWritableStream')) {
         return false;
     }
-    return true;
+    return x instanceof WritableStreamDefaultWriter;
 }
 // A client of WritableStreamDefaultWriter may use these functions directly to bypass state check.
 function WritableStreamDefaultWriterAbort(writer, reason) {
@@ -2145,6 +2217,30 @@ class WritableStreamDefaultController {
     constructor() {
         throw new TypeError('Illegal constructor');
     }
+    /**
+     * The reason which was passed to `WritableStream.abort(reason)` when the stream was aborted.
+     */
+    get abortReason() {
+        if (!IsWritableStreamDefaultController(this)) {
+            throw defaultControllerBrandCheckException$2('abortReason');
+        }
+        return this._abortReason;
+    }
+    /**
+     * An `AbortSignal` that can be used to abort the pending write or close operation when the stream is aborted.
+     */
+    get signal() {
+        if (!IsWritableStreamDefaultController(this)) {
+            throw defaultControllerBrandCheckException$2('signal');
+        }
+        if (this._abortController === undefined) {
+            // Older browsers or older Node versions may not support `AbortController` or `AbortSignal`.
+            // We don't want to bundle and ship an `AbortController` polyfill together with our polyfill,
+            // so instead we only implement support for `signal` if we find a global `AbortController` constructor.
+            throw new TypeError('WritableStreamDefaultController.prototype.signal is not supported');
+        }
+        return this._abortController.signal;
+    }
     /**
      * Closes the controlled writable stream, making all future interactions with it fail with the given error `e`.
      *
@@ -2154,7 +2250,7 @@ class WritableStreamDefaultController {
      */
     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') {
@@ -2192,7 +2288,7 @@ function IsWritableStreamDefaultController(x) {
     if (!Object.prototype.hasOwnProperty.call(x, '_controlledWritableStream')) {
         return false;
     }
-    return true;
+    return x instanceof WritableStreamDefaultController;
 }
 function SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm) {
     controller._controlledWritableStream = stream;
@@ -2201,6 +2297,8 @@ function SetUpWritableStreamDefaultController(stream, controller, startAlgorithm
     controller._queue = undefined;
     controller._queueTotalSize = undefined;
     ResetQueue(controller);
+    controller._abortReason = undefined;
+    controller._abortController = createAbortController();
     controller._started = false;
     controller._strategySizeAlgorithm = sizeAlgorithm;
     controller._strategyHWM = highWaterMark;
@@ -2353,6 +2451,10 @@ function WritableStreamDefaultControllerError(controller, error) {
 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`);
@@ -2438,19 +2540,6 @@ function defaultWriterReadyPromiseResolve(writer) {
     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;
 
@@ -2755,7 +2844,7 @@ function IsReadableStreamDefaultController(x) {
     if (!Object.prototype.hasOwnProperty.call(x, '_controlledReadableStream')) {
         return false;
     }
-    return true;
+    return x instanceof ReadableStreamDefaultController;
 }
 function ReadableStreamDefaultControllerCallPullIfNeeded(controller) {
     const shouldPull = ReadableStreamDefaultControllerShouldCallPull(controller);
@@ -2916,6 +3005,12 @@ function defaultControllerBrandCheckException$1(name) {
 }
 
 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;
@@ -2934,24 +3029,24 @@ function ReadableStreamTee(stream, cloneForBranch2) {
         }
         reading = true;
         const readRequest = {
-            _chunkSteps: value => {
+            _chunkSteps: chunk => {
                 // This needs to be delayed a microtask because it takes at least a microtask to detect errors (using
                 // reader._closedPromise below), and we want errors in stream to error both branches immediately. We cannot let
                 // successful synchronously-available reads get ahead of asynchronously-available errors.
                 queueMicrotask(() => {
                     reading = false;
-                    const value1 = value;
-                    const value2 = value;
+                    const chunk1 = chunk;
+                    const chunk2 = chunk;
                     // There is no way to access the cloning code right now in the reference implementation.
                     // If we add one then we'll need an implementation for serializable objects.
                     // if (!canceled2 && cloneForBranch2) {
-                    //   value2 = StructuredDeserialize(StructuredSerialize(value2));
+                    //   chunk2 = StructuredDeserialize(StructuredSerialize(chunk2));
                     // }
                     if (!canceled1) {
-                        ReadableStreamDefaultControllerEnqueue(branch1._readableStreamController, value1);
+                        ReadableStreamDefaultControllerEnqueue(branch1._readableStreamController, chunk1);
                     }
                     if (!canceled2) {
-                        ReadableStreamDefaultControllerEnqueue(branch2._readableStreamController, value2);
+                        ReadableStreamDefaultControllerEnqueue(branch2._readableStreamController, chunk2);
                     }
                 });
             },
@@ -3008,6 +3103,211 @@ function ReadableStreamTee(stream, cloneForBranch2) {
     });
     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);
@@ -3269,6 +3569,14 @@ function CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, hi
     SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm);
     return stream;
 }
+// Throws if and only if startAlgorithm throws.
+function CreateReadableByteStream(startAlgorithm, pullAlgorithm, cancelAlgorithm) {
+    const stream = Object.create(ReadableStream.prototype);
+    InitializeReadableStream(stream);
+    const controller = Object.create(ReadableByteStreamController.prototype);
+    SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, 0, undefined);
+    return stream;
+}
 function InitializeReadableStream(stream) {
     stream._state = 'readable';
     stream._reader = undefined;
@@ -3282,7 +3590,7 @@ function IsReadableStream(x) {
     if (!Object.prototype.hasOwnProperty.call(x, '_readableStreamController')) {
         return false;
     }
-    return true;
+    return x instanceof ReadableStream;
 }
 function IsReadableStreamLocked(stream) {
     if (stream._reader === undefined) {
@@ -3300,6 +3608,13 @@ function ReadableStreamCancel(stream, reason) {
         return promiseRejectedWith(stream._storedError);
     }
     ReadableStreamClose(stream);
+    const reader = stream._reader;
+    if (reader !== undefined && IsReadableStreamBYOBReader(reader)) {
+        reader._readIntoRequests.forEach(readIntoRequest => {
+            readIntoRequest._closeSteps(undefined);
+        });
+        reader._readIntoRequests = new SimpleQueue();
+    }
     const sourceCancelPromise = stream._readableStreamController[CancelSteps](reason);
     return transformPromiseWith(sourceCancelPromise, noop);
 }
@@ -3352,9 +3667,14 @@ function convertQueuingStrategyInit(init, context) {
     };
 }
 
-const byteLengthSizeFunction = function size(chunk) {
+// The size function must not have a prototype property nor be a constructor
+const byteLengthSizeFunction = (chunk) => {
     return chunk.byteLength;
 };
+Object.defineProperty(byteLengthSizeFunction, 'name', {
+    value: 'size',
+    configurable: true
+});
 /**
  * A queuing strategy that counts the number of bytes in each chunk.
  *
@@ -3406,12 +3726,17 @@ function IsByteLengthQueuingStrategy(x) {
     if (!Object.prototype.hasOwnProperty.call(x, '_byteLengthQueuingStrategyHighWaterMark')) {
         return false;
     }
-    return true;
+    return x instanceof ByteLengthQueuingStrategy;
 }
 
-const countSizeFunction = function size() {
+// The size function must not have a prototype property nor be a constructor
+const countSizeFunction = () => {
     return 1;
 };
+Object.defineProperty(countSizeFunction, 'name', {
+    value: 'size',
+    configurable: true
+});
 /**
  * A queuing strategy that counts the number of chunks.
  *
@@ -3464,7 +3789,7 @@ function IsCountQueuingStrategy(x) {
     if (!Object.prototype.hasOwnProperty.call(x, '_countQueuingStrategyHighWaterMark')) {
         return false;
     }
-    return true;
+    return x instanceof CountQueuingStrategy;
 }
 
 function convertTransformer(original, context) {
@@ -3606,7 +3931,7 @@ function IsTransformStream(x) {
     if (!Object.prototype.hasOwnProperty.call(x, '_transformStreamController')) {
         return false;
     }
-    return true;
+    return x instanceof TransformStream;
 }
 // This is a no-op if both sides are already errored.
 function TransformStreamError(stream, e) {
@@ -3700,7 +4025,7 @@ function IsTransformStreamDefaultController(x) {
     if (!Object.prototype.hasOwnProperty.call(x, '_controlledTransformStream')) {
         return false;
     }
-    return true;
+    return x instanceof TransformStreamDefaultController;
 }
 function SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm) {
     controller._controlledTransformStream = stream;