web-streams-polyfill 3.3.1 → 3.3.3

package/dist/polyfill.js

@@ -1,6 +1,6 @@
 /**
  * @license
- * web-streams-polyfill v3.3.1
+ * 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
@@ -641,22 +641,137 @@
         return new TypeError("ReadableStreamDefaultReader.prototype.".concat(name, " can only be used on a ReadableStreamDefaultReader"));
     }
 
-    /// <reference lib="es2018.asynciterable" />
-    var _a;
-    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;
-            },
+    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);
-        Object.defineProperty(AsyncIteratorPrototype, SymbolPolyfill.asyncIterator, { enumerable: false });
+        // 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;
     }
 
+    /// <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 });
+
     /// <reference lib="es2018.asynciterable" />
     var ReadableStreamAsyncIteratorImpl = /** @class */ (function () {
         function ReadableStreamAsyncIteratorImpl(reader, preventCancel) {
@@ -745,9 +860,7 @@
             return this._asyncIteratorImpl.return(value);
         }
     };
-    if (AsyncIteratorPrototype !== undefined) {
-        Object.setPrototypeOf(ReadableStreamAsyncIteratorPrototype, AsyncIteratorPrototype);
-    }
+    Object.setPrototypeOf(ReadableStreamAsyncIteratorPrototype, AsyncIteratorPrototype);
     // Abstract operations for the ReadableStream.
     function AcquireReadableStreamAsyncIterator(stream, preventCancel) {
         var reader = AcquireReadableStreamDefaultReader(stream);
@@ -784,122 +897,6 @@
         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);
-    }
-    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 };
-    }
-    function GetIterator(obj, hint, method) {
-        if (hint === void 0) { hint = 'sync'; }
-        if (method === undefined) {
-            if (hint === 'async') {
-                method = GetMethod(obj, SymbolPolyfill.asyncIterator);
-                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;
-    }
-
     function IsNonNegativeNumber(v) {
         if (typeof v !== 'number') {
             return false;
@@ -4183,6 +4180,10 @@
             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.
          *
@@ -4219,13 +4220,11 @@
             configurable: true
         });
     }
-    if (typeof SymbolPolyfill.asyncIterator === 'symbol') {
-        Object.defineProperty(ReadableStream.prototype, SymbolPolyfill.asyncIterator, {
-            value: ReadableStream.prototype.values,
-            writable: true,
-            configurable: true
-        });
-    }
+    Object.defineProperty(ReadableStream.prototype, SymbolAsyncIterator, {
+        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) {