流（Streams）

1. 如果 underlyingSource 缺失，则将其设为 null。

2. 令 underlyingSourceDict 为 underlyingSource，转换为类型为 UnderlyingSource 的 IDL 值。

   我们不能直接将 underlyingSource 参数声明为 UnderlyingSource 类型，否则会丢失原始对象的引用。我们需要保留该对象，以便调用其上的各种方法。

3. 执行 ! InitializeReadableStream(this)。

4. 如果 underlyingSourceDict["type"] 为 "bytes"：

   1. 如果 strategy["size"] 存在，则抛出 RangeError 异常。

   2. 令 highWaterMark 为 ? ExtractHighWaterMark(strategy, 0)。

   3. 执行 ? SetUpReadableByteStreamControllerFromUnderlyingSource(this, underlyingSource, underlyingSourceDict, highWaterMark)。

5. 否则，

   1. 断言：underlyingSourceDict["type"] 不存在。

   2. 令 sizeAlgorithm 为 ! ExtractSizeAlgorithm(strategy)。

   3. 令 highWaterMark 为 ? ExtractHighWaterMark(strategy, 1)。

   4. 执行 ? SetUpReadableStreamDefaultControllerFromUnderlyingSource(this, underlyingSource, underlyingSourceDict, highWaterMark, sizeAlgorithm)。

1. 返回 ? ReadableStreamFromIterable(asyncIterable)。

1. 返回 ! IsReadableStreamLocked(this)。

1. 如果 ! IsReadableStreamLocked(this) 为 true，则返回一个被拒绝的 promise，其原因是 TypeError 异常。

2. 返回 ! ReadableStreamCancel(this, reason)。

1. 如果 options["mode"] 不存在，则返回 ? AcquireReadableStreamDefaultReader(this)。

2. 断言：options["mode"] 的值为 "byob"。

3. 返回 ? AcquireReadableStreamBYOBReader(this)。

function readAllChunks(readableStream) {
  const reader = readableStream.getReader();
  const chunks = [];

  return pump();

  function pump() {
    return reader.read().then(({ value, done }) => {
      if (done) {
        return chunks;
      }

      chunks.push(value);
      return pump();
    });
  }
}

1. 如果 ! IsReadableStreamLocked(this) 为 true，则抛出 TypeError 异常。

2. 如果 ! IsWritableStreamLocked(transform["writable"]) 为 true，则抛出 TypeError 异常。

3. 令 signal 为 options["signal"]，如果存在则取该值，否则为 undefined。

4. 令 promise 为 ! ReadableStreamPipeTo(this, transform["writable"], options["preventClose"], options["preventAbort"], options["preventCancel"], signal)。

5. 将 promise.[[PromiseIsHandled]] 设为 true。

6. 返回 transform["readable"]。

httpResponseBody
  .pipeThrough(decompressorTransform)
  .pipeThrough(ignoreNonImageFilesTransform)
  .pipeTo(mediaGallery);

1. 如果 ! IsReadableStreamLocked(this) 为 true，返回一个被拒绝的 promise，其原因为 TypeError 异常。

2. 如果 ! IsWritableStreamLocked(destination) 为 true，返回一个被拒绝的 promise，其原因为 TypeError 异常。

3. 令 signal 为 options["signal"]，如果存在则取该值，否则为 undefined。

4. 返回 ! ReadableStreamPipeTo(this, destination, options["preventClose"], options["preventAbort"], options["preventCancel"], signal)。

const controller = new AbortController();
readable.pipeTo(writable, { signal: controller.signal });

// ... 之后的某个时刻 ...
controller.abort();

const controller = new AbortController();
const pipePromise = readable1.pipeTo(writable, { preventAbort: true, signal: controller.signal });

// ... 之后的某个时刻 ...
controller.abort();

// 等待管道完成后再启动新管道：
try {
 await pipePromise;
} catch (e) {
 // 预期 "AbortError" DOMException 可吞掉，其他错误需重新抛出。
 if (e.name !== "AbortError") {
  throw e;
 }
}

// 启动新的管道！
readable2.pipeTo(writable);

1. 返回 ? ReadableStreamTee(this, false)。

const [forLocal, forRemote] = readableStream.tee();

Promise.all([
  forLocal.pipeTo(cacheEntry),
  forRemote.pipeTo(httpRequestBody)
])
.then(() => console.log("已保存到缓存并上传！"))
.catch(e => console.error("缓存或上传失败：" , e));

1. 令 reader 为 ? AcquireReadableStreamDefaultReader(stream)。

2. 将 iterator 的 reader 设为 reader。

3. 令 preventCancel 为 args[0]["preventCancel"]。

4. 将 iterator 的 prevent cancel 设为 preventCancel。

1. 令 reader 为 iterator 的 reader。

2. 断言：reader.[[stream]] 不为 undefined。

3. 令 promise 为新建的 promise。

4. 令 readRequest 为新的读取请求（read request），包含以下条目：

   chunk steps，给定 chunk

   1. 解析 promise，值为 chunk。

   close steps

   1. 执行 ! ReadableStreamDefaultReaderRelease(reader)。

   2. 解析 promise，值为 迭代结束。

   error steps，给定 e

   1. 执行 ! ReadableStreamDefaultReaderRelease(reader)。

   2. 拒绝 promise，理由为 e。

5. 执行 ! ReadableStreamDefaultReaderRead(this, readRequest)。

6. 返回 promise。

1. 令 reader 为 iterator 的 reader。

2. 断言：reader.[[stream]] 不为 undefined。

3. 断言：reader.[[readRequests]] 为空（async iterator 机制保证所有之前对 next() 的调用都已 settle，才会调用此方法）。

4. 如果 iterator 的 prevent cancel 为 false：

   1. 令 result 为 ! ReadableStreamReaderGenericCancel(reader, arg)。

   2. 执行 ! ReadableStreamDefaultReaderRelease(reader)。

   3. 返回 result。

5. 执行 ! ReadableStreamDefaultReaderRelease(reader)。

6. 返回一个以 undefined 解决的 promise。

1. 如果 ! IsReadableStreamLocked(value) 为 true，则抛出 "DataCloneError" DOMException。

2. 令 port1 为在当前 Realm中新建的 MessagePort。

3. 令 port2 为在当前 Realm中新建的 MessagePort。

4. 关联 port1 和 port2。

5. 令 writable 为在当前 Realm中新建的 WritableStream。

6. 执行 ! SetUpCrossRealmTransformWritable(writable, port1)。

7. 令 promise 为 ! ReadableStreamPipeTo(value, writable, false, false, false)。

8. 将 promise.[[PromiseIsHandled]] 设为 true。

9. 将 dataHolder.[[port]] 设为 ! StructuredSerializeWithTransfer(port2, « port2 »)。

1. 令 deserializedRecord 为 ! StructuredDeserializeWithTransfer(dataHolder.[[port]], 当前 Realm)。

2. 令 port 为 deserializedRecord.[[Deserialized]]。

3. 执行 ! SetUpCrossRealmTransformReadable(value, port)。

1. 返回 this.[[closedPromise]]。

1. 如果 this.[[stream]] 为 undefined，则返回以 TypeError 异常拒绝的 promise。

2. 返回 ! ReadableStreamReaderGenericCancel(this, reason)。

1. 执行 ? SetUpReadableStreamDefaultReader(this, stream)。

1. 如果 this.[[stream]] 为 undefined，返回以 TypeError 异常拒绝的 promise。

2. 令 promise 为一个新的 promise。

3. 令 readRequest 为一个新的读取请求，包含以下项：

   分块步骤，给定 chunk

   1. 解析 promise，值为 «[ "value" → chunk, "done" → false ]»。

   关闭步骤

   1. 解析 promise，值为 «[ "value" → undefined, "done" → true ]»。

   错误步骤，给定 e

   1. 拒绝 promise，理由为 e。

4. 执行 ! ReadableStreamDefaultReaderRead(this, readRequest)。

5. 返回 promise。

1. 如果 this.[[stream]] 为 undefined，则返回。

2. 执行 ! ReadableStreamDefaultReaderRelease(this)。

1. 执行 ? SetUpReadableStreamBYOBReader(this, stream)。

1. 如果 view.[[ByteLength]] 为 0，返回以 TypeError 异常拒绝的 promise。

2. 如果 view.[[ViewedArrayBuffer]].[[ByteLength]] 为 0，返回以 TypeError 异常拒绝的 promise。

3. 如果 ! IsDetachedBuffer(view.[[ViewedArrayBuffer]]) 为 true，返回以 TypeError 异常拒绝的 promise。

4. 如果 options["min"] 为 0，返回以 TypeError 异常拒绝的 promise。

5. 如果 view 拥有 [[TypedArrayName]] 内部插槽，

   1. 如果 options["min"] > view.[[ArrayLength]]， 返回以 RangeError 异常拒绝的 promise。

6. 否则（即为 DataView），

   1. 如果 options["min"] > view.[[ByteLength]]， 返回以 RangeError 异常拒绝的 promise。

7. 如果 this.[[stream]] 为 undefined，返回以 TypeError 异常拒绝的 promise。

8. 令 promise 为一个新的 promise。

9. 令 readIntoRequest 为一个新的read-into 请求，包含以下项：

   分块步骤，给定 chunk

   1. 解析 promise，值为 «[ "value" → chunk, "done" → false ]»。

   关闭步骤，给定 chunk

   1. 解析 promise，值为 «[ "value" → chunk, "done" → true ]»。

   错误步骤，给定 e

   1. 拒绝 promise，理由为 e。

10. 执行 ! ReadableStreamBYOBReaderRead(this, view, options["min"], readIntoRequest).

11. 返回 promise。

1. 如果 this.[[stream]] 为 undefined，则返回。

2. 执行 ! ReadableStreamBYOBReaderRelease(this)。

1. 返回 ! ReadableStreamDefaultControllerGetDesiredSize(this)。

1. 如果 ! ReadableStreamDefaultControllerCanCloseOrEnqueue(this) 为 false，则抛出 TypeError 异常。

2. 执行 ! ReadableStreamDefaultControllerClose(this)。

1. 如果 ! ReadableStreamDefaultControllerCanCloseOrEnqueue(this) 为 false，则抛出 TypeError 异常。

2. 执行 ? ReadableStreamDefaultControllerEnqueue(this, chunk)。

1. 执行 ! ReadableStreamDefaultControllerError(this, e)。

1. 执行 ! ResetQueue(this)。

2. 令 result 为执行 this.[[cancelAlgorithm]]，传入 reason 的结果。

3. 执行 ! ReadableStreamDefaultControllerClearAlgorithms(this)。

4. 返回 result。

1. 令 stream 为 this.[[stream]]。

2. 如果 this.[[queue]] 非空，

   1. 令 chunk 为 ! DequeueValue(this)。

   2. 如果 this.[[closeRequested]] 为 true 且 this.[[queue]] 为空，

      1. 执行 ! ReadableStreamDefaultControllerClearAlgorithms(this)。

      2. 执行 ! ReadableStreamClose(stream).

   3. 否则，执行 ! ReadableStreamDefaultControllerCallPullIfNeeded(this)。

   4. 执行 readRequest 的 chunk steps，传入 chunk。

3. 否则，

   1. 执行 ! ReadableStreamAddReadRequest(stream, readRequest)。

   2. 执行 ! ReadableStreamDefaultControllerCallPullIfNeeded(this)。

1. 返回。

1. 返回 ! ReadableByteStreamControllerGetBYOBRequest(this)。

1. 返回 ! ReadableByteStreamControllerGetDesiredSize(this)。

1. 如果 this.[[closeRequested]] 为 true， 抛出 TypeError 异常。

2. 如果 this.[[stream]].[[state]] 不为 "readable"，抛出 TypeError 异常。

3. 执行 ? ReadableByteStreamControllerClose(this)。

1. 如果 chunk.[[ByteLength]] 为 0，抛出 TypeError 异常。

2. 如果 chunk.[[ViewedArrayBuffer]].[[ByteLength]] 为 0，抛出 TypeError 异常。

3. 如果 this.[[closeRequested]] 为 true， 抛出 TypeError 异常。

4. 如果 this.[[stream]].[[state]] 不为 "readable"，抛出 TypeError 异常。

5. 返回 ? ReadableByteStreamControllerEnqueue(this, chunk)。

1. 执行 ! ReadableByteStreamControllerError(this, e)。

1. 执行 ! ReadableByteStreamControllerClearPendingPullIntos(this)。

2. 执行 ! ResetQueue(this)。

3. 令 result 为执行 this.[[cancelAlgorithm]]，传入 reason 的结果。

4. 执行 ! ReadableByteStreamControllerClearAlgorithms(this)。

5. 返回 result。

1. 令 stream 为 this.[[stream]]。

2. 断言：! ReadableStreamHasDefaultReader(stream) 为 true。

3. 如果 this.[[queueTotalSize]] > 0，

   1. 断言：! ReadableStreamGetNumReadRequests(stream) 为 0。

   2. 执行 ! ReadableByteStreamControllerFillReadRequestFromQueue(this, readRequest)。

   3. 返回。

4. 令 autoAllocateChunkSize 为 this.[[autoAllocateChunkSize]]。

5. 如果 autoAllocateChunkSize 不为 undefined，

   1. 令 buffer 为 Construct(%ArrayBuffer%, « autoAllocateChunkSize »)。

   2. 如果 buffer 是异常完成，

      1. 执行 readRequest 的 error steps，参数为 buffer.[[Value]]。

      2. 返回。

   3. 令 pullIntoDescriptor 为一个新的pull-into 描述符，内容为

      buffer

      buffer.[[Value]]

      buffer byte length

      autoAllocateChunkSize

      byte offset

      0

      byte length

      autoAllocateChunkSize

      bytes filled

      0

      minimum fill

      1

      element size

      1

      view constructor

      %Uint8Array%

      reader type

      "default"

   4. 将 pullIntoDescriptor 添加到 this.[[pendingPullIntos]]。

6. 执行 ! ReadableStreamAddReadRequest(stream, readRequest)。

7. 执行 ! ReadableByteStreamControllerCallPullIfNeeded(this)。

1. 如果 this.[[pendingPullIntos]] 非 空，

   1. 令 firstPendingPullInto 为 this.[[pendingPullIntos]][0]。

   2. 将 firstPendingPullInto 的 reader type 设为 "none"。

   3. 将 this.[[pendingPullIntos]] 设为仅包含 firstPendingPullInto 的列表 « firstPendingPullInto »。

1. 返回 this.[[view]]。

1. 如果 this.[[controller]] 为 undefined，则抛出 TypeError 异常。

2. 如果 ! IsDetachedBuffer(this.[[view]].[[ArrayBuffer]]) 为 true，则抛出 TypeError 异常。

3. 断言：this.[[view]].[[ByteLength]] > 0。

4. 断言：this.[[view]].[[ViewedArrayBuffer]].[[ByteLength]] > 0。

5. 执行 ? ReadableByteStreamControllerRespond(this.[[controller]], bytesWritten)。

1. 如果 this.[[controller]] 为 undefined，则抛出 TypeError 异常。

2. 如果 ! IsDetachedBuffer(view.[[ViewedArrayBuffer]]) 为 true， 则抛出 TypeError 异常。

3. 返回 ? ReadableByteStreamControllerRespondWithNewView(this.[[controller]], view)。

1. 令 reader 为 新建的 ReadableStreamBYOBReader。

2. 执行 ? SetUpReadableStreamBYOBReader(reader, stream)。

3. 返回 reader。

1. 令 reader 为 新建的 ReadableStreamDefaultReader。

2. 执行 ? SetUpReadableStreamDefaultReader(reader, stream)。

3. 返回 reader。

1. 如果未传入 highWaterMark，则设为 1。

2. 如果未传入 sizeAlgorithm，则设为一个返回 1 的算法。

3. 断言：! IsNonNegativeNumber(highWaterMark) 为 true。

4. 令 stream 为 新建的 ReadableStream。

5. 执行 ! InitializeReadableStream(stream)。

6. 令 controller 为 新建的 ReadableStreamDefaultController。

7. 执行 ? SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm)。

8. 返回 stream。

本抽象操作仅当传入的 startAlgorithm 抛出异常时才会抛出异常。

1. 令 stream 为 新建的 ReadableStream。

2. 执行 ! InitializeReadableStream(stream)。

3. 令 controller 为 新建的 ReadableByteStreamController。

4. 执行 ? SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, 0, undefined)。

5. 返回 stream。

本抽象操作仅当传入的 startAlgorithm 抛出异常时才会抛出异常。

1. 将 stream.[[state]] 设为 "readable"。

2. 将 stream.[[reader]] 和 stream.[[storedError]] 设为 undefined。

3. 将 stream.[[disturbed]] 设为 false。

1. 如果 stream.[[reader]] 为 undefined，返回 false。

2. 返回 true。

1. 令 stream 为 undefined。

2. 令 iteratorRecord 为 ? GetIterator(asyncIterable, async)。

3. 令 startAlgorithm 为一个返回 undefined 的算法。

4. 令 pullAlgorithm 为以下步骤：

   1. 令 nextResult 为 IteratorNext(iteratorRecord)。

   2. 如果 nextResult 是异常完成，返回 以 nextResult.[[Value]] 拒绝的 promise。

   3. 令 nextPromise 为 以 nextResult.[[Value]] 解决的 promise。

   4. 返回对 nextPromise 反应的结果，满足时执行如下步骤，参数 iterResult：

      1. 如果 iterResult 不是对象，抛出 TypeError。

      2. 令 done 为 ? IteratorComplete(iterResult)。

      3. 如果 done 为 true：

         1. 执行 ! ReadableStreamDefaultControllerClose(stream.[[controller]])。

      4. 否则：

         1. 令 value 为 ? IteratorValue(iterResult)。

         2. 执行 ! ReadableStreamDefaultControllerEnqueue(stream.[[controller]], value)。

5. 令 cancelAlgorithm 为以下步骤，参数 reason：

   1. 令 iterator 为 iteratorRecord.[[Iterator]]。

   2. 令 returnMethod 为 GetMethod(iterator, "return")。

   3. 如果 returnMethod 是异常完成，返回 以 returnMethod.[[Value]] 拒绝的 promise。

   4. 如果 returnMethod.[[Value]] 为 undefined，返回 以 undefined 解决的 promise。

   5. 令 returnResult 为 Call(returnMethod.[[Value]], iterator, « reason »)。

   6. 如果 returnResult 是异常完成，返回 以 returnResult.[[Value]] 拒绝的 promise。

   7. 令 returnPromise 为 以 returnResult.[[Value]] 解决的 promise。

   8. 返回对 returnPromise 反应的结果，满足时执行如下步骤，参数 iterResult：

      1. 如果 iterResult 不是对象，抛出 TypeError。

      2. 返回 undefined。

6. 将 stream 设为 ! CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, 0)。

7. 返回 stream。

1. 断言：source 实现了 ReadableStream。

2. 断言：dest 实现了 WritableStream。

3. 断言：preventClose、preventAbort 和 preventCancel 都是布尔值。

4. 如果未传入 signal，则令 signal 为 undefined。

5. 断言：signal 要么为 undefined，要么 signal 实现了 AbortSignal。

6. 断言：! IsReadableStreamLocked(source) 为 false。

7. 断言：! IsWritableStreamLocked(dest) 为 false。

8. 如果 source.[[controller]] 实现了 ReadableByteStreamController， 则令 reader 为 ! AcquireReadableStreamBYOBReader(source) 或 ! AcquireReadableStreamDefaultReader(source), 由 user agent 自行决定。

9. 否则，令 reader 为 ! AcquireReadableStreamDefaultReader(source)。

10. 令 writer 为 ! AcquireWritableStreamDefaultWriter(dest)。

11. 将 source.[[disturbed]] 设为 true。

12. 令 shuttingDown 为 false。

13. 令 promise 为一个新的 promise。

14. 如果 signal 不为 undefined，

    1. 令 abortAlgorithm 为以下步骤：

       1. 令 error 为 signal 的 中止原因。

       2. 令 actions 为一个空的有序集合。

       3. 如果 preventAbort 为 false，添加以下 action 到 actions 中：

          1. 如果 dest.[[state]] 为 "writable"，返回 ! WritableStreamAbort(dest, error)。

          2. 否则，返回 以 undefined 解决的 promise。

       4. 如果 preventCancel 为 false，添加以下 action 到 actions 中：

          1. 如果 source.[[state]] 为 "readable"，返回 ! ReadableStreamCancel(source, error)。

          2. 否则，返回 以 undefined 解决的 promise。

       5. 带有 action 的关闭，action 为等待所有 actions 的 promise，error 为 error。

    2. 如果 signal 已中止，执行 abortAlgorithm 并返回 promise。

    3. 添加 abortAlgorithm 到 signal。

15. 并行 但实际上不是；参见 #905，使用 reader 和 writer，从 source 读取所有块并写入 dest。由于 reader 和 writer 提供的锁定机制，具体实现方式对作者代码不可见，因此有灵活性。无论实现方式如何，都必须遵循以下约束：

    • 禁止使用公共 API： 在读取或写入，或执行下面的任何操作时，不得使用 JS 可修改的 reader、writer 和 stream API（即相关原型上的方法）。必须直接操作流对象。

    • 必须执行背压：

      • 当 WritableStreamDefaultWriterGetDesiredSize(writer) ≤ 0 或为 null 时，不得从 reader 读取。

      • 如果 reader 是 BYOB reader，应以 WritableStreamDefaultWriterGetDesiredSize(writer) 作为读取块大小的参考。

        读取过大或过小的块通常效率较低。可结合其他信息综合确定最佳块大小。

      • 读取或写入不应因背压信号外的其他原因被延迟。

        如等待每次写入完成后才进行下一次读写，会导致 内部队列失效，始终最多只保留一个块。

    • Shutdown 必须停止活动： 若 shuttingDown 变为 true，则不得再从 reader 读取，只能写入已读取的块。在每次读写前都要检查 shutdown 状态。

    • 必须传播错误和关闭状态： 下列条件按顺序应用：

      1. 必须向前传播错误： 如果 source.[[state]] 为或变为 "errored"，则：

         1. 若 preventAbort 为 false，带有 action 的关闭，action 为 ! WritableStreamAbort(dest, source.[[storedError]])，error 为 source.[[storedError]]。

         2. 否则，关闭，error 为 source.[[storedError]]。

      2. 必须向后传播错误： 如果 dest.[[state]] 为或变为 "errored"，则：

         1. 若 preventCancel 为 false，带有 action 的关闭，action 为 ! ReadableStreamCancel(source, dest.[[storedError]])，error 为 dest.[[storedError]]。

         2. 否则，关闭，error 为 dest.[[storedError]]。

      3. 必须向前传播关闭： 如果 source.[[state]] 为或变为 "closed"，则：

         1. 若 preventClose 为 false，带有 action 的关闭，action 为 ! WritableStreamDefaultWriterCloseWithErrorPropagation(writer)。

         2. 否则，关闭。

      4. 必须向后传播关闭： 如果 ! WritableStreamCloseQueuedOrInFlight(dest) 为 true 或 dest.[[state]] 为 "closed"， 则：

         1. 断言：未读未写任何块。

         2. 令 destClosed 为新的 TypeError。

         3. 若 preventCancel 为 false，带有 action 的关闭，action 为 ! ReadableStreamCancel(source, destClosed)，error 为 destClosed。

         4. 否则，关闭，error 为 destClosed。

    • 带有 action 的关闭：如有上述要求需要带有 action 的关闭，action 为 action，可选 error 为 originalError，则：

      1. 若 shuttingDown 为 true，终止以下子步骤。

      2. 将 shuttingDown 设为 true。

      3. 如果 dest.[[state]] 为 "writable" 且 ! WritableStreamCloseQueuedOrInFlight(dest) 为 false，

         1. 若有已读但未写的块，写入 dest。

         2. 等待所有已读已写操作（即 promise 已 settle）。

      4. 令 p 为执行 action 的结果。

      5. 当 p 完成时，finalize，传递 originalError（如有）。

      6. 当 p 拒绝时，finalize，error 为 newError。

    • 关闭：如有上述要求或步骤需要关闭，可选 error 为 error，则：

      1. 若 shuttingDown 为 true，终止以下子步骤。

      2. 将 shuttingDown 设为 true。

      3. 如果 dest.[[state]] 为 "writable" 且 ! WritableStreamCloseQueuedOrInFlight(dest) 为 false，

         1. 若有已读但未写的块，写入 dest。

         2. 等待所有已读已写操作（即 promise 已 settle）。

      4. finalize，传递 error（如有）。

    • finalize：上述两种关闭最终都会要求 finalize，可选 error error，步骤如下：

      1. 执行 ! WritableStreamDefaultWriterRelease(writer)。

      2. 如果 reader 实现了 ReadableStreamBYOBReader， 执行 ! ReadableStreamBYOBReaderRelease(reader)。

      3. 否则，执行 ! ReadableStreamDefaultReaderRelease(reader)。

      4. 如果 signal 不为 undefined，移除 abortAlgorithm。

      5. 如果有 error，拒绝 promise，error 为 error。

      6. 否则，解决 promise，值为 undefined。

16. 返回 promise。

第二个参数 cloneForBranch2 控制原始流中的数据是否会在出现在返回的第二个分支前被克隆（使用 HTML 的 可序列化对象机制）。这对于两分支都会以会互相干扰的方式消费，例如转移其块的场景很有用。但这样会导致两个分支不对称，并限制块必须可序列化。[HTML]

如果 stream 是可读字节流，则 cloneForBranch2 被忽略，块始终无条件克隆。

在本标准中，ReadbleStreamTee 总是以 cloneForBranch2 为 false 调用；其他规范会通过 tee 包装算法传递 true。

执行以下步骤：

1. 断言：stream 实现了 ReadableStream。

2. 断言：cloneForBranch2 为布尔值。

3. 如果 stream.[[controller]] 实现了 ReadableByteStreamController， 返回 ? ReadableByteStreamTee(stream)。

4. 否则，返回 ? ReadableStreamDefaultTee(stream, cloneForBranch2)。

1. 断言：stream 实现了 ReadableStream。

2. 断言：cloneForBranch2 为布尔值。

3. 令 reader 为 ? AcquireReadableStreamDefaultReader(stream)。

4. 令 reading 为 false。

5. 令 readAgain 为 false。

6. 令 canceled1 为 false。

7. 令 canceled2 为 false。

8. 令 reason1 为 undefined。

9. 令 reason2 为 undefined。

10. 令 branch1 为 undefined。

11. 令 branch2 为 undefined。

12. 令 cancelPromise 为一个新的 promise。

13. 令 pullAlgorithm 为以下步骤：

    1. 如果 reading 为 true，

       1. 设 readAgain 为 true。

       2. 返回 以 undefined 解决的 promise。

    2. 设 reading 为 true。

    3. 令 readRequest 为一个读取请求，包含如下项：

       chunk steps，参数 chunk

       1. 队列一个 microtask执行如下步骤：

          1. 设 readAgain 为 false。

          2. 令 chunk1 和 chunk2 皆为 chunk。

          3. 如果 canceled2 为 false 且 cloneForBranch2 为 true，

             1. 令 cloneResult 为 StructuredClone(chunk2)。

             2. 如果 cloneResult 是异常完成，

                1. 执行 ! ReadableStreamDefaultControllerError(branch1.[[controller]], cloneResult.[[Value]])。

                2. 执行 ! ReadableStreamDefaultControllerError(branch2.[[controller]], cloneResult.[[Value]])。

                3. 解决 cancelPromise，值为 ! ReadableStreamCancel(stream, cloneResult.[[Value]])。

                4. 返回。

             3. 否则，设 chunk2 为 cloneResult.[[Value]]。

          4. 如果 canceled1 为 false，执行 ! ReadableStreamDefaultControllerEnqueue(branch1.[[controller]], chunk1)。

          5. 如果 canceled2 为 false，执行 ! ReadableStreamDefaultControllerEnqueue(branch2.[[controller]], chunk2)。

          6. 设 reading 为 false。

          7. 如果 readAgain 为 true，执行 pullAlgorithm。

       这里的 microtask 延迟是必要的，因为要检测错误至少需要一个 microtask（见下文 reader.[[closedPromise]]）。 这样才能保证流的错误会立即传递到两个分支，而不会先发生成功同步读取。

       close steps

       1. 设 reading 为 false。

       2. 如果 canceled1 为 false，执行 ! ReadableStreamDefaultControllerClose(branch1.[[controller]])。

       3. 如果 canceled2 为 false，执行 ! ReadableStreamDefaultControllerClose(branch2.[[controller]])。

       4. 如果 canceled1 为 false 或 canceled2 为 false，解决 cancelPromise，值为 undefined。

       error steps

       1. 设 reading 为 false。

    4. 执行 ! ReadableStreamDefaultReaderRead(reader, readRequest)。

    5. 返回 以 undefined 解决的 promise。

14. 令 cancel1Algorithm 为以下步骤，参数 reason：

    1. 设 canceled1 为 true。

    2. 设 reason1 为 reason。

    3. 如果 canceled2 为 true，

       1. 令 compositeReason 为 ! CreateArrayFromList(« reason1, reason2 »)。

       2. 令 cancelResult 为 ! ReadableStreamCancel(stream, compositeReason)。

       3. 解决 cancelPromise，值为 cancelResult。

    4. 返回 cancelPromise。

15. 令 cancel2Algorithm 为以下步骤，参数 reason：

    1. 设 canceled2 为 true。

    2. 设 reason2 为 reason。

    3. 如果 canceled1 为 true，

       1. 令 compositeReason 为 ! CreateArrayFromList(« reason1, reason2 »)。

       2. 令 cancelResult 为 ! ReadableStreamCancel(stream, compositeReason)。

       3. 解决 cancelPromise，值为 cancelResult。

    4. 返回 cancelPromise。

16. 令 startAlgorithm 为一个返回 undefined 的算法。

17. 设 branch1 为 ! CreateReadableStream(startAlgorithm, pullAlgorithm, cancel1Algorithm)。

18. 设 branch2 为 ! CreateReadableStream(startAlgorithm, pullAlgorithm, cancel2Algorithm)。

19. 当拒绝 reader.[[closedPromise]]，原因为 r，

    1. 执行 ! ReadableStreamDefaultControllerError(branch1.[[controller]], r)。

    2. 执行 ! ReadableStreamDefaultControllerError(branch2.[[controller]], r)。

    3. 如果 canceled1 为 false 或 canceled2 为 false，解决 cancelPromise，值为 undefined。

20. 返回 « branch1, branch2 »。

1. 断言：stream 实现了 ReadableStream。

2. 断言：stream.[[controller]] 实现了 ReadableByteStreamController。

3. 令 reader 为 ? AcquireReadableStreamDefaultReader(stream)。

4. 令 reading 为 false。

5. 令 readAgainForBranch1 为 false。

6. 令 readAgainForBranch2 为 false。

7. 令 canceled1 为 false。

8. 令 canceled2 为 false。

9. 令 reason1 为 undefined。

10. 令 reason2 为 undefined。

11. 令 branch1 为 undefined。

12. 令 branch2 为 undefined。

13. 令 cancelPromise 为一个新的 promise。

14. 令 forwardReaderError 为下述步骤，参数 thisReader：

    1. 当拒绝 thisReader.[[closedPromise]]，原因为 r，

       1. 如果 thisReader 不等于 reader，返回。

       2. 执行 ! ReadableByteStreamControllerError(branch1.[[controller]], r)。

       3. 执行 ! ReadableByteStreamControllerError(branch2.[[controller]], r)。

       4. 若 canceled1 为 false 或 canceled2 为 false，解决 cancelPromise，值为 undefined。

15. 令 pullWithDefaultReader 为下述步骤：

    1. 如果 reader 实现了 ReadableStreamBYOBReader，

       1. 断言：reader.[[readIntoRequests]] 为空。

       2. 执行 ! ReadableStreamBYOBReaderRelease(reader)。

       3. 设 reader 为 ! AcquireReadableStreamDefaultReader(stream)。

       4. 执行 forwardReaderError，参数 reader。

    2. 令 readRequest 为一个读取请求，包含如下项：

       chunk steps，参数 chunk

       1. 队列一个 microtask，执行以下步骤：

          1. 设 readAgainForBranch1 和 readAgainForBranch2 均为 false。

          2. 令 chunk1 和 chunk2 都为 chunk。

          3. 若 canceled1 和 canceled2 均为 false，

             1. 令 cloneResult 为 CloneAsUint8Array(chunk)。

             2. 若 cloneResult 为异常完成，

                1. 执行 ! ReadableByteStreamControllerError(branch1.[[controller]], cloneResult.[[Value]])。

                2. 执行 ! ReadableByteStreamControllerError(branch2.[[controller]], cloneResult.[[Value]])。

                3. 解决 cancelPromise，值为 ! ReadableStreamCancel(stream, cloneResult.[[Value]])。

                4. 返回。

             3. 否则，设 chunk2 为 cloneResult.[[Value]]。

          4. 若 canceled1 为 false，执行 ! ReadableByteStreamControllerEnqueue(branch1.[[controller]], chunk1)。

          5. 若 canceled2 为 false，执行 ! ReadableByteStreamControllerEnqueue(branch2.[[controller]], chunk2)。

          6. 设 reading 为 false。

          7. 若 readAgainForBranch1 为 true，执行 pull1Algorithm。

          8. 否则如 readAgainForBranch2 为 true，执行 pull2Algorithm。

       此处 microtask 延迟是必要的，因为要检测错误至少需要一个 microtask，见下文 reader.[[closedPromise]]。 这样可保证流错误立即传递到两个分支，而不会让同步读取领先于异步错误。

       close steps

       1. 设 reading 为 false。

       2. 若 canceled1 为 false，执行 ! ReadableByteStreamControllerClose(branch1.[[controller]])。

       3. 若 canceled2 为 false，执行 ! ReadableByteStreamControllerClose(branch2.[[controller]])。

       4. 若 branch1.[[controller]].[[pendingPullIntos]] 非空，执行 ! ReadableByteStreamControllerRespond(branch1.[[controller]], 0)。

       5. 若 branch2.[[controller]].[[pendingPullIntos]] 非空，执行 ! ReadableByteStreamControllerRespond(branch2.[[controller]], 0)。

       6. 若 canceled1 为 false 或 canceled2 为 false，解决 cancelPromise，值为 undefined。

       error steps

       1. 设 reading 为 false。

    3. 执行 ! ReadableStreamDefaultReaderRead(reader, readRequest)。

16. 令 pullWithBYOBReader 为下述步骤，参数 view 和 forBranch2：

    1. 如果 reader 实现了 ReadableStreamDefaultReader，

       1. 断言：reader.[[readRequests]] 为空。

       2. 执行 ! ReadableStreamDefaultReaderRelease(reader)。

       3. 设 reader 为 ! AcquireReadableStreamBYOBReader(stream)。

       4. 执行 forwardReaderError，参数 reader。

    2. 令 byobBranch 为 branch2 若 forBranch2 为 true，否则为 branch1。

    3. 令 otherBranch 为 branch2 若 forBranch2 为 false，否则为 branch1。

    4. 令 readIntoRequest 为一个read-into 请求，包含如下项：

       chunk steps，参数 chunk

       1. 队列一个 microtask，执行以下步骤：

          1. 设 readAgainForBranch1、readAgainForBranch2 均为 false。

          2. 令 byobCanceled 为 canceled2 若 forBranch2 为 true，否则为 canceled1。

          3. 令 otherCanceled 为 canceled2 若 forBranch2 为 false，否则为 canceled1。

          4. 若 otherCanceled 为 false，

             1. 令 cloneResult 为 CloneAsUint8Array(chunk)。

             2. 若 cloneResult 为异常完成，

                1. 执行 ! ReadableByteStreamControllerError(byobBranch.[[controller]], cloneResult.[[Value]])。

                2. 执行 ! ReadableByteStreamControllerError(otherBranch.[[controller]], cloneResult.[[Value]])。

                3. 解决 cancelPromise，值为 ! ReadableStreamCancel(stream, cloneResult.[[Value]])。

                4. 返回。

             3. 否则，令 clonedChunk 为 cloneResult.[[Value]]。

             4. 若 byobCanceled 为 false，执行 ! ReadableByteStreamControllerRespondWithNewView(byobBranch.[[controller]], chunk)。

             5. 执行 ! ReadableByteStreamControllerEnqueue(otherBranch.[[controller]], clonedChunk)。

          5. 否则如 byobCanceled 为 false，执行 ! ReadableByteStreamControllerRespondWithNewView(byobBranch.[[controller]], chunk)。

          6. 设 reading 为 false。

          7. 若 readAgainForBranch1 为 true，执行 pull1Algorithm。

          8. 否则如 readAgainForBranch2 为 true，执行 pull2Algorithm。

       此处 microtask 延迟是必要的，因为要检测错误至少需要一个 microtask，见下文 reader.[[closedPromise]]。 这样可保证流错误立即传递到两个分支，而不会让同步读取领先于异步错误。

       close steps，参数 chunk

       1. 设 reading 为 false。

       2. 令 byobCanceled 为 canceled2 若 forBranch2 为 true，否则为 canceled1。

       3. 令 otherCanceled 为 canceled2 若 forBranch2 为 false，否则为 canceled1。

       4. 若 byobCanceled 为 false，执行 ! ReadableByteStreamControllerClose(byobBranch.[[controller]])。

       5. 若 otherCanceled 为 false，执行 ! ReadableByteStreamControllerClose(otherBranch.[[controller]])。

       6. 如果 chunk 不为 undefined，

          1. 断言：chunk.[[ByteLength]] 为 0。

          2. 若 byobCanceled 为 false，执行 ! ReadableByteStreamControllerRespondWithNewView(byobBranch.[[controller]], chunk)。

          3. 若 otherCanceled 为 false 且 otherBranch.[[controller]].[[pendingPullIntos]] 非空，执行 ! ReadableByteStreamControllerRespond(otherBranch.[[controller]], 0)。

       7. 若 byobCanceled 为 false 或 otherCanceled 为 false， 解决 cancelPromise，值为 undefined。

       error steps

       1. 设 reading 为 false。

    5. 执行 ! ReadableStreamBYOBReaderRead(reader, view, 1, readIntoRequest)。

17. 令 pull1Algorithm 为下述步骤：

    1. 若 reading 为 true，

       1. 设 readAgainForBranch1 为 true。

       2. 返回 以 undefined 解决的 promise。

    2. 设 reading 为 true。

    3. 令 byobRequest 为 ! ReadableByteStreamControllerGetBYOBRequest(branch1.[[controller]])。

    4. 若 byobRequest 为 null，执行 pullWithDefaultReader。

    5. 否则，执行 pullWithBYOBReader，参数为 byobRequest.[[view]] 和 false。

    6. 返回 以 undefined 解决的 promise。

18. 令 pull2Algorithm 为下述步骤：

    1. 若 reading 为 true，

       1. 设 readAgainForBranch2 为 true。

       2. 返回 以 undefined 解决的 promise。

    2. 设 reading 为 true。

    3. 令 byobRequest 为 ! ReadableByteStreamControllerGetBYOBRequest(branch2.[[controller]])。

    4. 若 byobRequest 为 null，执行 pullWithDefaultReader。

    5. 否则，执行 pullWithBYOBReader，参数为 byobRequest.[[view]] 和 true。

    6. 返回 以 undefined 解决的 promise。

19. 令 cancel1Algorithm 为下述步骤，参数 reason：

    1. 设 canceled1 为 true。

    2. 设 reason1 为 reason。

    3. 若 canceled2 为 true，

       1. 令 compositeReason 为 ! CreateArrayFromList(« reason1, reason2 »)。

       2. 令 cancelResult 为 ! ReadableStreamCancel(stream, compositeReason)。

       3. 解决 cancelPromise，值为 cancelResult。

    4. 返回 cancelPromise。

20. 令 cancel2Algorithm 为下述步骤，参数 reason：

    1. 设 canceled2 为 true。

    2. 设 reason2 为 reason。

    3. 若 canceled1 为 true，

       1. 令 compositeReason 为 ! CreateArrayFromList(« reason1, reason2 »)。

       2. 令 cancelResult 为 ! ReadableStreamCancel(stream, compositeReason)。

       3. 解决 cancelPromise，值为 cancelResult。

    4. 返回 cancelPromise。

21. 令 startAlgorithm 为一个返回 undefined 的算法。

22. 设 branch1 为 ! CreateReadableByteStream(startAlgorithm, pull1Algorithm, cancel1Algorithm)。

23. 设 branch2 为 ! CreateReadableByteStream(startAlgorithm, pull2Algorithm, cancel2Algorithm)。

24. 执行 forwardReaderError，参数 reader。

25. 返回 « branch1, branch2 »。

1. 断言：stream.[[reader]] 实现了 ReadableStreamBYOBReader。

2. 断言：stream.[[state]] 为 "readable" 或 "closed"。

3. 追加 readRequest 到 stream.[[reader]].[[readIntoRequests]]。

1. 断言：stream.[[reader]] 实现了 ReadableStreamDefaultReader。

2. 断言：stream.[[state]] 为 "readable"。

3. 追加 readRequest 到 stream.[[reader]].[[readRequests]]。

1. 将 stream.[[disturbed]] 设为 true。

2. 如果 stream.[[state]] 为 "closed"，返回 以 undefined 解决的 promise。

3. 如果 stream.[[state]] 为 "errored"，返回 以 stream.[[storedError]] 拒绝的 promise。

4. 执行 ! ReadableStreamClose(stream)。

5. 令 reader 为 stream.[[reader]]。

6. 如果 reader 不为 undefined 且 reader 实现了 ReadableStreamBYOBReader，

   1. 令 readIntoRequests 为 reader.[[readIntoRequests]]。

   2. 将 reader.[[readIntoRequests]] 设为空 列表。

   3. 对于每个 readIntoRequest 属于 readIntoRequests，

      1. 以 undefined 作为参数，执行 readIntoRequest 的 close steps。

7. 令 sourceCancelPromise 为 ! stream.[[controller]].[[CancelSteps]](reason)。

8. 返回 对 sourceCancelPromise 的反应，fulfilled 时返回 undefined。

1. 断言：stream.[[state]] 为 "readable"。

2. 将 stream.[[state]] 设为 "closed"。

3. 令 reader 为 stream.[[reader]]。

4. 如果 reader 未定义，返回。

5. 解决 reader.[[closedPromise]]，值为 undefined。

6. 如果 reader 实现了 ReadableStreamDefaultReader，

   1. 令 readRequests 为 reader.[[readRequests]]。

   2. 将 reader.[[readRequests]] 设为空 列表。

   3. 对于每个 readRequest 属于 readRequests，

      1. 执行 readRequest 的 close steps。

1. 断言：stream.[[state]] 为 "readable"。

2. 将 stream.[[state]] 设为 "errored"。

3. 将 stream.[[storedError]] 设为 e。

4. 令 reader 为 stream.[[reader]]。

5. 如果 reader 未定义，返回。

6. 拒绝 reader.[[closedPromise]]，原因为 e。

7. 将 reader.[[closedPromise]].[[PromiseIsHandled]] 设为 true。

8. 如果 reader 实现了 ReadableStreamDefaultReader，

   1. 执行 !ReadableStreamDefaultReaderErrorReadRequests(reader, e)。

9. 否则，

   1. 断言：reader 实现了 ReadableStreamBYOBReader。

   2. 执行 !ReadableStreamBYOBReaderErrorReadIntoRequests(reader, e)。

1. 断言：!ReadableStreamHasBYOBReader(stream) 为 true。

2. 令 reader 为 stream.[[reader]]。

3. 断言：reader.[[readIntoRequests]] 不为 空。

4. 令 readIntoRequest 为 reader.[[readIntoRequests]][0]。

5. 移除 readIntoRequest 从 reader.[[readIntoRequests]]。

6. 如果 done 为 true，执行 readIntoRequest 的 close steps，参数为 chunk。

7. 否则，执行 readIntoRequest 的 chunk steps，参数为 chunk。

1. 断言：!ReadableStreamHasDefaultReader(stream) 为 true。

2. 令 reader 为 stream.[[reader]]。

3. 断言：reader.[[readRequests]] 不为 空。

4. 令 readRequest 为 reader.[[readRequests]][0]。

5. 移除 readRequest 从 reader.[[readRequests]]。

6. 如果 done 为 true，执行 readRequest 的 close steps。

7. 否则，执行 readRequest 的 chunk steps，参数为 chunk。

1. 断言：!ReadableStreamHasBYOBReader(stream) 为 true。

2. 返回 stream.[[reader]].[[readIntoRequests]] 的 大小。

1. 断言：!ReadableStreamHasDefaultReader(stream) 为 true。

2. 返回 stream.[[reader]].[[readRequests]] 的 大小。

1. 令 reader 为 stream.[[reader]]。

2. 如果 reader 未定义，返回 false。

3. 如果 reader 实现了 ReadableStreamBYOBReader，返回 true。

4. 返回 false。

1. 令 reader 为 stream.[[reader]]。

2. 如果 reader 未定义，返回 false。

3. 如果 reader 实现了 ReadableStreamDefaultReader，返回 true。

4. 返回 false。

1. 令 stream 为 reader.[[stream]]。

2. 断言：stream 不为 undefined。

3. 返回 !ReadableStreamCancel(stream, reason)。

1. 将 reader.[[stream]] 设为 stream。

2. 将 stream.[[reader]] 设为 reader。

3. 如果 stream.[[state]] 为 "readable"，

   1. 将 reader.[[closedPromise]] 设为新的 promise。

4. 否则，如果 stream.[[state]] 为 "closed"，

   1. 将 reader.[[closedPromise]] 设为以 undefined 解决的 promise。

5. 否则，

   1. 断言：stream.[[state]] 为 "errored"。

   2. 将 reader.[[closedPromise]] 设置为 一个被拒绝的 promise， 原因为 stream.[[storedError]]。

   3. 将 reader.[[closedPromise]].[[PromiseIsHandled]] 设为 true。

1. 令 stream 为 reader.[[stream]]。

2. 断言：stream 不为 undefined。

3. 断言：stream.[[reader]] 为 reader。

4. 如果 stream.[[state]] 为 "readable"，拒绝 reader.[[closedPromise]]，原因为 TypeError 异常。

5. 否则，将 reader.[[closedPromise]] 设置为 一个被拒绝的 promise， 原因为 TypeError 异常。

6. 将 reader.[[closedPromise]].[[PromiseIsHandled]] 设为 true。

7. 执行 !stream.[[controller]].[[ReleaseSteps]]()。

8. 将 stream.[[reader]] 设为 undefined。

9. 将 reader.[[stream]] 设为 undefined。

1. 令 readIntoRequests 为 reader.[[readIntoRequests]]。

2. 将 reader.[[readIntoRequests]] 设为一个新的空 列表。

3. 对于每个 readIntoRequest 属于 readIntoRequests，

   1. 以 e 作为参数，执行 readIntoRequest 的 error steps。

1. 令 stream 为 reader.[[stream]]。

2. 断言：stream 不为 undefined。

3. 将 stream.[[disturbed]] 设为 true。

4. 如果 stream.[[state]] 为 "errored"，以 stream.[[storedError]] 作为参数，执行 readIntoRequest 的 error steps。

5. 否则，执行 !ReadableByteStreamControllerPullInto(stream.[[controller]], view, min, readIntoRequest)。

1. 执行 !ReadableStreamReaderGenericRelease(reader)。

2. 令 e 为一个新的 TypeError 异常。

3. 执行 !ReadableStreamBYOBReaderErrorReadIntoRequests(reader, e)。

1. 令 readRequests 为 reader.[[readRequests]]。

2. 将 reader.[[readRequests]] 设为新的空 列表。

3. 对于每个 readRequest 属于 readRequests，

   1. 以 e 作为参数，执行 readRequest 的 error steps。

1. 令 stream 为 reader.[[stream]]。

2. 断言：stream 不为 undefined。

3. 将 stream.[[disturbed]] 设为 true。

4. 如果 stream.[[state]] 为 "closed"，执行 readRequest 的 close steps。

5. 否则，如果 stream.[[state]] 为 "errored"，以 stream.[[storedError]] 作为参数，执行 readRequest 的 error steps。

6. 否则，

   1. 断言：stream.[[state]] 为 "readable"。

   2. 执行 !stream.[[controller]].[[PullSteps]](readRequest)。

1. 执行 !ReadableStreamReaderGenericRelease(reader)。

2. 令 e 为一个新的 TypeError 异常。

3. 执行 !ReadableStreamDefaultReaderErrorReadRequests(reader, e)。

1. 如果 !IsReadableStreamLocked(stream) 为 true，抛出 TypeError 异常。

2. 如果 stream.[[controller]] 未实现 ReadableByteStreamController， 抛出 TypeError 异常。

3. 执行 !ReadableStreamReaderGenericInitialize(reader, stream)。

4. 将 reader.[[readIntoRequests]] 设为新的空 列表。

1. 如果 !IsReadableStreamLocked(stream) 为 true，抛出 TypeError 异常。

2. 执行 !ReadableStreamReaderGenericInitialize(reader, stream)。

3. 将 reader.[[readRequests]] 设为新的空 列表。

1. 令 shouldPull 为 !ReadableStreamDefaultControllerShouldCallPull(controller)。

2. 如果 shouldPull 为 false，返回。

3. 如果 controller.[[pulling]] 为 true，

   1. 将 controller.[[pullAgain]] 设为 true。

   2. 返回。

4. 断言：controller.[[pullAgain]] 为 false。

5. 将 controller.[[pulling]] 设为 true。

6. 令 pullPromise 为执行 controller.[[pullAlgorithm]] 的结果。

7. 当 pullPromise 成功时，

   1. 将 controller.[[pulling]] 设为 false。

   2. 如果 controller.[[pullAgain]] 为 true，

      1. 将 controller.[[pullAgain]] 设为 false。

      2. 执行 !ReadableStreamDefaultControllerCallPullIfNeeded(controller)。

8. 当 pullPromise 被拒绝且原因为 e 时，

   1. 执行 !ReadableStreamDefaultControllerError(controller, e)。

1. 令 stream 为 controller.[[stream]]。

2. 如果 !ReadableStreamDefaultControllerCanCloseOrEnqueue(controller) 为 false，返回 false。

3. 如果 controller.[[started]] 为 false，返回 false。

4. 如果 !IsReadableStreamLocked(stream) 为 true 且 !ReadableStreamGetNumReadRequests(stream) > 0，返回 true。

5. 令 desiredSize 为 !ReadableStreamDefaultControllerGetDesiredSize(controller)。

6. 断言：desiredSize 不为 null。

7. 如果 desiredSize > 0，返回 true。

8. 返回 false。

这可以通过弱引用观察到。详细内容见 tc39/proposal-weakrefs#31。

执行以下步骤：

1. 将 controller.[[pullAlgorithm]] 设为 undefined。

2. 将 controller.[[cancelAlgorithm]] 设为 undefined。

3. 将 controller.[[strategySizeAlgorithm]] 设为 undefined。

1. 如果 !ReadableStreamDefaultControllerCanCloseOrEnqueue(controller) 为 false，返回。

2. 令 stream 为 controller.[[stream]]。

3. 将 controller.[[closeRequested]] 设为 true。

4. 如果 controller.[[queue]] 为空，

   1. 执行 !ReadableStreamDefaultControllerClearAlgorithms(controller)。

   2. 执行 !ReadableStreamClose(stream)。

1. 如果 !ReadableStreamDefaultControllerCanCloseOrEnqueue(controller) 为 false，返回。

2. 令 stream 为 controller.[[stream]]。

3. 如果 !IsReadableStreamLocked(stream) 为 true 且 !ReadableStreamGetNumReadRequests(stream) > 0，执行 !ReadableStreamFulfillReadRequest(stream, chunk, false)。

4. 否则，

   1. 令 result 为执行 controller.[[strategySizeAlgorithm]]，参数为 chunk 并将结果视为 completion record。

   2. 如果 result 为异常完成，

      1. 执行 !ReadableStreamDefaultControllerError(controller, result.[[Value]])。

      2. 返回 result。

   3. 令 chunkSize 为 result.[[Value]]。

   4. 令 enqueueResult 为 EnqueueValueWithSize(controller, chunk, chunkSize)。

   5. 如果 enqueueResult 为异常完成，

      1. 执行 !ReadableStreamDefaultControllerError(controller, enqueueResult.[[Value]])。

      2. 返回 enqueueResult。

5. 执行 !ReadableStreamDefaultControllerCallPullIfNeeded(controller)。

1. 令 stream 为 controller.[[stream]]。

2. 如果 stream.[[state]] 不为 "readable"，返回。

3. 执行 !ResetQueue(controller)。

4. 执行 !ReadableStreamDefaultControllerClearAlgorithms(controller)。

5. 执行 !ReadableStreamError(stream, e)。

1. 令 state 为 controller.[[stream]].[[state]]。

2. 如果 state 为 "errored"，返回 null。

3. 如果 state 为 "closed"，返回 0。

4. 返回 controller.[[strategyHWM]] − controller.[[queueTotalSize]]。

1. 如果 !ReadableStreamDefaultControllerShouldCallPull(controller) 为 true，返回 false。

2. 否则，返回 true。

1. 令 state 为 controller.[[stream]].[[state]]。

2. 如果 controller.[[closeRequested]] 为 false 且 state 为 "readable"，返回 true。

3. 否则，返回 false。

当 controller.[[closeRequested]] 为 false，但 state 不为 "readable" 时，可能是因为流被 controller.error() 置为错误，或者流被关闭但未调用其控制器的 controller.close() 方法，例如通过调用 stream.cancel() 关闭流。

1. 断言：stream.[[controller]] 未定义。

2. 将 controller.[[stream]] 设为 stream。

3. 执行 !ResetQueue(controller)。

4. 将 controller.[[started]]、 controller.[[closeRequested]]、 controller.[[pullAgain]] 和 controller.[[pulling]] 设为 false。

5. 将 controller.[[strategySizeAlgorithm]] 设为 sizeAlgorithm，controller.[[strategyHWM]] 设为 highWaterMark。

6. 将 controller.[[pullAlgorithm]] 设为 pullAlgorithm。

7. 将 controller.[[cancelAlgorithm]] 设为 cancelAlgorithm。

8. 将 stream.[[controller]] 设为 controller。

9. 令 startResult 为执行 startAlgorithm 的结果。（此操作可能抛出异常。）

10. 令 startPromise 为 以 startResult 解决的 promise。

11. 当 startPromise fulfilled 时，

    1. 将 controller.[[started]] 设为 true。

    2. 断言：controller.[[pulling]] 为 false。

    3. 断言：controller.[[pullAgain]] 为 false。

    4. 执行 !ReadableStreamDefaultControllerCallPullIfNeeded(controller)。

12. 当 startPromise 被拒绝，原因为 r 时，

    1. 执行 !ReadableStreamDefaultControllerError(controller, r)。

1. 令 controller 为 新的 ReadableStreamDefaultController。

2. 令 startAlgorithm 为一个返回 undefined 的算法。

3. 令 pullAlgorithm 为一个返回 以 undefined 解决的 promise 的算法。

4. 令 cancelAlgorithm 为一个返回 以 undefined 解决的 promise 的算法。

5. 如果 underlyingSourceDict["start"] 存在，则将 startAlgorithm 设为一个算法，其返回 调用 underlyingSourceDict["start"]， 参数为 « controller »，回调 this 值为 underlyingSource 的结果。

6. 如果 underlyingSourceDict["pull"] 存在，则将 pullAlgorithm 设为一个算法，其返回 调用 underlyingSourceDict["pull"]， 参数为 « controller »，回调 this 值为 underlyingSource 的结果。

7. 如果 underlyingSourceDict["cancel"] 存在，则将 cancelAlgorithm 设为一个接收参数 reason 并返回 调用 underlyingSourceDict["cancel"]， 参数为 « reason »，回调 this 值为 underlyingSource 的结果的算法。

8. 执行 ?SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm)。

1. 令 shouldPull 为 !ReadableByteStreamControllerShouldCallPull(controller)。

2. 如果 shouldPull 为 false，返回。

3. 如果 controller.[[pulling]] 为 true，

   1. 将 controller.[[pullAgain]] 设为 true。

   2. 返回。

4. 断言：controller.[[pullAgain]] 为 false。

5. 将 controller.[[pulling]] 设为 true。

6. 令 pullPromise 为执行 controller.[[pullAlgorithm]] 的结果。

7. 当 pullPromise fulfilled 时，

   1. 将 controller.[[pulling]] 设为 false。

   2. 如果 controller.[[pullAgain]] 为 true，

      1. 将 controller.[[pullAgain]] 设为 false。

      2. 执行 !ReadableByteStreamControllerCallPullIfNeeded(controller)。

8. 当 pullPromise 被拒绝，原因为 e 时，

   1. 执行 !ReadableByteStreamControllerError(controller, e)。

这可以通过弱引用观察到。详细内容见 tc39/proposal-weakrefs#31。

执行以下步骤：

1. 将 controller.[[pullAlgorithm]] 设为 undefined。

2. 将 controller.[[cancelAlgorithm]] 设为 undefined。

1. 执行 !ReadableByteStreamControllerInvalidateBYOBRequest(controller)。

2. 将 controller.[[pendingPullIntos]] 设为新的空 列表。

1. 令 stream 为 controller.[[stream]]。

2. 如果 controller.[[closeRequested]] 为 true 或 stream.[[state]] 不为 "readable"，返回。

3. 如果 controller.[[queueTotalSize]] > 0，

   1. 将 controller.[[closeRequested]] 设为 true。

   2. 返回。

4. 如果 controller.[[pendingPullIntos]] 不为空，

   1. 令 firstPendingPullInto 为 controller.[[pendingPullIntos]][0]。

   2. 如果 firstPendingPullInto 的 bytes filled 除以 firstPendingPullInto 的 element size 的余数不为 0，

      1. 令 e 为一个新的 TypeError 异常。

      2. 执行 !ReadableByteStreamControllerError(controller, e)。

      3. 抛出 e。

5. 执行 !ReadableByteStreamControllerClearAlgorithms(controller)。

6. 执行 !ReadableStreamClose(stream)。

1. 断言：stream.[[state]] 不为 "errored"。

2. 断言：pullIntoDescriptor.reader type 不为 "none"。

3. 令 done 为 false。

4. 如果 stream.[[state]] 为 "closed"，

   1. 断言：pullIntoDescriptor 的 bytes filled 除以 pullIntoDescriptor 的 element size 的余数为 0。

   2. 将 done 设为 true。

5. 令 filledView 为 !ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor)。

6. 如果 pullIntoDescriptor 的 reader type 为 "default"，

   1. 执行 !ReadableStreamFulfillReadRequest(stream, filledView, done)。

7. 否则，

   1. 断言：pullIntoDescriptor 的 reader type 为 "byob"。

   2. 执行 !ReadableStreamFulfillReadIntoRequest(stream, filledView, done)。

1. 令 bytesFilled 为 pullIntoDescriptor 的 bytes filled。

2. 令 elementSize 为 pullIntoDescriptor 的 element size。

3. 断言：bytesFilled ≤ pullIntoDescriptor 的 byte length。

4. 断言：bytesFilled 除以 elementSize 的余数为 0。

5. 令 buffer 为 !TransferArrayBuffer(pullIntoDescriptor 的 buffer)。

6. 返回 !Construct(pullIntoDescriptor 的 view constructor，« buffer, pullIntoDescriptor 的 byte offset, bytesFilled ÷ elementSize »)。

1. 令 stream 为 controller.[[stream]]。

2. 如果 controller.[[closeRequested]] 为 true 或 stream.[[state]] 不为 "readable"，返回。

3. 令 buffer 为 chunk.[[ViewedArrayBuffer]]。

4. 令 byteOffset 为 chunk.[[ByteOffset]]。

5. 令 byteLength 为 chunk.[[ByteLength]]。

6. 如果 !IsDetachedBuffer(buffer) 为 true，抛出 TypeError 异常。

7. 令 transferredBuffer 为 ?TransferArrayBuffer(buffer)。

8. 如果 controller.[[pendingPullIntos]] 不为 空，

   1. 令 firstPendingPullInto 为 controller.[[pendingPullIntos]][0]。

   2. 如果 !IsDetachedBuffer(firstPendingPullInto 的 buffer) 为 true，抛出 TypeError 异常。

   3. 执行 !ReadableByteStreamControllerInvalidateBYOBRequest(controller)。

   4. 将 firstPendingPullInto 的 buffer 设为 !TransferArrayBuffer(firstPendingPullInto 的 buffer)。

   5. 如果 firstPendingPullInto 的 reader type 为 "none"，执行 ?ReadableByteStreamControllerEnqueueDetachedPullIntoToQueue(controller, firstPendingPullInto)。

9. 如果 !ReadableStreamHasDefaultReader(stream) 为 true，

   1. 执行 !ReadableByteStreamControllerProcessReadRequestsUsingQueue(controller)。

   2. 如果 !ReadableStreamGetNumReadRequests(stream) 为 0，

      1. 断言：controller.[[pendingPullIntos]] 为 空。

      2. 执行 !ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength)。

   3. 否则，

      1. 断言：controller.[[queue]] 为空。

      2. 如果 controller.[[pendingPullIntos]] 不为 空，

         1. 断言：controller.[[pendingPullIntos]][0] 的 reader type 为 "default"。

         2. 执行 !ReadableByteStreamControllerShiftPendingPullInto(controller)。

      3. 令 transferredView 为 !Construct(%Uint8Array%， « transferredBuffer, byteOffset, byteLength »)。

      4. 执行 !ReadableStreamFulfillReadRequest(stream, transferredView, false)。

10. 否则，如果 !ReadableStreamHasBYOBReader(stream) 为 true，

    1. 执行 !ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength)。

    2. 令 filledPullIntos 为执行 !ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller) 的结果。

    3. 对于每个 filledPullInto 属于 filledPullIntos，

       1. 执行 !ReadableByteStreamControllerCommitPullIntoDescriptor(stream, filledPullInto)。

11. 否则，

    1. 断言：!IsReadableStreamLocked(stream) 为 false。

    2. 执行 !ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength)。

12. 执行 !ReadableByteStreamControllerCallPullIfNeeded(controller)。

1. 追加 一个带有 buffer buffer、byte offset byteOffset 和 byte length byteLength 的新的 readable byte stream queue entry 到 controller.[[queue]]。

2. 将 controller.[[queueTotalSize]] 设为 controller.[[queueTotalSize]] + byteLength。

1. 令 cloneResult 为 CloneArrayBuffer(buffer, byteOffset, byteLength, %ArrayBuffer%)。

2. 如果 cloneResult 为异常完成，

   1. 执行 !ReadableByteStreamControllerError(controller, cloneResult.[[Value]])。

   2. 返回 cloneResult。

3. 执行 !ReadableByteStreamControllerEnqueueChunkToQueue(controller, cloneResult.[[Value]], 0, byteLength)。

1. 断言：pullIntoDescriptor 的 reader type 为 "none"。

2. 如果 pullIntoDescriptor 的 bytes filled > 0，执行 ?ReadableByteStreamControllerEnqueueClonedChunkToQueue(controller, pullIntoDescriptor 的 buffer, pullIntoDescriptor 的 byte offset, pullIntoDescriptor 的 bytes filled)。

3. 执行 !ReadableByteStreamControllerShiftPendingPullInto(controller)。

1. 令 stream 为 controller.[[stream]]。

2. 如果 stream.[[state]] 不为 "readable"，返回。

3. 执行 !ReadableByteStreamControllerClearPendingPullIntos(controller)。

4. 执行 !ResetQueue(controller)。

5. 执行 !ReadableByteStreamControllerClearAlgorithms(controller)。

6. 执行 !ReadableStreamError(stream, e)。

1. 断言：controller.[[pendingPullIntos]] 为空，或 controller.[[pendingPullIntos]][0] 为 pullIntoDescriptor。

2. 断言：controller.[[byobRequest]] 为 null。

3. 将 pullIntoDescriptor 的 bytes filled 设为 bytes filled + size。

1. 令 maxBytesToCopy 为 min(controller.[[queueTotalSize]]， pullIntoDescriptor 的 byte length − pullIntoDescriptor 的 bytes filled)。

2. 令 maxBytesFilled 为 pullIntoDescriptor 的 bytes filled + maxBytesToCopy。

3. 令 totalBytesToCopyRemaining 为 maxBytesToCopy。

4. 令 ready 为 false。

5. 断言：!IsDetachedBuffer(pullIntoDescriptor 的 buffer) 为 false。

6. 断言：pullIntoDescriptor 的 bytes filled < pullIntoDescriptor 的 minimum fill。

7. 令 remainderBytes 为 maxBytesFilled 除以 pullIntoDescriptor 的 element size 的余数。

8. 令 maxAlignedBytes 为 maxBytesFilled − remainderBytes。

9. 如果 maxAlignedBytes ≥ pullIntoDescriptor 的 minimum fill，

   1. 将 totalBytesToCopyRemaining 设为 maxAlignedBytes − pullIntoDescriptor 的 bytes filled。

   2. 将 ready 设为 true。

      尚未填充到最小长度的 read() 请求描述符会保持在队列头部，底层源 underlying source 可以继续填充。

10. 令 queue 为 controller.[[queue]]。

11. 当 totalBytesToCopyRemaining > 0，

    1. 令 headOfQueue 为 queue[0]。

    2. 令 bytesToCopy 为 min(totalBytesToCopyRemaining, headOfQueue 的 byte length)。

    3. 令 destStart 为 pullIntoDescriptor 的 byte offset + pullIntoDescriptor 的 bytes filled。

    4. 令 descriptorBuffer 为 pullIntoDescriptor 的 buffer。

    5. 令 queueBuffer 为 headOfQueue 的 buffer。

    6. 令 queueByteOffset 为 headOfQueue 的 byte offset。

    7. 断言：!CanCopyDataBlockBytes(descriptorBuffer, destStart, queueBuffer, queueByteOffset, bytesToCopy) 为 true。

       如断言失败（由于规范或实现错误），下一步可能会读写无效内存。实现应始终检查此断言，如失败应以实现定义方式终止（如崩溃或 erroring the stream）。

    8. 执行 !CopyDataBlockBytes(descriptorBuffer.[[ArrayBufferData]], destStart, queueBuffer.[[ArrayBufferData]], queueByteOffset, bytesToCopy)。

    9. 如果 headOfQueue 的 byte length 为 bytesToCopy，

       1. 移除 queue[0]。

    10. 否则，

        1. 将 headOfQueue 的 byte offset 设为 headOfQueue 的 byte offset + bytesToCopy。

        2. 将 headOfQueue 的 byte length 设为 headOfQueue 的 byte length − bytesToCopy。

    11. 将 controller.[[queueTotalSize]] 设为 controller.[[queueTotalSize]] − bytesToCopy。

    12. 执行 !ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesToCopy, pullIntoDescriptor)。

    13. 将 totalBytesToCopyRemaining 设为 totalBytesToCopyRemaining − bytesToCopy。

12. 如果 ready 为 false，

    1. 断言：controller.[[queueTotalSize]] 为 0。

    2. 断言：pullIntoDescriptor 的 bytes filled > 0。

    3. 断言：pullIntoDescriptor 的 bytes filled < pullIntoDescriptor 的 minimum fill。

13. 返回 ready。

1. 断言：controller.[[queueTotalSize]] > 0。

2. 令 entry 为 controller.[[queue]][0]。

3. 移除 entry 从 controller.[[queue]]。

4. 将 controller.[[queueTotalSize]] 设为 controller.[[queueTotalSize]] − entry 的 byte length。

5. 执行 !ReadableByteStreamControllerHandleQueueDrain(controller)。

6. 令 view 为 !Construct(%Uint8Array%， « entry 的 buffer，entry 的 byte offset， entry 的 byte length »)。

7. 以 view 作为参数，执行 readRequest 的 chunk steps。

1. 如果 controller.[[byobRequest]] 为 null 且 controller.[[pendingPullIntos]] 不为 空，

   1. 令 firstDescriptor 为 controller.[[pendingPullIntos]][0]。

   2. 令 view 为 !Construct(%Uint8Array%， « firstDescriptor 的 buffer，firstDescriptor 的 byte offset + firstDescriptor 的 bytes filled， firstDescriptor 的 byte length − firstDescriptor 的 bytes filled »)。

   3. 令 byobRequest 为 新的 ReadableStreamBYOBRequest。

   4. 将 byobRequest.[[controller]] 设为 controller。

   5. 将 byobRequest.[[view]] 设为 view。

   6. 将 controller.[[byobRequest]] 设为 byobRequest。

2. 返回 controller.[[byobRequest]]。

1. 令 state 为 controller.[[stream]].[[state]]。

2. 如果 state 为 "errored"，返回 null。

3. 如果 state 为 "closed"，返回 0。

4. 返回 controller.[[strategyHWM]] − controller.[[queueTotalSize]]。

1. 断言：controller.[[stream]].[[state]] 为 "readable"。

2. 如果 controller.[[queueTotalSize]] 为 0 且 controller.[[closeRequested]] 为 true，

   1. 执行 !ReadableByteStreamControllerClearAlgorithms(controller)。

   2. 执行 !ReadableStreamClose(controller.[[stream]])。

3. 否则，

   1. 执行 !ReadableByteStreamControllerCallPullIfNeeded(controller)。

1. 如果 controller.[[byobRequest]] 为 null，返回。

2. 将 controller.[[byobRequest]].[[controller]] 设为 undefined。

3. 将 controller.[[byobRequest]].[[view]] 设为 null。

4. 将 controller.[[byobRequest]] 设为 null。

1. 断言：controller.[[closeRequested]] 为 false。

2. 令 filledPullIntos 为新的空 列表。

3. 当 controller.[[pendingPullIntos]] 不为 空，

   1. 如果 controller.[[queueTotalSize]] 为 0，则 跳出循环。

   2. 令 pullIntoDescriptor 为 controller.[[pendingPullIntos]][0]。

   3. 如果 !ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) 为 true，

      1. 执行 !ReadableByteStreamControllerShiftPendingPullInto(controller)。

      2. 追加 pullIntoDescriptor 到 filledPullIntos。

4. 返回 filledPullIntos。

1. 令 reader 为 controller.[[stream]].[[reader]]。

2. 断言：reader 实现了 ReadableStreamDefaultReader。

3. 当 reader.[[readRequests]] 不为 空 时，

   1. 如果 controller.[[queueTotalSize]] 为 0，返回。

   2. 令 readRequest 为 reader.[[readRequests]][0]。

   3. 移除 readRequest 从 reader.[[readRequests]]。

   4. 执行 !ReadableByteStreamControllerFillReadRequestFromQueue(controller, readRequest)。

1. 令 stream 为 controller.[[stream]]。

2. 令 elementSize 为 1。

3. 令 ctor 为 %DataView%。

4. 如果 view 有 [[TypedArrayName]] 内部槽（即非 DataView），

   1. 将 elementSize 设为 typed array constructors table 中 view.[[TypedArrayName]] 对应的元素大小。

   2. 将 ctor 设为 typed array constructors table 中 view.[[TypedArrayName]] 对应的构造函数。

5. 令 minimumFill 为 min × elementSize。

6. 断言：minimumFill ≥ 0 且 minimumFill ≤ view.[[ByteLength]]。

7. 断言：minimumFill 除以 elementSize 的余数为 0。

8. 令 byteOffset 为 view.[[ByteOffset]]。

9. 令 byteLength 为 view.[[ByteLength]]。

10. 令 bufferResult 为 TransferArrayBuffer(view.[[ViewedArrayBuffer]])。

11. 如果 bufferResult 为异常完成，

    1. 以 bufferResult.[[Value]] 为参数，执行 readIntoRequest 的 error steps。

    2. 返回。

12. 令 buffer 为 bufferResult.[[Value]]。

13. 令 pullIntoDescriptor 为新的 pull-into descriptor，其中

    buffer

    buffer

    buffer byte length

    buffer.[[ArrayBufferByteLength]]

    byte offset

    byteOffset

    byte length

    byteLength

    bytes filled

    0

    minimum fill

    minimumFill

    element size

    elementSize

    view constructor

    ctor

    reader type

    "byob"

14. 如果 controller.[[pendingPullIntos]] 不为空，

    1. 追加 pullIntoDescriptor 到 controller.[[pendingPullIntos]]。

    2. 执行 !ReadableStreamAddReadIntoRequest(stream, readIntoRequest)。

    3. 返回。

15. 如果 stream.[[state]] 为 "closed"，

    1. 令 emptyView 为 !Construct(ctor, « pullIntoDescriptor 的 buffer， pullIntoDescriptor 的 byte offset，0 »)。

    2. 以 emptyView 为参数，执行 readIntoRequest 的 close steps。

    3. 返回。

16. 如果 controller.[[queueTotalSize]] > 0，

    1. 如果 !ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) 为 true，

       1. 令 filledView 为 !ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor)。

       2. 执行 !ReadableByteStreamControllerHandleQueueDrain(controller)。

       3. 以 filledView 为参数，执行 readIntoRequest 的 chunk steps。

       4. 返回。

    2. 如果 controller.[[closeRequested]] 为 true，

       1. 令 e 为 TypeError 异常。

       2. 执行 !ReadableByteStreamControllerError(controller, e)。

       3. 以 e 为参数，执行 readIntoRequest 的 error steps。

       4. 返回。

17. 追加 pullIntoDescriptor 到 controller.[[pendingPullIntos]]。

18. 执行 !ReadableStreamAddReadIntoRequest(stream, readIntoRequest)。

19. 执行 !ReadableByteStreamControllerCallPullIfNeeded(controller)。