web-streams-polyfill 3.0.1 → 3.1.1

package/dist/polyfill.mjs

@@ -1,5 +1,5 @@
 /**
- * web-streams-polyfill v3.0.1
+ * web-streams-polyfill v3.1.1
  */
 /// <reference lib="es2015.symbol" />
 var SymbolPolyfill = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol' ?
@@ -8,7 +8,7 @@ var SymbolPolyfill = typeof Symbol === 'function' && typeof Symbol.iterator ===
 
 /// <reference lib="dom" />
 function noop() {
-    // do nothing
+    return undefined;
 }
 function getGlobals() {
     if (typeof self !== 'undefined') {
@@ -27,7 +27,7 @@ var globals = getGlobals();
 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;
@@ -499,7 +499,7 @@ function IsReadableStreamDefaultReader(x) {
     if (!Object.prototype.hasOwnProperty.call(x, '_readRequests')) {
         return false;
     }
-    return true;
+    return x instanceof ReadableStreamDefaultReader;
 }
 function ReadableStreamDefaultReaderRead(reader, readRequest) {
     var stream = reader._ownerReadableStream;
@@ -647,7 +647,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) {
@@ -661,15 +668,35 @@ var 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;
+    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;
@@ -682,6 +709,10 @@ function IsNonNegativeNumber(v) {
     }
     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();
@@ -692,8 +723,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: value, size: size });
@@ -708,23 +738,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}.
  *
@@ -767,15 +780,10 @@ var ReadableStreamBYOBRequest = /** @class */ (function () {
         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;
@@ -808,14 +816,7 @@ var ReadableByteStreamController = /** @class */ (function () {
             if (!IsReadableByteStreamController(this)) {
                 throw byteStreamControllerBrandCheckException('byobRequest');
             }
-            if (this._byobRequest === null && this._pendingPullIntos.length > 0) {
-                var firstDescriptor = this._pendingPullIntos.peek();
-                var view = new Uint8Array(firstDescriptor.buffer, firstDescriptor.byteOffset + firstDescriptor.bytesFilled, firstDescriptor.byteLength - firstDescriptor.bytesFilled);
-                var byobRequest = Object.create(ReadableStreamBYOBRequest.prototype);
-                SetUpReadableStreamBYOBRequest(byobRequest, this, view);
-                this._byobRequest = byobRequest;
-            }
-            return this._byobRequest;
+            return ReadableByteStreamControllerGetBYOBRequest(this);
         },
         enumerable: false,
         configurable: true
@@ -886,10 +887,7 @@ var ReadableByteStreamController = /** @class */ (function () {
     };
     /** @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);
@@ -918,6 +916,7 @@ var ReadableByteStreamController = /** @class */ (function () {
             }
             var pullIntoDescriptor = {
                 buffer: buffer,
+                bufferByteLength: autoAllocateChunkSize,
                 byteOffset: 0,
                 byteLength: autoAllocateChunkSize,
                 bytesFilled: 0,
@@ -953,7 +952,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)) {
@@ -962,7 +961,7 @@ function IsReadableStreamBYOBRequest(x) {
     if (!Object.prototype.hasOwnProperty.call(x, '_associatedReadableByteStreamController')) {
         return false;
     }
-    return true;
+    return x instanceof ReadableStreamBYOBRequest;
 }
 function ReadableByteStreamControllerCallPullIfNeeded(controller) {
     var shouldPull = ReadableByteStreamControllerShouldCallPull(controller);
@@ -1044,7 +1043,6 @@ function ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller,
     return ready;
 }
 function ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, size, pullIntoDescriptor) {
-    ReadableByteStreamControllerInvalidateBYOBRequest(controller);
     pullIntoDescriptor.bytesFilled += size;
 }
 function ReadableByteStreamControllerHandleQueueDrain(controller) {
@@ -1083,9 +1081,15 @@ function ReadableByteStreamControllerPullInto(controller, view, readIntoRequest)
         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,
@@ -1125,7 +1129,6 @@ function ReadableByteStreamControllerPullInto(controller, view, readIntoRequest)
     ReadableByteStreamControllerCallPullIfNeeded(controller);
 }
 function ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor) {
-    firstDescriptor.buffer = TransferArrayBuffer(firstDescriptor.buffer);
     var stream = controller._controlledReadableByteStream;
     if (ReadableStreamHasBYOBReader(stream)) {
         while (ReadableStreamGetNumReadIntoRequests(stream) > 0) {
@@ -1135,34 +1138,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);
     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);
@@ -1171,7 +1167,6 @@ function ReadableByteStreamControllerRespondInternal(controller, bytesWritten) {
 }
 function ReadableByteStreamControllerShiftPendingPullInto(controller) {
     var descriptor = controller._pendingPullIntos.shift();
-    ReadableByteStreamControllerInvalidateBYOBRequest(controller);
     return descriptor;
 }
 function ReadableByteStreamControllerShouldCallPull(controller) {
@@ -1231,6 +1226,12 @@ function ReadableByteStreamControllerEnqueue(controller, chunk) {
     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);
@@ -1260,6 +1261,16 @@ function ReadableByteStreamControllerError(controller, e) {
     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') {
@@ -1271,21 +1282,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');
+    var firstDescriptor = controller._pendingPullIntos.peek();
+    var state = controller._controlledReadableByteStream._state;
+    if (state === 'closed') {
+        if (bytesWritten !== 0) {
+            throw new TypeError('bytesWritten must be 0 when calling respond() on a closed stream');
+        }
+    }
+    else {
+        if (bytesWritten === 0) {
+            throw new TypeError('bytesWritten must be greater than 0 when calling respond() on a readable stream');
+        }
+        if (firstDescriptor.bytesFilled + bytesWritten > firstDescriptor.byteLength) {
+            throw new RangeError('bytesWritten out of range');
+        }
     }
+    firstDescriptor.buffer = TransferArrayBuffer(firstDescriptor.buffer);
     ReadableByteStreamControllerRespondInternal(controller, bytesWritten);
 }
 function ReadableByteStreamControllerRespondWithNewView(controller, view) {
     var firstDescriptor = controller._pendingPullIntos.peek();
+    var state = controller._controlledReadableByteStream._state;
+    if (state === 'closed') {
+        if (view.byteLength !== 0) {
+            throw new TypeError('The view\'s length must be 0 when calling respondWithNewView() on a closed stream');
+        }
+    }
+    else {
+        if (view.byteLength === 0) {
+            throw new TypeError('The view\'s length must be greater than 0 when calling respondWithNewView() on a readable stream');
+        }
+    }
     if (firstDescriptor.byteOffset + firstDescriptor.bytesFilled !== view.byteOffset) {
         throw new RangeError('The region specified by view does not match byobRequest');
     }
-    if (firstDescriptor.byteLength !== view.byteLength) {
+    if (firstDescriptor.bufferByteLength !== view.buffer.byteLength) {
         throw new RangeError('The buffer of view has different capacity than byobRequest');
     }
-    firstDescriptor.buffer = view.buffer;
+    if (firstDescriptor.bytesFilled + view.byteLength > firstDescriptor.byteLength) {
+        throw new RangeError('The region specified by view is larger than byobRequest');
+    }
+    firstDescriptor.buffer = TransferArrayBuffer(view.buffer);
     ReadableByteStreamControllerRespondInternal(controller, view.byteLength);
 }
 function SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, autoAllocateChunkSize) {
@@ -1327,6 +1364,9 @@ function SetUpReadableByteStreamControllerFromUnderlyingSource(stream, underlyin
         cancelAlgorithm = function (reason) { return underlyingByteSource.cancel(reason); };
     }
     var autoAllocateChunkSize = underlyingByteSource.autoAllocateChunkSize;
+    if (autoAllocateChunkSize === 0) {
+        throw new TypeError('autoAllocateChunkSize must be greater than 0');
+    }
     SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, autoAllocateChunkSize);
 }
 function SetUpReadableStreamBYOBRequest(request, controller, view) {
@@ -1437,6 +1477,7 @@ var ReadableStreamBYOBReader = /** @class */ (function () {
         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'));
         }
@@ -1497,7 +1538,7 @@ function IsReadableStreamBYOBReader(x) {
     if (!Object.prototype.hasOwnProperty.call(x, '_readIntoRequests')) {
         return false;
     }
-    return true;
+    return x instanceof ReadableStreamBYOBReader;
 }
 function ReadableStreamBYOBReaderRead(reader, view, readIntoRequest) {
     var stream = reader._ownerReadableStream;
@@ -1592,6 +1633,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;
+    }
+}
+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.
  *
@@ -1624,7 +1690,7 @@ var WritableStream = /** @class */ (function () {
          */
         get: function () {
             if (!IsWritableStream(this)) {
-                throw streamBrandCheckException('locked');
+                throw streamBrandCheckException$2('locked');
             }
             return IsWritableStreamLocked(this);
         },
@@ -1643,7 +1709,7 @@ var WritableStream = /** @class */ (function () {
     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'));
@@ -1660,7 +1726,7 @@ var WritableStream = /** @class */ (function () {
      */
     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'));
@@ -1680,7 +1746,7 @@ var WritableStream = /** @class */ (function () {
      */
     WritableStream.prototype.getWriter = function () {
         if (!IsWritableStream(this)) {
-            throw streamBrandCheckException('getWriter');
+            throw streamBrandCheckException$2('getWriter');
         }
         return AcquireWritableStreamDefaultWriter(this);
     };
@@ -1745,7 +1811,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) {
@@ -1754,6 +1820,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.
     var state = stream._state;
     if (state === 'closed' || state === 'errored') {
         return promiseResolvedWith(undefined);
@@ -2114,7 +2189,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) {
@@ -2204,6 +2279,38 @@ var WritableStreamDefaultController = /** @class */ (function () {
     function WritableStreamDefaultController() {
         throw new TypeError('Illegal constructor');
     }
+    Object.defineProperty(WritableStreamDefaultController.prototype, "abortReason", {
+        /**
+         * The reason which was passed to `WritableStream.abort(reason)` when the stream was aborted.
+         */
+        get: function () {
+            if (!IsWritableStreamDefaultController(this)) {
+                throw defaultControllerBrandCheckException$2('abortReason');
+            }
+            return this._abortReason;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(WritableStreamDefaultController.prototype, "signal", {
+        /**
+         * An `AbortSignal` that can be used to abort the pending write or close operation when the stream is aborted.
+         */
+        get: function () {
+            if (!IsWritableStreamDefaultController(this)) {
+                throw defaultControllerBrandCheckException$2('signal');
+            }
+            if (this._abortController === undefined) {
+                // Older browsers or older Node versions may not support `AbortController` or `AbortSignal`.
+                // We don't want to bundle and ship an `AbortController` polyfill together with our polyfill,
+                // so instead we only implement support for `signal` if we find a global `AbortController` constructor.
+                throw new TypeError('WritableStreamDefaultController.prototype.signal is not supported');
+            }
+            return this._abortController.signal;
+        },
+        enumerable: false,
+        configurable: true
+    });
     /**
      * Closes the controlled writable stream, making all future interactions with it fail with the given error `e`.
      *
@@ -2214,7 +2321,7 @@ var WritableStreamDefaultController = /** @class */ (function () {
     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') {
@@ -2253,7 +2360,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;
@@ -2262,6 +2369,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;
@@ -2411,9 +2520,13 @@ function WritableStreamDefaultControllerError(controller, error) {
     WritableStreamStartErroring(stream, error);
 }
 // Helper functions for the WritableStream.
-function streamBrandCheckException(name) {
+function streamBrandCheckException$2(name) {
     return new TypeError("WritableStream.prototype." + name + " can only be used on a WritableStream");
 }
+// Helper functions for the WritableStreamDefaultController.
+function defaultControllerBrandCheckException$2(name) {
+    return new TypeError("WritableStreamDefaultController.prototype." + name + " can only be used on a WritableStreamDefaultController");
+}
 // Helper functions for the WritableStreamDefaultWriter.
 function defaultWriterBrandCheckException(name) {
     return new TypeError("WritableStreamDefaultWriter.prototype." + name + " can only be used on a WritableStreamDefaultWriter");
@@ -2499,19 +2612,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" />
 var NativeDOMException = typeof DOMException !== 'undefined' ? DOMException : undefined;
 
@@ -2529,6 +2629,7 @@ function isDOMExceptionConstructor(ctor) {
     }
 }
 function createDOMExceptionPolyfill() {
+    // eslint-disable-next-line no-shadow
     var ctor = function DOMException(message, name) {
         this.message = message || '';
         this.name = name || 'Error';
@@ -2540,6 +2641,7 @@ function createDOMExceptionPolyfill() {
     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) {
@@ -2733,7 +2835,7 @@ var ReadableStreamDefaultController = /** @class */ (function () {
          */
         get: function () {
             if (!IsReadableStreamDefaultController(this)) {
-                throw defaultControllerBrandCheckException('desiredSize');
+                throw defaultControllerBrandCheckException$1('desiredSize');
             }
             return ReadableStreamDefaultControllerGetDesiredSize(this);
         },
@@ -2746,7 +2848,7 @@ var ReadableStreamDefaultController = /** @class */ (function () {
      */
     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');
@@ -2756,7 +2858,7 @@ var ReadableStreamDefaultController = /** @class */ (function () {
     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');
@@ -2769,7 +2871,7 @@ var ReadableStreamDefaultController = /** @class */ (function () {
     ReadableStreamDefaultController.prototype.error = function (e) {
         if (e === void 0) { e = undefined; }
         if (!IsReadableStreamDefaultController(this)) {
-            throw defaultControllerBrandCheckException('error');
+            throw defaultControllerBrandCheckException$1('error');
         }
         ReadableStreamDefaultControllerError(this, e);
     };
@@ -2821,7 +2923,7 @@ function IsReadableStreamDefaultController(x) {
     if (!Object.prototype.hasOwnProperty.call(x, '_controlledReadableStream')) {
         return false;
     }
-    return true;
+    return x instanceof ReadableStreamDefaultController;
 }
 function ReadableStreamDefaultControllerCallPullIfNeeded(controller) {
     var shouldPull = ReadableStreamDefaultControllerShouldCallPull(controller);
@@ -2977,11 +3079,17 @@ function SetUpReadableStreamDefaultControllerFromUnderlyingSource(stream, underl
     SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm);
 }
 // Helper functions for the ReadableStreamDefaultController.
-function defaultControllerBrandCheckException(name) {
+function defaultControllerBrandCheckException$1(name) {
     return new TypeError("ReadableStreamDefaultController.prototype." + name + " can only be used on a ReadableStreamDefaultController");
 }
 
 function ReadableStreamTee(stream, cloneForBranch2) {
+    if (IsReadableByteStreamController(stream._readableStreamController)) {
+        return ReadableByteStreamTee(stream);
+    }
+    return ReadableStreamDefaultTee(stream);
+}
+function ReadableStreamDefaultTee(stream, cloneForBranch2) {
     var reader = AcquireReadableStreamDefaultReader(stream);
     var reading = false;
     var canceled1 = false;
@@ -3000,26 +3108,25 @@ function ReadableStreamTee(stream, cloneForBranch2) {
         }
         reading = true;
         var readRequest = {
-            _chunkSteps: function (value) {
+            _chunkSteps: function (chunk) {
                 // This needs to be delayed a microtask because it takes at least a microtask to detect errors (using
                 // reader._closedPromise below), and we want errors in stream to error both branches immediately. We cannot let
                 // successful synchronously-available reads get ahead of asynchronously-available errors.
                 queueMicrotask(function () {
                     reading = false;
-                    var value1 = value;
-                    var value2 = value;
+                    var chunk1 = chunk;
+                    var chunk2 = chunk;
                     // There is no way to access the cloning code right now in the reference implementation.
                     // If we add one then we'll need an implementation for serializable objects.
                     // if (!canceled2 && cloneForBranch2) {
-                    //   value2 = StructuredDeserialize(StructuredSerialize(value2));
+                    //   chunk2 = StructuredDeserialize(StructuredSerialize(chunk2));
                     // }
                     if (!canceled1) {
-                        ReadableStreamDefaultControllerEnqueue(branch1._readableStreamController, value1);
+                        ReadableStreamDefaultControllerEnqueue(branch1._readableStreamController, chunk1);
                     }
                     if (!canceled2) {
-                        ReadableStreamDefaultControllerEnqueue(branch2._readableStreamController, value2);
+                        ReadableStreamDefaultControllerEnqueue(branch2._readableStreamController, chunk2);
                     }
-                    resolveCancelPromise(undefined);
                 });
             },
             _closeSteps: function () {
@@ -3030,6 +3137,9 @@ function ReadableStreamTee(stream, cloneForBranch2) {
                 if (!canceled2) {
                     ReadableStreamDefaultControllerClose(branch2._readableStreamController);
                 }
+                if (!canceled1 || !canceled2) {
+                    resolveCancelPromise(undefined);
+                }
             },
             _errorSteps: function () {
                 reading = false;
@@ -3066,10 +3176,217 @@ function ReadableStreamTee(stream, cloneForBranch2) {
     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 canceled1 = false;
+    var canceled2 = false;
+    var reason1;
+    var reason2;
+    var branch1;
+    var branch2;
+    var resolveCancelPromise;
+    var cancelPromise = newPromise(function (resolve) {
+        resolveCancelPromise = resolve;
+    });
+    function forwardReaderError(thisReader) {
+        uponRejection(thisReader._closedPromise, function (r) {
+            if (thisReader !== reader) {
+                return;
+            }
+            ReadableByteStreamControllerError(branch1._readableStreamController, r);
+            ReadableByteStreamControllerError(branch2._readableStreamController, r);
+            if (!canceled1 || !canceled2) {
+                resolveCancelPromise(undefined);
+            }
+        });
+    }
+    function pullWithDefaultReader() {
+        if (IsReadableStreamBYOBReader(reader)) {
+            ReadableStreamReaderGenericRelease(reader);
+            reader = AcquireReadableStreamDefaultReader(stream);
+            forwardReaderError(reader);
+        }
+        var readRequest = {
+            _chunkSteps: function (chunk) {
+                // This needs to be delayed a microtask because it takes at least a microtask to detect errors (using
+                // reader._closedPromise below), and we want errors in stream to error both branches immediately. We cannot let
+                // successful synchronously-available reads get ahead of asynchronously-available errors.
+                queueMicrotask(function () {
+                    reading = false;
+                    var chunk1 = chunk;
+                    var chunk2 = chunk;
+                    if (!canceled1 && !canceled2) {
+                        try {
+                            chunk2 = CloneAsUint8Array(chunk);
+                        }
+                        catch (cloneE) {
+                            ReadableByteStreamControllerError(branch1._readableStreamController, cloneE);
+                            ReadableByteStreamControllerError(branch2._readableStreamController, cloneE);
+                            resolveCancelPromise(ReadableStreamCancel(stream, cloneE));
+                            return;
+                        }
+                    }
+                    if (!canceled1) {
+                        ReadableByteStreamControllerEnqueue(branch1._readableStreamController, chunk1);
+                    }
+                    if (!canceled2) {
+                        ReadableByteStreamControllerEnqueue(branch2._readableStreamController, chunk2);
+                    }
+                });
+            },
+            _closeSteps: function () {
+                reading = false;
+                if (!canceled1) {
+                    ReadableByteStreamControllerClose(branch1._readableStreamController);
+                }
+                if (!canceled2) {
+                    ReadableByteStreamControllerClose(branch2._readableStreamController);
+                }
+                if (branch1._readableStreamController._pendingPullIntos.length > 0) {
+                    ReadableByteStreamControllerRespond(branch1._readableStreamController, 0);
+                }
+                if (branch2._readableStreamController._pendingPullIntos.length > 0) {
+                    ReadableByteStreamControllerRespond(branch2._readableStreamController, 0);
+                }
+                if (!canceled1 || !canceled2) {
+                    resolveCancelPromise(undefined);
+                }
+            },
+            _errorSteps: function () {
+                reading = false;
+            }
+        };
+        ReadableStreamDefaultReaderRead(reader, readRequest);
+    }
+    function pullWithBYOBReader(view, forBranch2) {
+        if (IsReadableStreamDefaultReader(reader)) {
+            ReadableStreamReaderGenericRelease(reader);
+            reader = AcquireReadableStreamBYOBReader(stream);
+            forwardReaderError(reader);
+        }
+        var byobBranch = forBranch2 ? branch2 : branch1;
+        var otherBranch = forBranch2 ? branch1 : branch2;
+        var readIntoRequest = {
+            _chunkSteps: function (chunk) {
+                // This needs to be delayed a microtask because it takes at least a microtask to detect errors (using
+                // reader._closedPromise below), and we want errors in stream to error both branches immediately. We cannot let
+                // successful synchronously-available reads get ahead of asynchronously-available errors.
+                queueMicrotask(function () {
+                    reading = false;
+                    var byobCanceled = forBranch2 ? canceled2 : canceled1;
+                    var otherCanceled = forBranch2 ? canceled1 : canceled2;
+                    if (!otherCanceled) {
+                        var clonedChunk = void 0;
+                        try {
+                            clonedChunk = CloneAsUint8Array(chunk);
+                        }
+                        catch (cloneE) {
+                            ReadableByteStreamControllerError(byobBranch._readableStreamController, cloneE);
+                            ReadableByteStreamControllerError(otherBranch._readableStreamController, cloneE);
+                            resolveCancelPromise(ReadableStreamCancel(stream, cloneE));
+                            return;
+                        }
+                        if (!byobCanceled) {
+                            ReadableByteStreamControllerRespondWithNewView(byobBranch._readableStreamController, chunk);
+                        }
+                        ReadableByteStreamControllerEnqueue(otherBranch._readableStreamController, clonedChunk);
+                    }
+                    else if (!byobCanceled) {
+                        ReadableByteStreamControllerRespondWithNewView(byobBranch._readableStreamController, chunk);
+                    }
+                });
+            },
+            _closeSteps: function (chunk) {
+                reading = false;
+                var byobCanceled = forBranch2 ? canceled2 : canceled1;
+                var otherCanceled = forBranch2 ? canceled1 : canceled2;
+                if (!byobCanceled) {
+                    ReadableByteStreamControllerClose(byobBranch._readableStreamController);
+                }
+                if (!otherCanceled) {
+                    ReadableByteStreamControllerClose(otherBranch._readableStreamController);
+                }
+                if (chunk !== undefined) {
+                    if (!byobCanceled) {
+                        ReadableByteStreamControllerRespondWithNewView(byobBranch._readableStreamController, chunk);
+                    }
+                    if (!otherCanceled && otherBranch._readableStreamController._pendingPullIntos.length > 0) {
+                        ReadableByteStreamControllerRespond(otherBranch._readableStreamController, 0);
+                    }
+                }
+                if (!byobCanceled || !otherCanceled) {
+                    resolveCancelPromise(undefined);
+                }
+            },
+            _errorSteps: function () {
+                reading = false;
+            }
+        };
+        ReadableStreamBYOBReaderRead(reader, view, readIntoRequest);
+    }
+    function pull1Algorithm() {
+        if (reading) {
+            return promiseResolvedWith(undefined);
+        }
+        reading = true;
+        var byobRequest = ReadableByteStreamControllerGetBYOBRequest(branch1._readableStreamController);
+        if (byobRequest === null) {
+            pullWithDefaultReader();
+        }
+        else {
+            pullWithBYOBReader(byobRequest._view, false);
+        }
+        return promiseResolvedWith(undefined);
+    }
+    function pull2Algorithm() {
+        if (reading) {
+            return promiseResolvedWith(undefined);
+        }
+        reading = true;
+        var byobRequest = ReadableByteStreamControllerGetBYOBRequest(branch2._readableStreamController);
+        if (byobRequest === null) {
+            pullWithDefaultReader();
+        }
+        else {
+            pullWithBYOBReader(byobRequest._view, true);
+        }
+        return promiseResolvedWith(undefined);
+    }
+    function cancel1Algorithm(reason) {
+        canceled1 = true;
+        reason1 = reason;
+        if (canceled2) {
+            var compositeReason = CreateArrayFromList([reason1, reason2]);
+            var cancelResult = ReadableStreamCancel(stream, compositeReason);
+            resolveCancelPromise(cancelResult);
+        }
+        return cancelPromise;
+    }
+    function cancel2Algorithm(reason) {
+        canceled2 = true;
+        reason2 = reason;
+        if (canceled1) {
+            var compositeReason = CreateArrayFromList([reason1, reason2]);
+            var cancelResult = ReadableStreamCancel(stream, compositeReason);
+            resolveCancelPromise(cancelResult);
+        }
+        return cancelPromise;
+    }
+    function startAlgorithm() {
+        return;
+    }
+    branch1 = CreateReadableByteStream(startAlgorithm, pull1Algorithm, cancel1Algorithm);
+    branch2 = CreateReadableByteStream(startAlgorithm, pull2Algorithm, cancel2Algorithm);
+    forwardReaderError(reader);
+    return [branch1, branch2];
+}
 
 function convertUnderlyingDefaultOrByteSource(source, context) {
     assertDictionary(source, context);
@@ -3345,6 +3662,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) {
+    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;
@@ -3358,7 +3683,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) {
@@ -3376,6 +3701,13 @@ function ReadableStreamCancel(stream, reason) {
         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);
 }
@@ -3385,13 +3717,13 @@ function ReadableStreamClose(stream) {
     if (reader === undefined) {
         return;
     }
+    defaultReaderClosedPromiseResolve(reader);
     if (IsReadableStreamDefaultReader(reader)) {
         reader._readRequests.forEach(function (readRequest) {
             readRequest._closeSteps();
         });
         reader._readRequests = new SimpleQueue();
     }
-    defaultReaderClosedPromiseResolve(reader);
 }
 function ReadableStreamError(stream, e) {
     stream._state = 'errored';
@@ -3400,6 +3732,7 @@ function ReadableStreamError(stream, e) {
     if (reader === undefined) {
         return;
     }
+    defaultReaderClosedPromiseReject(reader, e);
     if (IsReadableStreamDefaultReader(reader)) {
         reader._readRequests.forEach(function (readRequest) {
             readRequest._errorSteps(e);
@@ -3412,7 +3745,6 @@ function ReadableStreamError(stream, e) {
         });
         reader._readIntoRequests = new SimpleQueue();
     }
-    defaultReaderClosedPromiseReject(reader, e);
 }
 // Helper functions for the ReadableStream.
 function streamBrandCheckException$1(name) {
@@ -3428,9 +3760,14 @@ function convertQueuingStrategyInit(init, context) {
     };
 }
 
-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.
  *
@@ -3491,12 +3828,17 @@ function IsByteLengthQueuingStrategy(x) {
     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.
  *
@@ -3558,7 +3900,7 @@ function IsCountQueuingStrategy(x) {
     if (!Object.prototype.hasOwnProperty.call(x, '_countQueuingStrategyHighWaterMark')) {
         return false;
     }
-    return true;
+    return x instanceof CountQueuingStrategy;
 }
 
 function convertTransformer(original, context) {
@@ -3644,7 +3986,7 @@ var TransformStream = /** @class */ (function () {
          */
         get: function () {
             if (!IsTransformStream(this)) {
-                throw streamBrandCheckException$2('readable');
+                throw streamBrandCheckException('readable');
             }
             return this._readable;
         },
@@ -3657,7 +3999,7 @@ var TransformStream = /** @class */ (function () {
          */
         get: function () {
             if (!IsTransformStream(this)) {
-                throw streamBrandCheckException$2('writable');
+                throw streamBrandCheckException('writable');
             }
             return this._writable;
         },
@@ -3712,7 +4054,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) {
@@ -3755,7 +4097,7 @@ var TransformStreamDefaultController = /** @class */ (function () {
          */
         get: function () {
             if (!IsTransformStreamDefaultController(this)) {
-                throw defaultControllerBrandCheckException$1('desiredSize');
+                throw defaultControllerBrandCheckException('desiredSize');
             }
             var readableController = this._controlledTransformStream._readable._readableStreamController;
             return ReadableStreamDefaultControllerGetDesiredSize(readableController);
@@ -3766,7 +4108,7 @@ var TransformStreamDefaultController = /** @class */ (function () {
     TransformStreamDefaultController.prototype.enqueue = function (chunk) {
         if (chunk === void 0) { chunk = undefined; }
         if (!IsTransformStreamDefaultController(this)) {
-            throw defaultControllerBrandCheckException$1('enqueue');
+            throw defaultControllerBrandCheckException('enqueue');
         }
         TransformStreamDefaultControllerEnqueue(this, chunk);
     };
@@ -3777,7 +4119,7 @@ var TransformStreamDefaultController = /** @class */ (function () {
     TransformStreamDefaultController.prototype.error = function (reason) {
         if (reason === void 0) { reason = undefined; }
         if (!IsTransformStreamDefaultController(this)) {
-            throw defaultControllerBrandCheckException$1('error');
+            throw defaultControllerBrandCheckException('error');
         }
         TransformStreamDefaultControllerError(this, reason);
     };
@@ -3787,7 +4129,7 @@ var TransformStreamDefaultController = /** @class */ (function () {
      */
     TransformStreamDefaultController.prototype.terminate = function () {
         if (!IsTransformStreamDefaultController(this)) {
-            throw defaultControllerBrandCheckException$1('terminate');
+            throw defaultControllerBrandCheckException('terminate');
         }
         TransformStreamDefaultControllerTerminate(this);
     };
@@ -3813,7 +4155,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;
@@ -3930,11 +4272,11 @@ function TransformStreamDefaultSourcePullAlgorithm(stream) {
     return stream._backpressureChangePromise;
 }
 // Helper functions for the TransformStreamDefaultController.
-function defaultControllerBrandCheckException$1(name) {
+function defaultControllerBrandCheckException(name) {
     return new TypeError("TransformStreamDefaultController.prototype." + name + " can only be used on a TransformStreamDefaultController");
 }
 // Helper functions for the TransformStream.
-function streamBrandCheckException$2(name) {
+function streamBrandCheckException(name) {
     return new TypeError("TransformStream.prototype." + name + " can only be used on a TransformStream");
 }