web-streams-polyfill 3.3.1 → 3.3.3

package/dist/polyfill.es6.mjs

@@ -1,15 +1,10 @@
 /**
  * @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
  */
-/// <reference lib="es2015.symbol" />
-const SymbolPolyfill = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol' ?
-    Symbol :
-    description => `Symbol(${description})`;
-
 function noop() {
     return undefined;
 }
@@ -202,11 +197,11 @@ class SimpleQueue {
     }
 }
 
-const AbortSteps = SymbolPolyfill('[[AbortSteps]]');
-const ErrorSteps = SymbolPolyfill('[[ErrorSteps]]');
-const CancelSteps = SymbolPolyfill('[[CancelSteps]]');
-const PullSteps = SymbolPolyfill('[[PullSteps]]');
-const ReleaseSteps = SymbolPolyfill('[[ReleaseSteps]]');
+const AbortSteps = Symbol('[[AbortSteps]]');
+const ErrorSteps = Symbol('[[ErrorSteps]]');
+const CancelSteps = Symbol('[[CancelSteps]]');
+const PullSteps = Symbol('[[PullSteps]]');
+const ReleaseSteps = Symbol('[[ReleaseSteps]]');
 
 function ReadableStreamReaderGenericInitialize(reader, stream) {
     reader._ownerReadableStream = stream;
@@ -486,8 +481,8 @@ Object.defineProperties(ReadableStreamDefaultReader.prototype, {
 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, {
+if (typeof Symbol.toStringTag === 'symbol') {
+    Object.defineProperty(ReadableStreamDefaultReader.prototype, Symbol.toStringTag, {
         value: 'ReadableStreamDefaultReader',
         configurable: true
     });
@@ -532,144 +527,6 @@ function defaultReaderBrandCheckException(name) {
     return new TypeError(`ReadableStreamDefaultReader.prototype.${name} can only be used on a ReadableStreamDefaultReader`);
 }
 
-/// <reference lib="es2018.asynciterable" />
-let 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 = {
-        // 25.1.3.1 %AsyncIteratorPrototype% [ @@asyncIterator ] ( )
-        // https://tc39.github.io/ecma262/#sec-asynciteratorprototype-asynciterator
-        [SymbolPolyfill.asyncIterator]() {
-            return this;
-        }
-    };
-    Object.defineProperty(AsyncIteratorPrototype, SymbolPolyfill.asyncIterator, { enumerable: false });
-}
-
-/// <reference lib="es2018.asynciterable" />
-class ReadableStreamAsyncIteratorImpl {
-    constructor(reader, preventCancel) {
-        this._ongoingPromise = undefined;
-        this._isFinished = false;
-        this._reader = reader;
-        this._preventCancel = preventCancel;
-    }
-    next() {
-        const nextSteps = () => this._nextSteps();
-        this._ongoingPromise = this._ongoingPromise ?
-            transformPromiseWith(this._ongoingPromise, nextSteps, nextSteps) :
-            nextSteps();
-        return this._ongoingPromise;
-    }
-    return(value) {
-        const returnSteps = () => this._returnSteps(value);
-        return this._ongoingPromise ?
-            transformPromiseWith(this._ongoingPromise, returnSteps, returnSteps) :
-            returnSteps();
-    }
-    _nextSteps() {
-        if (this._isFinished) {
-            return Promise.resolve({ value: undefined, done: true });
-        }
-        const reader = this._reader;
-        let resolvePromise;
-        let rejectPromise;
-        const promise = newPromise((resolve, reject) => {
-            resolvePromise = resolve;
-            rejectPromise = reject;
-        });
-        const readRequest = {
-            _chunkSteps: chunk => {
-                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(() => resolvePromise({ value: chunk, done: false }));
-            },
-            _closeSteps: () => {
-                this._ongoingPromise = undefined;
-                this._isFinished = true;
-                ReadableStreamReaderGenericRelease(reader);
-                resolvePromise({ value: undefined, done: true });
-            },
-            _errorSteps: reason => {
-                this._ongoingPromise = undefined;
-                this._isFinished = true;
-                ReadableStreamReaderGenericRelease(reader);
-                rejectPromise(reason);
-            }
-        };
-        ReadableStreamDefaultReaderRead(reader, readRequest);
-        return promise;
-    }
-    _returnSteps(value) {
-        if (this._isFinished) {
-            return Promise.resolve({ value, done: true });
-        }
-        this._isFinished = true;
-        const reader = this._reader;
-        if (!this._preventCancel) {
-            const result = ReadableStreamReaderGenericCancel(reader, value);
-            ReadableStreamReaderGenericRelease(reader);
-            return transformPromiseWith(result, () => ({ value, done: true }));
-        }
-        ReadableStreamReaderGenericRelease(reader);
-        return promiseResolvedWith({ value, done: true });
-    }
-}
-const ReadableStreamAsyncIteratorPrototype = {
-    next() {
-        if (!IsReadableStreamAsyncIterator(this)) {
-            return promiseRejectedWith(streamAsyncIteratorBrandCheckException('next'));
-        }
-        return this._asyncIteratorImpl.next();
-    },
-    return(value) {
-        if (!IsReadableStreamAsyncIterator(this)) {
-            return promiseRejectedWith(streamAsyncIteratorBrandCheckException('return'));
-        }
-        return this._asyncIteratorImpl.return(value);
-    }
-};
-if (AsyncIteratorPrototype !== undefined) {
-    Object.setPrototypeOf(ReadableStreamAsyncIteratorPrototype, AsyncIteratorPrototype);
-}
-// Abstract operations for the ReadableStream.
-function AcquireReadableStreamAsyncIterator(stream, preventCancel) {
-    const reader = AcquireReadableStreamDefaultReader(stream);
-    const impl = new ReadableStreamAsyncIteratorImpl(reader, preventCancel);
-    const iterator = Object.create(ReadableStreamAsyncIteratorPrototype);
-    iterator._asyncIteratorImpl = impl;
-    return iterator;
-}
-function IsReadableStreamAsyncIterator(x) {
-    if (!typeIsObject(x)) {
-        return false;
-    }
-    if (!Object.prototype.hasOwnProperty.call(x, '_asyncIteratorImpl')) {
-        return false;
-    }
-    try {
-        // noinspection SuspiciousTypeOfGuard
-        return x._asyncIteratorImpl instanceof
-            ReadableStreamAsyncIteratorImpl;
-    }
-    catch (_a) {
-        return false;
-    }
-}
-// Helper functions for the ReadableStream.
-function streamAsyncIteratorBrandCheckException(name) {
-    return new TypeError(`ReadableStreamAsyncIterator.${name} can only be used on a ReadableSteamAsyncIterator`);
-}
-
-/// <reference lib="es2015.core" />
-// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isNaN#Polyfill
-const NumberIsNaN = Number.isNaN || function (x) {
-    // eslint-disable-next-line no-self-compare
-    return x !== x;
-};
-
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
 
@@ -734,6 +591,7 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
+var _a, _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.
@@ -791,7 +649,7 @@ function CreateAsyncFromSyncIterator(syncIteratorRecord) {
     // we use yield* inside an async generator function to achieve the same result.
     // Wrap the sync iterator inside a sync iterable, so we can use it with yield*.
     const syncIterable = {
-        [SymbolPolyfill.iterator]: () => syncIteratorRecord.iterator
+        [Symbol.iterator]: () => syncIteratorRecord.iterator
     };
     // Create an async generator function and immediately invoke it.
     const asyncIterator = (function () {
@@ -803,18 +661,20 @@ function CreateAsyncFromSyncIterator(syncIteratorRecord) {
     const nextMethod = asyncIterator.next;
     return { iterator: asyncIterator, nextMethod, done: false };
 }
+// Aligns with core-js/modules/es.symbol.async-iterator.js
+const SymbolAsyncIterator = (_c = (_a = Symbol.asyncIterator) !== null && _a !== void 0 ? _a : (_b = Symbol.for) === null || _b === void 0 ? void 0 : _b.call(Symbol, 'Symbol.asyncIterator')) !== null && _c !== void 0 ? _c : '@@asyncIterator';
 function GetIterator(obj, hint = 'sync', method) {
     if (method === undefined) {
         if (hint === 'async') {
-            method = GetMethod(obj, SymbolPolyfill.asyncIterator);
+            method = GetMethod(obj, SymbolAsyncIterator);
             if (method === undefined) {
-                const syncMethod = GetMethod(obj, SymbolPolyfill.iterator);
+                const syncMethod = GetMethod(obj, Symbol.iterator);
                 const syncIteratorRecord = GetIterator(obj, 'sync', syncMethod);
                 return CreateAsyncFromSyncIterator(syncIteratorRecord);
             }
         }
         else {
-            method = GetMethod(obj, SymbolPolyfill.iterator);
+            method = GetMethod(obj, Symbol.iterator);
         }
     }
     if (method === undefined) {
@@ -841,6 +701,138 @@ function IteratorValue(iterResult) {
     return iterResult.value;
 }
 
+/// <reference lib="es2018.asynciterable" />
+// We cannot access %AsyncIteratorPrototype% without non-ES2018 syntax, but we can re-create it.
+const AsyncIteratorPrototype = {
+    // 25.1.3.1 %AsyncIteratorPrototype% [ @@asyncIterator ] ( )
+    // https://tc39.github.io/ecma262/#sec-asynciteratorprototype-asynciterator
+    [SymbolAsyncIterator]() {
+        return this;
+    }
+};
+Object.defineProperty(AsyncIteratorPrototype, SymbolAsyncIterator, { enumerable: false });
+
+/// <reference lib="es2018.asynciterable" />
+class ReadableStreamAsyncIteratorImpl {
+    constructor(reader, preventCancel) {
+        this._ongoingPromise = undefined;
+        this._isFinished = false;
+        this._reader = reader;
+        this._preventCancel = preventCancel;
+    }
+    next() {
+        const nextSteps = () => this._nextSteps();
+        this._ongoingPromise = this._ongoingPromise ?
+            transformPromiseWith(this._ongoingPromise, nextSteps, nextSteps) :
+            nextSteps();
+        return this._ongoingPromise;
+    }
+    return(value) {
+        const returnSteps = () => this._returnSteps(value);
+        return this._ongoingPromise ?
+            transformPromiseWith(this._ongoingPromise, returnSteps, returnSteps) :
+            returnSteps();
+    }
+    _nextSteps() {
+        if (this._isFinished) {
+            return Promise.resolve({ value: undefined, done: true });
+        }
+        const reader = this._reader;
+        let resolvePromise;
+        let rejectPromise;
+        const promise = newPromise((resolve, reject) => {
+            resolvePromise = resolve;
+            rejectPromise = reject;
+        });
+        const readRequest = {
+            _chunkSteps: chunk => {
+                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(() => resolvePromise({ value: chunk, done: false }));
+            },
+            _closeSteps: () => {
+                this._ongoingPromise = undefined;
+                this._isFinished = true;
+                ReadableStreamReaderGenericRelease(reader);
+                resolvePromise({ value: undefined, done: true });
+            },
+            _errorSteps: reason => {
+                this._ongoingPromise = undefined;
+                this._isFinished = true;
+                ReadableStreamReaderGenericRelease(reader);
+                rejectPromise(reason);
+            }
+        };
+        ReadableStreamDefaultReaderRead(reader, readRequest);
+        return promise;
+    }
+    _returnSteps(value) {
+        if (this._isFinished) {
+            return Promise.resolve({ value, done: true });
+        }
+        this._isFinished = true;
+        const reader = this._reader;
+        if (!this._preventCancel) {
+            const result = ReadableStreamReaderGenericCancel(reader, value);
+            ReadableStreamReaderGenericRelease(reader);
+            return transformPromiseWith(result, () => ({ value, done: true }));
+        }
+        ReadableStreamReaderGenericRelease(reader);
+        return promiseResolvedWith({ value, done: true });
+    }
+}
+const ReadableStreamAsyncIteratorPrototype = {
+    next() {
+        if (!IsReadableStreamAsyncIterator(this)) {
+            return promiseRejectedWith(streamAsyncIteratorBrandCheckException('next'));
+        }
+        return this._asyncIteratorImpl.next();
+    },
+    return(value) {
+        if (!IsReadableStreamAsyncIterator(this)) {
+            return promiseRejectedWith(streamAsyncIteratorBrandCheckException('return'));
+        }
+        return this._asyncIteratorImpl.return(value);
+    }
+};
+Object.setPrototypeOf(ReadableStreamAsyncIteratorPrototype, AsyncIteratorPrototype);
+// Abstract operations for the ReadableStream.
+function AcquireReadableStreamAsyncIterator(stream, preventCancel) {
+    const reader = AcquireReadableStreamDefaultReader(stream);
+    const impl = new ReadableStreamAsyncIteratorImpl(reader, preventCancel);
+    const iterator = Object.create(ReadableStreamAsyncIteratorPrototype);
+    iterator._asyncIteratorImpl = impl;
+    return iterator;
+}
+function IsReadableStreamAsyncIterator(x) {
+    if (!typeIsObject(x)) {
+        return false;
+    }
+    if (!Object.prototype.hasOwnProperty.call(x, '_asyncIteratorImpl')) {
+        return false;
+    }
+    try {
+        // noinspection SuspiciousTypeOfGuard
+        return x._asyncIteratorImpl instanceof
+            ReadableStreamAsyncIteratorImpl;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+// Helper functions for the ReadableStream.
+function streamAsyncIteratorBrandCheckException(name) {
+    return new TypeError(`ReadableStreamAsyncIterator.${name} can only be used on a ReadableSteamAsyncIterator`);
+}
+
+/// <reference lib="es2015.core" />
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isNaN#Polyfill
+const NumberIsNaN = Number.isNaN || function (x) {
+    // eslint-disable-next-line no-self-compare
+    return x !== x;
+};
+
 function IsNonNegativeNumber(v) {
     if (typeof v !== 'number') {
         return false;
@@ -951,8 +943,8 @@ Object.defineProperties(ReadableStreamBYOBRequest.prototype, {
 });
 setFunctionName(ReadableStreamBYOBRequest.prototype.respond, 'respond');
 setFunctionName(ReadableStreamBYOBRequest.prototype.respondWithNewView, 'respondWithNewView');
-if (typeof SymbolPolyfill.toStringTag === 'symbol') {
-    Object.defineProperty(ReadableStreamBYOBRequest.prototype, SymbolPolyfill.toStringTag, {
+if (typeof Symbol.toStringTag === 'symbol') {
+    Object.defineProperty(ReadableStreamBYOBRequest.prototype, Symbol.toStringTag, {
         value: 'ReadableStreamBYOBRequest',
         configurable: true
     });
@@ -1095,8 +1087,8 @@ Object.defineProperties(ReadableByteStreamController.prototype, {
 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, {
+if (typeof Symbol.toStringTag === 'symbol') {
+    Object.defineProperty(ReadableByteStreamController.prototype, Symbol.toStringTag, {
         value: 'ReadableByteStreamController',
         configurable: true
     });
@@ -1784,8 +1776,8 @@ Object.defineProperties(ReadableStreamBYOBReader.prototype, {
 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, {
+if (typeof Symbol.toStringTag === 'symbol') {
+    Object.defineProperty(ReadableStreamBYOBReader.prototype, Symbol.toStringTag, {
         value: 'ReadableStreamBYOBReader',
         configurable: true
     });
@@ -2025,8 +2017,8 @@ Object.defineProperties(WritableStream.prototype, {
 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, {
+if (typeof Symbol.toStringTag === 'symbol') {
+    Object.defineProperty(WritableStream.prototype, Symbol.toStringTag, {
         value: 'WritableStream',
         configurable: true
     });
@@ -2431,8 +2423,8 @@ 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, {
+if (typeof Symbol.toStringTag === 'symbol') {
+    Object.defineProperty(WritableStreamDefaultWriter.prototype, Symbol.toStringTag, {
         value: 'WritableStreamDefaultWriter',
         configurable: true
     });
@@ -2598,8 +2590,8 @@ Object.defineProperties(WritableStreamDefaultController.prototype, {
     signal: { enumerable: true },
     error: { enumerable: true }
 });
-if (typeof SymbolPolyfill.toStringTag === 'symbol') {
-    Object.defineProperty(WritableStreamDefaultController.prototype, SymbolPolyfill.toStringTag, {
+if (typeof Symbol.toStringTag === 'symbol') {
+    Object.defineProperty(WritableStreamDefaultController.prototype, Symbol.toStringTag, {
         value: 'WritableStreamDefaultController',
         configurable: true
     });
@@ -3213,8 +3205,8 @@ Object.defineProperties(ReadableStreamDefaultController.prototype, {
 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, {
+if (typeof Symbol.toStringTag === 'symbol') {
+    Object.defineProperty(ReadableStreamDefaultController.prototype, Symbol.toStringTag, {
         value: 'ReadableStreamDefaultController',
         configurable: true
     });
@@ -4049,6 +4041,10 @@ class ReadableStream {
         const options = convertIteratorOptions(rawOptions, 'First parameter');
         return AcquireReadableStreamAsyncIterator(this, options.preventCancel);
     }
+    [SymbolAsyncIterator](options) {
+        // Stub implementation, overridden below
+        return this.values(options);
+    }
     /**
      * Creates a new ReadableStream wrapping the provided iterable or async iterable.
      *
@@ -4078,19 +4074,17 @@ 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, {
+if (typeof Symbol.toStringTag === 'symbol') {
+    Object.defineProperty(ReadableStream.prototype, Symbol.toStringTag, {
         value: 'ReadableStream',
         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 = 1, sizeAlgorithm = () => 1) {
@@ -4233,8 +4227,8 @@ Object.defineProperties(ByteLengthQueuingStrategy.prototype, {
     highWaterMark: { enumerable: true },
     size: { enumerable: true }
 });
-if (typeof SymbolPolyfill.toStringTag === 'symbol') {
-    Object.defineProperty(ByteLengthQueuingStrategy.prototype, SymbolPolyfill.toStringTag, {
+if (typeof Symbol.toStringTag === 'symbol') {
+    Object.defineProperty(ByteLengthQueuingStrategy.prototype, Symbol.toStringTag, {
         value: 'ByteLengthQueuingStrategy',
         configurable: true
     });
@@ -4293,8 +4287,8 @@ Object.defineProperties(CountQueuingStrategy.prototype, {
     highWaterMark: { enumerable: true },
     size: { enumerable: true }
 });
-if (typeof SymbolPolyfill.toStringTag === 'symbol') {
-    Object.defineProperty(CountQueuingStrategy.prototype, SymbolPolyfill.toStringTag, {
+if (typeof Symbol.toStringTag === 'symbol') {
+    Object.defineProperty(CountQueuingStrategy.prototype, Symbol.toStringTag, {
         value: 'CountQueuingStrategy',
         configurable: true
     });
@@ -4418,8 +4412,8 @@ Object.defineProperties(TransformStream.prototype, {
     readable: { enumerable: true },
     writable: { enumerable: true }
 });
-if (typeof SymbolPolyfill.toStringTag === 'symbol') {
-    Object.defineProperty(TransformStream.prototype, SymbolPolyfill.toStringTag, {
+if (typeof Symbol.toStringTag === 'symbol') {
+    Object.defineProperty(TransformStream.prototype, Symbol.toStringTag, {
         value: 'TransformStream',
         configurable: true
     });
@@ -4545,8 +4539,8 @@ Object.defineProperties(TransformStreamDefaultController.prototype, {
 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, {
+if (typeof Symbol.toStringTag === 'symbol') {
+    Object.defineProperty(TransformStreamDefaultController.prototype, Symbol.toStringTag, {
         value: 'TransformStreamDefaultController',
         configurable: true
     });