web-streams-polyfill 3.1.0 → 3.2.1

package/dist/ponyfill.es6.mjs

@@ -1,5 +1,5 @@
 /**
- * web-streams-polyfill v3.1.0
+ * web-streams-polyfill v3.2.1
  */
 /// <reference lib="es2015.symbol" />
 const SymbolPolyfill = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol' ?
@@ -1206,6 +1206,9 @@ function ReadableByteStreamControllerEnqueue(controller, chunk) {
             ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);
         }
         else {
+            if (controller._pendingPullIntos.length > 0) {
+                ReadableByteStreamControllerShiftPendingPullInto(controller);
+            }
             const transferredView = new Uint8Array(transferredBuffer, byteOffset, byteLength);
             ReadableStreamFulfillReadRequest(stream, transferredView, false);
         }
@@ -1291,8 +1294,9 @@ function ReadableByteStreamControllerRespondWithNewView(controller, view) {
     if (firstDescriptor.bytesFilled + view.byteLength > firstDescriptor.byteLength) {
         throw new RangeError('The region specified by view is larger than byobRequest');
     }
+    const viewByteLength = view.byteLength;
     firstDescriptor.buffer = TransferArrayBuffer(view.buffer);
-    ReadableByteStreamControllerRespondInternal(controller, view.byteLength);
+    ReadableByteStreamControllerRespondInternal(controller, viewByteLength);
 }
 function SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, autoAllocateChunkSize) {
     controller._controlledReadableByteStream = stream;
@@ -2219,6 +2223,10 @@ class WritableStreamDefaultController {
     }
     /**
      * The reason which was passed to `WritableStream.abort(reason)` when the stream was aborted.
+     *
+     * @deprecated
+     *  This property has been removed from the specification, see https://github.com/whatwg/streams/pull/1177.
+     *  Use {@link WritableStreamDefaultController.signal}'s `reason` instead.
      */
     get abortReason() {
         if (!IsWritableStreamDefaultController(this)) {
@@ -2272,6 +2280,8 @@ class WritableStreamDefaultController {
     }
 }
 Object.defineProperties(WritableStreamDefaultController.prototype, {
+    abortReason: { enumerable: true },
+    signal: { enumerable: true },
     error: { enumerable: true }
 });
 if (typeof SymbolPolyfill.toStringTag === 'symbol') {
@@ -3013,6 +3023,7 @@ function ReadableStreamTee(stream, cloneForBranch2) {
 function ReadableStreamDefaultTee(stream, cloneForBranch2) {
     const reader = AcquireReadableStreamDefaultReader(stream);
     let reading = false;
+    let readAgain = false;
     let canceled1 = false;
     let canceled2 = false;
     let reason1;
@@ -3025,6 +3036,7 @@ function ReadableStreamDefaultTee(stream, cloneForBranch2) {
     });
     function pullAlgorithm() {
         if (reading) {
+            readAgain = true;
             return promiseResolvedWith(undefined);
         }
         reading = true;
@@ -3034,7 +3046,7 @@ function ReadableStreamDefaultTee(stream, cloneForBranch2) {
                 // 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(() => {
-                    reading = false;
+                    readAgain = false;
                     const chunk1 = chunk;
                     const chunk2 = chunk;
                     // There is no way to access the cloning code right now in the reference implementation.
@@ -3048,6 +3060,10 @@ function ReadableStreamDefaultTee(stream, cloneForBranch2) {
                     if (!canceled2) {
                         ReadableStreamDefaultControllerEnqueue(branch2._readableStreamController, chunk2);
                     }
+                    reading = false;
+                    if (readAgain) {
+                        pullAlgorithm();
+                    }
                 });
             },
             _closeSteps: () => {
@@ -3106,6 +3122,8 @@ function ReadableStreamDefaultTee(stream, cloneForBranch2) {
 function ReadableByteStreamTee(stream) {
     let reader = AcquireReadableStreamDefaultReader(stream);
     let reading = false;
+    let readAgainForBranch1 = false;
+    let readAgainForBranch2 = false;
     let canceled1 = false;
     let canceled2 = false;
     let reason1;
@@ -3140,7 +3158,8 @@ function ReadableByteStreamTee(stream) {
                 // 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(() => {
-                    reading = false;
+                    readAgainForBranch1 = false;
+                    readAgainForBranch2 = false;
                     const chunk1 = chunk;
                     let chunk2 = chunk;
                     if (!canceled1 && !canceled2) {
@@ -3160,6 +3179,13 @@ function ReadableByteStreamTee(stream) {
                     if (!canceled2) {
                         ReadableByteStreamControllerEnqueue(branch2._readableStreamController, chunk2);
                     }
+                    reading = false;
+                    if (readAgainForBranch1) {
+                        pull1Algorithm();
+                    }
+                    else if (readAgainForBranch2) {
+                        pull2Algorithm();
+                    }
                 });
             },
             _closeSteps: () => {
@@ -3200,7 +3226,8 @@ function ReadableByteStreamTee(stream) {
                 // 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(() => {
-                    reading = false;
+                    readAgainForBranch1 = false;
+                    readAgainForBranch2 = false;
                     const byobCanceled = forBranch2 ? canceled2 : canceled1;
                     const otherCanceled = forBranch2 ? canceled1 : canceled2;
                     if (!otherCanceled) {
@@ -3222,6 +3249,13 @@ function ReadableByteStreamTee(stream) {
                     else if (!byobCanceled) {
                         ReadableByteStreamControllerRespondWithNewView(byobBranch._readableStreamController, chunk);
                     }
+                    reading = false;
+                    if (readAgainForBranch1) {
+                        pull1Algorithm();
+                    }
+                    else if (readAgainForBranch2) {
+                        pull2Algorithm();
+                    }
                 });
             },
             _closeSteps: chunk => {
@@ -3254,6 +3288,7 @@ function ReadableByteStreamTee(stream) {
     }
     function pull1Algorithm() {
         if (reading) {
+            readAgainForBranch1 = true;
             return promiseResolvedWith(undefined);
         }
         reading = true;
@@ -3268,6 +3303,7 @@ function ReadableByteStreamTee(stream) {
     }
     function pull2Algorithm() {
         if (reading) {
+            readAgainForBranch2 = true;
             return promiseResolvedWith(undefined);
         }
         reading = true;
@@ -3671,10 +3707,16 @@ function convertQueuingStrategyInit(init, context) {
 const byteLengthSizeFunction = (chunk) => {
     return chunk.byteLength;
 };
-Object.defineProperty(byteLengthSizeFunction, 'name', {
-    value: 'size',
-    configurable: true
-});
+try {
+    Object.defineProperty(byteLengthSizeFunction, 'name', {
+        value: 'size',
+        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
+}
 /**
  * A queuing strategy that counts the number of bytes in each chunk.
  *
@@ -3733,10 +3775,16 @@ function IsByteLengthQueuingStrategy(x) {
 const countSizeFunction = () => {
     return 1;
 };
-Object.defineProperty(countSizeFunction, 'name', {
-    value: 'size',
-    configurable: true
-});
+try {
+    Object.defineProperty(countSizeFunction, 'name', {
+        value: 'size',
+        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
+}
 /**
  * A queuing strategy that counts the number of chunks.
  *