web-streams-polyfill 3.3.2 → 3.3.3

package/dist/ponyfill.mjs

@@ -1,6 +1,6 @@
 /**
  * @license
- * web-streams-polyfill v3.3.2
+ * 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
@@ -635,22 +635,137 @@ function defaultReaderBrandCheckException(name) {
     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) {
@@ -739,9 +854,7 @@ var ReadableStreamAsyncIteratorPrototype = {
         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);
@@ -778,122 +891,6 @@ 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);
-}
-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;
@@ -4177,6 +4174,10 @@ 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.
      *
@@ -4213,13 +4214,11 @@ if (typeof SymbolPolyfill.toStringTag === 'symbol') {
         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) {