ストリーム

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. Assert: 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なら、TypeError例外でrejectされたPromiseを返す。

2. ! ReadableStreamCancel(this, reason)を返す。

1. options["mode"] が存在しない場合、? AcquireReadableStreamDefaultReader(this)を返す。

2. Assert: 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なら、TypeError例外でrejectされたPromiseを返す。

2. ! IsWritableStreamLocked(destination) がtrueなら、TypeError例外でrejectされたPromiseを返す。

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. Assert: reader.[[stream]]はundefinedではない。

3. promiseを新しいPromiseとする。

4. readRequestを次のread requestとして作成する：

   chunk steps（chunkを受け取る）

   1. Resolve promise with chunk.

   close steps

   1. ! ReadableStreamDefaultReaderRelease(reader)を実行する。

   2. Resolve promise with イテレーション終了とする。

   error steps（eを受け取る）

   1. ! ReadableStreamDefaultReaderRelease(reader)を実行する。

   2. Reject promise with e。

5. ! ReadableStreamDefaultReaderRead(this, readRequest)を実行する。

6. promiseを返す。

1. readerをiteratorのreaderとする。

2. Assert: reader.[[stream]]はundefinedではない。

3. Assert: reader.[[readRequests]]は空である。async iteratorの仕組みでnext()の前回呼び出しが確定してから呼ばれることが保証されているため。

4. iteratorのprevent cancelがfalseの場合：

   1. resultを ! ReadableStreamReaderGenericCancel(reader, arg)とする。

   2. ! ReadableStreamDefaultReaderRelease(reader)を実行する。

   3. resultを返す。

5. ! ReadableStreamDefaultReaderRelease(reader)を実行する。

6. undefinedでresolveされたPromiseを返す。

1. ! IsReadableStreamLocked(value) がtrueなら、"DataCloneError"のDOMExceptionをスローする。

2. port1を新しいMessagePort （現在のRealm）とする。

3. port2を新しいMessagePort （現在のRealm）とする。

4. port1とport2をエンタングルする。

5. writableを新しいWritableStream （現在のRealm）とする。

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例外でrejectされたPromiseを返す。

2. ! ReadableStreamReaderGenericCancel(this, reason)を返す。

1. ? SetUpReadableStreamDefaultReader(this, stream)を実行する。

1. this.[[stream]]がundefinedなら、TypeError例外でrejectされたPromiseを返す。

2. promiseを新しいPromiseとする。

3. readRequestを次のread requestとして作成する（以下の項目を持つ）：

   chunk steps（chunkを受け取る）

   1. Resolve promise with «[ "value" → chunk, "done" → false ]»。

   close steps

   1. Resolve promise with «[ "value" → undefined, "done" → true ]»。

   error steps（eを受け取る）

   1. Reject promise with e。

4. ! ReadableStreamDefaultReaderRead(this, readRequest)を実行する。

5. promiseを返す。

1. this.[[stream]]がundefinedなら、return。

2. ! ReadableStreamDefaultReaderRelease(this)を実行する。

1. ? SetUpReadableStreamBYOBReader(this, stream)を実行する。

1. view.[[ByteLength]]が0の場合、TypeError例外でrejectされたPromiseを返す。

2. view.[[ViewedArrayBuffer]].[[ByteLength]]が0の場合、TypeError例外でrejectされたPromiseを返す。

3. ! IsDetachedBuffer(view.[[ViewedArrayBuffer]])がtrueの場合、 TypeError例外でrejectされたPromiseを返す。

4. options["min"]が0の場合、 TypeError例外でrejectされたPromiseを返す。

5. viewが[[TypedArrayName]]内部スロットを持つ場合、

   1. options["min"] > view.[[ArrayLength]]の場合、 RangeError例外でrejectされたPromiseを返す。

6. それ以外の場合（DataViewの場合）、

   1. options["min"] > view.[[ByteLength]]の場合、 RangeError例外でrejectされたPromiseを返す。

7. this.[[stream]]がundefinedなら、TypeError例外でrejectされたPromiseを返す。

8. promiseを新しいPromiseとする。

9. readIntoRequestを次のread-into requestとして作成する（以下の項目を持つ）：

   chunk steps（chunkを受け取る）

   1. Resolve promise with «[ "value" → chunk, "done" → false ]»。

   close steps（chunkを受け取る）

   1. Resolve promise with «[ "value" → chunk, "done" → true ]»。

   error steps（eを受け取る）

   1. Reject promise with e。

10. ! ReadableStreamBYOBReaderRead(this, view, options["min"], readIntoRequest)を実行する。

11. promiseを返す。

1. this.[[stream]]がundefinedなら、return。

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. return。

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. Return ? 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. Assert: ! ReadableStreamHasDefaultReader(stream) がtrueであることを確認する。

3. this.[[queueTotalSize]] > 0の場合、

   1. Assert: ! ReadableStreamGetNumReadRequests(stream) が0であることを確認する。

   2. ! ReadableByteStreamControllerFillReadRequestFromQueue(this, readRequest)を実行する。

   3. return。

4. autoAllocateChunkSizeを this.[[autoAllocateChunkSize]]とする。

5. autoAllocateChunkSizeがundefinedでない場合、

   1. bufferをConstruct(%ArrayBuffer%, « autoAllocateChunkSize »)で生成する。

   2. bufferがabrupt completionの場合、

      1. readRequestのerror stepsをbuffer.[[Value]]で実行する。

      2. return。

   3. pullIntoDescriptorを新しいpull-into descriptorとして以下の値で生成する：

      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. Append 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 »に設定する。

1. this.[[view]]を返す。

1. this.[[controller]]がundefinedの場合、TypeError例外をスローする。

2. ! IsDetachedBuffer(this.[[view]].[[ArrayBuffer]])がtrueの場合、TypeError例外をスローする。

3. Assert: this.[[view]].[[ByteLength]] > 0。

4. Assert: 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. Assert: ! 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. iterator を、asyncIterable を非同期シーケンスとして開いた結果とする。

3. startAlgorithm を、undefined を返すアルゴリズムとする。

4. pullAlgorithm を、次の手順とする：

   1. nextPromise を、iterator の次の値を取得した結果とする。

   2. nextPromise に反応した結果を返す：

      • nextPromise が値 v で充足された場合：

        1. v が反復の終了である場合、! ReadableStreamDefaultControllerClose(stream.[[controller]]) を実行する。

        2. そうでなければ、! ReadableStreamDefaultControllerEnqueue(stream.[[controller]], v) を実行する。

      • nextPromise が理由 r で拒否された場合、! ReadableStreamDefaultControllerError(stream.[[controller]], r) を実行する。

5. cancelAlgorithm を、reason を受け取る次の手順とする：

   1. reason を用いて iterator を閉じた結果を返す。

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 であるか、または AbortSignal を実装する。

6. 表明：! IsReadableStreamLocked(source) は false である。

7. 表明：! IsWritableStreamLocked(dest) は false である。

8. source.[[controller]] が ReadableByteStreamController を実装する場合、 reader を、ユーザーエージェントの裁量により、! AcquireReadableStreamBYOBReader(source) または ! AcquireReadableStreamDefaultReader(source) のいずれかとする。

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 の場合、次のアクションを actions に付加する：

          1. dest.[[state]] が "writable" である場合、! WritableStreamAbort(dest, error) を返す。

          2. そうでなければ、undefined で解決された promise を返す。

       4. preventCancel が false の場合、次のアクションを actions に付加する：

          1. source.[[state]] が "readable" である場合、! ReadableStreamCancel(source, error) を返す。

          2. そうでなければ、undefined で解決された promise を返す。

       5. actions 内のすべてのアクションについて、すべてを待機するための promise を取得する ことからなるアクションと、error を用いて、アクションを伴ってシャットダウンする。

    2. signal が中止済みである場合、 abortAlgorithm を実行し、promise を返す。

    3. abortAlgorithm を signal に追加する。

15. 並行して （ただし実際にはそうではない。#905 を参照）、 reader および writer を使用して、source からすべてのチャンクを読み取り、dest に書き込む。 reader および writer によって提供されるロックのため、これが行われる正確な方法は オーサーコードから観察できず、その実行方法には柔軟性がある。使用される正確なアルゴリズムに かかわらず、次の制約が適用される：

    • 公開 API を使用してはならない：読み取り、書き込み、または以下の 操作のいずれかを実行している間、JavaScript から変更可能な reader、writer、および stream の API（すなわち、適切なプロトタイプ上のメソッド）を使用してはならない。代わりに、stream を 直接操作しなければならない。

    • バックプレッシャーを適用しなければならない：

      • WritableStreamDefaultWriterGetDesiredSize(writer) が 0 以下または null である間、ユーザーエージェントは reader から読み取ってはならない。

      • reader が BYOB reader である場合、WritableStreamDefaultWriterGetDesiredSize(writer) を、reader から読み取るチャンクのサイズを決定するための基準として 使用するべきである。

        小さすぎる、または大きすぎるチャンクを読み取ることは、 多くの場合非効率である。 最適なチャンクサイズを決定するために、ほかの情報を考慮してもよい。

      • 読み取りまたは書き込みは、これらのバックプレッシャー信号以外の理由で 遅延させるべきではない。

        次の読み取りまたは書き込み操作へ進む前に、 各書き込みが正常に完了するまで待機する実装は、この勧告に違反する。 そのような実装では、dest に含まれるキュー済みのチャンクが 常に最大 1 個になることを保証してしまうため、dest の内部キューが無意味になる。

    • シャットダウンは動作を停止しなければならない：shuttingDown が true になった場合、ユーザーエージェントは reader からの追加の読み取りを 開始してはならず、以下に説明するように、すでに読み取られたチャンクのみを書き込まなければならない。 特に、以下の条件は即時のシャットダウンにつながる可能性があるため、ユーザーエージェントは 読み取りまたは書き込みを実行する前に、それらを確認しなければならない。

    • エラー状態およびクローズ状態を伝播しなければならない：次の条件を 順番に適用しなければならない。

      1. エラーを前方へ伝播しなければならない：source.[[state]] が "errored" であるか、その状態になった場合、

         1. preventAbort が false の場合、! WritableStreamAbort(dest, source.[[storedError]]) というアクション、および source.[[storedError]] を用いて、アクションを伴って シャットダウンする。

         2. そうでなければ、source.[[storedError]] を用いてシャットダウンする。

      2. エラーを後方へ伝播しなければならない：dest.[[state]] が "errored" であるか、その状態になった場合、

         1. preventCancel が false の場合、! ReadableStreamCancel(source, dest.[[storedError]]) というアクション、および dest.[[storedError]] を用いて、アクションを伴って シャットダウンする。

         2. そうでなければ、dest.[[storedError]] を用いてシャットダウンする。

      3. クローズを前方へ伝播しなければならない：source.[[state]] が "closed" であるか、その状態になった場合、

         1. preventClose が false の場合、! WritableStreamDefaultWriterCloseWithErrorPropagation(writer) というアクションを用いて、アクションを伴って シャットダウンする。

         2. そうでなければ、シャットダウンする。

      4. クローズを後方へ伝播しなければならない：! WritableStreamCloseQueuedOrInFlight(dest) が true であるか、dest.[[state]] が "closed" である場合、

         1. 表明：読み取られた、または書き込まれたチャンクは存在しない。

         2. destClosed を、新しい TypeError とする。

         3. preventCancel が false の場合、! ReadableStreamCancel(source, destClosed) というアクション、および destClosed を用いて、アクションを伴って シャットダウンする。

         4. そうでなければ、destClosed を用いて シャットダウンする。

    • アクションを伴うシャットダウン： 上記の要件のいずれかが、アクション action と、任意でエラー originalError を用いたシャットダウンを要求する場合、次を実行する：

      1. shuttingDown が true の場合、これらの副手順を中止する。

      2. shuttingDown を true に設定する。

      3. dest.[[state]] が "writable" であり、かつ ! WritableStreamCloseQueuedOrInFlight(dest) が false である場合、

         1. 読み取られたものの、まだ書き込まれていないチャンクがある場合、それらを dest に書き込む。

         2. 読み取られたすべてのチャンクが書き込まれるまで （すなわち、対応する promise が確定するまで）待機する。

      4. p を、action を実行した結果とする。

      5. p が充足されたとき、originalError が指定されていた場合はそれを渡して、ファイナライズする。

      6. p が理由 newError で拒否されたとき、newError を用いて ファイナライズする。

    • シャットダウン：上記の要件または手順の いずれかが、任意でエラー error を用いたシャットダウンを要求する場合、 次を実行する：

      1. shuttingDown が true の場合、これらの副手順を中止する。

      2. shuttingDown を true に設定する。

      3. dest.[[state]] が "writable" であり、かつ ! WritableStreamCloseQueuedOrInFlight(dest) が false である場合、

         1. 読み取られたものの、まだ書き込まれていないチャンクがある場合、それらを dest に書き込む。

         2. 読み取られたすべてのチャンクが書き込まれるまで （すなわち、対応する promise が確定するまで）待機する。

      4. error が指定されていた場合はそれを渡して、ファイナライズする。

    • ファイナライズ：どちらの形式のシャットダウンも、 最終的に、任意でエラー error を用いたファイナライズを要求する。 これは、次の手順を実行することを意味する：

      1. ! WritableStreamDefaultWriterRelease(writer) を実行する。

      2. reader が ReadableStreamBYOBReader を実装する場合、 ! ReadableStreamBYOBReaderRelease(reader) を実行する。

      3. そうでなければ、! ReadableStreamDefaultReaderRelease(reader) を実行する。

      4. signal が undefined でない場合、abortAlgorithm を signal から削除する。

      5. error が指定されていた場合、promise を error で拒否する。

      6. そうでなければ、promise を undefined で解決する。

16. promise を返す。

第2引数の cloneForBranch2 は、元のストリームのデータが、返される第2の分岐に現れる前に （HTML のシリアライズ可能オブジェクトの枠組みを使用して）複製されるかどうかを 制御する。これは、両方の分岐が、たとえばそれぞれの転送可能なチャンクを転送する場合など、そのままでは相互に干渉する可能性がある方法で 消費される状況に有用である。ただし、これは2つの分岐の間に顕著な非対称性を生じさせ、使用可能な チャンクをシリアライズ可能なものに限定する。[HTML]

stream が読み取り可能バイトストリームである場合、 cloneForBranch2 は無視され、チャンクは無条件に複製される。

この標準では、ReadableStreamTee は常に 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 を受け取るチャンク手順

       1. 次の手順を実行するマイクロタスクをキューに追加する：

          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 を実行する。

       ここでのマイクロタスク遅延は、以下で reader.[[closedPromise]] を使用する際、エラーの検出に少なくとも1つのマイクロタスクを要するため必要である。 stream のエラーによって両方の分岐を直ちにエラー状態にしたいため、 非同期に利用可能になるエラーより先に、同期的に利用可能な読み取りを成功させることはできない。

       クローズ手順

       1. reading を false に設定する。

       2. canceled1 が false の場合、! ReadableStreamDefaultControllerClose(branch1.[[controller]]) を実行する。

       3. canceled2 が false の場合、! ReadableStreamDefaultControllerClose(branch2.[[controller]]) を実行する。

       4. canceled1 が false であるか、canceled2 が false である場合、cancelPromise を undefined で解決する。

       エラー手順

       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. reader を受け取る forwardReaderError を実行する。

    2. readRequest を、次の項目を持つ読み取り要求とする：

       chunk を受け取るチャンク手順

       1. 次の手順を実行するマイクロタスクをキューに追加する：

          1. readAgainForBranch1 を false に設定する。

          2. readAgainForBranch2 を false に設定する。

          3. chunk1 および chunk2 を chunk とする。

          4. canceled1 が false であり、かつ 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]] に設定する。

          5. canceled1 が false の場合、! ReadableByteStreamControllerEnqueue(branch1.[[controller]], chunk1) を実行する。

          6. canceled2 が false の場合、! ReadableByteStreamControllerEnqueue(branch2.[[controller]], chunk2) を実行する。

          7. reading を false に設定する。

          8. readAgainForBranch1 が true の場合、 pull1Algorithm を実行する。

          9. そうでなければ、readAgainForBranch2 が true の場合、 pull2Algorithm を実行する。

       ここでのマイクロタスク遅延は、以下で reader.[[closedPromise]] を使用する際、エラーの検出に少なくとも1つのマイクロタスクを要するため必要である。 stream のエラーによって両方の分岐を直ちにエラー状態にしたいため、 非同期に利用可能になるエラーより先に、同期的に利用可能な読み取りを成功させることはできない。

       クローズ手順

       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 で解決する。

       エラー手順

       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. reader を受け取る forwardReaderError を実行する。

    2. byobBranch を、forBranch2 が true の場合は branch2、そうでなければ branch1 とする。

    3. otherBranch を、forBranch2 が false の場合は branch2、そうでなければ branch1 とする。

    4. readIntoRequest を、次の項目を持つ読み込み要求とする：

       chunk を受け取るチャンク手順

       1. 次の手順を実行するマイクロタスクをキューに追加する：

          1. readAgainForBranch1 を false に設定する。

          2. readAgainForBranch2 を false に設定する。

          3. byobCanceled を、forBranch2 が true の場合は canceled2、そうでなければ canceled1 とする。

          4. otherCanceled を、forBranch2 が false の場合は canceled2、そうでなければ canceled1 とする。

          5. 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) を実行する。

          6. そうでなければ、byobCanceled が false の場合、! ReadableByteStreamControllerRespondWithNewView(byobBranch.[[controller]], chunk) を実行する。

          7. reading を false に設定する。

          8. readAgainForBranch1 が true の場合、 pull1Algorithm を実行する。

          9. そうでなければ、readAgainForBranch2 が true の場合、 pull2Algorithm を実行する。

       ここでのマイクロタスク遅延は、以下で reader.[[closedPromise]] を使用する際、エラーの検出に少なくとも1つのマイクロタスクを要するため必要である。 stream のエラーによって両方の分岐を直ちにエラー状態にしたいため、 非同期に利用可能になるエラーより先に、同期的に利用可能な読み取りを成功させることはできない。

       chunk を受け取るクローズ手順

       1. reading を false に設定する。

       2. byobCanceled を、forBranch2 が true の場合は canceled2、そうでなければ canceled1 とする。

       3. otherCanceled を、forBranch2 が false の場合は canceled2、そうでなければ 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 で解決する。

       エラー手順

       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. そうでなければ、byobRequest.[[view]] および false を受け取る pullWithBYOBReader を実行する。

    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. そうでなければ、byobRequest.[[view]] および true を受け取る pullWithBYOBReader を実行する。

    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. reader を受け取る forwardReaderError を実行する。

25. « branch1, branch2 » を返す。

1. Assert: stream.[[reader]]がReadableStreamBYOBReaderをimplementsしていること。

2. Assert: stream.[[state]]が"readable"または"closed"であること。

3. Append readRequestを stream.[[reader]].[[readIntoRequests]]に追加する。

1. Assert: stream.[[reader]]がReadableStreamDefaultReaderをimplementsしていること。

2. Assert: stream.[[state]]が"readable"であること。

3. Append 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. readIntoRequests の各 readIntoRequest について反復し、

      1. undefined を渡して、readIntoRequest のクローズ手順を実行する。

7. sourceCancelPromise を ! stream.[[controller]].[[CancelSteps]](reason) とする。

8. sourceCancelPromise に対し、undefined を返す充足手順を用いて反応した結果を返す。

1. Assert: stream.[[state]]が"readable"であること。

2. stream.[[state]]に"closed"を設定する。

3. readerをstream.[[reader]]とする。

4. readerがundefinedならreturn。

5. resolve reader.[[closedPromise]] with undefined。

6. readerがReadableStreamDefaultReaderをimplementsしている場合、

   1. readRequestsをreader.[[readRequests]]とする。

   2. reader.[[readRequests]]に空のlistを設定する。

   3. For each readRequest of readRequestsについて、

      1. readRequestのclose stepsを実行。

1. Assert: stream.[[state]]が"readable"であること。

2. stream.[[state]]に"errored"を設定する。

3. stream.[[storedError]]にeを設定する。

4. readerをstream.[[reader]]とする。

5. readerがundefinedならreturn。

6. reject reader.[[closedPromise]] with e。

7. reader.[[closedPromise]].[[PromiseIsHandled]]にtrueを設定する。

8. readerがReadableStreamDefaultReaderをimplementsしている場合、

   1. ! ReadableStreamDefaultReaderErrorReadRequests(reader, e)を実行。

9. それ以外の場合、

   1. Assert: readerがReadableStreamBYOBReaderをimplementsしていること。

   2. ! ReadableStreamBYOBReaderErrorReadIntoRequests(reader, e)を実行。

1. Assert: ! ReadableStreamHasBYOBReader(stream) がtrueであること。

2. readerをstream.[[reader]]とする。

3. Assert: reader.[[readIntoRequests]]が空でないこと。

4. readIntoRequestをreader.[[readIntoRequests]][0]とする。

5. Remove readIntoRequestを reader.[[readIntoRequests]]から除去する。

6. doneがtrueなら、readIntoRequestのclose steps（chunk渡し）を実行。

7. それ以外の場合、readIntoRequestのchunk steps（chunk渡し）を実行。

1. Assert: ! ReadableStreamHasDefaultReader(stream) がtrueであること。

2. readerをstream.[[reader]]とする。

3. Assert: reader.[[readRequests]]が空でないこと。

4. readRequestをreader.[[readRequests]][0]とする。

5. Remove readRequestをreader.[[readRequests]]から除去する。

6. doneがtrueなら、readRequestのclose stepsを実行。

7. それ以外の場合、readRequestのchunk steps（chunk渡し）を実行。

1. Assert: ! ReadableStreamHasBYOBReader(stream) がtrueであること。

2. 返す：stream.[[reader]].[[readIntoRequests]]のsize。

1. Assert: ! ReadableStreamHasDefaultReader(stream) がtrueであること。

2. 返す：stream.[[reader]].[[readRequests]]のsize。

1. readerをstream.[[reader]]とする。

2. readerがundefinedならfalseを返す。

3. readerがReadableStreamBYOBReaderをimplementsしている場合、trueを返す。

4. falseを返す。

1. readerをstream.[[reader]]とする。

2. readerがundefinedならfalseを返す。

3. readerがReadableStreamDefaultReaderをimplementsしている場合、trueを返す。

4. falseを返す。

1. streamをreader.[[stream]]とする。

2. Assert: 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]] を stream.[[storedError]] で拒否された promiseに設定する。

   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]] を TypeError 例外で拒否された promiseに設定する。

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. readIntoRequests の各 readIntoRequest について反復し、

   1. e を渡して、readIntoRequest のエラー手順を実行する。

1. stream を reader.[[stream]] とする。

2. 表明：stream は undefined ではない。

3. stream.[[disturbed]] を true に設定する。

4. stream.[[state]] が "errored" である場合、 stream.[[storedError]] を渡して、 readIntoRequest のエラー手順を実行する。

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. readRequests の各 readRequest について反復し、

   1. e を渡して、readRequest のエラー手順を実行する。

1. stream を reader.[[stream]] とする。

2. 表明：stream は undefined ではない。

3. stream.[[disturbed]] を true に設定する。

4. stream.[[state]] が "closed" である場合、 readRequest のクローズ手順を実行する。

5. そうでなければ、stream.[[state]] が "errored" である場合、 stream.[[storedError]] を渡して、 readRequest のエラー手順を実行する。

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ならreturn。

3. controller.[[pulling]]がtrueなら、

   1. controller.[[pullAgain]]にtrueを設定する。

   2. return。

4. Assert: controller.[[pullAgain]]はfalse。

5. controller.[[pulling]]にtrueを設定する。

6. pullPromiseをcontroller.[[pullAlgorithm]]の実行結果とする。

7. pullPromiseのfulfillment時：

   1. controller.[[pulling]]にfalseを設定する。

   2. controller.[[pullAgain]]がtrueなら、

      1. controller.[[pullAgain]]にfalseを設定する。

      2. ! ReadableStreamDefaultControllerCallPullIfNeeded(controller)を実行する。

8. pullPromiseのrejection時、理由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. Assert: desiredSizeはnullではない。

7. desiredSize > 0ならtrueを返す。

8. falseを返す。

これはWeakRefで観測できます。詳細はtc39/proposal-weakrefs#31参照。

手順：

1. controller.[[pullAlgorithm]]にundefinedを設定。

2. controller.[[cancelAlgorithm]]にundefinedを設定。

3. controller.[[strategySizeAlgorithm]]にundefinedを設定。

1. ! ReadableStreamDefaultControllerCanCloseOrEnqueue(controller)がfalseならreturn。

2. streamをcontroller.[[stream]]とする。

3. controller.[[closeRequested]]にtrueを設定。

4. controller.[[queue]]が空なら、

   1. ! ReadableStreamDefaultControllerClearAlgorithms(controller)を実行。

   2. ! ReadableStreamClose(stream)を実行。

1. ! ReadableStreamDefaultControllerCanCloseOrEnqueue(controller)がfalseならreturn。

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がabrupt completionなら、

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

      2. resultを返す。

   3. chunkSizeをresult.[[Value]]とする。

   4. enqueueResultをEnqueueValueWithSize(controller, chunk, chunkSize)で取得する。

   5. enqueueResultがabrupt completionなら、

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

      2. enqueueResultを返す。

5. ! ReadableStreamDefaultControllerCallPullIfNeeded(controller)を実行。

1. streamをcontroller.[[stream]]とする。

2. stream.[[state]]が"readable"でなければreturn。

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() によりストリームがerroredになった場合や、 controllerのcontroller.close() が呼ばれないまま stream.cancel() などでストリームが閉じられた場合に発生します。

1. Assert: stream.[[controller]]はundefinedである。

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をa promise resolved with startResultとする。

11. startPromiseのfulfillment時：

    1. controller.[[started]]をtrueに設定する。

    2. Assert: controller.[[pulling]]はfalse。

    3. Assert: controller.[[pullAgain]]はfalse。

    4. ! ReadableStreamDefaultControllerCallPullIfNeeded(controller)を実行する。

12. startPromiseのrejection時、理由r：

    1. ! ReadableStreamDefaultControllerError(controller, r)を実行する。

1. controllerを新規ReadableStreamDefaultControllerとする。

2. startAlgorithmをundefinedを返すアルゴリズムとする。

3. pullAlgorithmをa promise resolved with undefinedを返すアルゴリズムとする。

4. cancelAlgorithmをa promise resolved with undefinedを返すアルゴリズムとする。

5. underlyingSourceDict["start"] existsなら、startAlgorithmを invoking underlyingSourceDict["start"] に引数« controller »とcallback this value underlyingSourceを使って呼び出すアルゴリズムに設定する。

6. underlyingSourceDict["pull"] existsなら、pullAlgorithmを invoking underlyingSourceDict["pull"] に引数« controller »とcallback this value underlyingSourceを使って呼び出すアルゴリズムに設定する。

7. underlyingSourceDict["cancel"] existsなら、cancelAlgorithmを「引数reasonを受け取り、 invoking underlyingSourceDict["cancel"] に引数« reason »とcallback this value underlyingSourceを使って呼び出すアルゴリズム」に設定する。

8. ? SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm)を実行する。

1. shouldPull に ! ReadableByteStreamControllerShouldCallPull(controller) の結果を格納する。

2. shouldPull が false なら、return する。

3. controller.[[pulling]] が true の場合、

   1. controller.[[pullAgain]] を true に設定する。

   2. return する。

4. アサーション: controller.[[pullAgain]] は false である。

5. controller.[[pulling]] を true に設定する。

6. pullPromise に controller.[[pullAlgorithm]] の実行結果を格納する。

7. pullPromise が fulfill されたとき、

   1. controller.[[pulling]] を false に設定する。

   2. controller.[[pullAgain]] が true の場合、

      1. controller.[[pullAgain]] を false に設定する。

      2. ! ReadableByteStreamControllerCallPullIfNeeded(controller) を実行する。

8. pullPromise が e という理由で reject されたとき、

   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" でない場合、return する。

3. controller.[[queueTotalSize]] > 0 の場合、

   1. controller.[[closeRequested]] を true に設定する。

   2. return する。

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 を throw する。

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" でない場合、return する。

3. buffer に chunk.[[ViewedArrayBuffer]] を格納する。

4. byteOffset に chunk.[[ByteOffset]] を格納する。

5. byteLength に chunk.[[ByteLength]] を格納する。

6. ! IsDetachedBuffer(buffer) が true の場合、 TypeError 例外をthrowする。

7. transferredBuffer に ? TransferArrayBuffer(buffer) を格納する。

8. controller.[[pendingPullIntos]] が 空でない場合、

   1. firstPendingPullInto に controller.[[pendingPullIntos]][0] を格納する。

   2. ! IsDetachedBuffer(firstPendingPullInto の buffer) が true の場合、 TypeError 例外をthrowする。

   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. filledPullIntos の各 filledPullInto について、

       1. ! ReadableByteStreamControllerCommitPullIntoDescriptor(stream, filledPullInto) を実行する。

11. それ以外の場合、

    1. アサーション: ! IsReadableStreamLocked(stream) は false。

    2. ! ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength) を実行する。

12. ! ReadableByteStreamControllerCallPullIfNeeded(controller) を実行する。

1. 新しい readable byte stream queue entry（buffer buffer、byte offset byteOffset、 byte length byteLength）を controller.[[queue]]に追加する。

2. controller.[[queueTotalSize]] を controller.[[queueTotalSize]] + byteLength に設定する。

1. cloneResult に CloneArrayBuffer(buffer, byteOffset, byteLength, %ArrayBuffer%) の結果を格納する。

2. cloneResult がabrupt completionの場合、

   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" でない場合、return する。

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() リクエストのためのディスクリプタがまだ最小長まで埋まっていない場合は、キューの先頭に残り、下層ソースが引き続き埋めることができる。

10. queue に controller.[[queue]] を格納する。

11. While 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。

       このアサーションが失敗した場合（仕様または実装のバグによる）、次のステップで不正なメモリ領域の読み書きが行われる可能性がある。 ユーザーエージェントは常にこのアサーションをチェックし、失敗した場合は実装定義の方法で停止すべきである（例：プロセスをクラッシュさせる、または ストリームをエラーにするなど）。

    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. readRequest の chunk steps を view を与えて実行する。

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 の場合、return する。

2. controller.[[byobRequest]].[[controller]] を undefined に設定する。

3. controller.[[byobRequest]].[[view]] を null に設定する。

4. controller.[[byobRequest]] を null に設定する。

1. アサーション: controller.[[closeRequested]] は false。

2. filledPullIntos に新しい空の リスト を格納する。

3. While controller.[[pendingPullIntos]] が 空でない場合、

   1. controller.[[queueTotalSize]] が 0 の場合、break。

   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 implements ReadableStreamDefaultReader である。

3. reader.[[readRequests]] が 空でない間、

   1. controller.[[queueTotalSize]] が 0 の場合、return する。

   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 を、view.[[TypedArrayName]] について型付き配列 コンストラクタ表で指定された要素サイズに設定する。

   2. ctor を、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 のエラー手順を実行する。

    2. 返る。

12. buffer を bufferResult.[[Value]] とする。

13. pullIntoDescriptor を、次を持つ新しいプル入力記述子とする：

    バッファ

    buffer

    バッファのバイト長

    buffer.[[ArrayBufferByteLength]]

    バイトオフセット

    byteOffset

    バイト長

    byteLength

    充填済みバイト数

    0

    最小充填量

    minimumFill

    要素サイズ

    elementSize

    ビューコンストラクタ

    ctor

    reader 型

    "byob"

14. controller.[[pendingPullIntos]] が 空でない場合、

    1. pullIntoDescriptor を controller.[[pendingPullIntos]] に付加する。

    2. ! ReadableStreamAddReadIntoRequest(stream, readIntoRequest) を実行する。

    3. 返る。

15. stream.[[state]] が "closed" である場合、

    1. emptyView を ! Construct(ctor, « pullIntoDescriptor のバッファ、 pullIntoDescriptor のバイトオフセット、0 ») とする。

    2. emptyView を渡して、readIntoRequest のクローズ手順を実行する。

    3. 返る。

16. controller.[[queueTotalSize]] > 0 である場合、

    1. ! ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) が true である場合、

       1. filledView を ! ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor) とする。

       2. ! ReadableByteStreamControllerHandleQueueDrain(controller) を実行する。

       3. filledView を渡して、readIntoRequest のチャンク手順を実行する。

       4. 返る。

    2. controller.[[closeRequested]] が true である場合、

       1. e を TypeError 例外とする。

       2. ! ReadableByteStreamControllerError(controller, e) を実行する。

       3. e を渡して、readIntoRequest のエラー手順を実行する。

       4. 返る。

17. pullIntoDescriptor を controller.[[pendingPullIntos]] に付加する。

18. ! ReadableStreamAddReadIntoRequest(stream, readIntoRequest) を実行する。

19. ! ReadableByteStreamControllerCallPullIfNeeded(controller) を実行する。

1. 表明：controller.[[pendingPullIntos]] は 空でない。

2. firstDescriptor を controller.[[pendingPullIntos]][0] とする。

3. state を controller.[[stream]].[[state]] とする。

4. state が "closed" である場合、

   1. bytesWritten が 0 でない場合、TypeError 例外をスローする。

5. そうでなければ、

   1. 表明：state は "readable" である。

   2. bytesWritten が 0 である場合、TypeError 例外をスローする。

   3. firstDescriptor の充填済みバイト数 + bytesWritten > firstDescriptor のバイト長である場合、RangeError 例外をスローする。

6. firstDescriptor のバッファを ! TransferArrayBuffer(firstDescriptor のバッファ) に設定する。

7. ? ReadableByteStreamControllerRespondInternal(controller, bytesWritten) を実行する。