@powersync/react-native 1.27.1 → 1.28.1

package/dist/index.js

@@ -117,7 +117,7 @@ function fromByteArray$1(uint8, urlSafe = false) {
  * @deprecated Use native btoa() instead - now supported in Hermes
  */
 function btoa$2(data) {
-  return global.base64FromArrayBuffer(stringToArrayBuffer(data));
+  return global.base64FromArrayBuffer(stringToArrayBuffer(data), false);
 }
 
 /**
@@ -14315,142 +14315,46 @@ let Headers$1 = class Headers {
 };
 
 /**
- * @license
- * web-streams-polyfill v3.3.3
- * Copyright 2024 Mattias Buelens, Diwank Singh Tomer and other contributors.
- * This code is released under the MIT license.
- * SPDX-License-Identifier: MIT
+ * web-streams-polyfill v3.2.1
  */
 /// <reference lib="es2015.symbol" />
 var SymbolPolyfill = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol' ?
     Symbol :
-    function (description) { return "Symbol(".concat(description, ")"); };
-
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol */
-
-
-function __generator(thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-}
-
-function __values(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-}
-
-function __await(v) {
-    return this instanceof __await ? (this.v = v, this) : new __await(v);
-}
-
-function __asyncGenerator(thisArg, _arguments, generator) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var g = generator.apply(thisArg, _arguments || []), i, q = [];
-    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
-    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
-    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
-    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
-    function fulfill(value) { resume("next", value); }
-    function reject(value) { resume("throw", value); }
-    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
-}
-
-function __asyncDelegator(o) {
-    var i, p;
-    return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
-    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }
-}
-
-function __asyncValues(o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
+    function (description) { return "Symbol(" + description + ")"; };
 
+/// <reference lib="dom" />
 function noop() {
     return undefined;
 }
+function getGlobals() {
+    if (typeof self !== 'undefined') {
+        return self;
+    }
+    else if (typeof window !== 'undefined') {
+        return window;
+    }
+    else if (typeof global !== 'undefined') {
+        return global;
+    }
+    return undefined;
+}
+var globals = getGlobals();
 
 function typeIsObject(x) {
     return (typeof x === 'object' && x !== null) || typeof x === 'function';
 }
 var rethrowAssertionErrorRejection = noop;
-function setFunctionName(fn, name) {
-    try {
-        Object.defineProperty(fn, 'name', {
-            value: name,
-            configurable: true
-        });
-    }
-    catch (_a) {
-        // This property is non-configurable in older browsers, so ignore if this throws.
-        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name#browser_compatibility
-    }
-}
 
 var originalPromise = Promise;
 var originalPromiseThen = Promise.prototype.then;
+var originalPromiseResolve = Promise.resolve.bind(originalPromise);
 var originalPromiseReject = Promise.reject.bind(originalPromise);
-// https://webidl.spec.whatwg.org/#a-new-promise
 function newPromise(executor) {
     return new originalPromise(executor);
 }
-// https://webidl.spec.whatwg.org/#a-promise-resolved-with
 function promiseResolvedWith(value) {
-    return newPromise(function (resolve) { return resolve(value); });
+    return originalPromiseResolve(value);
 }
-// https://webidl.spec.whatwg.org/#a-promise-rejected-with
 function promiseRejectedWith(reason) {
     return originalPromiseReject(reason);
 }
@@ -14459,9 +14363,6 @@ function PerformPromiseThen(promise, onFulfilled, onRejected) {
     // approximation.
     return originalPromiseThen.call(promise, onFulfilled, onRejected);
 }
-// Bluebird logs a warning when a promise is created within a fulfillment handler, but then isn't returned
-// from that handler. To prevent this, return null instead of void from all handlers.
-// http://bluebirdjs.com/docs/warning-explanations.html#warning-a-promise-was-created-in-a-handler-but-was-not-returned-from-it
 function uponPromise(promise, onFulfilled, onRejected) {
     PerformPromiseThen(PerformPromiseThen(promise, onFulfilled, onRejected), undefined, rethrowAssertionErrorRejection);
 }
@@ -14477,16 +14378,14 @@ function transformPromiseWith(promise, fulfillmentHandler, rejectionHandler) {
 function setPromiseIsHandledToTrue(promise) {
     PerformPromiseThen(promise, undefined, rethrowAssertionErrorRejection);
 }
-var _queueMicrotask = function (callback) {
-    if (typeof queueMicrotask === 'function') {
-        _queueMicrotask = queueMicrotask;
-    }
-    else {
-        var resolvedPromise_1 = promiseResolvedWith(undefined);
-        _queueMicrotask = function (cb) { return PerformPromiseThen(resolvedPromise_1, cb); };
+var queueMicrotask = (function () {
+    var globalQueueMicrotask = globals && globals.queueMicrotask;
+    if (typeof globalQueueMicrotask === 'function') {
+        return globalQueueMicrotask;
     }
-    return _queueMicrotask(callback);
-};
+    var resolvedPromise = promiseResolvedWith(undefined);
+    return function (fn) { return PerformPromiseThen(resolvedPromise, fn); };
+})();
 function reflectCall(F, V, args) {
     if (typeof F !== 'function') {
         throw new TypeError('Argument is not a function');
@@ -14615,12 +14514,6 @@ var SimpleQueue = /** @class */ (function () {
     return SimpleQueue;
 }());
 
-var AbortSteps = SymbolPolyfill('[[AbortSteps]]');
-var ErrorSteps = SymbolPolyfill('[[ErrorSteps]]');
-var CancelSteps = SymbolPolyfill('[[CancelSteps]]');
-var PullSteps = SymbolPolyfill('[[PullSteps]]');
-var ReleaseSteps = SymbolPolyfill('[[ReleaseSteps]]');
-
 function ReadableStreamReaderGenericInitialize(reader, stream) {
     reader._ownerReadableStream = stream;
     stream._reader = reader;
@@ -14641,15 +14534,13 @@ function ReadableStreamReaderGenericCancel(reader, reason) {
     return ReadableStreamCancel(stream, reason);
 }
 function ReadableStreamReaderGenericRelease(reader) {
-    var stream = reader._ownerReadableStream;
-    if (stream._state === 'readable') {
+    if (reader._ownerReadableStream._state === 'readable') {
         defaultReaderClosedPromiseReject(reader, new TypeError("Reader was released and can no longer be used to monitor the stream's closedness"));
     }
     else {
         defaultReaderClosedPromiseResetToRejected(reader, new TypeError("Reader was released and can no longer be used to monitor the stream's closedness"));
     }
-    stream._readableStreamController[ReleaseSteps]();
-    stream._reader = undefined;
+    reader._ownerReadableStream._reader = undefined;
     reader._ownerReadableStream = undefined;
 }
 // Helper functions for the readers.
@@ -14692,6 +14583,11 @@ function defaultReaderClosedPromiseResolve(reader) {
     reader._closedPromise_reject = undefined;
 }
 
+var AbortSteps = SymbolPolyfill('[[AbortSteps]]');
+var ErrorSteps = SymbolPolyfill('[[ErrorSteps]]');
+var CancelSteps = SymbolPolyfill('[[CancelSteps]]');
+var PullSteps = SymbolPolyfill('[[PullSteps]]');
+
 /// <reference lib="es2015.core" />
 // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isFinite#Polyfill
 var NumberIsFinite = Number.isFinite || function (x) {
@@ -14710,13 +14606,13 @@ function isDictionary(x) {
 }
 function assertDictionary(obj, context) {
     if (obj !== undefined && !isDictionary(obj)) {
-        throw new TypeError("".concat(context, " is not an object."));
+        throw new TypeError(context + " is not an object.");
     }
 }
 // https://heycam.github.io/webidl/#idl-callback-functions
 function assertFunction(x, context) {
     if (typeof x !== 'function') {
-        throw new TypeError("".concat(context, " is not a function."));
+        throw new TypeError(context + " is not a function.");
     }
 }
 // https://heycam.github.io/webidl/#idl-object
@@ -14725,17 +14621,17 @@ function isObject(x) {
 }
 function assertObject(x, context) {
     if (!isObject(x)) {
-        throw new TypeError("".concat(context, " is not an object."));
+        throw new TypeError(context + " is not an object.");
     }
 }
 function assertRequiredArgument(x, position, context) {
     if (x === undefined) {
-        throw new TypeError("Parameter ".concat(position, " is required in '").concat(context, "'."));
+        throw new TypeError("Parameter " + position + " is required in '" + context + "'.");
     }
 }
 function assertRequiredField(x, field, context) {
     if (x === undefined) {
-        throw new TypeError("".concat(field, " is required in '").concat(context, "'."));
+        throw new TypeError(field + " is required in '" + context + "'.");
     }
 }
 // https://heycam.github.io/webidl/#idl-unrestricted-double
@@ -14755,11 +14651,11 @@ function convertUnsignedLongLongWithEnforceRange(value, context) {
     var x = Number(value);
     x = censorNegativeZero(x);
     if (!NumberIsFinite(x)) {
-        throw new TypeError("".concat(context, " is not a finite number"));
+        throw new TypeError(context + " is not a finite number");
     }
     x = integerPart(x);
     if (x < lowerBound || x > upperBound) {
-        throw new TypeError("".concat(context, " is outside the accepted range of ").concat(lowerBound, " to ").concat(upperBound, ", inclusive"));
+        throw new TypeError(context + " is outside the accepted range of " + lowerBound + " to " + upperBound + ", inclusive");
     }
     if (!NumberIsFinite(x) || x === 0) {
         return 0;
@@ -14773,7 +14669,7 @@ function convertUnsignedLongLongWithEnforceRange(value, context) {
 
 function assertReadableStream(x, context) {
     if (!IsReadableStream(x)) {
-        throw new TypeError("".concat(context, " is not a ReadableStream."));
+        throw new TypeError(context + " is not a ReadableStream.");
     }
 }
 
@@ -14892,7 +14788,10 @@ var ReadableStreamDefaultReader = /** @class */ (function () {
         if (this._ownerReadableStream === undefined) {
             return;
         }
-        ReadableStreamDefaultReaderRelease(this);
+        if (this._readRequests.length > 0) {
+            throw new TypeError('Tried to release a reader lock when that reader has pending read() calls un-settled');
+        }
+        ReadableStreamReaderGenericRelease(this);
     };
     return ReadableStreamDefaultReader;
 }());
@@ -14902,9 +14801,6 @@ Object.defineProperties(ReadableStreamDefaultReader.prototype, {
     releaseLock: { enumerable: true },
     closed: { enumerable: true }
 });
-setFunctionName(ReadableStreamDefaultReader.prototype.cancel, 'cancel');
-setFunctionName(ReadableStreamDefaultReader.prototype.read, 'read');
-setFunctionName(ReadableStreamDefaultReader.prototype.releaseLock, 'releaseLock');
 if (typeof SymbolPolyfill.toStringTag === 'symbol') {
     Object.defineProperty(ReadableStreamDefaultReader.prototype, SymbolPolyfill.toStringTag, {
         value: 'ReadableStreamDefaultReader',
@@ -14934,153 +14830,26 @@ function ReadableStreamDefaultReaderRead(reader, readRequest) {
         stream._readableStreamController[PullSteps](readRequest);
     }
 }
-function ReadableStreamDefaultReaderRelease(reader) {
-    ReadableStreamReaderGenericRelease(reader);
-    var e = new TypeError('Reader was released');
-    ReadableStreamDefaultReaderErrorReadRequests(reader, e);
-}
-function ReadableStreamDefaultReaderErrorReadRequests(reader, e) {
-    var readRequests = reader._readRequests;
-    reader._readRequests = new SimpleQueue();
-    readRequests.forEach(function (readRequest) {
-        readRequest._errorSteps(e);
-    });
-}
 // Helper functions for the ReadableStreamDefaultReader.
 function defaultReaderBrandCheckException(name) {
-    return new TypeError("ReadableStreamDefaultReader.prototype.".concat(name, " can only be used on a ReadableStreamDefaultReader"));
-}
-
-var _a$1, _b, _c;
-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);
-}
-var TransferArrayBuffer = function (O) {
-    if (typeof O.transfer === 'function') {
-        TransferArrayBuffer = function (buffer) { return buffer.transfer(); };
-    }
-    else if (typeof structuredClone === 'function') {
-        TransferArrayBuffer = function (buffer) { return structuredClone(buffer, { transfer: [buffer] }); };
-    }
-    else {
-        // Not implemented correctly
-        TransferArrayBuffer = function (buffer) { return buffer; };
-    }
-    return TransferArrayBuffer(O);
-};
-var IsDetachedBuffer = function (O) {
-    if (typeof O.detached === 'boolean') {
-        IsDetachedBuffer = function (buffer) { return buffer.detached; };
-    }
-    else {
-        // Not implemented correctly
-        IsDetachedBuffer = function (buffer) { return buffer.byteLength === 0; };
-    }
-    return IsDetachedBuffer(O);
-};
-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);
-    }
-    var length = end - begin;
-    var slice = new ArrayBuffer(length);
-    CopyDataBlockBytes(slice, 0, buffer, begin, length);
-    return slice;
-}
-function GetMethod(receiver, prop) {
-    var func = receiver[prop];
-    if (func === undefined || func === null) {
-        return undefined;
-    }
-    if (typeof func !== 'function') {
-        throw new TypeError("".concat(String(prop), " is not a function"));
-    }
-    return func;
-}
-function CreateAsyncFromSyncIterator(syncIteratorRecord) {
-    // Instead of re-implementing CreateAsyncFromSyncIterator and %AsyncFromSyncIteratorPrototype%,
-    // we use yield* inside an async generator function to achieve the same result.
-    var _a;
-    // Wrap the sync iterator inside a sync iterable, so we can use it with yield*.
-    var syncIterable = (_a = {},
-        _a[SymbolPolyfill.iterator] = function () { return syncIteratorRecord.iterator; },
-        _a);
-    // Create an async generator function and immediately invoke it.
-    var asyncIterator = (function () {
-        return __asyncGenerator(this, arguments, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [5 /*yield**/, __values(__asyncDelegator(__asyncValues(syncIterable)))];
-                    case 1: return [4 /*yield*/, __await.apply(void 0, [_a.sent()])];
-                    case 2: return [4 /*yield*/, __await.apply(void 0, [_a.sent()])];
-                    case 3: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    }());
-    // Return as an async iterator record.
-    var nextMethod = asyncIterator.next;
-    return { iterator: asyncIterator, nextMethod: nextMethod, done: false };
-}
-// Aligns with core-js/modules/es.symbol.async-iterator.js
-var SymbolAsyncIterator = (_c = (_a$1 = SymbolPolyfill.asyncIterator) !== null && _a$1 !== void 0 ? _a$1 : (_b = SymbolPolyfill.for) === null || _b === void 0 ? void 0 : _b.call(SymbolPolyfill, 'Symbol.asyncIterator')) !== null && _c !== void 0 ? _c : '@@asyncIterator';
-function GetIterator(obj, hint, method) {
-    if (hint === void 0) { hint = 'sync'; }
-    if (method === undefined) {
-        if (hint === 'async') {
-            method = GetMethod(obj, SymbolAsyncIterator);
-            if (method === undefined) {
-                var syncMethod = GetMethod(obj, SymbolPolyfill.iterator);
-                var syncIteratorRecord = GetIterator(obj, 'sync', syncMethod);
-                return CreateAsyncFromSyncIterator(syncIteratorRecord);
-            }
-        }
-        else {
-            method = GetMethod(obj, SymbolPolyfill.iterator);
-        }
-    }
-    if (method === undefined) {
-        throw new TypeError('The object is not iterable');
-    }
-    var iterator = reflectCall(method, obj, []);
-    if (!typeIsObject(iterator)) {
-        throw new TypeError('The iterator method must return an object');
-    }
-    var nextMethod = iterator.next;
-    return { iterator: iterator, nextMethod: nextMethod, done: false };
-}
-function IteratorNext(iteratorRecord) {
-    var result = reflectCall(iteratorRecord.nextMethod, iteratorRecord.iterator, []);
-    if (!typeIsObject(result)) {
-        throw new TypeError('The iterator.next() method must return an object');
-    }
-    return result;
-}
-function IteratorComplete(iterResult) {
-    return Boolean(iterResult.done);
-}
-function IteratorValue(iterResult) {
-    return iterResult.value;
+    return new TypeError("ReadableStreamDefaultReader.prototype." + name + " can only be used on a ReadableStreamDefaultReader");
 }
 
 /// <reference lib="es2018.asynciterable" />
 var _a;
-// We cannot access %AsyncIteratorPrototype% without non-ES2018 syntax, but we can re-create it.
-var AsyncIteratorPrototype = (_a = {},
-    // 25.1.3.1 %AsyncIteratorPrototype% [ @@asyncIterator ] ( )
-    // https://tc39.github.io/ecma262/#sec-asynciteratorprototype-asynciterator
-    _a[SymbolAsyncIterator] = function () {
-        return this;
-    },
-    _a);
-Object.defineProperty(AsyncIteratorPrototype, SymbolAsyncIterator, { enumerable: false });
+var AsyncIteratorPrototype;
+if (typeof SymbolPolyfill.asyncIterator === 'symbol') {
+    // We're running inside a ES2018+ environment, but we're compiling to an older syntax.
+    // We cannot access %AsyncIteratorPrototype% without non-ES2018 syntax, but we can re-create it.
+    AsyncIteratorPrototype = (_a = {},
+        // 25.1.3.1 %AsyncIteratorPrototype% [ @@asyncIterator ] ( )
+        // https://tc39.github.io/ecma262/#sec-asynciteratorprototype-asynciterator
+        _a[SymbolPolyfill.asyncIterator] = function () {
+            return this;
+        },
+        _a);
+    Object.defineProperty(AsyncIteratorPrototype, SymbolPolyfill.asyncIterator, { enumerable: false });
+}
 
 /// <reference lib="es2018.asynciterable" />
 var ReadableStreamAsyncIteratorImpl = /** @class */ (function () {
@@ -15111,6 +14880,9 @@ var ReadableStreamAsyncIteratorImpl = /** @class */ (function () {
             return Promise.resolve({ value: undefined, done: true });
         }
         var reader = this._reader;
+        if (reader._ownerReadableStream === undefined) {
+            return promiseRejectedWith(readerLockException('iterate'));
+        }
         var resolvePromise;
         var rejectPromise;
         var promise = newPromise(function (resolve, reject) {
@@ -15122,7 +14894,7 @@ var ReadableStreamAsyncIteratorImpl = /** @class */ (function () {
                 _this._ongoingPromise = undefined;
                 // This needs to be delayed by one microtask, otherwise we stop pulling too early which breaks a test.
                 // FIXME Is this a bug in the specification, or in the test?
-                _queueMicrotask(function () { return resolvePromise({ value: chunk, done: false }); });
+                queueMicrotask(function () { return resolvePromise({ value: chunk, done: false }); });
             },
             _closeSteps: function () {
                 _this._ongoingPromise = undefined;
@@ -15146,6 +14918,9 @@ var ReadableStreamAsyncIteratorImpl = /** @class */ (function () {
         }
         this._isFinished = true;
         var reader = this._reader;
+        if (reader._ownerReadableStream === undefined) {
+            return promiseRejectedWith(readerLockException('finish iterating'));
+        }
         if (!this._preventCancel) {
             var result = ReadableStreamReaderGenericCancel(reader, value);
             ReadableStreamReaderGenericRelease(reader);
@@ -15170,7 +14945,9 @@ var ReadableStreamAsyncIteratorPrototype = {
         return this._asyncIteratorImpl.return(value);
     }
 };
-Object.setPrototypeOf(ReadableStreamAsyncIteratorPrototype, AsyncIteratorPrototype);
+if (AsyncIteratorPrototype !== undefined) {
+    Object.setPrototypeOf(ReadableStreamAsyncIteratorPrototype, AsyncIteratorPrototype);
+}
 // Abstract operations for the ReadableStream.
 function AcquireReadableStreamAsyncIterator(stream, preventCancel) {
     var reader = AcquireReadableStreamDefaultReader(stream);
@@ -15197,7 +14974,7 @@ function IsReadableStreamAsyncIterator(x) {
 }
 // Helper functions for the ReadableStream.
 function streamAsyncIteratorBrandCheckException(name) {
-    return new TypeError("ReadableStreamAsyncIterator.".concat(name, " can only be used on a ReadableSteamAsyncIterator"));
+    return new TypeError("ReadableStreamAsyncIterator." + name + " can only be used on a ReadableSteamAsyncIterator");
 }
 
 /// <reference lib="es2015.core" />
@@ -15207,6 +14984,35 @@ var NumberIsNaN = Number.isNaN || function (x) {
     return x !== x;
 };
 
+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);
+    }
+    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;
@@ -15248,19 +15054,6 @@ function ResetQueue(container) {
     container._queueTotalSize = 0;
 }
 
-function isDataViewConstructor(ctor) {
-    return ctor === DataView;
-}
-function isDataView(view) {
-    return isDataViewConstructor(view.constructor);
-}
-function arrayBufferViewElementSize(ctor) {
-    if (isDataViewConstructor(ctor)) {
-        return 1;
-    }
-    return ctor.BYTES_PER_ELEMENT;
-}
-
 /**
  * A pull-into request in a {@link ReadableByteStreamController}.
  *
@@ -15292,9 +15085,7 @@ var ReadableStreamBYOBRequest = /** @class */ (function () {
         if (this._associatedReadableByteStreamController === undefined) {
             throw new TypeError('This BYOB request has been invalidated');
         }
-        if (IsDetachedBuffer(this._view.buffer)) {
-            throw new TypeError("The BYOB request's buffer has been detached and so cannot be used as a response");
-        }
+        if (IsDetachedBuffer(this._view.buffer)) ;
         ReadableByteStreamControllerRespond(this._associatedReadableByteStreamController, bytesWritten);
     };
     ReadableStreamBYOBRequest.prototype.respondWithNewView = function (view) {
@@ -15308,9 +15099,7 @@ var ReadableStreamBYOBRequest = /** @class */ (function () {
         if (this._associatedReadableByteStreamController === undefined) {
             throw new TypeError('This BYOB request has been invalidated');
         }
-        if (IsDetachedBuffer(view.buffer)) {
-            throw new TypeError('The given view\'s buffer has been detached and so cannot be used as a response');
-        }
+        if (IsDetachedBuffer(view.buffer)) ;
         ReadableByteStreamControllerRespondWithNewView(this._associatedReadableByteStreamController, view);
     };
     return ReadableStreamBYOBRequest;
@@ -15320,8 +15109,6 @@ Object.defineProperties(ReadableStreamBYOBRequest.prototype, {
     respondWithNewView: { enumerable: true },
     view: { enumerable: true }
 });
-setFunctionName(ReadableStreamBYOBRequest.prototype.respond, 'respond');
-setFunctionName(ReadableStreamBYOBRequest.prototype.respondWithNewView, 'respondWithNewView');
 if (typeof SymbolPolyfill.toStringTag === 'symbol') {
     Object.defineProperty(ReadableStreamBYOBRequest.prototype, SymbolPolyfill.toStringTag, {
         value: 'ReadableStreamBYOBRequest',
@@ -15377,7 +15164,7 @@ var ReadableByteStreamController = /** @class */ (function () {
         }
         var state = this._controlledReadableByteStream._state;
         if (state !== 'readable') {
-            throw new TypeError("The stream (in ".concat(state, " state) is not in the readable state and cannot be closed"));
+            throw new TypeError("The stream (in " + state + " state) is not in the readable state and cannot be closed");
         }
         ReadableByteStreamControllerClose(this);
     };
@@ -15400,7 +15187,7 @@ var ReadableByteStreamController = /** @class */ (function () {
         }
         var state = this._controlledReadableByteStream._state;
         if (state !== 'readable') {
-            throw new TypeError("The stream (in ".concat(state, " state) is not in the readable state and cannot be enqueued to"));
+            throw new TypeError("The stream (in " + state + " state) is not in the readable state and cannot be enqueued to");
         }
         ReadableByteStreamControllerEnqueue(this, chunk);
     };
@@ -15426,7 +15213,11 @@ var ReadableByteStreamController = /** @class */ (function () {
     ReadableByteStreamController.prototype[PullSteps] = function (readRequest) {
         var stream = this._controlledReadableByteStream;
         if (this._queueTotalSize > 0) {
-            ReadableByteStreamControllerFillReadRequestFromQueue(this, readRequest);
+            var entry = this._queue.shift();
+            this._queueTotalSize -= entry.byteLength;
+            ReadableByteStreamControllerHandleQueueDrain(this);
+            var view = new Uint8Array(entry.buffer, entry.byteOffset, entry.byteLength);
+            readRequest._chunkSteps(view);
             return;
         }
         var autoAllocateChunkSize = this._autoAllocateChunkSize;
@@ -15445,7 +15236,6 @@ var ReadableByteStreamController = /** @class */ (function () {
                 byteOffset: 0,
                 byteLength: autoAllocateChunkSize,
                 bytesFilled: 0,
-                minimumFill: 1,
                 elementSize: 1,
                 viewConstructor: Uint8Array,
                 readerType: 'default'
@@ -15455,15 +15245,6 @@ var ReadableByteStreamController = /** @class */ (function () {
         ReadableStreamAddReadRequest(stream, readRequest);
         ReadableByteStreamControllerCallPullIfNeeded(this);
     };
-    /** @internal */
-    ReadableByteStreamController.prototype[ReleaseSteps] = function () {
-        if (this._pendingPullIntos.length > 0) {
-            var firstPullInto = this._pendingPullIntos.peek();
-            firstPullInto.readerType = 'none';
-            this._pendingPullIntos = new SimpleQueue();
-            this._pendingPullIntos.push(firstPullInto);
-        }
-    };
     return ReadableByteStreamController;
 }());
 Object.defineProperties(ReadableByteStreamController.prototype, {
@@ -15473,9 +15254,6 @@ Object.defineProperties(ReadableByteStreamController.prototype, {
     byobRequest: { enumerable: true },
     desiredSize: { enumerable: true }
 });
-setFunctionName(ReadableByteStreamController.prototype.close, 'close');
-setFunctionName(ReadableByteStreamController.prototype.enqueue, 'enqueue');
-setFunctionName(ReadableByteStreamController.prototype.error, 'error');
 if (typeof SymbolPolyfill.toStringTag === 'symbol') {
     Object.defineProperty(ReadableByteStreamController.prototype, SymbolPolyfill.toStringTag, {
         value: 'ReadableByteStreamController',
@@ -15519,10 +15297,8 @@ function ReadableByteStreamControllerCallPullIfNeeded(controller) {
             controller._pullAgain = false;
             ReadableByteStreamControllerCallPullIfNeeded(controller);
         }
-        return null;
     }, function (e) {
         ReadableByteStreamControllerError(controller, e);
-        return null;
     });
 }
 function ReadableByteStreamControllerClearPendingPullIntos(controller) {
@@ -15551,33 +15327,15 @@ function ReadableByteStreamControllerEnqueueChunkToQueue(controller, buffer, byt
     controller._queue.push({ buffer: buffer, byteOffset: byteOffset, byteLength: byteLength });
     controller._queueTotalSize += byteLength;
 }
-function ReadableByteStreamControllerEnqueueClonedChunkToQueue(controller, buffer, byteOffset, byteLength) {
-    var clonedChunk;
-    try {
-        clonedChunk = ArrayBufferSlice(buffer, byteOffset, byteOffset + byteLength);
-    }
-    catch (cloneE) {
-        ReadableByteStreamControllerError(controller, cloneE);
-        throw cloneE;
-    }
-    ReadableByteStreamControllerEnqueueChunkToQueue(controller, clonedChunk, 0, byteLength);
-}
-function ReadableByteStreamControllerEnqueueDetachedPullIntoToQueue(controller, firstDescriptor) {
-    if (firstDescriptor.bytesFilled > 0) {
-        ReadableByteStreamControllerEnqueueClonedChunkToQueue(controller, firstDescriptor.buffer, firstDescriptor.byteOffset, firstDescriptor.bytesFilled);
-    }
-    ReadableByteStreamControllerShiftPendingPullInto(controller);
-}
 function ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) {
+    var elementSize = pullIntoDescriptor.elementSize;
+    var currentAlignedBytes = pullIntoDescriptor.bytesFilled - pullIntoDescriptor.bytesFilled % elementSize;
     var maxBytesToCopy = Math.min(controller._queueTotalSize, pullIntoDescriptor.byteLength - pullIntoDescriptor.bytesFilled);
     var maxBytesFilled = pullIntoDescriptor.bytesFilled + maxBytesToCopy;
+    var maxAlignedBytes = maxBytesFilled - maxBytesFilled % elementSize;
     var totalBytesToCopyRemaining = maxBytesToCopy;
     var ready = false;
-    var remainderBytes = maxBytesFilled % pullIntoDescriptor.elementSize;
-    var maxAlignedBytes = maxBytesFilled - remainderBytes;
-    // A descriptor for a read() request that is not yet filled up to its minimum length will stay at the head
-    // of the queue, so the underlying source can keep filling it.
-    if (maxAlignedBytes >= pullIntoDescriptor.minimumFill) {
+    if (maxAlignedBytes > currentAlignedBytes) {
         totalBytesToCopyRemaining = maxAlignedBytes - pullIntoDescriptor.bytesFilled;
         ready = true;
     }
@@ -15632,37 +15390,25 @@ function ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(contro
         }
     }
 }
-function ReadableByteStreamControllerProcessReadRequestsUsingQueue(controller) {
-    var reader = controller._controlledReadableByteStream._reader;
-    while (reader._readRequests.length > 0) {
-        if (controller._queueTotalSize === 0) {
-            return;
-        }
-        var readRequest = reader._readRequests.shift();
-        ReadableByteStreamControllerFillReadRequestFromQueue(controller, readRequest);
-    }
-}
-function ReadableByteStreamControllerPullInto(controller, view, min, readIntoRequest) {
+function ReadableByteStreamControllerPullInto(controller, view, readIntoRequest) {
     var stream = controller._controlledReadableByteStream;
-    var ctor = view.constructor;
-    var elementSize = arrayBufferViewElementSize(ctor);
-    var byteOffset = view.byteOffset, byteLength = view.byteLength;
-    var minimumFill = min * elementSize;
-    var buffer;
-    try {
-        buffer = TransferArrayBuffer(view.buffer);
-    }
-    catch (e) {
-        readIntoRequest._errorSteps(e);
-        return;
+    var elementSize = 1;
+    if (view.constructor !== DataView) {
+        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: byteOffset,
-        byteLength: byteLength,
+        byteOffset: view.byteOffset,
+        byteLength: view.byteLength,
         bytesFilled: 0,
-        minimumFill: minimumFill,
         elementSize: elementSize,
         viewConstructor: ctor,
         readerType: 'byob'
@@ -15699,9 +15445,6 @@ function ReadableByteStreamControllerPullInto(controller, view, min, readIntoReq
     ReadableByteStreamControllerCallPullIfNeeded(controller);
 }
 function ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor) {
-    if (firstDescriptor.readerType === 'none') {
-        ReadableByteStreamControllerShiftPendingPullInto(controller);
-    }
     var stream = controller._controlledReadableByteStream;
     if (ReadableStreamHasBYOBReader(stream)) {
         while (ReadableStreamGetNumReadIntoRequests(stream) > 0) {
@@ -15712,21 +15455,15 @@ function ReadableByteStreamControllerRespondInClosedState(controller, firstDescr
 }
 function ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, pullIntoDescriptor) {
     ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesWritten, pullIntoDescriptor);
-    if (pullIntoDescriptor.readerType === 'none') {
-        ReadableByteStreamControllerEnqueueDetachedPullIntoToQueue(controller, pullIntoDescriptor);
-        ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);
-        return;
-    }
-    if (pullIntoDescriptor.bytesFilled < pullIntoDescriptor.minimumFill) {
-        // A descriptor for a read() request that is not yet filled up to its minimum length will stay at the head
-        // of the queue, so the underlying source can keep filling it.
+    if (pullIntoDescriptor.bytesFilled < pullIntoDescriptor.elementSize) {
         return;
     }
     ReadableByteStreamControllerShiftPendingPullInto(controller);
     var remainderSize = pullIntoDescriptor.bytesFilled % pullIntoDescriptor.elementSize;
     if (remainderSize > 0) {
         var end = pullIntoDescriptor.byteOffset + pullIntoDescriptor.bytesFilled;
-        ReadableByteStreamControllerEnqueueClonedChunkToQueue(controller, pullIntoDescriptor.buffer, end - remainderSize, remainderSize);
+        var remainder = ArrayBufferSlice(pullIntoDescriptor.buffer, end - remainderSize, end);
+        ReadableByteStreamControllerEnqueueChunkToQueue(controller, remainder, 0, remainder.byteLength);
     }
     pullIntoDescriptor.bytesFilled -= remainderSize;
     ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableByteStream, pullIntoDescriptor);
@@ -15737,7 +15474,7 @@ function ReadableByteStreamControllerRespondInternal(controller, bytesWritten) {
     ReadableByteStreamControllerInvalidateBYOBRequest(controller);
     var state = controller._controlledReadableByteStream._state;
     if (state === 'closed') {
-        ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor);
+        ReadableByteStreamControllerRespondInClosedState(controller);
     }
     else {
         ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, firstDescriptor);
@@ -15787,7 +15524,7 @@ function ReadableByteStreamControllerClose(controller) {
     }
     if (controller._pendingPullIntos.length > 0) {
         var firstPendingPullInto = controller._pendingPullIntos.peek();
-        if (firstPendingPullInto.bytesFilled % firstPendingPullInto.elementSize !== 0) {
+        if (firstPendingPullInto.bytesFilled > 0) {
             var e = new TypeError('Insufficient bytes to fill elements in the given buffer');
             ReadableByteStreamControllerError(controller, e);
             throw e;
@@ -15801,24 +15538,17 @@ function ReadableByteStreamControllerEnqueue(controller, chunk) {
     if (controller._closeRequested || stream._state !== 'readable') {
         return;
     }
-    var buffer = chunk.buffer, byteOffset = chunk.byteOffset, byteLength = chunk.byteLength;
-    if (IsDetachedBuffer(buffer)) {
-        throw new TypeError('chunk\'s buffer is detached and so cannot be enqueued');
-    }
+    var buffer = chunk.buffer;
+    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)) {
-            throw new TypeError('The BYOB request\'s buffer has been detached and so cannot be filled with an enqueued chunk');
-        }
-        ReadableByteStreamControllerInvalidateBYOBRequest(controller);
+        if (IsDetachedBuffer(firstPendingPullInto.buffer)) ;
         firstPendingPullInto.buffer = TransferArrayBuffer(firstPendingPullInto.buffer);
-        if (firstPendingPullInto.readerType === 'none') {
-            ReadableByteStreamControllerEnqueueDetachedPullIntoToQueue(controller, firstPendingPullInto);
-        }
     }
+    ReadableByteStreamControllerInvalidateBYOBRequest(controller);
     if (ReadableStreamHasDefaultReader(stream)) {
-        ReadableByteStreamControllerProcessReadRequestsUsingQueue(controller);
         if (ReadableStreamGetNumReadRequests(stream) === 0) {
             ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);
         }
@@ -15850,13 +15580,6 @@ function ReadableByteStreamControllerError(controller, e) {
     ReadableByteStreamControllerClearAlgorithms(controller);
     ReadableStreamError(stream, e);
 }
-function ReadableByteStreamControllerFillReadRequestFromQueue(controller, readRequest) {
-    var entry = controller._queue.shift();
-    controller._queueTotalSize -= entry.byteLength;
-    ReadableByteStreamControllerHandleQueueDrain(controller);
-    var view = new Uint8Array(entry.buffer, entry.byteOffset, entry.byteLength);
-    readRequest._chunkSteps(view);
-}
 function ReadableByteStreamControllerGetBYOBRequest(controller) {
     if (controller._byobRequest === null && controller._pendingPullIntos.length > 0) {
         var firstDescriptor = controller._pendingPullIntos.peek();
@@ -15942,35 +15665,24 @@ function SetUpReadableByteStreamController(stream, controller, startAlgorithm, p
     uponPromise(promiseResolvedWith(startResult), function () {
         controller._started = true;
         ReadableByteStreamControllerCallPullIfNeeded(controller);
-        return null;
     }, function (r) {
         ReadableByteStreamControllerError(controller, r);
-        return null;
     });
 }
 function SetUpReadableByteStreamControllerFromUnderlyingSource(stream, underlyingByteSource, highWaterMark) {
     var controller = Object.create(ReadableByteStreamController.prototype);
-    var startAlgorithm;
-    var pullAlgorithm;
-    var cancelAlgorithm;
+    var startAlgorithm = function () { return undefined; };
+    var pullAlgorithm = function () { return promiseResolvedWith(undefined); };
+    var cancelAlgorithm = function () { return promiseResolvedWith(undefined); };
     if (underlyingByteSource.start !== undefined) {
         startAlgorithm = function () { return underlyingByteSource.start(controller); };
     }
-    else {
-        startAlgorithm = function () { return undefined; };
-    }
     if (underlyingByteSource.pull !== undefined) {
         pullAlgorithm = function () { return underlyingByteSource.pull(controller); };
     }
-    else {
-        pullAlgorithm = function () { return promiseResolvedWith(undefined); };
-    }
     if (underlyingByteSource.cancel !== undefined) {
         cancelAlgorithm = function (reason) { return underlyingByteSource.cancel(reason); };
     }
-    else {
-        cancelAlgorithm = function () { return promiseResolvedWith(undefined); };
-    }
     var autoAllocateChunkSize = underlyingByteSource.autoAllocateChunkSize;
     if (autoAllocateChunkSize === 0) {
         throw new TypeError('autoAllocateChunkSize must be greater than 0');
@@ -15983,34 +15695,11 @@ function SetUpReadableStreamBYOBRequest(request, controller, view) {
 }
 // Helper functions for the ReadableStreamBYOBRequest.
 function byobRequestBrandCheckException(name) {
-    return new TypeError("ReadableStreamBYOBRequest.prototype.".concat(name, " can only be used on a ReadableStreamBYOBRequest"));
+    return new TypeError("ReadableStreamBYOBRequest.prototype." + name + " can only be used on a ReadableStreamBYOBRequest");
 }
 // Helper functions for the ReadableByteStreamController.
 function byteStreamControllerBrandCheckException(name) {
-    return new TypeError("ReadableByteStreamController.prototype.".concat(name, " can only be used on a ReadableByteStreamController"));
-}
-
-function convertReaderOptions(options, context) {
-    assertDictionary(options, context);
-    var mode = options === null || options === void 0 ? void 0 : options.mode;
-    return {
-        mode: mode === undefined ? undefined : convertReadableStreamReaderMode(mode, "".concat(context, " has member 'mode' that"))
-    };
-}
-function convertReadableStreamReaderMode(mode, context) {
-    mode = "".concat(mode);
-    if (mode !== 'byob') {
-        throw new TypeError("".concat(context, " '").concat(mode, "' is not a valid enumeration value for ReadableStreamReaderMode"));
-    }
-    return mode;
-}
-function convertByobReadOptions(options, context) {
-    var _a;
-    assertDictionary(options, context);
-    var min = (_a = options === null || options === void 0 ? void 0 : options.min) !== null && _a !== void 0 ? _a : 1;
-    return {
-        min: convertUnsignedLongLongWithEnforceRange(min, "".concat(context, " has member 'min' that"))
-    };
+    return new TypeError("ReadableByteStreamController.prototype." + name + " can only be used on a ReadableByteStreamController");
 }
 
 // Abstract operations for the ReadableStream.
@@ -16090,8 +15779,12 @@ var ReadableStreamBYOBReader = /** @class */ (function () {
         }
         return ReadableStreamReaderGenericCancel(this, reason);
     };
-    ReadableStreamBYOBReader.prototype.read = function (view, rawOptions) {
-        if (rawOptions === void 0) { rawOptions = {}; }
+    /**
+     * Attempts to reads bytes into view, and returns a promise resolved with the result.
+     *
+     * If reading a chunk causes the queue to become empty, more data will be pulled from the underlying source.
+     */
+    ReadableStreamBYOBReader.prototype.read = function (view) {
         if (!IsReadableStreamBYOBReader(this)) {
             return promiseRejectedWith(byobReaderBrandCheckException('read'));
         }
@@ -16104,28 +15797,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)) {
-            return promiseRejectedWith(new TypeError('view\'s buffer has been detached'));
-        }
-        var options;
-        try {
-            options = convertByobReadOptions(rawOptions, 'options');
-        }
-        catch (e) {
-            return promiseRejectedWith(e);
-        }
-        var min = options.min;
-        if (min === 0) {
-            return promiseRejectedWith(new TypeError('options.min must be greater than 0'));
-        }
-        if (!isDataView(view)) {
-            if (min > view.length) {
-                return promiseRejectedWith(new RangeError('options.min must be less than or equal to view\'s length'));
-            }
-        }
-        else if (min > view.byteLength) {
-            return promiseRejectedWith(new RangeError('options.min must be less than or equal to view\'s byteLength'));
-        }
+        if (IsDetachedBuffer(view.buffer)) ;
         if (this._ownerReadableStream === undefined) {
             return promiseRejectedWith(readerLockException('read from'));
         }
@@ -16140,7 +15812,7 @@ var ReadableStreamBYOBReader = /** @class */ (function () {
             _closeSteps: function (chunk) { return resolvePromise({ value: chunk, done: true }); },
             _errorSteps: function (e) { return rejectPromise(e); }
         };
-        ReadableStreamBYOBReaderRead(this, view, min, readIntoRequest);
+        ReadableStreamBYOBReaderRead(this, view, readIntoRequest);
         return promise;
     };
     /**
@@ -16159,7 +15831,10 @@ var ReadableStreamBYOBReader = /** @class */ (function () {
         if (this._ownerReadableStream === undefined) {
             return;
         }
-        ReadableStreamBYOBReaderRelease(this);
+        if (this._readIntoRequests.length > 0) {
+            throw new TypeError('Tried to release a reader lock when that reader has pending read() calls un-settled');
+        }
+        ReadableStreamReaderGenericRelease(this);
     };
     return ReadableStreamBYOBReader;
 }());
@@ -16169,9 +15844,6 @@ Object.defineProperties(ReadableStreamBYOBReader.prototype, {
     releaseLock: { enumerable: true },
     closed: { enumerable: true }
 });
-setFunctionName(ReadableStreamBYOBReader.prototype.cancel, 'cancel');
-setFunctionName(ReadableStreamBYOBReader.prototype.read, 'read');
-setFunctionName(ReadableStreamBYOBReader.prototype.releaseLock, 'releaseLock');
 if (typeof SymbolPolyfill.toStringTag === 'symbol') {
     Object.defineProperty(ReadableStreamBYOBReader.prototype, SymbolPolyfill.toStringTag, {
         value: 'ReadableStreamBYOBReader',
@@ -16188,31 +15860,19 @@ function IsReadableStreamBYOBReader(x) {
     }
     return x instanceof ReadableStreamBYOBReader;
 }
-function ReadableStreamBYOBReaderRead(reader, view, min, readIntoRequest) {
+function ReadableStreamBYOBReaderRead(reader, view, readIntoRequest) {
     var stream = reader._ownerReadableStream;
     stream._disturbed = true;
     if (stream._state === 'errored') {
         readIntoRequest._errorSteps(stream._storedError);
     }
     else {
-        ReadableByteStreamControllerPullInto(stream._readableStreamController, view, min, readIntoRequest);
+        ReadableByteStreamControllerPullInto(stream._readableStreamController, view, readIntoRequest);
     }
 }
-function ReadableStreamBYOBReaderRelease(reader) {
-    ReadableStreamReaderGenericRelease(reader);
-    var e = new TypeError('Reader was released');
-    ReadableStreamBYOBReaderErrorReadIntoRequests(reader, e);
-}
-function ReadableStreamBYOBReaderErrorReadIntoRequests(reader, e) {
-    var readIntoRequests = reader._readIntoRequests;
-    reader._readIntoRequests = new SimpleQueue();
-    readIntoRequests.forEach(function (readIntoRequest) {
-        readIntoRequest._errorSteps(e);
-    });
-}
 // Helper functions for the ReadableStreamBYOBReader.
 function byobReaderBrandCheckException(name) {
-    return new TypeError("ReadableStreamBYOBReader.prototype.".concat(name, " can only be used on a ReadableStreamBYOBReader"));
+    return new TypeError("ReadableStreamBYOBReader.prototype." + name + " can only be used on a ReadableStreamBYOBReader");
 }
 
 function ExtractHighWaterMark(strategy, defaultHWM) {
@@ -16239,7 +15899,7 @@ function convertQueuingStrategy(init, context) {
     var size = init === null || init === void 0 ? void 0 : init.size;
     return {
         highWaterMark: highWaterMark === undefined ? undefined : convertUnrestrictedDouble(highWaterMark),
-        size: size === undefined ? undefined : convertQueuingStrategySize(size, "".concat(context, " has member 'size' that"))
+        size: size === undefined ? undefined : convertQueuingStrategySize(size, context + " has member 'size' that")
     };
 }
 function convertQueuingStrategySize(fn, context) {
@@ -16257,16 +15917,16 @@ function convertUnderlyingSink(original, context) {
     return {
         abort: abort === undefined ?
             undefined :
-            convertUnderlyingSinkAbortCallback(abort, original, "".concat(context, " has member 'abort' that")),
+            convertUnderlyingSinkAbortCallback(abort, original, context + " has member 'abort' that"),
         close: close === undefined ?
             undefined :
-            convertUnderlyingSinkCloseCallback(close, original, "".concat(context, " has member 'close' that")),
+            convertUnderlyingSinkCloseCallback(close, original, context + " has member 'close' that"),
         start: start === undefined ?
             undefined :
-            convertUnderlyingSinkStartCallback(start, original, "".concat(context, " has member 'start' that")),
+            convertUnderlyingSinkStartCallback(start, original, context + " has member 'start' that"),
         write: write === undefined ?
             undefined :
-            convertUnderlyingSinkWriteCallback(write, original, "".concat(context, " has member 'write' that")),
+            convertUnderlyingSinkWriteCallback(write, original, context + " has member 'write' that"),
         type: type
     };
 }
@@ -16289,7 +15949,7 @@ function convertUnderlyingSinkWriteCallback(fn, original, context) {
 
 function assertWritableStream(x, context) {
     if (!IsWritableStream(x)) {
-        throw new TypeError("".concat(context, " is not a WritableStream."));
+        throw new TypeError(context + " is not a WritableStream.");
     }
 }
 
@@ -16418,9 +16078,6 @@ Object.defineProperties(WritableStream.prototype, {
     getWriter: { enumerable: true },
     locked: { enumerable: true }
 });
-setFunctionName(WritableStream.prototype.abort, 'abort');
-setFunctionName(WritableStream.prototype.close, 'close');
-setFunctionName(WritableStream.prototype.getWriter, 'getWriter');
 if (typeof SymbolPolyfill.toStringTag === 'symbol') {
     Object.defineProperty(WritableStream.prototype, SymbolPolyfill.toStringTag, {
         value: 'WritableStream',
@@ -16431,16 +16088,6 @@ if (typeof SymbolPolyfill.toStringTag === 'symbol') {
 function AcquireWritableStreamDefaultWriter(stream) {
     return new WritableStreamDefaultWriter(stream);
 }
-// Throws if and only if startAlgorithm throws.
-function CreateWritableStream(startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm) {
-    if (highWaterMark === void 0) { highWaterMark = 1; }
-    if (sizeAlgorithm === void 0) { sizeAlgorithm = function () { return 1; }; }
-    var stream = Object.create(WritableStream.prototype);
-    InitializeWritableStream(stream);
-    var controller = Object.create(WritableStreamDefaultController.prototype);
-    SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm);
-    return stream;
-}
 function InitializeWritableStream(stream) {
     stream._state = 'writable';
     // The error that will be reported by new method calls once the state becomes errored. Only set when [[state]] is
@@ -16488,7 +16135,7 @@ function WritableStreamAbort(stream, reason) {
         return promiseResolvedWith(undefined);
     }
     stream._writableStreamController._abortReason = reason;
-    (_a = stream._writableStreamController._abortController) === null || _a === void 0 ? void 0 : _a.abort(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.
@@ -16523,7 +16170,7 @@ function WritableStreamAbort(stream, reason) {
 function WritableStreamClose(stream) {
     var state = stream._state;
     if (state === 'closed' || state === 'errored') {
-        return promiseRejectedWith(new TypeError("The stream (in ".concat(state, " state) is not in the writable state and cannot be closed")));
+        return promiseRejectedWith(new TypeError("The stream (in " + state + " state) is not in the writable state and cannot be closed"));
     }
     var promise = newPromise(function (resolve, reject) {
         var closeRequest = {
@@ -16593,11 +16240,9 @@ function WritableStreamFinishErroring(stream) {
     uponPromise(promise, function () {
         abortRequest._resolve();
         WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
-        return null;
     }, function (reason) {
         abortRequest._reject(reason);
         WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
-        return null;
     });
 }
 function WritableStreamFinishInFlightWrite(stream) {
@@ -16840,10 +16485,6 @@ Object.defineProperties(WritableStreamDefaultWriter.prototype, {
     desiredSize: { enumerable: true },
     ready: { enumerable: true }
 });
-setFunctionName(WritableStreamDefaultWriter.prototype.abort, 'abort');
-setFunctionName(WritableStreamDefaultWriter.prototype.close, 'close');
-setFunctionName(WritableStreamDefaultWriter.prototype.releaseLock, 'releaseLock');
-setFunctionName(WritableStreamDefaultWriter.prototype.write, 'write');
 if (typeof SymbolPolyfill.toStringTag === 'symbol') {
     Object.defineProperty(WritableStreamDefaultWriter.prototype, SymbolPolyfill.toStringTag, {
         value: 'WritableStreamDefaultWriter',
@@ -17059,43 +16700,29 @@ function SetUpWritableStreamDefaultController(stream, controller, startAlgorithm
     uponPromise(startPromise, function () {
         controller._started = true;
         WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
-        return null;
     }, function (r) {
         controller._started = true;
         WritableStreamDealWithRejection(stream, r);
-        return null;
     });
 }
 function SetUpWritableStreamDefaultControllerFromUnderlyingSink(stream, underlyingSink, highWaterMark, sizeAlgorithm) {
     var controller = Object.create(WritableStreamDefaultController.prototype);
-    var startAlgorithm;
-    var writeAlgorithm;
-    var closeAlgorithm;
-    var abortAlgorithm;
+    var startAlgorithm = function () { return undefined; };
+    var writeAlgorithm = function () { return promiseResolvedWith(undefined); };
+    var closeAlgorithm = function () { return promiseResolvedWith(undefined); };
+    var abortAlgorithm = function () { return promiseResolvedWith(undefined); };
     if (underlyingSink.start !== undefined) {
         startAlgorithm = function () { return underlyingSink.start(controller); };
     }
-    else {
-        startAlgorithm = function () { return undefined; };
-    }
     if (underlyingSink.write !== undefined) {
         writeAlgorithm = function (chunk) { return underlyingSink.write(chunk, controller); };
     }
-    else {
-        writeAlgorithm = function () { return promiseResolvedWith(undefined); };
-    }
     if (underlyingSink.close !== undefined) {
         closeAlgorithm = function () { return underlyingSink.close(); };
     }
-    else {
-        closeAlgorithm = function () { return promiseResolvedWith(undefined); };
-    }
     if (underlyingSink.abort !== undefined) {
         abortAlgorithm = function (reason) { return underlyingSink.abort(reason); };
     }
-    else {
-        abortAlgorithm = function () { return promiseResolvedWith(undefined); };
-    }
     SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm);
 }
 // ClearAlgorithms may be called twice. Erroring the same stream in multiple ways will often result in redundant calls.
@@ -17174,10 +16801,8 @@ function WritableStreamDefaultControllerProcessClose(controller) {
     WritableStreamDefaultControllerClearAlgorithms(controller);
     uponPromise(sinkClosePromise, function () {
         WritableStreamFinishInFlightClose(stream);
-        return null;
     }, function (reason) {
         WritableStreamFinishInFlightCloseWithError(stream, reason);
-        return null;
     });
 }
 function WritableStreamDefaultControllerProcessWrite(controller, chunk) {
@@ -17193,13 +16818,11 @@ function WritableStreamDefaultControllerProcessWrite(controller, chunk) {
             WritableStreamUpdateBackpressure(stream, backpressure);
         }
         WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
-        return null;
     }, function (reason) {
         if (stream._state === 'writable') {
             WritableStreamDefaultControllerClearAlgorithms(controller);
         }
         WritableStreamFinishInFlightWriteWithError(stream, reason);
-        return null;
     });
 }
 function WritableStreamDefaultControllerGetBackpressure(controller) {
@@ -17214,15 +16837,15 @@ function WritableStreamDefaultControllerError(controller, error) {
 }
 // Helper functions for the WritableStream.
 function streamBrandCheckException$2(name) {
-    return new TypeError("WritableStream.prototype.".concat(name, " can only be used on a WritableStream"));
+    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.".concat(name, " can only be used on a WritableStreamDefaultController"));
+    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.".concat(name, " can only be used on a WritableStreamDefaultWriter"));
+    return new TypeError("WritableStreamDefaultWriter.prototype." + name + " can only be used on a WritableStreamDefaultWriter");
 }
 function defaultWriterLockException(name) {
     return new TypeError('Cannot ' + name + ' a stream using a released writer');
@@ -17306,28 +16929,13 @@ function defaultWriterReadyPromiseResolve(writer) {
 }
 
 /// <reference lib="dom" />
-function getGlobals() {
-    if (typeof globalThis !== 'undefined') {
-        return globalThis;
-    }
-    else if (typeof self !== 'undefined') {
-        return self;
-    }
-    else if (typeof global !== 'undefined') {
-        return global;
-    }
-    return undefined;
-}
-var globals = getGlobals();
+var NativeDOMException = typeof DOMException !== 'undefined' ? DOMException : undefined;
 
 /// <reference types="node" />
 function isDOMExceptionConstructor(ctor) {
     if (!(typeof ctor === 'function' || typeof ctor === 'object')) {
         return false;
     }
-    if (ctor.name !== 'DOMException') {
-        return false;
-    }
     try {
         new ctor();
         return true;
@@ -17336,21 +16944,8 @@ function isDOMExceptionConstructor(ctor) {
         return false;
     }
 }
-/**
- * Support:
- * - Web browsers
- * - Node 18 and higher (https://github.com/nodejs/node/commit/e4b1fb5e6422c1ff151234bb9de792d45dd88d87)
- */
-function getFromGlobal() {
-    var ctor = globals === null || globals === void 0 ? void 0 : globals.DOMException;
-    return isDOMExceptionConstructor(ctor) ? ctor : undefined;
-}
-/**
- * Support:
- * - All platforms
- */
-function createPolyfill() {
-    // eslint-disable-next-line @typescript-eslint/no-shadow
+function createDOMExceptionPolyfill() {
+    // eslint-disable-next-line no-shadow
     var ctor = function DOMException(message, name) {
         this.message = message || '';
         this.name = name || 'Error';
@@ -17358,13 +16953,12 @@ function createPolyfill() {
             Error.captureStackTrace(this, this.constructor);
         }
     };
-    setFunctionName(ctor, 'DOMException');
     ctor.prototype = Object.create(Error.prototype);
     Object.defineProperty(ctor.prototype, 'constructor', { value: ctor, writable: true, configurable: true });
     return ctor;
 }
-// eslint-disable-next-line @typescript-eslint/no-redeclare
-var DOMException = getFromGlobal() || createPolyfill();
+// eslint-disable-next-line no-redeclare
+var DOMException$1 = isDOMExceptionConstructor(NativeDOMException) ? NativeDOMException : createDOMExceptionPolyfill();
 
 function ReadableStreamPipeTo(source, dest, preventClose, preventAbort, preventCancel, signal) {
     var reader = AcquireReadableStreamDefaultReader(source);
@@ -17377,7 +16971,7 @@ function ReadableStreamPipeTo(source, dest, preventClose, preventAbort, preventC
         var abortAlgorithm;
         if (signal !== undefined) {
             abortAlgorithm = function () {
-                var error = signal.reason !== undefined ? signal.reason : new DOMException('Aborted', 'AbortError');
+                var error = new DOMException$1('Aborted', 'AbortError');
                 var actions = [];
                 if (!preventAbort) {
                     actions.push(function () {
@@ -17446,7 +17040,6 @@ function ReadableStreamPipeTo(source, dest, preventClose, preventAbort, preventC
             else {
                 shutdown(true, storedError);
             }
-            return null;
         });
         // Errors must be propagated backward
         isOrBecomesErrored(dest, writer._closedPromise, function (storedError) {
@@ -17456,7 +17049,6 @@ function ReadableStreamPipeTo(source, dest, preventClose, preventAbort, preventC
             else {
                 shutdown(true, storedError);
             }
-            return null;
         });
         // Closing must be propagated forward
         isOrBecomesClosed(source, reader._closedPromise, function () {
@@ -17466,7 +17058,6 @@ function ReadableStreamPipeTo(source, dest, preventClose, preventAbort, preventC
             else {
                 shutdown();
             }
-            return null;
         });
         // Closing must be propagated backward
         if (WritableStreamCloseQueuedOrInFlight(dest) || dest._state === 'closed') {
@@ -17514,7 +17105,6 @@ function ReadableStreamPipeTo(source, dest, preventClose, preventAbort, preventC
             }
             function doTheRest() {
                 uponPromise(action(), function () { return finalize(originalIsError, originalError); }, function (newError) { return finalize(true, newError); });
-                return null;
             }
         }
         function shutdown(isError, error) {
@@ -17541,7 +17131,6 @@ function ReadableStreamPipeTo(source, dest, preventClose, preventAbort, preventC
             else {
                 resolve(undefined);
             }
-            return null;
         }
     });
 }
@@ -17628,10 +17217,6 @@ var ReadableStreamDefaultController = /** @class */ (function () {
             ReadableStreamDefaultControllerCallPullIfNeeded(this);
         }
     };
-    /** @internal */
-    ReadableStreamDefaultController.prototype[ReleaseSteps] = function () {
-        // Do nothing.
-    };
     return ReadableStreamDefaultController;
 }());
 Object.defineProperties(ReadableStreamDefaultController.prototype, {
@@ -17640,9 +17225,6 @@ Object.defineProperties(ReadableStreamDefaultController.prototype, {
     error: { enumerable: true },
     desiredSize: { enumerable: true }
 });
-setFunctionName(ReadableStreamDefaultController.prototype.close, 'close');
-setFunctionName(ReadableStreamDefaultController.prototype.enqueue, 'enqueue');
-setFunctionName(ReadableStreamDefaultController.prototype.error, 'error');
 if (typeof SymbolPolyfill.toStringTag === 'symbol') {
     Object.defineProperty(ReadableStreamDefaultController.prototype, SymbolPolyfill.toStringTag, {
         value: 'ReadableStreamDefaultController',
@@ -17676,10 +17258,8 @@ function ReadableStreamDefaultControllerCallPullIfNeeded(controller) {
             controller._pullAgain = false;
             ReadableStreamDefaultControllerCallPullIfNeeded(controller);
         }
-        return null;
     }, function (e) {
         ReadableStreamDefaultControllerError(controller, e);
-        return null;
     });
 }
 function ReadableStreamDefaultControllerShouldCallPull(controller) {
@@ -17794,40 +17374,29 @@ function SetUpReadableStreamDefaultController(stream, controller, startAlgorithm
     uponPromise(promiseResolvedWith(startResult), function () {
         controller._started = true;
         ReadableStreamDefaultControllerCallPullIfNeeded(controller);
-        return null;
     }, function (r) {
         ReadableStreamDefaultControllerError(controller, r);
-        return null;
     });
 }
 function SetUpReadableStreamDefaultControllerFromUnderlyingSource(stream, underlyingSource, highWaterMark, sizeAlgorithm) {
     var controller = Object.create(ReadableStreamDefaultController.prototype);
-    var startAlgorithm;
-    var pullAlgorithm;
-    var cancelAlgorithm;
+    var startAlgorithm = function () { return undefined; };
+    var pullAlgorithm = function () { return promiseResolvedWith(undefined); };
+    var cancelAlgorithm = function () { return promiseResolvedWith(undefined); };
     if (underlyingSource.start !== undefined) {
         startAlgorithm = function () { return underlyingSource.start(controller); };
     }
-    else {
-        startAlgorithm = function () { return undefined; };
-    }
     if (underlyingSource.pull !== undefined) {
         pullAlgorithm = function () { return underlyingSource.pull(controller); };
     }
-    else {
-        pullAlgorithm = function () { return promiseResolvedWith(undefined); };
-    }
     if (underlyingSource.cancel !== undefined) {
         cancelAlgorithm = function (reason) { return underlyingSource.cancel(reason); };
     }
-    else {
-        cancelAlgorithm = function () { return promiseResolvedWith(undefined); };
-    }
     SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm);
 }
 // Helper functions for the ReadableStreamDefaultController.
 function defaultControllerBrandCheckException$1(name) {
-    return new TypeError("ReadableStreamDefaultController.prototype.".concat(name, " can only be used on a ReadableStreamDefaultController"));
+    return new TypeError("ReadableStreamDefaultController.prototype." + name + " can only be used on a ReadableStreamDefaultController");
 }
 
 function ReadableStreamTee(stream, cloneForBranch2) {
@@ -17861,7 +17430,7 @@ function ReadableStreamDefaultTee(stream, cloneForBranch2) {
                 // 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 () {
+                queueMicrotask(function () {
                     readAgain = false;
                     var chunk1 = chunk;
                     var chunk2 = chunk;
@@ -17932,7 +17501,6 @@ function ReadableStreamDefaultTee(stream, cloneForBranch2) {
         if (!canceled1 || !canceled2) {
             resolveCancelPromise(undefined);
         }
-        return null;
     });
     return [branch1, branch2];
 }
@@ -17954,14 +17522,13 @@ function ReadableByteStreamTee(stream) {
     function forwardReaderError(thisReader) {
         uponRejection(thisReader._closedPromise, function (r) {
             if (thisReader !== reader) {
-                return null;
+                return;
             }
             ReadableByteStreamControllerError(branch1._readableStreamController, r);
             ReadableByteStreamControllerError(branch2._readableStreamController, r);
             if (!canceled1 || !canceled2) {
                 resolveCancelPromise(undefined);
             }
-            return null;
         });
     }
     function pullWithDefaultReader() {
@@ -17975,7 +17542,7 @@ function ReadableByteStreamTee(stream) {
                 // 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 () {
+                queueMicrotask(function () {
                     readAgainForBranch1 = false;
                     readAgainForBranch2 = false;
                     var chunk1 = chunk;
@@ -18043,7 +17610,7 @@ function ReadableByteStreamTee(stream) {
                 // 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 () {
+                queueMicrotask(function () {
                     readAgainForBranch1 = false;
                     readAgainForBranch2 = false;
                     var byobCanceled = forBranch2 ? canceled2 : canceled1;
@@ -18102,7 +17669,7 @@ function ReadableByteStreamTee(stream) {
                 reading = false;
             }
         };
-        ReadableStreamBYOBReaderRead(reader, view, 1, readIntoRequest);
+        ReadableStreamBYOBReaderRead(reader, view, readIntoRequest);
     }
     function pull1Algorithm() {
         if (reading) {
@@ -18163,109 +17730,6 @@ function ReadableByteStreamTee(stream) {
     return [branch1, branch2];
 }
 
-function isReadableStreamLike(stream) {
-    return typeIsObject(stream) && typeof stream.getReader !== 'undefined';
-}
-
-function ReadableStreamFrom(source) {
-    if (isReadableStreamLike(source)) {
-        return ReadableStreamFromDefaultReader(source.getReader());
-    }
-    return ReadableStreamFromIterable(source);
-}
-function ReadableStreamFromIterable(asyncIterable) {
-    var stream;
-    var iteratorRecord = GetIterator(asyncIterable, 'async');
-    var startAlgorithm = noop;
-    function pullAlgorithm() {
-        var nextResult;
-        try {
-            nextResult = IteratorNext(iteratorRecord);
-        }
-        catch (e) {
-            return promiseRejectedWith(e);
-        }
-        var nextPromise = promiseResolvedWith(nextResult);
-        return transformPromiseWith(nextPromise, function (iterResult) {
-            if (!typeIsObject(iterResult)) {
-                throw new TypeError('The promise returned by the iterator.next() method must fulfill with an object');
-            }
-            var done = IteratorComplete(iterResult);
-            if (done) {
-                ReadableStreamDefaultControllerClose(stream._readableStreamController);
-            }
-            else {
-                var value = IteratorValue(iterResult);
-                ReadableStreamDefaultControllerEnqueue(stream._readableStreamController, value);
-            }
-        });
-    }
-    function cancelAlgorithm(reason) {
-        var iterator = iteratorRecord.iterator;
-        var returnMethod;
-        try {
-            returnMethod = GetMethod(iterator, 'return');
-        }
-        catch (e) {
-            return promiseRejectedWith(e);
-        }
-        if (returnMethod === undefined) {
-            return promiseResolvedWith(undefined);
-        }
-        var returnResult;
-        try {
-            returnResult = reflectCall(returnMethod, iterator, [reason]);
-        }
-        catch (e) {
-            return promiseRejectedWith(e);
-        }
-        var returnPromise = promiseResolvedWith(returnResult);
-        return transformPromiseWith(returnPromise, function (iterResult) {
-            if (!typeIsObject(iterResult)) {
-                throw new TypeError('The promise returned by the iterator.return() method must fulfill with an object');
-            }
-            return undefined;
-        });
-    }
-    stream = CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, 0);
-    return stream;
-}
-function ReadableStreamFromDefaultReader(reader) {
-    var stream;
-    var startAlgorithm = noop;
-    function pullAlgorithm() {
-        var readPromise;
-        try {
-            readPromise = reader.read();
-        }
-        catch (e) {
-            return promiseRejectedWith(e);
-        }
-        return transformPromiseWith(readPromise, function (readResult) {
-            if (!typeIsObject(readResult)) {
-                throw new TypeError('The promise returned by the reader.read() method must fulfill with an object');
-            }
-            if (readResult.done) {
-                ReadableStreamDefaultControllerClose(stream._readableStreamController);
-            }
-            else {
-                var value = readResult.value;
-                ReadableStreamDefaultControllerEnqueue(stream._readableStreamController, value);
-            }
-        });
-    }
-    function cancelAlgorithm(reason) {
-        try {
-            return promiseResolvedWith(reader.cancel(reason));
-        }
-        catch (e) {
-            return promiseRejectedWith(e);
-        }
-    }
-    stream = CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, 0);
-    return stream;
-}
-
 function convertUnderlyingDefaultOrByteSource(source, context) {
     assertDictionary(source, context);
     var original = source;
@@ -18277,17 +17741,17 @@ function convertUnderlyingDefaultOrByteSource(source, context) {
     return {
         autoAllocateChunkSize: autoAllocateChunkSize === undefined ?
             undefined :
-            convertUnsignedLongLongWithEnforceRange(autoAllocateChunkSize, "".concat(context, " has member 'autoAllocateChunkSize' that")),
+            convertUnsignedLongLongWithEnforceRange(autoAllocateChunkSize, context + " has member 'autoAllocateChunkSize' that"),
         cancel: cancel === undefined ?
             undefined :
-            convertUnderlyingSourceCancelCallback(cancel, original, "".concat(context, " has member 'cancel' that")),
+            convertUnderlyingSourceCancelCallback(cancel, original, context + " has member 'cancel' that"),
         pull: pull === undefined ?
             undefined :
-            convertUnderlyingSourcePullCallback(pull, original, "".concat(context, " has member 'pull' that")),
+            convertUnderlyingSourcePullCallback(pull, original, context + " has member 'pull' that"),
         start: start === undefined ?
             undefined :
-            convertUnderlyingSourceStartCallback(start, original, "".concat(context, " has member 'start' that")),
-        type: type === undefined ? undefined : convertReadableStreamType(type, "".concat(context, " has member 'type' that"))
+            convertUnderlyingSourceStartCallback(start, original, context + " has member 'start' that"),
+        type: type === undefined ? undefined : convertReadableStreamType(type, context + " has member 'type' that")
     };
 }
 function convertUnderlyingSourceCancelCallback(fn, original, context) {
@@ -18303,13 +17767,28 @@ function convertUnderlyingSourceStartCallback(fn, original, context) {
     return function (controller) { return reflectCall(fn, original, [controller]); };
 }
 function convertReadableStreamType(type, context) {
-    type = "".concat(type);
+    type = "" + type;
     if (type !== 'bytes') {
-        throw new TypeError("".concat(context, " '").concat(type, "' is not a valid enumeration value for ReadableStreamType"));
+        throw new TypeError(context + " '" + type + "' is not a valid enumeration value for ReadableStreamType");
     }
     return type;
 }
 
+function convertReaderOptions(options, context) {
+    assertDictionary(options, context);
+    var mode = options === null || options === void 0 ? void 0 : options.mode;
+    return {
+        mode: mode === undefined ? undefined : convertReadableStreamReaderMode(mode, context + " has member 'mode' that")
+    };
+}
+function convertReadableStreamReaderMode(mode, context) {
+    mode = "" + mode;
+    if (mode !== 'byob') {
+        throw new TypeError(context + " '" + mode + "' is not a valid enumeration value for ReadableStreamReaderMode");
+    }
+    return mode;
+}
+
 function convertIteratorOptions(options, context) {
     assertDictionary(options, context);
     var preventCancel = options === null || options === void 0 ? void 0 : options.preventCancel;
@@ -18323,7 +17802,7 @@ function convertPipeOptions(options, context) {
     var preventClose = options === null || options === void 0 ? void 0 : options.preventClose;
     var signal = options === null || options === void 0 ? void 0 : options.signal;
     if (signal !== undefined) {
-        assertAbortSignal(signal, "".concat(context, " has member 'signal' that"));
+        assertAbortSignal(signal, context + " has member 'signal' that");
     }
     return {
         preventAbort: Boolean(preventAbort),
@@ -18334,7 +17813,7 @@ function convertPipeOptions(options, context) {
 }
 function assertAbortSignal(signal, context) {
     if (!isAbortSignal(signal)) {
-        throw new TypeError("".concat(context, " is not an AbortSignal."));
+        throw new TypeError(context + " is not an AbortSignal.");
     }
 }
 
@@ -18342,10 +17821,10 @@ function convertReadableWritablePair(pair, context) {
     assertDictionary(pair, context);
     var readable = pair === null || pair === void 0 ? void 0 : pair.readable;
     assertRequiredField(readable, 'readable', 'ReadableWritablePair');
-    assertReadableStream(readable, "".concat(context, " has member 'readable' that"));
+    assertReadableStream(readable, context + " has member 'readable' that");
     var writable = pair === null || pair === void 0 ? void 0 : pair.writable;
     assertRequiredField(writable, 'writable', 'ReadableWritablePair');
-    assertWritableStream(writable, "".concat(context, " has member 'writable' that"));
+    assertWritableStream(writable, context + " has member 'writable' that");
     return { readable: readable, writable: writable };
 }
 
@@ -18490,24 +17969,8 @@ var ReadableStream = /** @class */ (function () {
         var options = convertIteratorOptions(rawOptions, 'First parameter');
         return AcquireReadableStreamAsyncIterator(this, options.preventCancel);
     };
-    ReadableStream.prototype[SymbolAsyncIterator] = function (options) {
-        // Stub implementation, overridden below
-        return this.values(options);
-    };
-    /**
-     * Creates a new ReadableStream wrapping the provided iterable or async iterable.
-     *
-     * This can be used to adapt various kinds of objects into a readable stream,
-     * such as an array, an async generator, or a Node.js readable stream.
-     */
-    ReadableStream.from = function (asyncIterable) {
-        return ReadableStreamFrom(asyncIterable);
-    };
     return ReadableStream;
 }());
-Object.defineProperties(ReadableStream, {
-    from: { enumerable: true }
-});
 Object.defineProperties(ReadableStream.prototype, {
     cancel: { enumerable: true },
     getReader: { enumerable: true },
@@ -18517,24 +17980,19 @@ Object.defineProperties(ReadableStream.prototype, {
     values: { enumerable: true },
     locked: { enumerable: true }
 });
-setFunctionName(ReadableStream.from, 'from');
-setFunctionName(ReadableStream.prototype.cancel, 'cancel');
-setFunctionName(ReadableStream.prototype.getReader, 'getReader');
-setFunctionName(ReadableStream.prototype.pipeThrough, 'pipeThrough');
-setFunctionName(ReadableStream.prototype.pipeTo, 'pipeTo');
-setFunctionName(ReadableStream.prototype.tee, 'tee');
-setFunctionName(ReadableStream.prototype.values, 'values');
 if (typeof SymbolPolyfill.toStringTag === 'symbol') {
     Object.defineProperty(ReadableStream.prototype, SymbolPolyfill.toStringTag, {
         value: 'ReadableStream',
         configurable: true
     });
 }
-Object.defineProperty(ReadableStream.prototype, SymbolAsyncIterator, {
-    value: ReadableStream.prototype.values,
-    writable: true,
-    configurable: true
-});
+if (typeof SymbolPolyfill.asyncIterator === 'symbol') {
+    Object.defineProperty(ReadableStream.prototype, SymbolPolyfill.asyncIterator, {
+        value: ReadableStream.prototype.values,
+        writable: true,
+        configurable: true
+    });
+}
 // Abstract operations for the ReadableStream.
 // Throws if and only if startAlgorithm throws.
 function CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm) {
@@ -18587,11 +18045,10 @@ function ReadableStreamCancel(stream, reason) {
     ReadableStreamClose(stream);
     var reader = stream._reader;
     if (reader !== undefined && IsReadableStreamBYOBReader(reader)) {
-        var readIntoRequests = reader._readIntoRequests;
-        reader._readIntoRequests = new SimpleQueue();
-        readIntoRequests.forEach(function (readIntoRequest) {
+        reader._readIntoRequests.forEach(function (readIntoRequest) {
             readIntoRequest._closeSteps(undefined);
         });
+        reader._readIntoRequests = new SimpleQueue();
     }
     var sourceCancelPromise = stream._readableStreamController[CancelSteps](reason);
     return transformPromiseWith(sourceCancelPromise, noop);
@@ -18604,11 +18061,10 @@ function ReadableStreamClose(stream) {
     }
     defaultReaderClosedPromiseResolve(reader);
     if (IsReadableStreamDefaultReader(reader)) {
-        var readRequests = reader._readRequests;
-        reader._readRequests = new SimpleQueue();
-        readRequests.forEach(function (readRequest) {
+        reader._readRequests.forEach(function (readRequest) {
             readRequest._closeSteps();
         });
+        reader._readRequests = new SimpleQueue();
     }
 }
 function ReadableStreamError(stream, e) {
@@ -18620,322 +18076,51 @@ function ReadableStreamError(stream, e) {
     }
     defaultReaderClosedPromiseReject(reader, e);
     if (IsReadableStreamDefaultReader(reader)) {
-        ReadableStreamDefaultReaderErrorReadRequests(reader, e);
+        reader._readRequests.forEach(function (readRequest) {
+            readRequest._errorSteps(e);
+        });
+        reader._readRequests = new SimpleQueue();
     }
     else {
-        ReadableStreamBYOBReaderErrorReadIntoRequests(reader, e);
+        reader._readIntoRequests.forEach(function (readIntoRequest) {
+            readIntoRequest._errorSteps(e);
+        });
+        reader._readIntoRequests = new SimpleQueue();
     }
 }
 // Helper functions for the ReadableStream.
 function streamBrandCheckException$1(name) {
-    return new TypeError("ReadableStream.prototype.".concat(name, " can only be used on a ReadableStream"));
-}
-
-function convertQueuingStrategyInit(init, context) {
-    assertDictionary(init, context);
-    var highWaterMark = init === null || init === void 0 ? void 0 : init.highWaterMark;
-    assertRequiredField(highWaterMark, 'highWaterMark', 'QueuingStrategyInit');
-    return {
-        highWaterMark: convertUnrestrictedDouble(highWaterMark)
-    };
+    return new TypeError("ReadableStream.prototype." + name + " can only be used on a ReadableStream");
 }
 
 // The size function must not have a prototype property nor be a constructor
 var byteLengthSizeFunction = function (chunk) {
     return chunk.byteLength;
 };
-setFunctionName(byteLengthSizeFunction, 'size');
-/**
- * A queuing strategy that counts the number of bytes in each chunk.
- *
- * @public
- */
-var ByteLengthQueuingStrategy = /** @class */ (function () {
-    function ByteLengthQueuingStrategy(options) {
-        assertRequiredArgument(options, 1, 'ByteLengthQueuingStrategy');
-        options = convertQueuingStrategyInit(options, 'First parameter');
-        this._byteLengthQueuingStrategyHighWaterMark = options.highWaterMark;
-    }
-    Object.defineProperty(ByteLengthQueuingStrategy.prototype, "highWaterMark", {
-        /**
-         * Returns the high water mark provided to the constructor.
-         */
-        get: function () {
-            if (!IsByteLengthQueuingStrategy(this)) {
-                throw byteLengthBrandCheckException('highWaterMark');
-            }
-            return this._byteLengthQueuingStrategyHighWaterMark;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ByteLengthQueuingStrategy.prototype, "size", {
-        /**
-         * Measures the size of `chunk` by returning the value of its `byteLength` property.
-         */
-        get: function () {
-            if (!IsByteLengthQueuingStrategy(this)) {
-                throw byteLengthBrandCheckException('size');
-            }
-            return byteLengthSizeFunction;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return ByteLengthQueuingStrategy;
-}());
-Object.defineProperties(ByteLengthQueuingStrategy.prototype, {
-    highWaterMark: { enumerable: true },
-    size: { enumerable: true }
-});
-if (typeof SymbolPolyfill.toStringTag === 'symbol') {
-    Object.defineProperty(ByteLengthQueuingStrategy.prototype, SymbolPolyfill.toStringTag, {
-        value: 'ByteLengthQueuingStrategy',
+try {
+    Object.defineProperty(byteLengthSizeFunction, 'name', {
+        value: 'size',
         configurable: true
     });
 }
-// Helper functions for the ByteLengthQueuingStrategy.
-function byteLengthBrandCheckException(name) {
-    return new TypeError("ByteLengthQueuingStrategy.prototype.".concat(name, " can only be used on a ByteLengthQueuingStrategy"));
-}
-function IsByteLengthQueuingStrategy(x) {
-    if (!typeIsObject(x)) {
-        return false;
-    }
-    if (!Object.prototype.hasOwnProperty.call(x, '_byteLengthQueuingStrategyHighWaterMark')) {
-        return false;
-    }
-    return x instanceof ByteLengthQueuingStrategy;
+catch (_a) {
+    // This property is non-configurable in older browsers, so ignore if this throws.
+    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name#browser_compatibility
 }
 
 // The size function must not have a prototype property nor be a constructor
 var countSizeFunction = function () {
     return 1;
 };
-setFunctionName(countSizeFunction, 'size');
-/**
- * A queuing strategy that counts the number of chunks.
- *
- * @public
- */
-var CountQueuingStrategy = /** @class */ (function () {
-    function CountQueuingStrategy(options) {
-        assertRequiredArgument(options, 1, 'CountQueuingStrategy');
-        options = convertQueuingStrategyInit(options, 'First parameter');
-        this._countQueuingStrategyHighWaterMark = options.highWaterMark;
-    }
-    Object.defineProperty(CountQueuingStrategy.prototype, "highWaterMark", {
-        /**
-         * Returns the high water mark provided to the constructor.
-         */
-        get: function () {
-            if (!IsCountQueuingStrategy(this)) {
-                throw countBrandCheckException('highWaterMark');
-            }
-            return this._countQueuingStrategyHighWaterMark;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(CountQueuingStrategy.prototype, "size", {
-        /**
-         * Measures the size of `chunk` by always returning 1.
-         * This ensures that the total queue size is a count of the number of chunks in the queue.
-         */
-        get: function () {
-            if (!IsCountQueuingStrategy(this)) {
-                throw countBrandCheckException('size');
-            }
-            return countSizeFunction;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return CountQueuingStrategy;
-}());
-Object.defineProperties(CountQueuingStrategy.prototype, {
-    highWaterMark: { enumerable: true },
-    size: { enumerable: true }
-});
-if (typeof SymbolPolyfill.toStringTag === 'symbol') {
-    Object.defineProperty(CountQueuingStrategy.prototype, SymbolPolyfill.toStringTag, {
-        value: 'CountQueuingStrategy',
-        configurable: true
-    });
-}
-// Helper functions for the CountQueuingStrategy.
-function countBrandCheckException(name) {
-    return new TypeError("CountQueuingStrategy.prototype.".concat(name, " can only be used on a CountQueuingStrategy"));
-}
-function IsCountQueuingStrategy(x) {
-    if (!typeIsObject(x)) {
-        return false;
-    }
-    if (!Object.prototype.hasOwnProperty.call(x, '_countQueuingStrategyHighWaterMark')) {
-        return false;
-    }
-    return x instanceof CountQueuingStrategy;
-}
-
-function convertTransformer(original, context) {
-    assertDictionary(original, context);
-    var cancel = original === null || original === void 0 ? void 0 : original.cancel;
-    var flush = original === null || original === void 0 ? void 0 : original.flush;
-    var readableType = original === null || original === void 0 ? void 0 : original.readableType;
-    var start = original === null || original === void 0 ? void 0 : original.start;
-    var transform = original === null || original === void 0 ? void 0 : original.transform;
-    var writableType = original === null || original === void 0 ? void 0 : original.writableType;
-    return {
-        cancel: cancel === undefined ?
-            undefined :
-            convertTransformerCancelCallback(cancel, original, "".concat(context, " has member 'cancel' that")),
-        flush: flush === undefined ?
-            undefined :
-            convertTransformerFlushCallback(flush, original, "".concat(context, " has member 'flush' that")),
-        readableType: readableType,
-        start: start === undefined ?
-            undefined :
-            convertTransformerStartCallback(start, original, "".concat(context, " has member 'start' that")),
-        transform: transform === undefined ?
-            undefined :
-            convertTransformerTransformCallback(transform, original, "".concat(context, " has member 'transform' that")),
-        writableType: writableType
-    };
-}
-function convertTransformerFlushCallback(fn, original, context) {
-    assertFunction(fn, context);
-    return function (controller) { return promiseCall(fn, original, [controller]); };
-}
-function convertTransformerStartCallback(fn, original, context) {
-    assertFunction(fn, context);
-    return function (controller) { return reflectCall(fn, original, [controller]); };
-}
-function convertTransformerTransformCallback(fn, original, context) {
-    assertFunction(fn, context);
-    return function (chunk, controller) { return promiseCall(fn, original, [chunk, controller]); };
-}
-function convertTransformerCancelCallback(fn, original, context) {
-    assertFunction(fn, context);
-    return function (reason) { return promiseCall(fn, original, [reason]); };
-}
-
-// Class TransformStream
-/**
- * A transform stream consists of a pair of streams: a {@link WritableStream | writable stream},
- * known as its writable side, and a {@link ReadableStream | readable stream}, known as its readable side.
- * In a manner specific to the transform stream in question, writes to the writable side result in new data being
- * made available for reading from the readable side.
- *
- * @public
- */
-var TransformStream = /** @class */ (function () {
-    function TransformStream(rawTransformer, rawWritableStrategy, rawReadableStrategy) {
-        if (rawTransformer === void 0) { rawTransformer = {}; }
-        if (rawWritableStrategy === void 0) { rawWritableStrategy = {}; }
-        if (rawReadableStrategy === void 0) { rawReadableStrategy = {}; }
-        if (rawTransformer === undefined) {
-            rawTransformer = null;
-        }
-        var writableStrategy = convertQueuingStrategy(rawWritableStrategy, 'Second parameter');
-        var readableStrategy = convertQueuingStrategy(rawReadableStrategy, 'Third parameter');
-        var transformer = convertTransformer(rawTransformer, 'First parameter');
-        if (transformer.readableType !== undefined) {
-            throw new RangeError('Invalid readableType specified');
-        }
-        if (transformer.writableType !== undefined) {
-            throw new RangeError('Invalid writableType specified');
-        }
-        var readableHighWaterMark = ExtractHighWaterMark(readableStrategy, 0);
-        var readableSizeAlgorithm = ExtractSizeAlgorithm(readableStrategy);
-        var writableHighWaterMark = ExtractHighWaterMark(writableStrategy, 1);
-        var writableSizeAlgorithm = ExtractSizeAlgorithm(writableStrategy);
-        var startPromise_resolve;
-        var startPromise = newPromise(function (resolve) {
-            startPromise_resolve = resolve;
-        });
-        InitializeTransformStream(this, startPromise, writableHighWaterMark, writableSizeAlgorithm, readableHighWaterMark, readableSizeAlgorithm);
-        SetUpTransformStreamDefaultControllerFromTransformer(this, transformer);
-        if (transformer.start !== undefined) {
-            startPromise_resolve(transformer.start(this._transformStreamController));
-        }
-        else {
-            startPromise_resolve(undefined);
-        }
-    }
-    Object.defineProperty(TransformStream.prototype, "readable", {
-        /**
-         * The readable side of the transform stream.
-         */
-        get: function () {
-            if (!IsTransformStream(this)) {
-                throw streamBrandCheckException('readable');
-            }
-            return this._readable;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(TransformStream.prototype, "writable", {
-        /**
-         * The writable side of the transform stream.
-         */
-        get: function () {
-            if (!IsTransformStream(this)) {
-                throw streamBrandCheckException('writable');
-            }
-            return this._writable;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return TransformStream;
-}());
-Object.defineProperties(TransformStream.prototype, {
-    readable: { enumerable: true },
-    writable: { enumerable: true }
-});
-if (typeof SymbolPolyfill.toStringTag === 'symbol') {
-    Object.defineProperty(TransformStream.prototype, SymbolPolyfill.toStringTag, {
-        value: 'TransformStream',
+try {
+    Object.defineProperty(countSizeFunction, 'name', {
+        value: 'size',
         configurable: true
     });
 }
-function InitializeTransformStream(stream, startPromise, writableHighWaterMark, writableSizeAlgorithm, readableHighWaterMark, readableSizeAlgorithm) {
-    function startAlgorithm() {
-        return startPromise;
-    }
-    function writeAlgorithm(chunk) {
-        return TransformStreamDefaultSinkWriteAlgorithm(stream, chunk);
-    }
-    function abortAlgorithm(reason) {
-        return TransformStreamDefaultSinkAbortAlgorithm(stream, reason);
-    }
-    function closeAlgorithm() {
-        return TransformStreamDefaultSinkCloseAlgorithm(stream);
-    }
-    stream._writable = CreateWritableStream(startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, writableHighWaterMark, writableSizeAlgorithm);
-    function pullAlgorithm() {
-        return TransformStreamDefaultSourcePullAlgorithm(stream);
-    }
-    function cancelAlgorithm(reason) {
-        return TransformStreamDefaultSourceCancelAlgorithm(stream, reason);
-    }
-    stream._readable = CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, readableHighWaterMark, readableSizeAlgorithm);
-    // The [[backpressure]] slot is set to undefined so that it can be initialised by TransformStreamSetBackpressure.
-    stream._backpressure = undefined;
-    stream._backpressureChangePromise = undefined;
-    stream._backpressureChangePromise_resolve = undefined;
-    TransformStreamSetBackpressure(stream, true);
-    stream._transformStreamController = undefined;
-}
-function IsTransformStream(x) {
-    if (!typeIsObject(x)) {
-        return false;
-    }
-    if (!Object.prototype.hasOwnProperty.call(x, '_transformStreamController')) {
-        return false;
-    }
-    return x instanceof TransformStream;
+catch (_a) {
+    // This property is non-configurable in older browsers, so ignore if this throws.
+    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name#browser_compatibility
 }
 // This is a no-op if both sides are already errored.
 function TransformStreamError(stream, e) {
@@ -18945,9 +18130,6 @@ function TransformStreamError(stream, e) {
 function TransformStreamErrorWritableAndUnblockWrite(stream, e) {
     TransformStreamDefaultControllerClearAlgorithms(stream._transformStreamController);
     WritableStreamDefaultControllerErrorIfNeeded(stream._writable._writableStreamController, e);
-    TransformStreamUnblockWrite(stream);
-}
-function TransformStreamUnblockWrite(stream) {
     if (stream._backpressure) {
         // Pretend that pull() was called to permit any pending write() calls to complete. TransformStreamSetBackpressure()
         // cannot be called from enqueue() or pull() once the ReadableStream is errored, so this will will be the final time
@@ -19025,9 +18207,6 @@ Object.defineProperties(TransformStreamDefaultController.prototype, {
     terminate: { enumerable: true },
     desiredSize: { enumerable: true }
 });
-setFunctionName(TransformStreamDefaultController.prototype.enqueue, 'enqueue');
-setFunctionName(TransformStreamDefaultController.prototype.error, 'error');
-setFunctionName(TransformStreamDefaultController.prototype.terminate, 'terminate');
 if (typeof SymbolPolyfill.toStringTag === 'symbol') {
     Object.defineProperty(TransformStreamDefaultController.prototype, SymbolPolyfill.toStringTag, {
         value: 'TransformStreamDefaultController',
@@ -19044,53 +18223,9 @@ function IsTransformStreamDefaultController(x) {
     }
     return x instanceof TransformStreamDefaultController;
 }
-function SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm, cancelAlgorithm) {
-    controller._controlledTransformStream = stream;
-    stream._transformStreamController = controller;
-    controller._transformAlgorithm = transformAlgorithm;
-    controller._flushAlgorithm = flushAlgorithm;
-    controller._cancelAlgorithm = cancelAlgorithm;
-    controller._finishPromise = undefined;
-    controller._finishPromise_resolve = undefined;
-    controller._finishPromise_reject = undefined;
-}
-function SetUpTransformStreamDefaultControllerFromTransformer(stream, transformer) {
-    var controller = Object.create(TransformStreamDefaultController.prototype);
-    var transformAlgorithm;
-    var flushAlgorithm;
-    var cancelAlgorithm;
-    if (transformer.transform !== undefined) {
-        transformAlgorithm = function (chunk) { return transformer.transform(chunk, controller); };
-    }
-    else {
-        transformAlgorithm = function (chunk) {
-            try {
-                TransformStreamDefaultControllerEnqueue(controller, chunk);
-                return promiseResolvedWith(undefined);
-            }
-            catch (transformResultE) {
-                return promiseRejectedWith(transformResultE);
-            }
-        };
-    }
-    if (transformer.flush !== undefined) {
-        flushAlgorithm = function () { return transformer.flush(controller); };
-    }
-    else {
-        flushAlgorithm = function () { return promiseResolvedWith(undefined); };
-    }
-    if (transformer.cancel !== undefined) {
-        cancelAlgorithm = function (reason) { return transformer.cancel(reason); };
-    }
-    else {
-        cancelAlgorithm = function () { return promiseResolvedWith(undefined); };
-    }
-    SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm, cancelAlgorithm);
-}
 function TransformStreamDefaultControllerClearAlgorithms(controller) {
     controller._transformAlgorithm = undefined;
     controller._flushAlgorithm = undefined;
-    controller._cancelAlgorithm = undefined;
 }
 function TransformStreamDefaultControllerEnqueue(controller, chunk) {
     var stream = controller._controlledTransformStream;
@@ -19116,13 +18251,6 @@ function TransformStreamDefaultControllerEnqueue(controller, chunk) {
 function TransformStreamDefaultControllerError(controller, e) {
     TransformStreamError(controller._controlledTransformStream, e);
 }
-function TransformStreamDefaultControllerPerformTransform(controller, chunk) {
-    var transformPromise = controller._transformAlgorithm(chunk);
-    return transformPromiseWith(transformPromise, undefined, function (r) {
-        TransformStreamError(controller._controlledTransformStream, r);
-        throw r;
-    });
-}
 function TransformStreamDefaultControllerTerminate(controller) {
     var stream = controller._controlledTransformStream;
     var readableController = stream._readable._readableStreamController;
@@ -19130,149 +18258,9 @@ function TransformStreamDefaultControllerTerminate(controller) {
     var error = new TypeError('TransformStream terminated');
     TransformStreamErrorWritableAndUnblockWrite(stream, error);
 }
-// TransformStreamDefaultSink Algorithms
-function TransformStreamDefaultSinkWriteAlgorithm(stream, chunk) {
-    var controller = stream._transformStreamController;
-    if (stream._backpressure) {
-        var backpressureChangePromise = stream._backpressureChangePromise;
-        return transformPromiseWith(backpressureChangePromise, function () {
-            var writable = stream._writable;
-            var state = writable._state;
-            if (state === 'erroring') {
-                throw writable._storedError;
-            }
-            return TransformStreamDefaultControllerPerformTransform(controller, chunk);
-        });
-    }
-    return TransformStreamDefaultControllerPerformTransform(controller, chunk);
-}
-function TransformStreamDefaultSinkAbortAlgorithm(stream, reason) {
-    var controller = stream._transformStreamController;
-    if (controller._finishPromise !== undefined) {
-        return controller._finishPromise;
-    }
-    // stream._readable cannot change after construction, so caching it across a call to user code is safe.
-    var readable = stream._readable;
-    // Assign the _finishPromise now so that if _cancelAlgorithm calls readable.cancel() internally,
-    // we don't run the _cancelAlgorithm again.
-    controller._finishPromise = newPromise(function (resolve, reject) {
-        controller._finishPromise_resolve = resolve;
-        controller._finishPromise_reject = reject;
-    });
-    var cancelPromise = controller._cancelAlgorithm(reason);
-    TransformStreamDefaultControllerClearAlgorithms(controller);
-    uponPromise(cancelPromise, function () {
-        if (readable._state === 'errored') {
-            defaultControllerFinishPromiseReject(controller, readable._storedError);
-        }
-        else {
-            ReadableStreamDefaultControllerError(readable._readableStreamController, reason);
-            defaultControllerFinishPromiseResolve(controller);
-        }
-        return null;
-    }, function (r) {
-        ReadableStreamDefaultControllerError(readable._readableStreamController, r);
-        defaultControllerFinishPromiseReject(controller, r);
-        return null;
-    });
-    return controller._finishPromise;
-}
-function TransformStreamDefaultSinkCloseAlgorithm(stream) {
-    var controller = stream._transformStreamController;
-    if (controller._finishPromise !== undefined) {
-        return controller._finishPromise;
-    }
-    // stream._readable cannot change after construction, so caching it across a call to user code is safe.
-    var readable = stream._readable;
-    // Assign the _finishPromise now so that if _flushAlgorithm calls readable.cancel() internally,
-    // we don't also run the _cancelAlgorithm.
-    controller._finishPromise = newPromise(function (resolve, reject) {
-        controller._finishPromise_resolve = resolve;
-        controller._finishPromise_reject = reject;
-    });
-    var flushPromise = controller._flushAlgorithm();
-    TransformStreamDefaultControllerClearAlgorithms(controller);
-    uponPromise(flushPromise, function () {
-        if (readable._state === 'errored') {
-            defaultControllerFinishPromiseReject(controller, readable._storedError);
-        }
-        else {
-            ReadableStreamDefaultControllerClose(readable._readableStreamController);
-            defaultControllerFinishPromiseResolve(controller);
-        }
-        return null;
-    }, function (r) {
-        ReadableStreamDefaultControllerError(readable._readableStreamController, r);
-        defaultControllerFinishPromiseReject(controller, r);
-        return null;
-    });
-    return controller._finishPromise;
-}
-// TransformStreamDefaultSource Algorithms
-function TransformStreamDefaultSourcePullAlgorithm(stream) {
-    // Invariant. Enforced by the promises returned by start() and pull().
-    TransformStreamSetBackpressure(stream, false);
-    // Prevent the next pull() call until there is backpressure.
-    return stream._backpressureChangePromise;
-}
-function TransformStreamDefaultSourceCancelAlgorithm(stream, reason) {
-    var controller = stream._transformStreamController;
-    if (controller._finishPromise !== undefined) {
-        return controller._finishPromise;
-    }
-    // stream._writable cannot change after construction, so caching it across a call to user code is safe.
-    var writable = stream._writable;
-    // Assign the _finishPromise now so that if _flushAlgorithm calls writable.abort() or
-    // writable.cancel() internally, we don't run the _cancelAlgorithm again, or also run the
-    // _flushAlgorithm.
-    controller._finishPromise = newPromise(function (resolve, reject) {
-        controller._finishPromise_resolve = resolve;
-        controller._finishPromise_reject = reject;
-    });
-    var cancelPromise = controller._cancelAlgorithm(reason);
-    TransformStreamDefaultControllerClearAlgorithms(controller);
-    uponPromise(cancelPromise, function () {
-        if (writable._state === 'errored') {
-            defaultControllerFinishPromiseReject(controller, writable._storedError);
-        }
-        else {
-            WritableStreamDefaultControllerErrorIfNeeded(writable._writableStreamController, reason);
-            TransformStreamUnblockWrite(stream);
-            defaultControllerFinishPromiseResolve(controller);
-        }
-        return null;
-    }, function (r) {
-        WritableStreamDefaultControllerErrorIfNeeded(writable._writableStreamController, r);
-        TransformStreamUnblockWrite(stream);
-        defaultControllerFinishPromiseReject(controller, r);
-        return null;
-    });
-    return controller._finishPromise;
-}
 // Helper functions for the TransformStreamDefaultController.
 function defaultControllerBrandCheckException(name) {
-    return new TypeError("TransformStreamDefaultController.prototype.".concat(name, " can only be used on a TransformStreamDefaultController"));
-}
-function defaultControllerFinishPromiseResolve(controller) {
-    if (controller._finishPromise_resolve === undefined) {
-        return;
-    }
-    controller._finishPromise_resolve();
-    controller._finishPromise_resolve = undefined;
-    controller._finishPromise_reject = undefined;
-}
-function defaultControllerFinishPromiseReject(controller, reason) {
-    if (controller._finishPromise_reject === undefined) {
-        return;
-    }
-    setPromiseIsHandledToTrue(controller._finishPromise);
-    controller._finishPromise_reject(reason);
-    controller._finishPromise_resolve = undefined;
-    controller._finishPromise_reject = undefined;
-}
-// Helper functions for the TransformStream.
-function streamBrandCheckException(name) {
-    return new TypeError("TransformStream.prototype.".concat(name, " can only be used on a TransformStream"));
+    return new TypeError("TransformStreamDefaultController.prototype." + name + " can only be used on a TransformStreamDefaultController");
 }
 
 function createBlobReader(blob) {