Streams

`new ReadableStream(underlyingSource, strategy)@m 構築子~手続きは： ◎ The new ReadableStream(underlyingSource, strategy) constructor steps are:

1. ~IF［ %underlyingSource ~EQ ε ］ ⇒ %underlyingSource ~SET ~NULL ◎ If underlyingSource is missing, set it to null.

2. %underlyingSourceDict ~LET `~IDL値に変換する$( %underlyingSource, `UnderlyingSource$I ) ◎ Let underlyingSourceDict be underlyingSource, converted to an IDL value of type UnderlyingSource.

   注記： %underlyingSource 引数を `UnderlyingSource$I 型として直に宣言できないのは、 元の~objへの参照が失われるからである。 ~obj上の各種`~methodを呼出せる$よう，~objは維持する必要がある。 ◎ We cannot declare the underlyingSource argument as having the UnderlyingSource type directly, because doing so would lose the reference to the original object. We need to retain the object so we can invoke the various methods on it.

3. ~NOABRUPT `InitializeReadableStream$A( コレ ) ◎ Perform ! InitializeReadableStream(this).

4. ~IF［ %underlyingSourceDict[ "`type$usc" ] ~EQ `bytes$l ］： ◎ If underlyingSourceDict["type"] is "bytes":

   1. ~IF［ %size ~NEQ `undefined^jv ］ ⇒ ~THROW `RangeError$E ◎ If strategy["size"] exists, throw a RangeError exception.
   2. %highWaterMark ~LET ~ABRUPT `ExtractHighWaterMark$A( %strategy, 0 ) ◎ Let highWaterMark be ? ExtractHighWaterMark(strategy, 0).
   3. ~ABRUPT `SetUpReadableByteStreamControllerFromUnderlyingSource$A( コレ, %underlyingSource, %underlyingSourceDict, %highWaterMark ) ◎ Perform ? SetUpReadableByteStreamControllerFromUnderlyingSource(this, underlyingSource, underlyingSourceDict, highWaterMark).

5. ~ELSE： ◎ Otherwise,

   1. ~Assert： %underlyingSourceDict[ "`type$usc" ] ~EQ ε ◎ Assert: underlyingSourceDict["type"] does not exist.
   2. %sizeAlgorithm ~LET ~ABRUPT `ExtractSizeAlgorithm$A( %strategy ) ◎ Let sizeAlgorithm be ! ExtractSizeAlgorithm(strategy).
   3. %highWaterMark ~LET ~ABRUPT `ExtractHighWaterMark$A( %strategy, 1 ) ◎ Let highWaterMark be ? ExtractHighWaterMark(strategy, 1).
   4. ~ABRUPT `SetUpReadableStreamDefaultControllerFromUnderlyingSource$A( コレ, %underlyingSource, %underlyingSourceDict, %highWaterMark, %sizeAlgorithm ) ◎ Perform ? SetUpReadableStreamDefaultControllerFromUnderlyingSource(this, underlyingSource, underlyingSourceDict, highWaterMark, sizeAlgorithm).

静的な `from(asyncIterable)@rs ~method手続きは： ◎ The static from(asyncIterable) method steps are:

1. ~RET ~ABRUPT `ReadableStreamFromIterable$A( %asyncIterable ) ◎ Return ? ReadableStreamFromIterable(asyncIterable).

`locked@rs 取得子~手続きは： ◎ The locked getter steps are:

1. ~RET ~NOABRUPT `IsReadableStreamLocked$A( コレ ) ◎ Return ! IsReadableStreamLocked(this).

`cancel(reason)@rs ~method手続きは： ◎ The cancel(reason) method steps are:

1. ~IF［ ~NOABRUPT `IsReadableStreamLocked$A( コレ ) ~EQ ~T ］ ⇒ ~RET `却下される~promise$( `TypeError$jE 例外 ) ◎ If ! IsReadableStreamLocked(this) is true, return a promise rejected with a TypeError exception.
2. ~RET ~NOABRUPT `ReadableStreamCancel$A( コレ, %reason ) ◎ Return ! ReadableStreamCancel(this, reason).

`getReader(options)@rs ~method手続きは： ◎ The getReader(options) method steps are:

1. ~IF［ %options[ "`mode$rsgo" ] ~EQ ε ］ ⇒ ~RET ~ABRUPT `AcquireReadableStreamDefaultReader$A( コレ ) ◎ If options["mode"] does not exist, return ? AcquireReadableStreamDefaultReader(this).
2. ~Assert： %options[ "`mode$rsgo" ] ~EQ `byob$l ◎ Assert: options["mode"] is "byob".
3. ~RET ~ABRUPT `AcquireReadableStreamBYOBReader$A( コレ ) ◎ Return ? 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();
    });
  }
}

`pipeThrough(transform, options)@rs ~method手続きは： ◎ The pipeThrough(transform, options) method steps are:

1. ~IF［ ~NOABRUPT `IsReadableStreamLocked$A( コレ ) ~EQ ~T ］ ⇒ ~THROW `TypeError$jE ◎ If ! IsReadableStreamLocked(this) is true, throw a TypeError exception.
2. ~IF［ ~NOABRUPT `IsWritableStreamLocked$A( %transform[ "`writable$rwp" ] ) ~EQ ~T ］ ⇒ ~THROW `TypeError$jE ◎ If ! IsWritableStreamLocked(transform["writable"]) is true, throw a TypeError exception.
3. %signal ~LET %options[ "`signal$spo" ] ◎ Let signal be options["signal"]＼
4. ~IF［ %signal ~EQ ε ］ ⇒ %signal ~SET `undefined^jv ◎ if it exists, or undefined otherwise.
5. %promise ~LET ~NOABRUPT `ReadableStreamPipeTo$A( コレ, %transform[ "`writable$rwp" ], %options[ "`preventClose$spo" ], %options[ "`preventAbort$spo" ], %options[ "`preventCancel$spo" ], %signal ) ◎ Let promise be ! ReadableStreamPipeTo(this, transform["writable"], options["preventClose"], options["preventAbort"], options["preventCancel"], signal).
6. %promise.`PromiseIsHandled^sl ~SET ~T ◎ Set promise.[[PromiseIsHandled]] to true.
7. ~RET %transform[ "`readable$rwp" ] ◎ Return transform["readable"].

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

`pipeTo(destination, options)@rs ~method手続きは： ◎ The pipeTo(destination, options) method steps are:

1. ~IF［ ~NOABRUPT `IsReadableStreamLocked$A( コレ ) ~EQ ~T ］ ⇒ ~RET `却下される~promise$( `TypeError$jE 例外 ) ◎ If ! IsReadableStreamLocked(this) is true, return a promise rejected with a TypeError exception.
2. ~IF［ ~NOABRUPT `IsWritableStreamLocked$A( %destination ) ~EQ ~T ］ ⇒ ~RET `却下される~promise$( `TypeError$jE 例外 ) ◎ If ! IsWritableStreamLocked(destination) is true, return a promise rejected with a TypeError exception.
3. %signal ~LET %options[ "`signal$spo" ] ◎ Let signal be options["signal"]＼
4. ~IF［ %signal ~EQ ε ］ ⇒ %signal ~SET `undefined^jv ◎ if it exists, or undefined otherwise.
5. ~RET ~NOABRUPT `ReadableStreamPipeTo$A( コレ, %destination, %options[ "`preventClose$spo" ], %options[ "`preventAbort$spo" ], %options[ "`preventCancel$spo" ], %signal ) ◎ Return ! ReadableStreamPipeTo(this, destination, options["preventClose"], options["preventAbort"], options["preventCancel"], signal).

`tee()@rs ~method手続きは： ◎ The tee() method steps are:

1. ~RET ~ABRUPT `ReadableStreamTee$A( コレ, ~F ) ◎ Return ? ReadableStreamTee(this, false).

const [%forLocal, %forRemote] = %readableStream.tee();
Promise.all([
  %forLocal.pipeTo(%cacheEntry),
  %forRemote.pipeTo(%httpRequestBody)
])
.then(() => console.log(
    `~streamは ~cacheに保存され, ~uploadされました^l【！Saved the stream to the cache and also uploaded it!】))
.catch(%e => console.error(
    `~cache時または~upload時に失敗しました: ^l【！Either caching or uploading failed: 】, %e));

`ReadableStream$I 用の`非同期~反復子の初期化~手続き$は、 所与の ( %stream, %iterator, %args ) に対し： ◎ The asynchronous iterator initialization steps for a ReadableStream, given stream, iterator, and args, are:

1. %reader ~LET ~ABRUPT `AcquireReadableStreamDefaultReader$A( %stream ) ◎ Let reader be ? AcquireReadableStreamDefaultReader(stream).
2. %iterator の `非同期c読取器@ ~SET %reader ◎ Set iterator’s reader to reader.
3. %preventCancel ~LET %args[0][ "`preventCancel$rsio" ] ◎ Let preventCancel be args[0]["preventCancel"].
4. %iterator の `取消-を防止するか@ ~SET %preventCancel ◎ Set iterator’s prevent cancel to preventCancel.

`ReadableStream$I 用の`次回の反復~結果を取得する手続き$は、 所与の ( %stream, %iterator ) に対し： ◎ The get the next iteration result steps for a ReadableStream, given stream and iterator, are:

1. %reader ~LET %iterator の`非同期c読取器$ ◎ Let reader be iterator’s reader.
2. ~Assert： %reader.`stream$rsR ~NEQ `undefined^jv ◎ Assert: reader.[[stream]] is not undefined.
3. %promise ~LET `新たな~promise$ ◎ Let promise be a new promise.

4. %readRequest ~LET 次に挙げる`~item$sctを伴う，新たな`読取n要請$： ◎ Let readRequest be a new read request with the following items:

   • `~chunk手続き$rRは、 所与の ( %chunk ) に対し ⇒ `~promiseを解決する$( %promise, %chunk ) ◎ chunk steps, given chunk • Resolve promise with chunk.

   • `~close手続き$rRは： ◎ close steps

     1. ~NOABRUPT `ReadableStreamDefaultReaderRelease$A( %reader ) ◎ Perform ! ReadableStreamDefaultReaderRelease(reader).
     2. `~promiseを解決する$( %promise, `反復~終了$i ) ◎ Resolve promise with end of iteration.

   • `~error手続き$rRは、 所与の ( %e ) に対し： ◎ error steps, given e

     1. ~NOABRUPT `ReadableStreamDefaultReaderRelease$A( %reader ) ◎ Perform ! ReadableStreamDefaultReaderRelease(reader).
     2. `~promiseを却下する$( %promise, %e ) ◎ Reject promise with e.
5. ~NOABRUPT `ReadableStreamDefaultReaderRead$A( コレ, %readRequest ) ◎ Perform ! ReadableStreamDefaultReaderRead(this, readRequest).
6. ~RET %promise ◎ Return promise.

`ReadableStream$I 用の`非同期~反復子から返る手続き$は、 所与の ( %stream, %iterator, %arg ) に対し： ◎ The asynchronous iterator return steps for a ReadableStream, given stream, iterator, and arg, are:

1. %reader ~LET %iterator の`非同期c読取器$ ◎ Let reader be iterator’s reader.
2. ~Assert： %reader.`stream$rsR ~NEQ `undefined^jv ◎ Assert: reader.[[stream]] is not undefined.
3. ~Assert： %reader.`readRequests$rsR は`空$である — `next()^c に対する以前の~callは、 非同期c反復子の機構により， これが~callされる前に決着することが保証されるので。 ◎ Assert: reader.[[readRequests]] is empty, as the async iterator machinery guarantees that any previous calls to next() have settled before this is called.

4. ~IF［ %iterator の`取消-を防止するか$ ~EQ ~F ］： ◎ If iterator’s prevent cancel is false:

   1. %result ~LET ~NOABRUPT `ReadableStreamReaderGenericCancel$A( %reader, %arg ) ◎ Let result be ! ReadableStreamReaderGenericCancel(reader, arg).
   2. ~NOABRUPT `ReadableStreamDefaultReaderRelease$A( %reader ) ◎ Perform ! ReadableStreamDefaultReaderRelease(reader).
   3. ~RET %result ◎ Return result.
5. ~NOABRUPT `ReadableStreamDefaultReaderRelease$A( %reader ) ◎ Perform ! ReadableStreamDefaultReaderRelease(reader).
6. ~RET `解決される~promise$( `undefined^jv ) ◎ Return a promise resolved with undefined.

`closed@gr 取得子~手続きは： ◎ The closed getter steps are:

1. ~RET コレ.`closedPromise$rsR ◎ Return this.[[closedPromise]].

`cancel(reason)@gr ~method手続きは： ◎ The cancel(reason) method steps are:

1. ~IF［ コレ.`stream$rsR ~EQ `undefined^jv ］ ⇒ ~RET `却下される~promise$( `TypeError$jE 例外 ) ◎ If this.[[stream]] is undefined, return a promise rejected with a TypeError exception.
2. ~RET ~NOABRUPT `ReadableStreamReaderGenericCancel$A( コレ, %reason ) ◎ Return ! ReadableStreamReaderGenericCancel(this, reason).

`new ReadableStreamDefaultReader(stream)@m 構築子~手続きは： ◎ The new ReadableStreamDefaultReader(stream) constructor steps are:

1. ~ABRUPT `SetUpReadableStreamDefaultReader$A(コレ, %stream). ◎ Perform ? SetUpReadableStreamDefaultReader(this, stream).

`read()@dr ~method手続きは： ◎ The read() method steps are:

1. ~IF［ コレ.`stream$rsR ~EQ `undefined^jv ］ ⇒ ~RET `却下される~promise$( `TypeError$jE 例外 ) ◎ If this.[[stream]] is undefined, return a promise rejected with a TypeError exception.
2. %promise ~LET `新たな~promise$ ◎ Let promise be a new promise.

3. %readRequest ~LET 次に挙げる`~item$sctを伴う，新たな`読取n要請$ : ◎ Let readRequest be a new read request with the following items:

   • `~chunk手続き$rRは、 所与の ( %chunk ) に対し ⇒ `~promiseを解決する$( %promise, «[ "`value$rrr" → %chunk, "`done$rrr" → ~F ]» ) ◎ chunk steps, given chunk • Resolve promise with «[ "value" → chunk, "done" → false ]».
   • `~close手続き$rRは ⇒ `~promiseを解決する$( %promise, «[ "`value$rrr" → `undefined^jv, "`done$rrr" → ~T ]» ) ◎ close steps • Resolve promise with «[ "value" → undefined, "done" → true ]».
   • `~error手続き$rRは、 所与の ( %e ) に対し ⇒ `~promiseを却下する$( %promise, %e ) ◎ error steps, given e • Reject promise with e.
4. ~RET ~NOABRUPT `ReadableStreamDefaultReaderRead$A( コレ, %readRequest ) ◎ Perform ! ReadableStreamDefaultReaderRead(this, readRequest).
5. ~RET %promise ◎ Return promise.

`releaseLock()@dr ~method手続きは： ◎ The releaseLock() method steps are:

1. ~IF［ コレ.`stream$rsR ~EQ `undefined^jv ］ ⇒ ~RET ◎ If this.[[stream]] is undefined, return.
2. ~NOABRUPT `ReadableStreamDefaultReaderRelease$A( コレ ) ◎ Perform ! ReadableStreamDefaultReaderRelease(this).

`new ReadableStreamBYOBReader(stream)@m 構築子~手続きは： ◎ The new ReadableStreamBYOBReader(stream) constructor steps are:

1. ~ABRUPT `SetUpReadableStreamBYOBReader$A(コレ, %stream). ◎ Perform ? SetUpReadableStreamBYOBReader(this, stream).

`read(view, options)@byob ~method手続きは： ◎ The read(view, options) method steps are:

1. ~IF［ %view.`ByteLength^sl ~EQ 0 ］ ⇒ ~RET `却下される~promise$( `TypeError$jE 例外 ) ◎ If view.[[ByteLength]] is 0, return a promise rejected with a TypeError exception.
2. ~IF［ %view.`ViewedArrayBuffer^sl.`ByteLength^sl ~EQ 0 ］ ⇒ ~RET `却下される~promise$( `TypeError$jE 例外 ) ◎ If view.[[ViewedArrayBuffer]].[[ByteLength]] is 0, return a promise rejected with a TypeError exception.
3. ~IF［ ~NOABRUPT `IsDetachedBuffer$Ax( %view.`ViewedArrayBuffer^sl）~EQ ~T ］ ⇒ ~RET `却下される~promise$( `TypeError$jE 例外 ) ◎ If ! IsDetachedBuffer(view.[[ViewedArrayBuffer]]) is true, return a promise rejected with a TypeError exception.
4. %min ~LET %options[ "`min$brO" ] ◎ ↓
5. ~IF［ %min ~EQ 0 ］ ⇒ ~RET `却下される~promise$( `TypeError$jE 例外 ) ◎ If options["min"] is 0, return a promise rejected with a TypeError exception.
6. ~IF［ %view は `TypedArrayName^sl 内部~slotを有する ］ ⇒ ~IF［ %min ~GT %view.`ArrayLength^sl ］ ⇒ ~RET `却下される~promise$( `RangeError$E 例外 ) ◎ If view has a [[TypedArrayName]] internal slot, • If options["min"] > view.[[ArrayLength]], return a promise rejected with a RangeError exception.
7. ~ELSE（すなわち， %view は `DataView$I である） ⇒ ~IF［ %min ~GT %view.`ByteLength^sl ］ ⇒ ~RET `却下される~promise$( `RangeError$E 例外 ) ◎ Otherwise (i.e., it is a DataView), • If options["min"] > view.[[ByteLength]], return a promise rejected with a RangeError exception.
8. ~IF［ コレ.`stream$rsR ~EQ `undefined^jv ］ ⇒ ~RET `却下される~promise$( `TypeError$jE 例外 ) ◎ If this.[[stream]] is undefined, return a promise rejected with a TypeError exception.
9. %promise ~LET `新たな~promise$ ◎ Let promise be a new promise.

10. %readIntoRequest ~LET 次に挙げる`~item$sctを伴う，新たな`中へ読取る要請$： ◎ Let readIntoRequest be a new read-into request with the following items:

    • `~chunk手続き$riRは、 所与の ( %chunk ) に対し ⇒ `~promiseを解決する$( %promise, «[ "`value$rrr" → %chunk, "`done$rrr" → ~F ]» ) ◎ chunk steps, given chunk • Resolve promise with «[ "value" → chunk, "done" → false ]».
    • `~close手続き$riRは、 所与の ( %chunk ) に対し ⇒ `~promiseを解決する$( %promise, «[ "`value$rrr" → %chunk, "`done$rrr" → ~T ]» ) ◎ close steps, given chunk • Resolve promise with «[ "value" → chunk, "done" → true ]».
    • `~error手続き$riRは、 所与の ( %e ) に対し ⇒ `~promiseを却下する$( %promise, %e ) ◎ error steps, given e • Reject promise with e.
11. ~RET ~NOABRUPT `ReadableStreamBYOBReaderRead$A( コレ, %view, %min, %readIntoRequest ) ◎ Perform ! ReadableStreamBYOBReaderRead(this, view, options["min"], readIntoRequest).
12. ~RET %promise ◎ Return promise.

`releaseLock()@byob ~method手続きは： ◎ The releaseLock() method steps are:

1. ~IF［ コレ.`stream$rsR ~EQ `undefined^jv ］ ⇒ ~RET ◎ If this.[[stream]] is undefined, return.
2. ~NOABRUPT `ReadableStreamBYOBReaderRelease$A( コレ ) ◎ Perform ! ReadableStreamBYOBReaderRelease(this).

`desiredSize@rsdc 取得子~手続きは： ◎ The desiredSize getter steps are:

1. ~RET ~NOABRUPT `ReadableStreamDefaultControllerGetDesiredSize$A( コレ ) ◎ Return ! ReadableStreamDefaultControllerGetDesiredSize(this).

`close()@rsdc ~method手続きは： ◎ The close() method steps are:

1. ~IF［ ~NOABRUPT `ReadableStreamDefaultControllerCanCloseOrEnqueue$A( コレ ) ~EQ ~F ］ ⇒ ~THROW `TypeError$jE ◎ If ! ReadableStreamDefaultControllerCanCloseOrEnqueue(this) is false, throw a TypeError exception.
2. ~NOABRUPT `ReadableStreamDefaultControllerClose$A( コレ ) ◎ Perform ! ReadableStreamDefaultControllerClose(this).

`enqueue(chunk)@rsdc ~method手続きは： ◎ The enqueue(chunk) method steps are:

1. ~IF［ ~NOABRUPT `ReadableStreamDefaultControllerCanCloseOrEnqueue$A( コレ ) ~EQ ~F ］ ⇒ ~THROW `TypeError$jE ◎ If ! ReadableStreamDefaultControllerCanCloseOrEnqueue(this) is false, throw a TypeError exception.
2. ~ABRUPT `ReadableStreamDefaultControllerEnqueue$A( コレ, %chunk ) ◎ Perform ? ReadableStreamDefaultControllerEnqueue(this, chunk).

`error(e)@rsdc ~method手続きは： ◎ The error(e) method steps are:

1. ~NOABRUPT `ReadableStreamDefaultControllerError$A( コレ, %e ) ◎ Perform ! ReadableStreamDefaultControllerError(this, e).

`[[CancelSteps]]( reason )@rsdc は、 `CancelSteps$sl の契約を実装する。 それは、 次の手続きを遂行する： ◎ [[CancelSteps]](reason) implements the [[CancelSteps]] contract. It performs the following steps:

1. ~NOABRUPT `ResetQueue$A( コレ ) ◎ Perform ! ResetQueue(this).
2. %result ~LET コレ.`cancelAlgorithm$rsdC( %reason ) ◎ Let result be the result of performing this.[[cancelAlgorithm]], passing reason.
3. ~NOABRUPT `ReadableStreamDefaultControllerClearAlgorithms$A( コレ ) ◎ Perform ! ReadableStreamDefaultControllerClearAlgorithms(this).
4. ~RET %result ◎ Return result.

`[[PullSteps]](readRequest)@rsdc は、 `PullSteps$sl の契約を実装する。 それは、 次の手続きを遂行する： ◎ [[PullSteps]](readRequest) implements the [[PullSteps]] contract. It performs the following steps:

1. %stream ~LET コレ.`stream$rsdC ◎ Let stream be this.[[stream]].

2. ~IF［ コレ.`queue$rsdC は`空$でない ］： ◎ If this.[[queue]] is not empty,

   1. %chunk ~LET ~NOABRUPT `DequeueValue$A( コレ ) ◎ Let chunk be ! DequeueValue(this).

   2. ~IF［ コレ.`closeRequested$rsdC ~EQ ~T ］~AND［ コレ.`queue$rsdC は`空$である ］ ◎ If this.[[closeRequested]] is true and this.[[queue]] is empty,

      1. ~NOABRUPT `ReadableStreamDefaultControllerClearAlgorithms$A( コレ ) ◎ Perform ! ReadableStreamDefaultControllerClearAlgorithms(this).
      2. ~NOABRUPT `ReadableStreamClose$A( %stream ) ◎ Perform ! ReadableStreamClose(stream).
   3. ~ELSE ⇒ ~NOABRUPT `ReadableStreamDefaultControllerCallPullIfNeeded$A( コレ ) ◎ Otherwise, perform ! ReadableStreamDefaultControllerCallPullIfNeeded(this).
   4. %readRequest の`~chunk手続き$rR( %chunk ) ◎ Perform readRequest’s chunk steps, given chunk.

3. ~ELSE： ◎ Otherwise,

   1. ~NOABRUPT `ReadableStreamAddReadRequest$A( %stream ) ◎ Perform ! ReadableStreamAddReadRequest(stream, readRequest).
   2. ~NOABRUPT `ReadableStreamDefaultControllerCallPullIfNeeded$A( コレ ) ◎ Perform ! ReadableStreamDefaultControllerCallPullIfNeeded(this).

`[[ReleaseSteps]]()@rsdc は、 `ReleaseSteps$sl の契約を実装する。 それは、 次の手続きを遂行する： ◎ [[ReleaseSteps]]() implements the [[ReleaseSteps]] contract. It performs the following steps:

1. ~RET ◎ Return.

`byobRequest@rbsc 取得子~手続きは： ◎ The byobRequest getter steps are:

1. ~RET ~NOABRUPT `ReadableByteStreamControllerGetBYOBRequest$A( コレ ) ◎ Return ! ReadableByteStreamControllerGetBYOBRequest(this).

`desiredSize@rbsc 取得子~手続きは： ◎ The desiredSize getter steps are:

1. ~RET ~NOABRUPT `ReadableByteStreamControllerGetDesiredSize$A( コレ ) ◎ Return ! ReadableByteStreamControllerGetDesiredSize(this).

`close()@rbsc ~method手続きは： ◎ The close() method steps are:

1. ~IF［ コレ.`closeRequested$rbsC ~EQ ~T ］ ⇒ ~THROW `TypeError$jE ◎ If this.[[closeRequested]] is true, throw a TypeError exception.
2. ~IF［ コレ.`stream$rbsC.`state$rS ~NEQ `readable^l ］ ⇒ ~THROW `TypeError$jE ◎ If this.[[stream]].[[state]] is not "readable", throw a TypeError exception.
3. ~ABRUPT `ReadableByteStreamControllerClose$A( コレ ) ◎ Perform ? ReadableByteStreamControllerClose(this).

`enqueue(chunk)@rbsc ~method手続きは： ◎ The enqueue(chunk) method steps are:

1. ~IF［ %chunk.`ByteLength^sl ~EQ 0 ］ ⇒ ~THROW `TypeError$jE ◎ If chunk.[[ByteLength]] is 0, throw a TypeError exception.
2. ~IF［ %chunk.`ViewedArrayBuffer^sl.`ByteLength^sl ~EQ 0 ］ ⇒ ~THROW `TypeError$jE ◎ If chunk.[[ViewedArrayBuffer]].[[ByteLength]] is 0, throw a TypeError exception.
3. ~IF［ コレ.`closeRequested$rbsC ~EQ ~T ］ ⇒ ~THROW `TypeError$jE ◎ If this.[[closeRequested]] is true, throw a TypeError exception.
4. ~IF［ コレ.`stream$rbsC.`state$rS ~NEQ `readable^l ］ ⇒ ~THROW `TypeError$jE ◎ If this.[[stream]].[[state]] is not "readable", throw a TypeError exception.
5. ~RET ~ABRUPT `ReadableByteStreamControllerEnqueue$A( コレ, %chunk ) ◎ Return ? ReadableByteStreamControllerEnqueue(this, chunk).

`error(e)@rbsc ~method手続きは： ◎ The error(e) method steps are:

1. ~NOABRUPT `ReadableByteStreamControllerError$A( コレ, %e ) ◎ Perform ! ReadableByteStreamControllerError(this, e).

`[[CancelSteps]]( reason )@rbsc は、 `CancelSteps$sl の契約を実装する。 それは、 次の手続きを遂行する： ◎ [[CancelSteps]](reason) implements the [[CancelSteps]] contract. It performs the following steps:

1. ~NOABRUPT `ReadableByteStreamControllerClearPendingPullIntos$A( コレ ) ◎ Perform ! ReadableByteStreamControllerClearPendingPullIntos(this).
2. ~NOABRUPT `ResetQueue$A( コレ ) ◎ Perform ! ResetQueue(this).
3. %result ~LET コレ.`cancelAlgorithm$rbsC( %reason ) ◎ Let result be the result of performing this.[[cancelAlgorithm]], passing in reason.
4. ~NOABRUPT `ReadableByteStreamControllerClearAlgorithms$A( コレ ) ◎ Perform ! ReadableByteStreamControllerClearAlgorithms(this).
5. ~RET %result ◎ Return result.

`[[PullSteps]](readRequest)@rbsc は、 `PullSteps$sl の契約を実装する。 それは、 次の手続きを遂行する： ◎ [[PullSteps]](readRequest) implements the [[PullSteps]] contract. It performs the following steps:

1. %stream ~LET コレ.`stream$rbsC ◎ Let stream be this.[[stream]].
2. ~Assert： ~NOABRUPT `ReadableStreamHasDefaultReader$A( %stream ) ~EQ ~T ◎ Assert: ! ReadableStreamHasDefaultReader(stream) is true.

3. ~IF［ コレ.`queueTotalSize$rbsC ~GT 0 ］： ◎ If this.[[queueTotalSize]] > 0,

   1. ~Assert： ~NOABRUPT `ReadableStreamGetNumReadRequests$A( %stream ) ~EQ 0： ◎ Assert: ! ReadableStreamGetNumReadRequests(stream) is 0.
   2. ~NOABRUPT `ReadableByteStreamControllerFillReadRequestFromQueue$A( コレ, %readRequest) ◎ Perform ! ReadableByteStreamControllerFillReadRequestFromQueue(this, readRequest).
   3. ~RET ◎ Return.
4. %autoAllocateChunkSize ~LET コレ.`autoAllocateChunkSize$rbsC ◎ Let autoAllocateChunkSize be this.[[autoAllocateChunkSize]].

5. ~IF［ %autoAllocateChunkSize ~NEQ `undefined^jv ］： ◎ If autoAllocateChunkSize is not undefined,

   1. %buffer ~LET `Construct$Ax( `ArrayBuffer$jI, « %autoAllocateChunkSize » ) ◎ Let buffer be Construct(%ArrayBuffer%, « autoAllocateChunkSize »).

   2. ~IF［ %buffer は`中途完了^である ］： ◎ If buffer is an abrupt completion,

      1. %readRequest の`~error手続き$rR( %buffer.`Value^sl ) ◎ Perform readRequest’s error steps, given buffer.[[Value]].
      2. ~RET ◎ Return.
   3. %pullIntoDescriptor ~LET 次を伴う，新たな`~pull~into記述子$ ⇒＃ `~buffer$pD ~SET %buffer.`Value^sl, `~buffer~byte長さ$pD ~SET %autoAllocateChunkSize, `~byte~offset$pD ~SET 0, `~byte長さ$pD ~SET %autoAllocateChunkSize, `埋まった~byte数$pD ~SET 0, `最小な埋n$pD ~SET 1, `要素~size$pD ~SET 1, `~view構築子$pD ~SET `Uint8Array$jI, `読取器~型$pD ~SET `default^l ◎ Let pullIntoDescriptor be a new pull-into descriptor with ◎ 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. コレ.`pendingPullIntos$rbsC に %pullIntoDescriptor を`付加する$ ◎ Append pullIntoDescriptor to this.[[pendingPullIntos]].
6. ~NOABRUPT `ReadableStreamAddReadRequest$A( %stream, %readRequest ) ◎ Perform ! ReadableStreamAddReadRequest(stream, readRequest).
7. ~NOABRUPT `ReadableByteStreamControllerCallPullIfNeeded$A( コレ ) ◎ Perform ! ReadableByteStreamControllerCallPullIfNeeded(this).

`[[ReleaseSteps]]()@rbsc は、 `ReleaseSteps$sl の契約を実装する。 それは、 次の手続きを遂行する： ◎ [[ReleaseSteps]]() implements the [[ReleaseSteps]] contract. It performs the following steps:

1. ~IF［ コレ.`pendingPullIntos$rbsC は`空$でない ］： ◎ If this.[[pendingPullIntos]] is not empty,

   1. %firstPendingPullInto ~LET コレ.`pendingPullIntos$rbsC[ 0 ] ◎ Let firstPendingPullInto be this.[[pendingPullIntos]][0].
   2. %firstPendingPullInto の`読取器~型$pD ~SET `none^l ◎ Set firstPendingPullInto’s reader type to "none".
   3. コレ.`pendingPullIntos$rbsC ~SET « %firstPendingPullInto » ◎ Set this.[[pendingPullIntos]] to the list « firstPendingPullInto ».

`view@bbrq 取得子~手続きは： ◎ The view getter steps are:

1. ~RET コレ.`view$bbrQ ◎ Return this.[[view]].

`respond(bytesWritten)@bbrq ~method手続きは： ◎ The respond(bytesWritten) method steps are:

1. ~IF［ コレ.`controller$bbrQ ~EQ `undefined^jv ］ ⇒ ~THROW `TypeError$jE ◎ If this.[[controller]] is undefined, throw a TypeError exception.
2. ~IF［ ~NOABRUPT `IsDetachedBuffer$Ax( コレ.`view$bbrQ.`ArrayBuffer^sl ) ~EQ ~T ］ ⇒ ~THROW `TypeError$jE ◎ If ! IsDetachedBuffer(this.[[view]].[[ArrayBuffer]]) is true, throw a TypeError exception.
3. ~Assert： コレ.`view$bbrQ.`ByteLength^sl ~GT 0 ◎ Assert: this.[[view]].[[ByteLength]] > 0.
4. ~Assert： コレ.`view$bbrQ.`ViewedArrayBuffer^sl.`ByteLength^sl ~GT 0 ◎ Assert: this.[[view]].[[ViewedArrayBuffer]].[[ByteLength]] > 0.
5. ~ABRUPT `ReadableByteStreamControllerRespond$A( コレ.`controller$bbrQ, %bytesWritten ) ◎ Perform ? ReadableByteStreamControllerRespond(this.[[controller]], bytesWritten).

`respondWithNewView(view)@bbrq ~method手続きは： ◎ The respondWithNewView(view) method steps are:

1. ~IF［ コレ.`controller$bbrQ ~EQ `undefined^jv ］ ⇒ ~THROW `TypeError$jE ◎ If this.[[controller]] is undefined, throw a TypeError exception.
2. ~IF［ ~NOABRUPT `IsDetachedBuffer$Ax( %view.`ViewedArrayBuffer^sl）~EQ ~T ］ ⇒ ~THROW `TypeError$jE ◎ If ! IsDetachedBuffer(view.[[ViewedArrayBuffer]]) is true, throw a TypeError exception.
3. ~RET ~ABRUPT `ReadableByteStreamControllerRespondWithNewView$A( コレ.`controller$bbrQ, %view) ◎ Return ? ReadableByteStreamControllerRespondWithNewView(this.[[controller]], view).

`AcquireReadableStreamBYOBReader(stream)@A は、 次の手続きを遂行する： ◎ AcquireReadableStreamBYOBReader(stream) performs the following steps:

1. %reader ~LET `新たな~obj$( `ReadableStreamBYOBReader$I ) ◎ Let reader be a new ReadableStreamBYOBReader.
2. ~ABRUPT `SetUpReadableStreamBYOBReader$A( %reader, « %stream » ) ◎ Perform ? SetUpReadableStreamBYOBReader(reader, stream).
3. ~RET %reader ◎ Return reader.

`AcquireReadableStreamDefaultReader(stream)@A は、 次の手続きを遂行する： ◎ AcquireReadableStreamDefaultReader(stream) performs the following steps:

1. %reader ~LET `新たな~obj$( `ReadableStreamDefaultReader$I ) ◎ Let reader be a new ReadableStreamDefaultReader.
2. ~ABRUPT `SetUpReadableStreamDefaultReader$A( %reader, « %stream » ) ◎ Perform ? SetUpReadableStreamDefaultReader(reader, stream).
3. ~RET %reader ◎ Return reader.

`CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm[, highWaterMark[, sizeAlgorithm ] ])@A は、 次の手続きを遂行する： ◎ CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm[, highWaterMark, [, sizeAlgorithm]]) performs the following steps:

1. ~IF［ %highWaterMark は渡されていない ］ ⇒ %highWaterMark ~SET 1 ◎ If highWaterMark was not passed, set it to 1.
2. ~IF［ %sizeAlgorithm は渡されていない ］ ⇒ %sizeAlgorithm ~SET 次を走らす~algo ⇒ ~RET 1 ◎ If sizeAlgorithm was not passed, set it to an algorithm that returns 1.
3. ~Assert： ~NOABRUPT `IsNonNegativeNumber$A( %highWaterMark ) ~EQ ~T ◎ Assert: ! IsNonNegativeNumber(highWaterMark) is true.
4. %stream ~LET `新たな~obj$( `ReadableStream$I ) ◎ Let stream be a new ReadableStream.
5. ~NOABRUPT `InitializeReadableStream$A( %stream ) ◎ Perform ! InitializeReadableStream(stream).
6. %controller ~LET `新たな~obj$( `ReadableStreamDefaultController$I ) ◎ Let controller be a new ReadableStreamDefaultController.
7. ~ABRUPT `SetUpReadableStreamDefaultController$A( ↓ ) ⇒＃ %stream, %controller, %startAlgorithm, %pullAlgorithm, %cancelAlgorithm, %highWaterMark, %sizeAlgorithm ◎ Perform ? SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm).
8. ~RET %stream ◎ Return stream.

注記： この抽象-演算は、 給された %startAlgorithm が投出するとき, そのときに限り， 例外を投出することになる。 ◎ This abstract operation will throw an exception if and only if the supplied startAlgorithm throws.

`CreateReadableByteStream(startAlgorithm, pullAlgorithm, cancelAlgorithm)@A は、 次の手続きを遂行する： ◎ CreateReadableByteStream(startAlgorithm, pullAlgorithm, cancelAlgorithm) performs the following steps:

1. %stream ~LET `新たな~obj$( `ReadableStream$I ) ◎ Let stream be a new ReadableStream.
2. ~NOABRUPT `InitializeReadableStream$A( %stream ) ◎ Perform ! InitializeReadableStream(stream).
3. %controller ~LET `新たな~obj$( `ReadableByteStreamController$I ) ◎ Let controller be a new ReadableByteStreamController.
4. ~ABRUPT `SetUpReadableByteStreamController$A( %stream, %controller, %startAlgorithm, %pullAlgorithm, %cancelAlgorithm, 0, `undefined^jv ) ◎ Perform ? SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, 0, undefined).
5. ~RET %stream ◎ Return stream.

注記： この抽象-演算は、 給された %startAlgorithm が投出するとき, そのときに限り， 例外を投出することになる。 ◎ This abstract operation will throw an exception if and only if the supplied startAlgorithm throws.

`InitializeReadableStream(stream)@A は、 次の手続きを遂行する： ◎ InitializeReadableStream(stream) performs the following steps:

1. %stream の ⇒＃ .`state$rS ~SET `readable^l, .`reader$rS ~SET `undefined^jv, .`storedError$rS ~SET `undefined^jv, .`disturbed$rS ~SET ~F ◎ Set stream.[[state]] to "readable". ◎ Set stream.[[reader]] and stream.[[storedError]] to undefined. ◎ Set stream.[[disturbed]] to false.

`IsReadableStreamLocked(stream)@A は、 次の手続きを遂行する： ◎ IsReadableStreamLocked(stream) performs the following steps:

1. ~IF［ %stream.`reader$rS ~EQ `undefined^jv ］ ⇒ ~RET ~F ◎ If stream.[[reader]] is undefined, return false.
2. ~RET ~T ◎ Return true.

`ReadableStreamFromIterable(asyncIterable)@A は、 次の手続きを遂行する： ◎ ReadableStreamFromIterable(asyncIterable) performs the following steps:

1. %stream ~LET `undefined^jv ◎ Let stream be undefined.
2. %iteratorRecord ~LET ~ABRUPT `GetIterator$Ax( %asyncIterable, `async^i ) ◎ Let iteratorRecord be ? GetIterator(asyncIterable, async).
3. %startAlgorithm ~LET 次を走らす~algo ⇒ ~RET `undefined^jv ◎ Let startAlgorithm be an algorithm that returns undefined.

4. %pullAlgorithm ~LET 次を走らす~algo： ◎ Let pullAlgorithm be the following steps:

   1. %nextResult ~LET `IteratorNext$Ax( %iteratorRecord ) ◎ Let nextResult be IteratorNext(iteratorRecord).
   2. ~IF［ %nextResult は`中途完了^である ］ ⇒ ~RET `却下される~promise$( %nextResult.`Value^sl ) ◎ If nextResult is an abrupt completion, return a promise rejected with nextResult.[[Value]].
   3. %nextPromise ~LET `解決される~promise$( %nextResult.`Value^sl ) ◎ Let nextPromise be a promise resolved with nextResult.[[Value]].

   4. ~RET `~promiseに反応する$( %nextPromise ) — 次を与える下で： ◎ Return the result of reacting to nextPromise with＼

      • `充足~手続き^i は、 所与の ( %iterResult ) に対し： ◎ the following fulfillment steps, given iterResult:

        1. ~IF［ %iterResult は `Object$jt でない ］ ⇒ ~THROW `TypeError$jE ◎ If iterResult is not an Object, throw a TypeError.
        2. %done ~LET ~ABRUPT `IteratorComplete$Ax( %iterResult ) ◎ Let done be ? IteratorComplete(iterResult).
        3. ~IF［ %done ~EQ ~T ］ ⇒ ~NOABRUPT `ReadableStreamDefaultControllerClose$A( %stream.`controller$rS ) ◎ If done is true: • Perform ! ReadableStreamDefaultControllerClose(stream.[[controller]]).

        4. ~ELSE： ◎ Otherwise:

           1. %value ~LET ~ABRUPT `IteratorValue$Ax( %iterResult ) ◎ Let value be ? IteratorValue(iterResult).
           2. ~NOABRUPT `ReadableStreamDefaultControllerEnqueue$A( %stream.`controller$rS, %value ) ◎ Perform ! ReadableStreamDefaultControllerEnqueue(stream.[[controller]], value).

5. %cancelAlgorithm ~LET 所与の ( %reason ) に対し，次を走らす~algo： ◎ Let cancelAlgorithm be the following steps, given reason:

   1. %iterator ~LET %iteratorRecord.`Iterator^sl ◎ Let iterator be iteratorRecord.[[Iterator]].
   2. %returnMethod ~LET `GetMethod$Ax( %iterator, `return^l ) ◎ Let returnMethod be GetMethod(iterator, "return").
   3. ~IF［ %returnMethod は`中途完了^である ］ ⇒ ~RET `却下される~promise$( %returnMethod.`Value^sl ) ◎ If returnMethod is an abrupt completion, return a promise rejected with returnMethod.[[Value]].
   4. ~IF［ %returnMethod.`Value^sl ~EQ `undefined^jv ］ ⇒ ~RET `解決される~promise$( `undefined^jv ) ◎ If returnMethod.[[Value]] is undefined, return a promise resolved with undefined.
   5. %returnResult ~LET `Call$Ax( %returnMethod.`Value^sl, %iterator, « %reason » ) ◎ Let returnResult be Call(returnMethod.[[Value]], iterator, « reason »).
   6. ~IF［ %returnResult は`中途完了^である ］ ⇒ ~RET `却下される~promise$( %returnResult.`Value^sl ) ◎ If returnResult is an abrupt completion, return a promise rejected with returnResult.[[Value]].
   7. %returnPromise ~LET `解決される~promise$( %returnResult.`Value^sl ) ◎ Let returnPromise be a promise resolved with returnResult.[[Value]].

   8. ~RET `~promiseに反応する$( %returnPromise ) — 次を与える下で： ◎ Return the result of reacting to returnPromise with＼

      • `充足~手続き^i は、 所与の ( %iterResult ) に対し： ◎ the following fulfillment steps, given iterResult:

        1. ~IF［ %iterResult は `Object$jt でない ］ ⇒ ~THROW `TypeError$jE ◎ If iterResult is not an Object, throw a TypeError.
        2. ~RET `undefined^jv ◎ Return undefined.
6. %stream ~SET ~NOABRUPT `CreateReadableStream$A( %startAlgorithm, %pullAlgorithm, %cancelAlgorithm, 0 ) ◎ Set stream to ! CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, 0).
7. ~RET %stream ◎ Return stream.

`ReadableStreamPipeTo(source, dest, preventClose, preventAbort, preventCancel[, signal])@A は、 次の手続きを遂行する： ◎ ReadableStreamPipeTo(source, dest, preventClose, preventAbort, preventCancel[, signal]) performs the following steps:

1. ~Assert： %source は `ReadableStream$I を`実装する$ ◎ Assert: source implements ReadableStream.
2. ~Assert： %dest は `WritableStream$I を`実装する$ ◎ Assert: dest implements WritableStream.
3. ~Assert： ［ %preventClose, %preventAbort, %preventCancel ］は、 どれも真偽値である ◎ Assert: preventClose, preventAbort, and preventCancel are all booleans.
4. ~IF［ %signal は与えられていない ］ ⇒ %signal ~SET `undefined^jv ◎ If signal was not given, let signal be undefined.
5. ~Assert： ［ %signal ~EQ `undefined^jv ］~OR［ %signal は `AbortSignal$I を`実装する$ ］ ◎ Assert: either signal is undefined, or signal implements AbortSignal.
6. ~Assert： ~NOABRUPT `IsReadableStreamLocked$A( %source ) ~EQ ~F ◎ Assert: ! IsReadableStreamLocked(source) is false.
7. ~Assert： ~NOABRUPT `IsWritableStreamLocked$A( %dest ) ~EQ ~F ◎ Assert: ! IsWritableStreamLocked(dest) is false.
8. %reader ~LET ε ◎ ↓
9. ~IF［ %source.`controller$rS は `ReadableByteStreamController$I を`実装する$ ］ ⇒ %reader ~SET ~UAの裁量で，次のいずれかを遂行した結果 ⇒＃ ~NOABRUPT `AcquireReadableStreamBYOBReader$A( %source ) ／ ~NOABRUPT `AcquireReadableStreamDefaultReader$A( %source ) ◎ If source.[[controller]] implements ReadableByteStreamController, let reader be either ! AcquireReadableStreamBYOBReader(source) or ! AcquireReadableStreamDefaultReader(source), at the user agent’s discretion.
10. ~ELSE ⇒ %reader ~SET ~NOABRUPT `AcquireReadableStreamDefaultReader$A( %source ) ◎ Otherwise, let reader be ! AcquireReadableStreamDefaultReader(source).
11. %writer ~LET ~NOABRUPT `AcquireWritableStreamDefaultWriter$A( %dest ) ◎ Let writer be ! AcquireWritableStreamDefaultWriter(dest).
12. %source.`disturbed$rS ~SET ~T ◎ Set source.[[disturbed]] to true.
13. %shuttingDown ~LET ~F ◎ Let shuttingDown be false.
14. %promise ~LET `新たな~promise$ ◎ Let promise be a new promise.

15. ~IF［ %signal ~NEQ `undefined^jv ］： ◎ If signal is not undefined,

    1. %abortAlgorithm ~LET 次を走らす~algo： ◎ Let abortAlgorithm be the following steps:

       1. %error ~LET %signal の`中止-事由$aB ◎ Let error be signal’s abort reason.
       2. %actions ~LET 新たな`有順序~集合$ ◎ Let actions be an empty ordered set.

       3. ~IF［ %preventAbort ~EQ ~F ］ ⇒ %actions に次の手続きが成す動作を`付加する$set ◎ If preventAbort is false, append the following action to actions:

          手続きは： ◎ ↑

          1. ~IF［ %dest.`state$wS ~EQ `writable^l ］ ⇒ ~RET ~NOABRUPT `WritableStreamAbort$A( %dest, %error ) ◎ If dest.[[state]] is "writable", return ! WritableStreamAbort(dest, error).
          2. ~RET `解決される~promise$( `undefined^jv ) ◎ Otherwise, return a promise resolved with undefined.

       4. ~IF［ %preventCancel ~EQ ~F ］ ⇒ %actions に次の手続きが成す動作を`付加する$set ◎ If preventCancel is false, append the following action to actions:

          手続きは： ◎ ↑

          1. ~IF［ %source.`state$rS ~EQ `readable^l ］ ⇒ ~RET ~NOABRUPT `ReadableStreamCancel$A( %source, %error ) ◎ If source.[[state]] is "readable", return ! ReadableStreamCancel(source, error).
          2. ~RET `解決される~promise$( `undefined^jv ) ◎ Otherwise, return a promise resolved with undefined.

       5. `~shutdownする$( %error, 次の手続きが成す動作 )

          手続きは ⇒ `すべてを待機する~promiseを取得する$( %actions 内の動作たち )
          ◎ Shutdown with an action consisting of getting a promise to wait for all of the actions in actions, and with error.
    2. ~IF［ %signal は`中止-済み$aBである ］ ⇒＃ %abortAlgorithm を遂行する； ~RET %promise ◎ If signal is aborted, perform abortAlgorithm and return promise.
    3. `通達に~algoを追加する$( %signal, %abortAlgorithm ) ◎ Add abortAlgorithm to signal.

16. ( %reader, %writer ) を利用して，`並列的$に 本当はそうでない — `課題 #905＠https://github.com/whatwg/streams/issues/905$ を見よ — %source から すべての`~chunk$を読取って %dest に書込む。 これが起こる正確な方式は、 ( 読取器, 書込器 ) が供する~lock法に因り，作者~codeからは観測-可能でない。 よって，~UAには これを柔軟に行う余地があるが、 利用される正確な~algoを問わず，~UAには以下の拘束が適用される： ◎ In parallel but not really; see #905, using reader and writer, read all chunks from source and write them to dest. Due to the locking provided by the reader and writer, the exact manner in which this happens is not observable to author code, and so there is flexibility in how this is done. The following constraints apply regardless of the exact algorithm used:

    • `公な~APIを利用しないモノトスル^strong ⇒ ［ 読取り／書込み ］の間, および 以下に挙げる演算を遂行している間は、 何かを改変-可能な~JSの［ 読取器, 書込器, ~stream~API ］（すなわち，適切な~prototype上の~methodたち）は，利用しないモノトスル — ~streamは，直に操作するモノトスル。 ◎ Public API must not be used: while reading or writing, or performing any of the operations below, the JavaScript-modifiable reader, writer, and stream APIs (i.e. methods on the appropriate prototypes) must not be used. Instead, the streams must be manipulated directly.

    • `背圧を施行するモノトスル^strong： ◎ Backpressure must be enforced:

      • `WritableStreamDefaultWriterGetDesiredSize$A( %writer ) の結果が［ 0 以下, または ~NULL ］になる間は、 %reader から読取らないモノトスル ◎ While WritableStreamDefaultWriterGetDesiredSize(writer) is ≤ 0 or is null, the user agent must not read from reader.

      • %reader が`~BYOB読取器$である場合、 %reader から読取る~chunkの~sizeを決定するときには， `WritableStreamDefaultWriterGetDesiredSize$A( %writer ) をその基礎に利用するベキである。 ◎ If reader is a BYOB reader, WritableStreamDefaultWriterGetDesiredSize(writer) should be used as a basis to determine the size of the chunks read from reader.

        注記： ［ 小さすぎる／大きすぎる ］~chunkたちを読取ることは、 効率的でないことが多い。 他の情報も，最適な~chunk~sizeを決定する要因になるかもしれない。 ◎ It’s frequently inefficient to read chunks that are too small or too large. Other information might be factored in to determine the optimal chunk size.

      • ［ 読取n／書込n ］を背圧~通達~以外の理由で遅延するベキでない。 ◎ Reads or writes should not be delayed for reasons other than these backpressure signals.

        次回の［ 読取n／書込n ］演算を続行する前に，各~書込nが成功裡に完了するまで待機するような実装は、 この推奨に違反する。 そのような実装においては、 %dest の`内部~queue$は［ 常に，`~chunk$を 1 個までしか包含しない ］ようになり，役立たずになるので。 ◎ An implementation that waits for each write to successfully complete before proceeding to the next read/write operation violates this recommendation. In doing so, such an implementation makes the internal queue of dest useless, as it ensures dest always contains at most one queued chunk.

    • `~shutdownは活動を停止させるモノトスル^strong — %shuttingDown が ~T になって以降は、 次に従うモノトスル：

      • それ以上 %reader からの読取nを起動しない。
      • 以下に述べるとおり， すでに読取られた~chunkの書込nのみを遂行する。
      • 特に、［ 読取n／書込n ］を遂行する前に，以下に挙げる条件を検査する — それらは、 即時に~shutdownへ至らすこともあるので。
      ◎ Shutdown must stop activity: if shuttingDown becomes true, the user agent must not initiate further reads from reader, and must only perform writes of already-read chunks, as described below. In particular, the user agent must check the below conditions before performing any reads or writes, since they might lead to immediate shutdown.

    • `~error／~close状態は伝播するモノトスル^strong — 以下に挙げる条件は、 挙げられた順に適用するモノトスル： ◎ Error and close states must be propagated: the following conditions must be applied in order.

      1. `~errorは前方へ伝播するモノトスル^strong： ◎ Errors must be propagated forward:＼

         %source.`state$rS ~EQ `errored^l のとき, または そうなったときは： ◎ if source.[[state]] is or becomes "errored", then

         1. ~IF［ %preventAbort ~EQ ~F ］ ⇒ `~shutdownする$( %source.`storedError$rS, 次を行う動作 ) ⇒ ~NOABRUPT `WritableStreamAbort$A( %dest, %source.`storedError$rS ) ◎ If preventAbort is false, shutdown with an action of ! WritableStreamAbort(dest, source.[[storedError]]) and with source.[[storedError]].
         2. ~ELSE ⇒ `~shutdownする$( %source.`storedError$rS, ε ) ◎ Otherwise, shutdown with source.[[storedError]].

      2. `~errorは後方へ伝播するモノトスル^strong： ◎ Errors must be propagated backward:＼

         %dest.`state$wS ~EQ `errored^l のとき, または そうなったときは： ◎ if dest.[[state]] is or becomes "errored", then

         1. ~IF［ %preventCancel ~EQ ~F ］ ⇒ `~shutdownする$( %dest.`storedError$wS, 次を行う動作 ) ⇒ ~NOABRUPT `ReadableStreamCancel$A( %source, %dest.`storedError$wS ) ◎ If preventCancel is false, shutdown with an action of ! ReadableStreamCancel(source, dest.[[storedError]]) and with dest.[[storedError]].
         2. ~ELSE ⇒ `~shutdownする$( %dest.`storedError$wS, ε ) ◎ Otherwise, shutdown with dest.[[storedError]].

      3. `~closingは前方へ伝播するモノトスル^strong： ◎ Closing must be propagated forward:＼

         %source.`state$rS ~EQ `closed^l のとき, または そうなったときは： ◎ if source.[[state]] is or becomes "closed", then

         1. ~IF［ %preventClose ~EQ ~F ］ ⇒ `~shutdownする$( ε, 次を行う動作 ) ⇒ ~NOABRUPT `WritableStreamDefaultWriterCloseWithErrorPropagation$A( %writer ) ◎ If preventClose is false, shutdown with an action of ! WritableStreamDefaultWriterCloseWithErrorPropagation(writer).
         2. ~ELSE ⇒ `~shutdownする$( ε, ε ) ◎ Otherwise, shutdown.

      4. `~closingは後方へ伝播するモノトスル^strong： ◎ Closing must be propagated backward:＼

         ［ ~NOABRUPT `WritableStreamCloseQueuedOrInFlight$A( %dest ) ~EQ ~T ］~OR［ %dest.`state$wS ~EQ `closed^l ］のときは： ◎ if ! WritableStreamCloseQueuedOrInFlight(dest) is true or dest.[[state]] is "closed", then

         1. ~Assert： ［ 読取った／書込んだ ］`~chunk$はない ◎ Assert: no chunks have been read or written.
         2. %destClosed ~LET 新たな `TypeError$jE ◎ Let destClosed be a new TypeError.
         3. ~IF［ %preventCancel ~EQ ~F ］ ⇒ `~shutdownする$( %destClosed, 次を行う動作 ) ⇒ ~NOABRUPT `ReadableStreamCancel$A( %source, %destClosed ) ◎ If preventCancel is false, shutdown with an action of ! ReadableStreamCancel(source, destClosed) and with destClosed.
         4. ~ELSE ⇒ `~shutdownする$( %destClosed, ε ) ◎ Otherwise, shutdown with destClosed.

      上に挙げた［ 要件／手続き ］に利用される `~shutdownする@ 下位-手続きは、 所与の ( %error, %action ) に対し，次を遂行する： ◎ Shutdown with an action: if any of the above requirements ask to shutdown with an action action, optionally with an error originalError, then:

      1. ~IF［ %shuttingDown ~EQ ~T ］ ⇒ ~RET ◎ If shuttingDown is true, abort these substeps.
      2. %shuttingDown ~SET ~T ◎ Set shuttingDown to true.

      3. ~IF［ %dest.`state$wS ~EQ `writable^l ］~AND［ ~NOABRUPT `WritableStreamCloseQueuedOrInFlight$A( %dest ) ~EQ ~F ］： ◎ If dest.[[state]] is "writable" and ! WritableStreamCloseQueuedOrInFlight(dest) is false,

         1. ~IF［ 読取られたがまだ書込まれていない`~chunk$はある ］ ⇒ それらを %dest に書込む ◎ If any chunks have been read but not yet written, write them to dest.
         2. 読取られたすべての`~chunk$が書込まれるまで（すなわち，対応する~promiseは決着するまで）待機する ◎ Wait until every chunk that has been read has been written (i.e. the corresponding promises have settled).

      4. ~IF［ %action ~EQ ε ］：

         1. `完結する$( %error )
         2. ~RET
         ◎ ↓↓

      5. %p ~LET %action を遂行した結果： ◎ Let p be the result of performing action.

         • %p の`充足-時$には ⇒ `完結する$( %error ) ◎ Upon fulfillment of p, finalize, passing along originalError if it was given.
         • %p の`却下-時$には、 所与の ( 事由 %newError ) に対し ⇒ `完結する$( %newError ) ◎ Upon rejection of p with reason newError, finalize with newError.

      【 この手続きは、 原文では， 2 つに分けて記されているが （ %action ~EQ ε の場合と 非 ε の場合）、 表記上の都合により この訳では一つに集約している。 】

      ◎ Shutdown: if any of the above requirements or steps ask to shutdown, optionally with an error error, then: • If shuttingDown is true, abort these substeps. • Set shuttingDown to true. • If dest.[[state]] is "writable" and ! WritableStreamCloseQueuedOrInFlight(dest) is false, •• If any chunks have been read but not yet written, write them to dest. •• Wait until every chunk that has been read has been written (i.e. the corresponding promises have settled). • Finalize, passing along error if it was given.

      上で利用される `完結する@ 下位-手続きは、 所与の ( %error ) に対し，次を遂行する： ◎ Finalize: both forms of shutdown will eventually ask to finalize, optionally with an error error, which means to perform the following steps:

      1. ~NOABRUPT `WritableStreamDefaultWriterRelease$A( %writer ) ◎ Perform ! WritableStreamDefaultWriterRelease(writer).
      2. ~IF［ %reader は `ReadableStreamBYOBReader$I を`実装する$ ］ ⇒ ~NOABRUPT `ReadableStreamBYOBReaderRelease$A( %reader ) ◎ If reader implements ReadableStreamBYOBReader, perform ! ReadableStreamBYOBReaderRelease(reader).
      3. ~ELSE ⇒ ~NOABRUPT `ReadableStreamDefaultReaderRelease$A( %reader ) ◎ Otherwise, perform ! ReadableStreamDefaultReaderRelease(reader).
      4. ~IF［ %signal ~NEQ `undefined^jv ］ ⇒ `通達から~algoを除去する$( %signal, %abortAlgorithm ) ◎ If signal is not undefined, remove abortAlgorithm from signal.
      5. ~IF［ %error ~NEQ ε ］ ⇒ `~promiseを却下する$( %promise, %error ) ◎ If error was given, reject promise with error.
      6. ~ELSE ⇒ `~promiseを解決する$( %promise, `undefined^jv ) ◎ Otherwise, resolve promise with undefined.
17. ~RET %promise ◎ Return promise.

`ReadableStreamTee(stream, cloneForBranch2)@A は、 所与の可読~streamを`二叉化-$する。 ◎ ReadableStreamTee(stream, cloneForBranch2) will tee a given readable stream.

2 個目の引数 %cloneForBranch2 は、［ 元の~streamからの~dataは、 2 個目の分岐~内に現れる前に~cloneされるかどうか ］を統治する（ `HTML$r による，`直列化-可能$な~obj用の~frameworkを利用して）。 これは、 両 分岐が消費されるとき，［ ~chunkを`転送する＠~HTMLcloning#transferable-objects$ことにより， 互いに干渉しあうおそれがある局面 ］で有用になる。 しかしながら、［ 両 分岐の間に外から見える非対称性 ］も導入され， アリな`~chunk$も直列化-可能なものに制限されることになる。 ◎ The second argument, cloneForBranch2, governs whether or not the data from the original stream will be cloned (using HTML’s serializable objects framework) before appearing in the second of the returned branches. This is useful for scenarios where both branches are to be consumed in such a way that they might otherwise interfere with each other, such as by transferring their chunks. However, it does introduce a noticeable asymmetry between the two branches, and limits the possible chunks to serializable ones. [HTML]

%stream は`可読~byte~stream$である場合、 %cloneForBranch2 は無視され，各~chunkは無条件に~cloneされる。 ◎ If stream is a readable byte stream, then cloneForBranch2 is ignored and chunks are cloned unconditionally.

注記： この標準においては、 `ReadableStreamTee$A が~callされるときは， 常に %cloneForBranch2 は ~F に設定される。 他の仕様は、 二叉化-を包装する~algoを介して ~T を渡す。 ◎ In this standard ReadableStreamTee is always called with cloneForBranch2 set to false; other specifications pass true via the tee wrapper algorithm.

それは、 次の手続きを遂行する： ◎ It performs the following steps:

1. ~Assert： %stream は `ReadableStream$I を`実装する$ ◎ Assert: stream implements ReadableStream.
2. ~Assert： %cloneForBranch2 は真偽値である ◎ Assert: cloneForBranch2 is a boolean.
3. ~IF［ %stream.`controller$rS は `ReadableByteStreamController$I を`実装する$ ］ ⇒ ~RET ~ABRUPT `ReadableByteStreamTee$A( %stream ) ◎ If stream.[[controller]] implements ReadableByteStreamController, return ? ReadableByteStreamTee(stream).
4. ~RET ~ABRUPT `ReadableStreamDefaultTee$A( %stream, %cloneForBranch2 ) ◎ Return ? ReadableStreamDefaultTee(stream, cloneForBranch2).

`ReadableStreamDefaultTee(stream, cloneForBranch2)@A は、 次の手続きを遂行する： ◎ ReadableStreamDefaultTee(stream, cloneForBranch2) performs the following steps:

1. ~Assert： %stream は `ReadableStream$I を`実装する$ ◎ Assert: stream implements ReadableStream.
2. ~Assert： %cloneForBranch2 は真偽値である ◎ Assert: cloneForBranch2 is a boolean.
3. %reader ~LET ~ABRUPT `AcquireReadableStreamDefaultReader$A( %stream ) ◎ Let reader be ? AcquireReadableStreamDefaultReader(stream).
4. %reading ~LET ~F ◎ Let reading be false.
5. %readAgain ~LET ~F ◎ Let readAgain be false.
6. %canceled1 ~LET ~F ◎ Let canceled1 be false.
7. %canceled2 ~LET ~F ◎ Let canceled2 be false.
8. %reason1 ~LET `undefined^jv ◎ Let reason1 be undefined.
9. %reason2 ~LET `undefined^jv ◎ Let reason2 be undefined.
10. %branch1 ~LET `undefined^jv ◎ Let branch1 be undefined.
11. %branch2 ~LET `undefined^jv ◎ Let branch2 be undefined.
12. %cancelPromise ~LET `新たな~promise$ ◎ Let cancelPromise be a new promise.

13. %pullAlgorithm ~LET 次を走らす~algo： ◎ Let pullAlgorithm be the following steps:

    1. ~IF［ %reading ~EQ ~T ］： ◎ If reading is true,

       1. %readAgain ~SET ~T ◎ Set readAgain to true.
       2. ~RET `解決される~promise$( `undefined^jv ) ◎ Return a promise resolved with undefined.
    2. %reading ~SET ~T ◎ Set reading to true.

    3. %readRequest ~LET 次に挙げる`~item$sctを伴う，`読取n要請$： ◎ Let readRequest be a read request with the following items:

       • `~chunk手続き$rRは、 所与の ( %chunk ) に対し ⇒ `小taskを~queueする$( 次の手続き ) ◎ chunk steps, given chunk • Queue a microtask to perform＼

         手続きは： ◎ the following steps:

         1. %readAgain ~SET ~F ◎ Set readAgain to false.
         2. %chunk1 ~LET %chunk ◎ ↓
         3. %chunk2 ~LET %chunk ◎ Let chunk1 and chunk2 be chunk.

         4. ~IF［ %canceled2 ~EQ ~F ］~AND［ %cloneForBranch2 ~EQ ~T ］： ◎ If canceled2 is false and cloneForBranch2 is true,

            1. %cloneResult ~LET `StructuredClone$A( %chunk2 ) ◎ Let cloneResult be StructuredClone(chunk2).

            2. ~IF［ %cloneResult は`中途完了^である ］： ◎ If cloneResult is an abrupt completion,

               1. ~NOABRUPT `ReadableStreamDefaultControllerError$A( %branch1.`controller$rS, %cloneResult.`Value^sl ) ◎ Perform ! ReadableStreamDefaultControllerError(branch1.[[controller]], cloneResult.[[Value]]).
               2. ~NOABRUPT `ReadableStreamDefaultControllerError$A( %branch2.`controller$rS, %cloneResult.`Value^sl ) ◎ Perform ! ReadableStreamDefaultControllerError(branch2.[[controller]], cloneResult.[[Value]]).
               3. `~promiseを解決する$( %cancelPromise, 次の結果 ) ⇒ ~NOABRUPT `ReadableStreamCancel$A( %stream, %cloneResult.`Value^sl ) ◎ Resolve cancelPromise with ! ReadableStreamCancel(stream, cloneResult.[[Value]]).
               4. ~RET ◎ Return.
            3. ~ELSE ⇒ %chunk2 ~SET %cloneResult.`Value^sl ◎ Otherwise, set chunk2 to cloneResult.[[Value]].
         5. ~IF［ %canceled1 ~EQ ~F ］ ⇒ ~NOABRUPT `ReadableStreamDefaultControllerEnqueue$A( %branch1.`controller$rS, %chunk1 ) ◎ If canceled1 is false, perform ! ReadableStreamDefaultControllerEnqueue(branch1.[[controller]], chunk1).
         6. ~IF［ %canceled2 ~EQ ~F ］ ⇒ ~NOABRUPT `ReadableStreamDefaultControllerEnqueue$A( %branch2.`controller$rS, %chunk2 ) ◎ If canceled2 is false, perform ! ReadableStreamDefaultControllerEnqueue(branch2.[[controller]], chunk2).
         7. %reading ~SET ~F ◎ Set reading to false.
         8. ~IF［ %readAgain ~EQ ~T ］ ⇒ %pullAlgorithm を遂行する ◎ If readAgain is true, perform pullAlgorithm.

         注記： ここでの小taskによる遅延は、 必要yである — 下にて %reader.`closedPromise$rsR を利用するとき、 少なくとも，~errorを検出する小taskがかかるので。 %stream における~errorは，両~分岐とも即時に~errorにすることが求まれるので、 非同期的に可用な~errorに先んじて，成功裡な読取nを同期的に可用にするわけにはいかない。 ◎ The microtask delay here is necessary because it takes at least a microtask to detect errors, when we use reader.[[closedPromise]] below. We want errors in stream to error both branches immediately, so we cannot let successful synchronously-available reads happen ahead of asynchronously-available errors.

       • `~close手続き$rRは： ◎ close steps

         1. %reading ~SET ~F ◎ Set reading to false.
         2. ~IF［ %canceled1 ~EQ ~F ］ ⇒ ~NOABRUPT `ReadableStreamDefaultControllerClose$A( %branch1.`controller$rS ) ◎ If canceled1 is false, perform ! ReadableStreamDefaultControllerClose(branch1.[[controller]]).
         3. ~IF［ %canceled2 ~EQ ~F ］ ⇒ ~NOABRUPT `ReadableStreamDefaultControllerClose$A( %branch2.`controller$rS ) ◎ If canceled2 is false, perform ! ReadableStreamDefaultControllerClose(branch2.[[controller]]).
         4. ~IF［ %canceled1 ~EQ ~F ］~OR［ %canceled2 ~EQ ~F ］ ⇒ `~promiseを解決する$( %cancelPromise, `undefined^jv ) ◎ If canceled1 is false or canceled2 is false, resolve cancelPromise with undefined.
       • `~error手続き$rRは ⇒ %reading ~SET ~F ◎ error steps • Set reading to false.
    4. ~NOABRUPT `ReadableStreamDefaultReaderRead$A( %reader, %readRequest ) ◎ Perform ! ReadableStreamDefaultReaderRead(reader, readRequest).
    5. ~RET `解決される~promise$( `undefined^jv ) ◎ Return a promise resolved with undefined.

14. %cancel1Algorithm ~LET 所与の ( %reason ) に対し，次を走らす~algo： ◎ Let cancel1Algorithm be the following steps, taking a reason argument:

    1. %canceled1 ~SET ~T ◎ Set canceled1 to true.
    2. %reason1 ~SET %reason ◎ Set reason1 to reason.

    3. ~IF［ %canceled2 ~EQ ~T ］： ◎ If canceled2 is true,

       1. %compositeReason ~LET ~NOABRUPT `CreateArrayFromList$Ax( « %reason1, %reason2 » ) ◎ Let compositeReason be ! CreateArrayFromList(« reason1, reason2 »).
       2. %cancelResult ~LET ~NOABRUPT `ReadableStreamCancel$A( %stream, %compositeReason ) ◎ Let cancelResult be ! ReadableStreamCancel(stream, compositeReason).
       3. `~promiseを解決する$( %cancelPromise, %cancelResult ) ◎ Resolve cancelPromise with cancelResult.
    4. ~RET %cancelPromise ◎ Return cancelPromise.

15. %cancel2Algorithm ~LET 所与の ( %reason ) に対し，次を走らす~algo： ◎ Let cancel2Algorithm be the following steps, taking a reason argument:

    1. %canceled2 ~SET ~T ◎ Set canceled2 to true.
    2. %reason2 ~SET %reason ◎ Set reason2 to reason.

    3. ~IF［ %canceled1 ~EQ ~T ］： ◎ If canceled1 is true,

       1. %compositeReason ~LET ~NOABRUPT `CreateArrayFromList$Ax( « %reason1, %reason2 » ) ◎ Let compositeReason be ! CreateArrayFromList(« reason1, reason2 »).
       2. %cancelResult ~LET ~NOABRUPT `ReadableStreamCancel$A( %stream, %compositeReason ) ◎ Let cancelResult be ! ReadableStreamCancel(stream, compositeReason).
       3. `~promiseを解決する$( %cancelPromise, %cancelResult ) ◎ Resolve cancelPromise with cancelResult.
    4. ~RET %cancelPromise ◎ Return cancelPromise.
16. %startAlgorithm ~LET 次を走らす~algo ⇒ ~RET `undefined^jv ◎ Let startAlgorithm be an algorithm that returns undefined.
17. %branch1 ~SET ~NOABRUPT `CreateReadableStream$A( %startAlgorithm, %pullAlgorithm, %cancel1Algorithm) ◎ Set branch1 to ! CreateReadableStream(startAlgorithm, pullAlgorithm, cancel1Algorithm).
18. %branch2 ~SET ~NOABRUPT `CreateReadableStream$A( %startAlgorithm, %pullAlgorithm, %cancel2Algorithm) ◎ Set branch2 to ! CreateReadableStream(startAlgorithm, pullAlgorithm, cancel2Algorithm).

19. %reader.`closedPromise$rsR の`却下-時$には、 所与の ( 事由 %r ) に対し： ◎ Upon rejection of reader.[[closedPromise]] with reason r,

    1. ~NOABRUPT `ReadableStreamDefaultControllerError$A( %branch1.`controller$rS, %r ) ◎ Perform ! ReadableStreamDefaultControllerError(branch1.[[controller]], r).
    2. ~NOABRUPT `ReadableStreamDefaultControllerError$A( %branch2.`controller$rS, %r ) ◎ Perform ! ReadableStreamDefaultControllerError(branch2.[[controller]], r).
    3. ~IF［ %canceled1 ~EQ ~F ］~OR［ %canceled2 ~EQ ~F ］ ⇒ `~promiseを解決する$( %cancelPromise, `undefined^jv ) ◎ If canceled1 is false or canceled2 is false, resolve cancelPromise with undefined.
20. ~RET « %branch1, %branch1 » ◎ Return « branch1, branch2 ».

`ReadableByteStreamTee(stream)@A は、 次の手続きを遂行する： ◎ ReadableByteStreamTee(stream) performs the following steps:

1. ~Assert： %stream は `ReadableStream$I を`実装する$ ◎ Assert: stream implements ReadableStream.
2. ~Assert： %stream.`controller$rS は `ReadableByteStreamController$I を`実装する$ ◎ Assert: stream.[[controller]] implements ReadableByteStreamController.
3. %reader ~LET ~ABRUPT `AcquireReadableStreamDefaultReader$A( %stream ) ◎ Let reader be ? AcquireReadableStreamDefaultReader(stream).
4. %reading ~LET ~F ◎ Let reading be false.
5. %readAgainForBranch1 ~LET ~F ◎ Let readAgainForBranch1 be false.
6. %readAgainForBranch2 ~LET ~F ◎ Let readAgainForBranch2 be false.
7. %canceled1 ~LET ~F ◎ Let canceled1 be false.
8. %canceled2 ~LET ~F ◎ Let canceled2 be false.
9. %reason1 ~LET `undefined^jv ◎ Let reason1 be undefined.
10. %reason2 ~LET `undefined^jv ◎ Let reason2 be undefined.
11. %branch1 ~LET `undefined^jv ◎ Let branch1 be undefined.
12. %branch2 ~LET `undefined^jv ◎ Let branch2 be undefined.
13. %cancelPromise ~LET `新たな~promise$ ◎ Let cancelPromise be a new promise.

14. %forwardReaderError ~LET 所与の ( %thisReader ) に対し，次を走らす~algo： ◎ Let forwardReaderError be the following steps, taking a thisReader argument:

    1. %thisReader.`closedPromise$rsR の`却下-時$には、 所与の ( 事由 %r ) に対し： ◎ Upon rejection of thisReader.[[closedPromise]] with reason r,

       1. ~IF［ %thisReader ~NEQ %reader ］ ⇒ ~RET ◎ If thisReader is not reader, return.
       2. ~NOABRUPT `ReadableByteStreamControllerError$A( %branch1.`controller$rS, %r ) ◎ Perform ! ReadableByteStreamControllerError(branch1.[[controller]], r).
       3. ~NOABRUPT `ReadableByteStreamControllerError$A( %branch2.`controller$rS, %r ) ◎ Perform ! ReadableByteStreamControllerError(branch2.[[controller]], r).
       4. ~IF［ %canceled1 ~EQ ~F ］~OR［ %canceled2 ~EQ ~F ］ ⇒ `~promiseを解決する$( %cancelPromise, `undefined^jv ) ◎ If canceled1 is false or canceled2 is false, resolve cancelPromise with undefined.

15. %pullWithDefaultReader ~LET 次を走らす~algo： ◎ Let pullWithDefaultReader be the following steps:

    1. ~IF［ %reader は `ReadableStreamBYOBReader$I を`実装する$ ］： ◎ If reader implements ReadableStreamBYOBReader,

       1. ~Assert： %reader.`readIntoRequests$rsR は`空$である ◎ Assert: reader.[[readIntoRequests]] is empty.
       2. ~NOABRUPT `ReadableStreamBYOBReaderRelease$A( %reader ) ◎ Perform ! ReadableStreamBYOBReaderRelease(reader).
       3. %reader ~SET ~NOABRUPT `AcquireReadableStreamDefaultReader$A( %stream ) ◎ Set reader to ! AcquireReadableStreamDefaultReader(stream).
       4. %forwardReaderError( %reader ) ◎ Perform forwardReaderError, given reader.

    2. %readRequest ~LET 次に挙げる`~item$sctを伴う，新たな`読取n要請$： ◎ Let readRequest be a read request with the following items:

       • `~chunk手続き$rRは、 所与の ( %chunk ) に対し ⇒ `小taskを~queueする$( 次の手続き ) ◎ chunk steps, given chunk • Queue a microtask to perform＼

         手続きは： ◎ the following steps:

         1. %readAgainForBranch1 ~SET ~F ◎ Set readAgainForBranch1 to false.
         2. %readAgainForBranch2 ~SET ~F ◎ Set readAgainForBranch2 to false.
         3. %chunk1 ~LET %chunk ◎ ↓
         4. %chunk2 ~LET %chunk ◎ Let chunk1 and chunk2 be chunk.

         5. ~IF［ %canceled1 ~EQ ~F ］~AND［ %canceled2 ~EQ ~F ］： ◎ If canceled1 is false and canceled2 is false,

            1. %cloneResult ~LET `CloneAsUint8Array$A( %chunk ) ◎ Let cloneResult be CloneAsUint8Array(chunk).

            2. ~IF［ %cloneResult は`中途完了^である ］： ◎ If cloneResult is an abrupt completion,

               1. ~NOABRUPT `ReadableByteStreamControllerError$A( %branch1.`controller$rS, %cloneResult.`Value^sl ) ◎ Perform ! ReadableByteStreamControllerError(branch1.[[controller]], cloneResult.[[Value]]).
               2. ~NOABRUPT `ReadableByteStreamControllerError$A( %branch2.`controller$rS, %cloneResult.`Value^sl ) ◎ Perform ! ReadableByteStreamControllerError(branch2.[[controller]], cloneResult.[[Value]]).
               3. `~promiseを解決する$( %cancelPromise, 次の結果 ) ⇒ ~NOABRUPT `ReadableStreamCancel$A( %stream, %cloneResult.`Value^sl ) ◎ Resolve cancelPromise with ! ReadableStreamCancel(stream, cloneResult.[[Value]]).
               4. ~RET ◎ Return.
            3. ~ELSE ⇒ %chunk2 ~SET %cloneResult.`Value^sl ◎ Otherwise, set chunk2 to cloneResult.[[Value]].
         6. ~IF［ %canceled1 ~EQ ~F ］ ⇒ ~NOABRUPT `ReadableByteStreamControllerEnqueue$A( %branch1.`controller$rS, %chunk1 ) ◎ If canceled1 is false, perform ! ReadableByteStreamControllerEnqueue(branch1.[[controller]], chunk1).
         7. ~IF［ %canceled2 ~EQ ~F ］ ⇒ ~NOABRUPT `ReadableByteStreamControllerEnqueue$A( %branch2.`controller$rS, %chunk2 ) ◎ If canceled2 is false, perform ! ReadableByteStreamControllerEnqueue(branch2.[[controller]], chunk2).
         8. %reading ~SET ~F ◎ Set reading to false.
         9. ~IF［ %readAgainForBranch1 ~EQ ~T ］ ⇒ %pull1Algorithm を遂行する ◎ If readAgainForBranch1 is true, perform pull1Algorithm.
         10. ~ELIF［ %readAgainForBranch2 ~EQ ~T ］ ⇒ %pull2Algorithm を遂行する ◎ Otherwise, if readAgainForBranch2 is true, perform pull2Algorithm.

         注記： ここでの小taskによる遅延は、 必要yである — 下にて %reader.`closedPromise$rsR を利用するとき、 少なくとも，~errorを検出する小taskがかかるので。 %stream における~errorは，両~分岐とも即時に~errorにすることが求まれるので、 非同期的に可用な~errorに先んじて，成功裡な読取nを同期的に可用にするわけにはいかない。 ◎ The microtask delay here is necessary because it takes at least a microtask to detect errors, when we use reader.[[closedPromise]] below. We want errors in stream to error both branches immediately, so we cannot let successful synchronously-available reads happen ahead of asynchronously-available errors.

       • `~close手続き$rRは： ◎ close steps

         1. %reading ~SET ~F ◎ Set reading to false.
         2. ~IF［ %canceled1 ~EQ ~F ］ ⇒ ~NOABRUPT `ReadableByteStreamControllerClose$A( %branch1.`controller$rS ) ◎ If canceled1 is false, perform ! ReadableByteStreamControllerClose(branch1.[[controller]]).
         3. ~IF［ %canceled2 ~EQ ~F ］ ⇒ ~NOABRUPT `ReadableByteStreamControllerClose$A( %branch2.`controller$rS ) ◎ If canceled2 is false, perform ! ReadableByteStreamControllerClose(branch2.[[controller]]).
         4. ~IF［ %branch1.`controller$rS.`pendingPullIntos$rbsC は`空$でない ］ ⇒ ~NOABRUPT `ReadableByteStreamControllerRespond$A( %branch1.`controller$rS, 0 ) ◎ If branch1.[[controller]].[[pendingPullIntos]] is not empty, perform ! ReadableByteStreamControllerRespond(branch1.[[controller]], 0).
         5. ~IF［ %branch2.`controller$rS.`pendingPullIntos$rbsC は`空$でない ］ ⇒ ~NOABRUPT `ReadableByteStreamControllerRespond$A( %branch2.`controller$rS, 0 ) ◎ If branch2.[[controller]].[[pendingPullIntos]] is not empty, perform ! ReadableByteStreamControllerRespond(branch2.[[controller]], 0).
         6. ~IF［ %canceled1 ~EQ ~F ］~OR［ %canceled2 ~EQ ~F ］ ⇒ `~promiseを解決する$( %cancelPromise, `undefined^jv ) ◎ If canceled1 is false or canceled2 is false, resolve cancelPromise with undefined.
       • `~error手続き$rRは ⇒ %reading ~SET ~F ◎ error steps • Set reading to false.
    3. ~NOABRUPT `ReadableStreamDefaultReaderRead$A( %reader, %readRequest ) ◎ Perform ! ReadableStreamDefaultReaderRead(reader, readRequest).

16. %pullWithBYOBReader ~LET 所与の ( %view, %forBranch2 ) に対し，次を走らす~algo： ◎ Let pullWithBYOBReader be the following steps, given view and forBranch2:

    1. ~IF［ %reader は `ReadableStreamDefaultReader$I を`実装する$ ］： ◎ If reader implements ReadableStreamDefaultReader,

       1. ~Assert： %reader.`readRequests$rsR は`空$である ◎ Assert: reader.[[readRequests]] is empty.
       2. ~NOABRUPT `ReadableStreamDefaultReaderRelease$A( %reader ) ◎ Perform ! ReadableStreamDefaultReaderRelease(reader).
       3. %reader ~SET ~NOABRUPT `AcquireReadableStreamBYOBReader$A( %stream ) ◎ Set reader to ! AcquireReadableStreamBYOBReader(stream).
       4. %forwardReaderError( %reader ) ◎ Perform forwardReaderError, given reader.
    2. %byobBranch ~LET %forBranch2 に応じて ⇒＃ ~T ならば %branch2 ／ ~F ならば %branch1 ◎ Let byobBranch be branch2 if forBranch2 is true, and branch1 otherwise.
    3. %otherBranch ~LET %forBranch2 に応じて ⇒＃ ~F ならば %branch2 ／ ~T ならば %branch1 ◎ Let otherBranch be branch2 if forBranch2 is false, and branch1 otherwise.

    4. %readIntoRequest ~LET 次に挙げる`~item$sctを伴う，新たな`中へ読取る要請$： ◎ Let readIntoRequest be a read-into request with the following items:

       • `~chunk手続き$riRは、 所与の ( %chunk ) に対し ⇒ `小taskを~queueする$( 次の手続き ) ◎ chunk steps, given chunk • Queue a microtask to perform＼

         手続きは： ◎ the following steps:

         1. %readAgainForBranch1 ~SET ~F ◎ Set readAgainForBranch1 to false.
         2. %readAgainForBranch2 ~SET ~F ◎ Set readAgainForBranch2 to false.
         3. %byobCanceled ~LET %forBranch2 に応じて ⇒＃ ~T ならば %canceled2 ／ ~F ならば %canceled1 ◎ Let byobCanceled be canceled2 if forBranch2 is true, and canceled1 otherwise.
         4. %otherCanceled ~LET %forBranch2 に応じて ⇒＃ ~F ならば %canceled2 ／ ~T ならば %canceled1 ◎ Let otherCanceled be canceled2 if forBranch2 is false, and canceled1 otherwise.

         5. ~IF［ %otherCanceled ~EQ ~F ］： ◎ If otherCanceled is false,

            1. %cloneResult ~LET `CloneAsUint8Array$A( %chunk ) ◎ Let cloneResult be CloneAsUint8Array(chunk).

            2. ~IF［ %cloneResult は`中途完了^である ］： ◎ If cloneResult is an abrupt completion,

               1. ~NOABRUPT `ReadableByteStreamControllerError$A( %byobBranch.`controller$rS, %cloneResult.`Value^sl ) ◎ Perform ! ReadableByteStreamControllerError(byobBranch.[[controller]], cloneResult.[[Value]]).
               2. ~NOABRUPT `ReadableByteStreamControllerError$A( %otherBranch.`controller$rS, %cloneResult.`Value^sl ) ◎ Perform ! ReadableByteStreamControllerError(otherBranch.[[controller]], cloneResult.[[Value]]).
               3. `~promiseを解決する$( %cancelPromise, 次の結果 ) ⇒ ~NOABRUPT `ReadableStreamCancel$A( %stream, %cloneResult.`Value^sl ) ◎ Resolve cancelPromise with ! ReadableStreamCancel(stream, cloneResult.[[Value]]).
               4. ~RET ◎ Return.
            3. ~ELSE ⇒ %clonedChunk ~LET %cloneResult.`Value^sl ◎ Otherwise, let clonedChunk be cloneResult.[[Value]].
            4. ~IF［ %byobCanceled ~EQ ~F ］ ⇒ ~NOABRUPT `ReadableByteStreamControllerRespondWithNewView$A( %byobBranch.`controller$rS, %chunk ) ◎ If byobCanceled is false, perform ! ReadableByteStreamControllerRespondWithNewView(byobBranch.[[controller]], chunk).
            5. ~NOABRUPT `ReadableByteStreamControllerEnqueue$A( %otherBranch.`controller$rS, %clonedChunk ) ◎ Perform ! ReadableByteStreamControllerEnqueue(otherBranch.[[controller]], clonedChunk).
         6. ~ELIF［ %byobCanceled ~EQ ~F ］ ⇒ ~NOABRUPT `ReadableByteStreamControllerRespondWithNewView$A( %byobBranch.`controller$rS, %chunk ) ◎ Otherwise, if byobCanceled is false, perform ! ReadableByteStreamControllerRespondWithNewView(byobBranch.[[controller]], chunk).
         7. %reading ~SET ~F ◎ Set reading to false.
         8. ~IF［ %readAgainForBranch1 ~EQ ~T ］ ⇒ %pull1Algorithm を遂行する ◎ If readAgainForBranch1 is true, perform pull1Algorithm.
         9. ~ELIF［ %readAgainForBranch2 ~EQ ~T ］ ⇒ %pull2Algorithm を遂行する ◎ Otherwise, if readAgainForBranch2 is true, perform pull2Algorithm.

         注記： ここでの小taskによる遅延は、 必要yである — 下にて %reader.`closedPromise$rsR を利用するとき、 少なくとも，~errorを検出する小taskがかかるので。 %stream における~errorは，両~分岐とも即時に~errorにすることが求まれるので、 非同期的に可用な~errorに先んじて，成功裡な読取nを同期的に可用にするわけにはいかない。 ◎ The microtask delay here is necessary because it takes at least a microtask to detect errors, when we use reader.[[closedPromise]] below. We want errors in stream to error both branches immediately, so we cannot let successful synchronously-available reads happen ahead of asynchronously-available errors.

       • `~close手続き$riRは、 所与の ( %chunk ) に対し： ◎ close steps, given chunk

         1. %reading ~SET ~F ◎ Set reading to false.
         2. %byobCanceled ~LET %forBranch2 に応じて ⇒＃ ~T ならば %canceled2 ／ ~F ならば %canceled1 ◎ Let byobCanceled be canceled2 if forBranch2 is true, and canceled1 otherwise.
         3. %otherCanceled ~LET %forBranch2 に応じて ⇒＃ ~F ならば %canceled2 ／ ~T ならば %canceled1 ◎ Let otherCanceled be canceled2 if forBranch2 is false, and canceled1 otherwise.
         4. ~IF［ %byobCanceled ~EQ ~F ］ ⇒ ~NOABRUPT `ReadableByteStreamControllerClose$A( %byobBranch.`controller$rS ) ◎ If byobCanceled is false, perform ! ReadableByteStreamControllerClose(byobBranch.[[controller]]).
         5. ~IF［ %otherCanceled ~EQ ~F ］ ⇒ ~NOABRUPT `ReadableByteStreamControllerClose$A( %otherBranch.`controller$rS ) ◎ If otherCanceled is false, perform ! ReadableByteStreamControllerClose(otherBranch.[[controller]]).

         6. ~IF［ %chunk ~NEQ `undefined^jv ］： ◎ If chunk is not undefined,

            1. ~Assert： %chunk.`ByteLength^sl ~EQ 0 ◎ Assert: chunk.[[ByteLength]] is 0.
            2. ~IF［ %byobCanceled ~EQ ~F ］ ⇒ ~NOABRUPT `ReadableByteStreamControllerRespondWithNewView$A( %byobBranch.`controller$rS, %chunk ) ◎ If byobCanceled is false, perform ! ReadableByteStreamControllerRespondWithNewView(byobBranch.[[controller]], chunk).
            3. ~IF［ %otherCanceled ~EQ ~F ］~AND［ %otherBranch.`controller$rS.`pendingPullIntos$rbsC は`空$でない ］ ⇒ ~NOABRUPT `ReadableByteStreamControllerRespond$A( %otherBranch.`controller$rS, 0 ) ◎ If otherCanceled is false and otherBranch.[[controller]].[[pendingPullIntos]] is not empty, perform ! ReadableByteStreamControllerRespond(otherBranch.[[controller]], 0).
         7. ~IF［ %byobCanceled ~EQ ~F ］~OR［ %otherCanceled ~EQ ~F ］ ⇒ `~promiseを解決する$( %cancelPromise, `undefined^jv ) ◎ If byobCanceled is false or otherCanceled is false, resolve cancelPromise with undefined.

       • `~error手続き$riRは ⇒ %reading ~SET ~F ◎ error steps • Set reading to false.

    5. ~NOABRUPT `ReadableStreamBYOBReaderRead$A( %reader, %view, 1, %readIntoRequest ) ◎ Perform ! ReadableStreamBYOBReaderRead(reader, view, 1, readIntoRequest).

17. %pull1Algorithm ~LET 次を走らす~algo： ◎ Let pull1Algorithm be the following steps:

    1. ~IF［ %reading ~EQ ~T ］： ◎ If reading is true,

       1. %readAgainForBranch1 ~SET ~T ◎ Set readAgainForBranch1 to true.
       2. ~RET `解決される~promise$( `undefined^jv ) ◎ Return a promise resolved with undefined.
    2. %reading ~SET ~T ◎ Set reading to true.
    3. %byobRequest ~LET ~NOABRUPT `ReadableByteStreamControllerGetBYOBRequest$A( %branch1.`controller$rS ) ◎ Let byobRequest be ! ReadableByteStreamControllerGetBYOBRequest(branch1.[[controller]]).
    4. ~IF［ %byobRequest ~EQ ~NULL ］ ⇒ %pullWithDefaultReader() ◎ If byobRequest is null, perform pullWithDefaultReader.
    5. ~ELSE ⇒ %pullWithBYOBReader( %byobRequest.`view$bbrQ, ~F ) ◎ Otherwise, perform pullWithBYOBReader, given byobRequest.[[view]] and false.
    6. ~RET `解決される~promise$( `undefined^jv ) ◎ Return a promise resolved with undefined.

18. %pull2Algorithm ~LET 次を走らす~algo： ◎ Let pull2Algorithm be the following steps:

    1. ~IF［ %reading ~EQ ~T ］： ◎ If reading is true,

       1. %readAgainForBranch2 ~SET ~T ◎ Set readAgainForBranch2 to true.
       2. ~RET `解決される~promise$( `undefined^jv ) ◎ Return a promise resolved with undefined.
    2. %reading ~SET ~T ◎ Set reading to true.
    3. %byobRequest ~LET ~NOABRUPT `ReadableByteStreamControllerGetBYOBRequest$A( %branch2.`controller$rS ) ◎ Let byobRequest be ! ReadableByteStreamControllerGetBYOBRequest(branch2.[[controller]]).
    4. ~IF［ %byobRequest ~EQ ~NULL ］ ⇒ %pullWithDefaultReader() ◎ If byobRequest is null, perform pullWithDefaultReader.
    5. ~ELSE ⇒ %pullWithBYOBReader( %byobRequest.`view$bbrQ, ~T ) ◎ Otherwise, perform pullWithBYOBReader, given byobRequest.[[view]] and true.
    6. ~RET `解決される~promise$( `undefined^jv ) ◎ Return a promise resolved with undefined.

19. %cancel1Algorithm ~LET 所与の ( %reason ) に対し，次を走らす~algo： ◎ Let cancel1Algorithm be the following steps, taking a reason argument:

    1. %canceled1 ~SET ~T ◎ Set canceled1 to true.
    2. %reason1 ~SET %reason ◎ Set reason1 to reason.

    3. ~IF［ %canceled2 ~EQ ~T ］： ◎ If canceled2 is true,

       1. %compositeReason ~LET ~NOABRUPT `CreateArrayFromList$Ax ( « %reason1, %reason2 » ) ◎ Let compositeReason be ! CreateArrayFromList(« reason1, reason2 »).
       2. %cancelResult ~LET ~NOABRUPT `ReadableStreamCancel$A( %stream, %compositeReason ) ◎ Let cancelResult be ! ReadableStreamCancel(stream, compositeReason).
       3. `~promiseを解決する$( %cancelPromise, %cancelResult ) ◎ Resolve cancelPromise with cancelResult.
    4. ~RET %cancelPromise ◎ Return cancelPromise.

20. %cancel2Algorithm ~LET 所与の ( %reason ) に対し，次を走らす~algo： ◎ Let cancel2Algorithm be the following steps, taking a reason argument:

    1. %canceled2 ~SET ~T ◎ Set canceled2 to true.
    2. %reason2 ~SET %reason ◎ Set reason2 to reason.

    3. ~IF［ %canceled1 ~EQ ~T ］： ◎ If canceled1 is true,

       1. %compositeReason ~LET ~NOABRUPT `CreateArrayFromList$Ax ( « %reason1, %reason2 » ) ◎ Let compositeReason be ! CreateArrayFromList(« reason1, reason2 »).
       2. %cancelResult ~LET ~NOABRUPT `ReadableStreamCancel$A( %stream, %compositeReason ) ◎ Let cancelResult be ! ReadableStreamCancel(stream, compositeReason).
       3. `~promiseを解決する$( %cancelPromise, %cancelResult ) ◎ Resolve cancelPromise with cancelResult.
    4. ~RET %cancelPromise ◎ Return cancelPromise.
21. %startAlgorithm ~LET 次を走らす~algo ⇒ ~RET `undefined^jv ◎ Let startAlgorithm be an algorithm that returns undefined.
22. %branch1 ~SET ~NOABRUPT `CreateReadableByteStream$A( %startAlgorithm, %pull1Algorithm, %cancel1Algorithm ) ◎ Set branch1 to ! CreateReadableByteStream(startAlgorithm, pull1Algorithm, cancel1Algorithm).
23. %branch2 ~SET ~NOABRUPT `CreateReadableByteStream$A( %startAlgorithm, %pull2Algorithm, %cancel2Algorithm ) ◎ Set branch2 to ! CreateReadableByteStream(startAlgorithm, pull2Algorithm, cancel2Algorithm).
24. %forwardReaderError( %reader ) ◎ Perform forwardReaderError, given reader.
25. ~RET « %branch1, %branch2 » ◎ Return « branch1, branch2 ».

`ReadableStreamAddReadIntoRequest(stream, readRequest)@A は、 次の手続きを遂行する： ◎ ReadableStreamAddReadIntoRequest(stream, readRequest) performs the following steps:

1. ~Assert： %stream.`reader$rS は `ReadableStreamBYOBReader$I を`実装する$ ◎ Assert: stream.[[reader]] implements ReadableStreamBYOBReader.
2. ~Assert： %stream.`state$rS ~IN { `readable^l, `closed^l } ◎ Assert: stream.[[state]] is "readable" or "closed".
3. %stream.`reader$rS.`readIntoRequests$rsR に %readRequest を`付加する$ ◎ Append readRequest to stream.[[reader]].[[readIntoRequests]].

`ReadableStreamAddReadRequest(stream, readRequest)@A は、 次の手続きを遂行する： ◎ ReadableStreamAddReadRequest(stream, readRequest) performs the following steps:

1. ~Assert： %stream.`reader$rS は `ReadableStreamDefaultReader$I を`実装する$ ◎ Assert: stream.[[reader]] implements ReadableStreamDefaultReader.
2. ~Assert： %stream.`state$rS ~EQ `readable^l ◎ Assert: stream.[[state]] is "readable".
3. %stream.`reader$rS.`readRequests$rsR に %readRequest を`付加する$ ◎ Append readRequest to stream.[[reader]].[[readRequests]].

`ReadableStreamCancel(stream, reason)@A は、 次の手続きを遂行する： ◎ ReadableStreamCancel(stream, reason) performs the following steps:

1. %stream.`disturbed$rS ~SET ~T ◎ Set stream.[[disturbed]] to true.
2. ~IF［ %stream.`state$rS ~EQ `closed^l ］ ⇒ ~RET `解決される~promise$( `undefined^jv ) ◎ If stream.[[state]] is "closed", return a promise resolved with undefined.
3. ~IF［ %stream.`state$rS ~EQ `errored^l ］ ⇒ ~RET `却下される~promise$( %stream.`storedError$rS ) ◎ If stream.[[state]] is "errored", return a promise rejected with stream.[[storedError]].
4. ~NOABRUPT `ReadableStreamClose$A( %stream ) ◎ Perform ! ReadableStreamClose(stream).
5. %reader ~LET %stream.`reader$rS ◎ Let reader be stream.[[reader]].

6. ~IF［ %reader ~NEQ `undefined^jv ］~AND［ %reader は `ReadableStreamBYOBReader$I を`実装する$ ］： ◎ If reader is not undefined and reader implements ReadableStreamBYOBReader,

   1. %readIntoRequests ~LET %reader.`readIntoRequests$rsR ◎ Let readIntoRequests be reader.[[readIntoRequests]].
   2. %reader.`readIntoRequests$rsR ~SET 空`~list$ ◎ Set reader.[[readIntoRequests]] to an empty list.
   3. %readIntoRequests を成す ~EACH( %readIntoRequest ) に対し ⇒ %readIntoRequest の`~close手続き$riR( `undefined^jv ) ◎ For each readIntoRequest of readIntoRequests, • Perform readIntoRequest’s close steps, given undefined.
7. %sourceCancelPromise ~LET ~NOABRUPT %stream.`controller$rS.`CancelSteps$sl( %reason ) ◎ Let sourceCancelPromise be ! stream.[[controller]].[[CancelSteps]](reason).

8. ~RET `~promiseに反応する$( %sourceCancelPromise ) — 次を与える下で：

   • `充足~手続き^i は ⇒ ~RET `undefined^jv
   ◎ Return the result of reacting to sourceCancelPromise with a fulfillment step that returns undefined.

`ReadableStreamClose(stream)@A は、 次の手続きを遂行する： ◎ ReadableStreamClose(stream) performs the following steps:

1. ~Assert： %stream.`state$rS ~EQ `readable^l ◎ Assert: stream.[[state]] is "readable".
2. %stream.`state$rS ~SET `closed^l ◎ Set stream.[[state]] to "closed".
3. %reader ~LET %stream.`reader$rS ◎ Let reader be stream.[[reader]].
4. ~IF［ %reader ~EQ `undefined^jv ］ ⇒ ~RET ◎ If reader is undefined, return.
5. `~promiseを解決する$( %reader.`closedPromise$rsR, `undefined^jv ) ◎ Resolve reader.[[closedPromise]] with undefined.

6. ~IF［ %reader は `ReadableStreamDefaultReader$I を`実装する$ ］： ◎ If reader implements ReadableStreamDefaultReader,

   1. %readRequests ~LET %reader.`readRequests$rsR ◎ Let readRequests be reader.[[readRequests]].
   2. %reader.`readRequests$rsR ~SET 空`~list$ ◎ Set reader.[[readRequests]] to an empty list.
   3. %readRequests を成す ~EACH( %readRequest ) に対し ⇒ %readRequest の`~close手続き$rR() ◎ For each readRequest of readRequests, • Perform readRequest’s close steps.

`ReadableStreamError(stream, e)@A は、 次の手続きを遂行する： ◎ ReadableStreamError(stream, e) performs the following steps:

1. ~Assert： %stream.`state$rS ~EQ `readable^l ◎ Assert: stream.[[state]] is "readable".
2. %stream.`state$rS ~SET `errored^l ◎ Set stream.[[state]] to "errored".
3. %stream.`storedError$rS ~SET %e ◎ Set stream.[[storedError]] to e.
4. %reader ~LET %stream.`reader$rS ◎ Let reader be stream.[[reader]].
5. ~IF［ %reader ~EQ `undefined^jv ］ ⇒ ~RET ◎ If reader is undefined, return.
6. `~promiseを却下する$( %reader.`closedPromise$rsR, %e ) ◎ Reject reader.[[closedPromise]] with e.
7. %reader.`closedPromise$rsR.`PromiseIsHandled^sl ~SET ~T ◎ Set reader.[[closedPromise]].[[PromiseIsHandled]] to true.

8. ~IF［ %reader は `ReadableStreamDefaultReader$I を`実装する$ ］ ⇒ ~NOABRUPT `ReadableStreamDefaultReaderErrorReadRequests$A( %reader, %e ) ◎ If reader implements ReadableStreamDefaultReader, • Perform ! ReadableStreamDefaultReaderErrorReadRequests(reader, e).

9. ~ELSE： ◎ Otherwise,

   1. ~Assert： %reader は `ReadableStreamBYOBReader$I を`実装する$ ◎ Assert: reader implements ReadableStreamBYOBReader.
   2. ~NOABRUPT `ReadableStreamBYOBReaderErrorReadIntoRequests$A( %reader, %e ) ◎ Perform ! ReadableStreamBYOBReaderErrorReadIntoRequests(reader, e).

`ReadableStreamFulfillReadIntoRequest(stream, chunk, done)@A は、 次の手続きを遂行する： ◎ ReadableStreamFulfillReadIntoRequest(stream, chunk, done) performs the following steps:

1. ~Assert： ~NOABRUPT `ReadableStreamHasBYOBReader$A( %stream ) ~EQ ~T ◎ Assert: ! ReadableStreamHasBYOBReader(stream) is true.
2. %reader ~LET %stream.`reader$rS ◎ Let reader be stream.[[reader]].
3. ~Assert： %reader.`readIntoRequests$rsR は`空$でない ◎ Assert: reader.[[readIntoRequests]] is not empty.
4. %readIntoRequest ~LET %reader.`readIntoRequests$rsR[0] ◎ Let readIntoRequest be reader.[[readIntoRequests]][0].
5. %reader.`readIntoRequests$rsR から %readIntoRequest を`除去する$ ◎ Remove readIntoRequest from reader.[[readIntoRequests]].
6. ~IF［ %done ~EQ ~T ］ ⇒ %readIntoRequest の`~close手続き$riR( %chunk ) ◎ If done is true, perform readIntoRequest’s close steps, given chunk.
7. ~ELSE ⇒ %readIntoRequest の`~chunk手続き$riR( %chunk ) ◎ Otherwise, perform readIntoRequest’s chunk steps, given chunk.

`ReadableStreamFulfillReadRequest(stream, chunk, done)@A は、 次の手続きを遂行する： ◎ ReadableStreamFulfillReadRequest(stream, chunk, done) performs the following steps:

1. ~Assert： ~NOABRUPT `ReadableStreamHasDefaultReader$A( %stream ) ~EQ ~T ◎ Assert: ! ReadableStreamHasDefaultReader(stream) is true.
2. %reader ~LET %stream.`reader$rS ◎ Let reader be stream.[[reader]].
3. ~Assert： %reader.`readRequests$rsR は`空$でない ◎ Assert: reader.[[readRequests]] is not empty.
4. %readRequest ~LET %reader.`readRequests$rsR[0] ◎ Let readRequest be reader.[[readRequests]][0].
5. %reader.`readRequests$rsR から %readRequest を`除去する$ ◎ Remove readRequest from reader.[[readRequests]].
6. ~IF［ %done ~EQ ~T ］ ⇒ %readRequest の`~close手続き$rR() ◎ If done is true, perform readRequest’s close steps.
7. ~ELSE ⇒ %readRequest の`~chunk手続き$rR( %chunk ) ◎ Otherwise, perform readRequest’s chunk steps, given chunk.

`ReadableStreamGetNumReadIntoRequests(stream)@A は、 次の手続きを遂行する： ◎ ReadableStreamGetNumReadIntoRequests(stream) performs the following steps:

1. ~Assert： ~NOABRUPT `ReadableStreamHasBYOBReader$A( %stream ) ~EQ ~T ◎ Assert: ! ReadableStreamHasBYOBReader(stream) is true.
2. ~RET %stream.`reader$rS.`readIntoRequests$rsR の`~size$ ◎ Return stream.[[reader]].[[readIntoRequests]]’s size.

`ReadableStreamGetNumReadRequests(stream)@A は、 次の手続きを遂行する： ◎ ReadableStreamGetNumReadRequests(stream) performs the following steps:

1. ~Assert： ~NOABRUPT `ReadableStreamHasDefaultReader$A( %stream ) ~EQ ~T ◎ Assert: ! ReadableStreamHasDefaultReader(stream) is true.
2. ~RET %stream.`reader$rS.`readRequests$rsR の`~size$ ◎ Return stream.[[reader]].[[readRequests]]’s size.

`ReadableStreamHasBYOBReader(stream)@A は、 次の手続きを遂行する： ◎ ReadableStreamHasBYOBReader(stream) performs the following steps:

1. %reader ~LET %stream.`reader$rS ◎ Let reader be stream.[[reader]].
2. ~IF［ %reader ~EQ `undefined^jv ］ ⇒ ~RET ~F ◎ If reader is undefined, return false.
3. ~IF［ %reader は `ReadableStreamBYOBReader$I を`実装する$ ］ ⇒ ~RET ~T ◎ If reader implements ReadableStreamBYOBReader, return true.
4. ~RET ~F ◎ Return false.

`ReadableStreamHasDefaultReader(stream)@A は、 次の手続きを遂行する： ◎ ReadableStreamHasDefaultReader(stream) performs the following steps:

1. %reader ~LET %stream.`reader$rS ◎ Let reader be stream.[[reader]].
2. ~IF［ %reader ~EQ `undefined^jv ］ ⇒ ~RET ~F ◎ If reader is undefined, return false.
3. ~IF［ %reader は `ReadableStreamDefaultReader$I を`実装する$ ］ ⇒ ~RET ~T ◎ If reader implements ReadableStreamDefaultReader, return true.
4. ~RET ~F ◎ Return false.

`ReadableStreamReaderGenericCancel(reader, reason)@A は、 次の手続きを遂行する： ◎ ReadableStreamReaderGenericCancel(reader, reason) performs the following steps:

1. %stream ~LET %reader.`stream$rsR ◎ Let stream be reader.[[stream]].
2. ~Assert： %stream ~NEQ `undefined^jv ◎ Assert: stream is not undefined.
3. ~RET ~NOABRUPT `ReadableStreamCancel$A( %stream, %reason ) ◎ Return ! ReadableStreamCancel(stream, reason).

`ReadableStreamReaderGenericInitialize(reader, stream)@A は、 次の手続きを遂行する： ◎ ReadableStreamReaderGenericInitialize(reader, stream) performs the following steps:

1. %reader.`stream$rsR ~SET %stream ◎ Set reader.[[stream]] to stream.
2. %stream.`reader$rS ~SET %reader ◎ Set stream.[[reader]] to reader.

3. ~IF［ %stream.`state$rS ~EQ `readable^l ］： ◎ If stream.[[state]] is "readable",

   1. %reader.`closedPromise$rsR ~SET `新たな~promise$ ◎ Set reader.[[closedPromise]] to a new promise.

4. ~ELIF［ %stream.`state$rS ~EQ `closed^l ］： ◎ Otherwise, if stream.[[state]] is "closed",

   1. %reader.`closedPromise$rsR ~SET `解決される~promise$( `undefined^jv ) ◎ Set reader.[[closedPromise]] to a promise resolved with undefined.

5. ~ELSE： ◎ Otherwise,

   1. ~Assert： %stream.`state$rS ~EQ `errored^l ◎ Assert: stream.[[state]] is "errored".
   2. %reader.`closedPromise$rsR ~SET `却下される~promise$( %stream.`storedError$rS ) ◎ Set reader.[[closedPromise]] to a promise rejected with stream.[[storedError]].
   3. %reader.`closedPromise$rsR.`PromiseIsHandled^sl ~SET ~T ◎ Set reader.[[closedPromise]].[[PromiseIsHandled]] to true.

`ReadableStreamReaderGenericRelease(reader)@A は、 次の手続きを遂行する： ◎ ReadableStreamReaderGenericRelease(reader) performs the following steps:

1. %stream ~LET %reader.`stream$rsR ◎ Let stream be reader.[[stream]].
2. ~Assert： %stream ~NEQ `undefined^jv ◎ Assert: stream is not undefined.
3. ~Assert： %stream.`reader$rS ~EQ %reader ◎ Assert: stream.[[reader]] is reader.
4. ~IF［ %stream.`state$rS ~EQ `readable^l ］ ⇒ `~promiseを却下する$( %reader.`closedPromise$rsR, `TypeError$jE ) ◎ If stream.[[state]] is "readable", reject reader.[[closedPromise]] with a TypeError exception.
5. ~ELSE ⇒ %reader.`closedPromise$rsR ~SET `却下される~promise$( `TypeError$jE 例外 ) ◎ Otherwise, set reader.[[closedPromise]] to a promise rejected with a TypeError exception.
6. %reader.`closedPromise$rsR.`PromiseIsHandled^sl ~SET ~T ◎ Set reader.[[closedPromise]].[[PromiseIsHandled]] to true.
7. ~NOABRUPT %stream.`controller$rS.`ReleaseSteps$sl ◎ Perform ! stream.[[controller]].[[ReleaseSteps]]().
8. %stream.`reader$rS ~SET `undefined^jv ◎ Set stream.[[reader]] to undefined.
9. %stream.`stream$rsR ~SET `undefined^jv ◎ Set reader.[[stream]] to undefined.

`ReadableStreamBYOBReaderErrorReadIntoRequests(reader, e)@A は、 次の手続きを遂行する： ◎ ReadableStreamBYOBReaderErrorReadIntoRequests(reader, e) performs the following steps:

1. %readIntoRequests ~LET %reader.`readIntoRequests$rsR ◎ Let readIntoRequests be reader.[[readIntoRequests]].
2. %reader.`readIntoRequests$rsR ~SET 新たな`~list$ ◎ Set reader.[[readIntoRequests]] to a new empty list.
3. %readIntoRequests を成す ~EACH( %readIntoRequest ) に対し ⇒ %readIntoRequest の`~error手続き$riR( %e ) ◎ For each readIntoRequest of readIntoRequests, • Perform readIntoRequest’s error steps, given e.

`ReadableStreamBYOBReaderRead(reader, view, min, readIntoRequest)@A は、 次の手続きを遂行する： ◎ ReadableStreamBYOBReaderRead(reader, view, min, readIntoRequest) performs the following steps:

1. %stream ~LET %reader.`stream$rsR ◎ Let stream be reader.[[stream]].
2. ~Assert： %stream ~NEQ `undefined^jv ◎ Assert: stream is not undefined.
3. %stream.`disturbed$rS ~SET ~T ◎ Set stream.[[disturbed]] to true.
4. ~IF［ %stream.`state$rS ~EQ `errored^l ］ ⇒ %readIntoRequest の`~error手続き$riR( %stream.`storedError$rS ) ◎ If stream.[[state]] is "errored", perform readIntoRequest’s error steps given stream.[[storedError]].
5. ~ELSE ⇒ ~NOABRUPT `ReadableByteStreamControllerPullInto$A( %stream.`controller$rS, %view, %min, %readIntoRequest ) ◎ Otherwise, perform ! ReadableByteStreamControllerPullInto(stream.[[controller]], view, min, readIntoRequest).

`ReadableStreamBYOBReaderRelease(reader)@A は、 次の手続きを遂行する： ◎ ReadableStreamBYOBReaderRelease(reader) performs the following steps:

1. ~NOABRUPT `ReadableStreamReaderGenericRelease$A( %reader ) ◎ Perform ! ReadableStreamReaderGenericRelease(reader).
2. %e ~LET 新たな `TypeError$jE 例外 ◎ Let e be a new TypeError exception.
3. ~NOABRUPT `ReadableStreamBYOBReaderErrorReadIntoRequests$A( %reader, %e ) ◎ Perform ! ReadableStreamBYOBReaderErrorReadIntoRequests(reader, e).

`ReadableStreamDefaultReaderErrorReadRequests(reader, e)@A は、 次の手続きを遂行する： ◎ ReadableStreamDefaultReaderErrorReadRequests(reader, e) performs the following steps:

1. %readRequests ~LET %reader.`readRequests$rsR ◎ Let readRequests be reader.[[readRequests]].
2. %reader.`readRequests$rsR ~SET 新たな`~list$ ◎ Set reader.[[readRequests]] to a new empty list.
3. %readRequests を成す ~EACH( %readRequest ) に対し ⇒ %readRequest の`~error手続き$rR( %e ) ◎ For each readRequest of readRequests, • Perform readRequest’s error steps, given e.

`ReadableStreamDefaultReaderRead(reader, readRequest)@A は、 次の手続きを遂行する： ◎ ReadableStreamDefaultReaderRead(reader, readRequest) performs the following steps:

1. %stream ~LET %reader.`stream$rsR ◎ Let stream be reader.[[stream]].
2. ~Assert： %stream ~NEQ `undefined^jv ◎ Assert: stream is not undefined.
3. %stream.`disturbed$rS ~SET ~T ◎ Set stream.[[disturbed]] to true.
4. ~IF［ %stream.`state$rS ~EQ `closed^l ］ ⇒ %readRequest の`~close手続き$rR() ◎ If stream.[[state]] is "closed", perform readRequest’s close steps.
5. ~ELIF［ %stream.`state$rS ~EQ `errored^l ］ ⇒ %readRequest の`~error手続き$rR( %stream.`storedError$rS ) ◎ Otherwise, if stream.[[state]] is "errored", perform readRequest’s error steps given stream.[[storedError]].

6. ~ELSE： ◎ Otherwise,

   1. ~Assert： %stream.`state$rS ~EQ `readable^l ◎ Assert: stream.[[state]] is "readable".
   2. ~NOABRUPT %stream.`controller$rS.`PullSteps$sl( %readRequest ) ◎ Perform ! stream.[[controller]].[[PullSteps]](readRequest).

`ReadableStreamDefaultReaderRelease(reader)@A は、 次の手続きを遂行する： ◎ ReadableStreamDefaultReaderRelease(reader) performs the following steps:

1. ~NOABRUPT `ReadableStreamReaderGenericRelease$A( %reader ) ◎ Perform ! ReadableStreamReaderGenericRelease(reader).
2. %e ~LET 新たな `TypeError$jE 例外 ◎ Let e be a new TypeError exception.
3. ~NOABRUPT `ReadableStreamDefaultReaderErrorReadRequests$A( %reader, %e ) ◎ Perform ! ReadableStreamDefaultReaderErrorReadRequests(reader, e).

`SetUpReadableStreamBYOBReader(reader, stream)@A は、 次の手続きを遂行する： ◎ SetUpReadableStreamBYOBReader(reader, stream) performs the following steps:

1. ~IF［ ~NOABRUPT `IsReadableStreamLocked$A( %stream ) ~EQ ~T ］ ⇒ ~THROW `TypeError$jE ◎ If ! IsReadableStreamLocked(stream) is true, throw a TypeError exception.
2. ~IF［ %stream.`controller$rS は `ReadableByteStreamController$I を`実装しない$ ］ ⇒ ~THROW `TypeError$jE ◎ If stream.[[controller]] does not implement ReadableByteStreamController, throw a TypeError exception.
3. ~NOABRUPT `ReadableStreamReaderGenericInitialize$A( %reader, %stream ) ◎ Perform ! ReadableStreamReaderGenericInitialize(reader, stream).
4. %reader.`readIntoRequests$rsR ~SET 新たな`~list$ ◎ Set reader.[[readIntoRequests]] to a new empty list.

`SetUpReadableStreamDefaultReader(reader, stream)@A は、 次の手続きを遂行する： ◎ SetUpReadableStreamDefaultReader(reader, stream) performs the following steps:

1. ~IF［ ~NOABRUPT `IsReadableStreamLocked$A( %stream ) ~EQ ~T ］ ⇒ ~THROW `TypeError$jE ◎ If ! IsReadableStreamLocked(stream) is true, throw a TypeError exception.
2. ~NOABRUPT `ReadableStreamReaderGenericInitialize$A( %reader, %stream ) ◎ Perform ! ReadableStreamReaderGenericInitialize(reader, stream).
3. %reader.`readRequests$rsR ~SET 新たな`~list$ ◎ Set reader.[[readRequests]] to a new empty list.

`ReadableStreamDefaultControllerCallPullIfNeeded(controller)@A は、 次の手続きを遂行する： ◎ ReadableStreamDefaultControllerCallPullIfNeeded(controller) performs the following steps:

1. %shouldPull ~LET ~NOABRUPT `ReadableStreamDefaultControllerShouldCallPull$A( %controller ) ◎ Let shouldPull be ! ReadableStreamDefaultControllerShouldCallPull(controller).
2. ~IF［ %shouldPull ~EQ ~F ］ ⇒ ~RET ◎ If shouldPull is false, return.

3. ~IF［ %controller.`pulling$rsdC ~EQ ~T ］： ◎ If controller.[[pulling]] is true,

   1. %controller.`pullAgain$rsdC ~SET ~T ◎ Set controller.[[pullAgain]] to true.
   2. ~RET ◎ Return.
4. ~Assert： %controller.`pullAgain$rsdC ~EQ ~F ◎ Assert: controller.[[pullAgain]] is false.
5. %controller.`pulling$rsdC ~SET ~T ◎ Set controller.[[pulling]] to true.

6. %pullPromise ~LET %controller.`pullAlgorithm$rsdC() ◎ Let pullPromise be the result of performing controller.[[pullAlgorithm]].

   • %pullPromise の`充足-時$には： ◎ Upon fulfillment of pullPromise,

     1. %controller.`pulling$rsdC ~SET ~F ◎ Set controller.[[pulling]] to false.

     2. ~IF［ %controller.`pullAgain$rsdC ~EQ ~T ］： ◎ If controller.[[pullAgain]] is true,

        1. %controller.`pullAgain$rsdC ~SET ~F ◎ Set controller.[[pullAgain]] to false.
        2. ~NOABRUPT `ReadableStreamDefaultControllerCallPullIfNeeded$A( %controller ) ◎ Perform ! ReadableStreamDefaultControllerCallPullIfNeeded(controller).

   • %pullPromise の`却下-時$には、 所与の ( 事由 %e ) に対し： ◎ Upon rejection of pullPromise with reason e,

     1. ~NOABRUPT `ReadableStreamDefaultControllerError$A( %controller, %e ) ◎ Perform ! ReadableStreamDefaultControllerError(controller, e).

`ReadableStreamDefaultControllerShouldCallPull(controller)@A は、 次の手続きを遂行する： ◎ ReadableStreamDefaultControllerShouldCallPull(controller) performs the following steps:

1. %stream ~LET %controller.`stream$rsdC ◎ Let stream be controller.[[stream]].
2. ~IF［ ~NOABRUPT `ReadableStreamDefaultControllerCanCloseOrEnqueue$A( %controller ) ~EQ ~F ］ ⇒ ~RET ~F ◎ If ! ReadableStreamDefaultControllerCanCloseOrEnqueue(controller) is false, return false.
3. ~IF［ %controller.`started$rsdC ~EQ ~F ］ ⇒ ~RET ~F ◎ If controller.[[started]] is false, return false.
4. ~IF［ ~NOABRUPT `IsReadableStreamLocked$A( %stream ) ~EQ ~T ］~AND［ ~NOABRUPT `ReadableStreamGetNumReadRequests$A( %stream ) ~GT 0 ］ ⇒ ~RET ~T ◎ If ! IsReadableStreamLocked(stream) is true and ! ReadableStreamGetNumReadRequests(stream) > 0, return true.
5. %desiredSize ~LET ~NOABRUPT `ReadableStreamDefaultControllerGetDesiredSize$A( %controller ) ◎ Let desiredSize be ! ReadableStreamDefaultControllerGetDesiredSize(controller).
6. ~Assert： %desiredSize ~NEQ ~NULL ◎ Assert: desiredSize is not null.
7. ~IF［ %desiredSize ~GT 0 ］ ⇒ ~RET ~T ◎ If desiredSize > 0, return true.
8. ~RET ~F ◎ Return false.

`ReadableStreamDefaultControllerClearAlgorithms(controller)@A は、［ ~streamが~closeされるか~errorして， 各種~algoが それ以上~実行されなくなったとき ］に~callされる。 これは、 各種~algoへの参照を除去することにより， `下層~source$（ `ReadableStream$I ~obj）自身が — まだ参照されていても — ~garbage収集されることを許可する。 ◎ ReadableStreamDefaultControllerClearAlgorithms(controller) is called once the stream is closed or errored and the algorithms will not be executed any more. By removing the algorithm references it permits the underlying source object to be garbage collected even if the ReadableStream itself is still referenced.

注記： これは、 `弱い参照＠https://github.com/tc39/proposal-weakrefs/$を利用すれば観測-可能になる。 詳細は `tc39/proposal-weakrefs#31＠https://github.com/tc39/proposal-weakrefs/issues/31$ を見よ。 ◎ This is observable using weak references. See tc39/proposal-weakrefs#31 for more detail.

それは、 次の手続きを遂行する： ◎ It performs the following steps:

1. %controller.`pullAlgorithm$rsdC ~SET `undefined^jv ◎ Set controller.[[pullAlgorithm]] to undefined.
2. %controller.`cancelAlgorithm$rsdC ~SET `undefined^jv ◎ Set controller.[[cancelAlgorithm]] to undefined.
3. %controller.`strategySizeAlgorithm$rsdC ~SET `undefined^jv ◎ Set controller.[[strategySizeAlgorithm]] to undefined.

`ReadableStreamDefaultControllerClose(controller)@A は、 次の手続きを遂行する： ◎ ReadableStreamDefaultControllerClose(controller) performs the following steps:

1. ~IF［ ~NOABRUPT `ReadableStreamDefaultControllerCanCloseOrEnqueue$A( %controller ) ~EQ ~F ］ ⇒ ~RET ◎ If ! ReadableStreamDefaultControllerCanCloseOrEnqueue(controller) is false, return.
2. %stream ~LET %controller.`stream$rsdC ◎ Let stream be controller.[[stream]].
3. %controller.`closeRequested$rsdC ~SET ~T ◎ Set controller.[[closeRequested]] to true.

4. ~IF［ %controller.`queue$rsdC は`空$である ］： ◎ If controller.[[queue]] is empty,

   1. ~NOABRUPT `ReadableStreamDefaultControllerClearAlgorithms$A( %controller ) ◎ Perform ! ReadableStreamDefaultControllerClearAlgorithms(controller).
   2. ~NOABRUPT `ReadableStreamClose$A( %stream ) ◎ Perform ! ReadableStreamClose(stream).

`ReadableStreamDefaultControllerEnqueue(controller, chunk)@A は、 次の手続きを遂行する： ◎ ReadableStreamDefaultControllerEnqueue(controller, chunk) performs the following steps:

1. ~IF［ ~NOABRUPT `ReadableStreamDefaultControllerCanCloseOrEnqueue$A( %controller ) ~EQ ~F ］ ⇒ ~RET ◎ If ! ReadableStreamDefaultControllerCanCloseOrEnqueue(controller) is false, return.
2. %stream ~LET %controller.`stream$rsdC ◎ Let stream be controller.[[stream]].
3. ~IF［ ~NOABRUPT `IsReadableStreamLocked$A( %stream ) ~EQ ~T ］~AND［ ~NOABRUPT `ReadableStreamGetNumReadRequests$A( %stream ) ~GT 0 ］ ⇒ ~NOABRUPT `ReadableStreamFulfillReadRequest$A( %stream, %chunk, ~F ) ◎ If ! IsReadableStreamLocked(stream) is true and ! ReadableStreamGetNumReadRequests(stream) > 0, perform ! ReadableStreamFulfillReadRequest(stream, chunk, false).

4. ~ELSE： ◎ Otherwise,

   1. %result ~LET 次を遂行した結果を`完了~record$として解釈した結果 ⇒ %controller.`strategySizeAlgorithm$rsdC( %chunk ) ◎ Let result be the result of performing controller.[[strategySizeAlgorithm]], passing in chunk, and interpreting the result as a completion record.

   2. ~IF［ %result は`中途完了^である ］： ◎ If result is an abrupt completion,

      1. ~NOABRUPT `ReadableStreamDefaultControllerError$A( %controller, %result.`Value^sl ) ◎ Perform ! ReadableStreamDefaultControllerError(controller, result.[[Value]]).
      2. ~RET %result ◎ Return result.
   3. %chunkSize ~LET %result.`Value^sl ◎ Let chunkSize be result.[[Value]].
   4. %enqueueResult ~LET `EnqueueValueWithSize$A( %controller, %chunk, %chunkSize ) ◎ Let enqueueResult be EnqueueValueWithSize(controller, chunk, chunkSize).

   5. ~IF［ %enqueueResult は`中途完了^である ］： ◎ If enqueueResult is an abrupt completion,

      1. ~NOABRUPT `ReadableStreamDefaultControllerError$A( %controller, %enqueueResult.`Value^sl ) ◎ Perform ! ReadableStreamDefaultControllerError(controller, enqueueResult.[[Value]]).
      2. ~RET %enqueueResult ◎ Return enqueueResult.
5. ~NOABRUPT `ReadableStreamDefaultControllerCallPullIfNeeded$A( %controller ) ◎ Perform ! ReadableStreamDefaultControllerCallPullIfNeeded(controller).

`ReadableStreamDefaultControllerError(controller, e)@A は、 次の手続きを遂行する： ◎ ReadableStreamDefaultControllerError(controller, e) performs the following steps:

1. %stream ~LET %controller.`stream$rsdC ◎ Let stream be controller.[[stream]].
2. ~IF［ %stream.`state$rS ~NEQ `readable^l ］ ⇒ ~RET ◎ If stream.[[state]] is not "readable", return.
3. ~NOABRUPT `ResetQueue$A( %controller ) ◎ Perform ! ResetQueue(controller).
4. ~NOABRUPT `ReadableStreamDefaultControllerClearAlgorithms$A( %controller ) ◎ Perform ! ReadableStreamDefaultControllerClearAlgorithms(controller).
5. ~NOABRUPT `ReadableStreamError$A( %stream, %e ) ◎ Perform ! ReadableStreamError(stream, e).

`ReadableStreamDefaultControllerGetDesiredSize(controller)@A は、 次の手続きを遂行する： ◎ ReadableStreamDefaultControllerGetDesiredSize(controller) performs the following steps:

1. %state ~LET %controller.`stream$rsdC.`state$rS ◎ Let state be controller.[[stream]].[[state]].
2. ~IF［ %state ~EQ `errored^l ］ ⇒ ~RET ~NULL ◎ If state is "errored", return null.
3. ~IF［ %state ~EQ `closed^l ］ ⇒ ~RET 0 ◎ If state is "closed", return 0.
4. ~RET %controller.`strategyHWM$rsdC ~MINUS %controller.`queueTotalSize$rsdC ◎ Return controller.[[strategyHWM]] − controller.[[queueTotalSize]].

`ReadableStreamDefaultControllerHasBackpressure(controller)@A は、 `TransformStream$I の実装に利用される。 それは、 次の手続きを遂行する： ◎ ReadableStreamDefaultControllerHasBackpressure(controller) is used in the implementation of TransformStream. It performs the following steps:

1. ~IF［ ~NOABRUPT `ReadableStreamDefaultControllerShouldCallPull$A( %controller ) ~EQ ~T ］ ⇒ ~RET ~F ◎ If ! ReadableStreamDefaultControllerShouldCallPull(controller) is true, return false.
2. ~RET ~T ◎ Otherwise, return true.

`ReadableStreamDefaultControllerCanCloseOrEnqueue(controller)@A は、 次の手続きを遂行する： ◎ ReadableStreamDefaultControllerCanCloseOrEnqueue(controller) performs the following steps:

1. %state ~LET %controller.`stream$rsdC.`state$rS ◎ Let state be controller.[[stream]].[[state]].
2. ~IF［ %controller.`closeRequested$rsdC ~EQ ~F ］~AND［ %state ~EQ `readable^l ］ ⇒ ~RET ~T ◎ If controller.[[closeRequested]] is false and state is "readable", return true.
3. ~RET ~F ◎ Otherwise, return false.

`SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm)@A は、 次の手続きを遂行する： ◎ SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm) performs the following steps:

1. ~Assert： %stream.`controller$rS ~EQ `undefined^jv ◎ Assert: stream.[[controller]] is undefined.
2. %controller.`stream$rsdC ~SET %stream ◎ Set controller.[[stream]] to stream.
3. ~NOABRUPT `ResetQueue$A( %controller ) ◎ Perform ! ResetQueue(controller).
4. %controller の ⇒＃ .`started$rsdC ~SET ~F, .`closeRequested$rsdC ~SET ~F, .`pullAgain$rsdC ~SET ~F, .`pulling$rsdC ~SET ~F, .`strategySizeAlgorithm$rsdC ~SET %sizeAlgorithm, .`strategyHWM$rsdC ~SET %highWaterMark, .`pullAlgorithm$rsdC ~SET %pullAlgorithm, .`cancelAlgorithm$rsdC ~SET %cancelAlgorithm ◎ Set controller.[[started]], controller.[[closeRequested]], controller.[[pullAgain]], and controller.[[pulling]] to false. ◎ Set controller.[[strategySizeAlgorithm]] to sizeAlgorithm and controller.[[strategyHWM]] to highWaterMark. ◎ Set controller.[[pullAlgorithm]] to pullAlgorithm. ◎ Set controller.[[cancelAlgorithm]] to cancelAlgorithm.
5. %stream.`controller$rS ~SET %controller ◎ Set stream.[[controller]] to controller.
6. %startResult ~LET %startAlgorithm() （これは、例外を投出するかもしれない） ◎ Let startResult be the result of performing startAlgorithm. (This might throw an exception.)

7. %startPromise ~LET `解決される~promise$( %startResult ) ◎ Let startPromise be a promise resolved with startResult.

   • %startPromise の`充足-時$には： ◎ Upon fulfillment of startPromise,

     1. %controller.`started$rsdC ~SET ~T ◎ Set controller.[[started]] to true.
     2. ~Assert： %controller.`pulling$rsdC ~EQ ~F ◎ Assert: controller.[[pulling]] is false.
     3. ~Assert： %controller.`pullAgain$rsdC ~EQ ~F ◎ Assert: controller.[[pullAgain]] is false.
     4. ~NOABRUPT `ReadableStreamDefaultControllerCallPullIfNeeded$A( %controller ) ◎ Perform ! ReadableStreamDefaultControllerCallPullIfNeeded(controller).

   • %startPromise の`却下-時$には、 所与の ( 事由 %r ) に対し： ◎ Upon rejection of startPromise with reason r,

     1. ~NOABRUPT `ReadableStreamDefaultControllerError$A( %controller, %r ) ◎ Perform ! ReadableStreamDefaultControllerError(controller, r).

`SetUpReadableStreamDefaultControllerFromUnderlyingSource(stream, underlyingSource, underlyingSourceDict, highWaterMark, sizeAlgorithm)@A は、 次の手続きを遂行する： ◎ SetUpReadableStreamDefaultControllerFromUnderlyingSource(stream, underlyingSource, underlyingSourceDict, highWaterMark, sizeAlgorithm) performs the following steps:

1. %controller ~LET `新たな~obj$( `ReadableStreamDefaultController$I ) ◎ Let controller be a new ReadableStreamDefaultController.
2. %startAlgorithm ~LET 次を走らす~algo ⇒ ~RET `undefined^jv ◎ Let startAlgorithm be an algorithm that returns undefined.
3. %pullAlgorithm ~LET 次を走らす~algo ⇒ ~RET `解決される~promise$( `undefined^jv ) ◎ Let pullAlgorithm be an algorithm that returns a promise resolved with undefined.
4. %cancelAlgorithm ~LET 次を走らす~algo ⇒ ~RET `解決される~promise$( `undefined^jv ) ◎ Let cancelAlgorithm be an algorithm that returns a promise resolved with undefined.
5. ~IF［ %underlyingSourceDict[ "`start$usc" ] ~NEQ ε ］ ⇒ %startAlgorithm ~SET 次を走らす~algo ⇒ ~RET `~callback関数を呼出す$( %underlyingSourceDict[ "`start$usc" ], « %controller »【, `投出し直す^i ？】, %underlyingSource ) ◎ If underlyingSourceDict["start"] exists, then set startAlgorithm to an algorithm which returns the result of invoking underlyingSourceDict["start"] with argument list « controller » and callback this value underlyingSource.
6. ~IF［ %underlyingSourceDict[ "`pull$usc" ] ~NEQ ε ］ ⇒ %pullAlgorithm ~SET 次を走らす~algo ⇒ ~RET `~callback関数を呼出す$( %underlyingSourceDict[ "`pull$usc" ], « %controller », ε, %underlyingSource ) ◎ If underlyingSourceDict["pull"] exists, then set pullAlgorithm to an algorithm which returns the result of invoking underlyingSourceDict["pull"] with argument list « controller » and callback this value underlyingSource.
7. ~IF［ %underlyingSourceDict[ "`cancel$usc" ] ~NEQ ε ］ ⇒ %cancelAlgorithm ~SET 所与の ( %reason ) に対し，次を走らす~algo ⇒ ~RET `~callback関数を呼出す$( %underlyingSourceDict[ "`cancel$usc" ], « %reason », ε, %underlyingSource ) ◎ If underlyingSourceDict["cancel"] exists, then set cancelAlgorithm to an algorithm which takes an argument reason and returns the result of invoking underlyingSourceDict["cancel"] with argument list « reason » and callback this value underlyingSource.
8. ~ABRUPT `SetUpReadableStreamDefaultController$A( ↓ ) ⇒＃ %stream, %controller, %startAlgorithm, %pullAlgorithm, %cancelAlgorithm, %highWaterMark, %sizeAlgorithm ◎ Perform ? SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm).

`ReadableByteStreamControllerCallPullIfNeeded(controller)@A は、 次の手続きを遂行する： ◎ ReadableByteStreamControllerCallPullIfNeeded(controller) performs the following steps:

1. %shouldPull ~LET ~NOABRUPT `ReadableByteStreamControllerShouldCallPull$A( %controller ) ◎ Let shouldPull be ! ReadableByteStreamControllerShouldCallPull(controller).
2. ~IF［ %shouldPull ~EQ ~F ］ ⇒ ~RET ◎ If shouldPull is false, return.

3. ~IF［ %controller.`pulling$rbsC ~EQ ~T ］： ◎ If controller.[[pulling]] is true,

   1. %controller.`pullAgain$rbsC ~SET ~T ◎ Set controller.[[pullAgain]] to true.
   2. ~RET ◎ Return.
4. ~Assert： %controller.`pullAgain$rbsC ~EQ ~F ◎ Assert: controller.[[pullAgain]] is false.
5. %controller.`pulling$rbsC ~SET ~T ◎ Set controller.[[pulling]] to true.

6. %pullPromise ~LET %controller.`pullAlgorithm$rbsC() ◎ Let pullPromise be the result of performing controller.[[pullAlgorithm]].

   • %pullPromise の`充足-時$には： ◎ Upon fulfillment of pullPromise,

     1. %controller.`pulling$rbsC ~SET ~F ◎ Set controller.[[pulling]] to false.

     2. ~IF［ %controller.`pullAgain$rbsC ~EQ ~T ］： ◎ If controller.[[pullAgain]] is true,

        1. %controller.`pullAgain$rbsC ~SET ~F ◎ Set controller.[[pullAgain]] to false.
        2. ~NOABRUPT `ReadableByteStreamControllerCallPullIfNeeded$A( %controller ) ◎ Perform ! ReadableByteStreamControllerCallPullIfNeeded(controller).

   • %pullPromise の`却下-時$には、 所与の ( 事由 %e ) に対し： ◎ Upon rejection of pullPromise with reason e,

     1. ~NOABRUPT `ReadableByteStreamControllerError$A( %controller, %e ) ◎ Perform ! ReadableByteStreamControllerError(controller, e).

`ReadableByteStreamControllerClearAlgorithms(controller)@A は、［ ~streamが~closeされるか~errorして， 各種~algoが それ以上~実行されなくなったとき ］に~callされる。 これは、 各種~algoへの参照を除去して，［ `ReadableStream$I ~obj自体は まだ参照されていても， `下層~byte~source$は~garbage収集される ］ことを許可する。 ◎ ReadableByteStreamControllerClearAlgorithms(controller) is called once the stream is closed or errored and the algorithms will not be executed any more. By removing the algorithm references it permits the underlying byte source object to be garbage collected even if the ReadableStream itself is still referenced.

注記： これは、 `弱い参照＠https://github.com/tc39/proposal-weakrefs/$を利用すると観測-可能になる。 詳細は `tc39/proposal-weakrefs#31＠https://github.com/tc39/proposal-weakrefs/issues/31$ を見よ。 ◎ This is observable using weak references. See tc39/proposal-weakrefs#31 for more detail.

それは、 次の手続きを遂行する： ◎ It performs the following steps:

1. %controller.`pullAlgorithm$rbsC ~SET `undefined^jv ◎ Set controller.[[pullAlgorithm]] to undefined.
2. %controller.`cancelAlgorithm$rbsC ~SET `undefined^jv ◎ Set controller.[[cancelAlgorithm]] to undefined.

`ReadableByteStreamControllerClearPendingPullIntos(controller)@A は、 次の手続きを遂行する： ◎ ReadableByteStreamControllerClearPendingPullIntos(controller) performs the following steps:

1. ~NOABRUPT `ReadableByteStreamControllerInvalidateBYOBRequest$A( %controller ) ◎ Perform ! ReadableByteStreamControllerInvalidateBYOBRequest(controller).
2. %controller.`pendingPullIntos$rbsC ~SET 新たな`~list$ ◎ Set controller.[[pendingPullIntos]] to a new empty list.

`ReadableByteStreamControllerClose(controller)@A は、 次の手続きを遂行する： ◎ ReadableByteStreamControllerClose(controller) performs the following steps:

1. %stream ~LET %controller.`stream$rbsC ◎ Let stream be controller.[[stream]].
2. ~IF［ %controller.`closeRequested$rbsC ~EQ ~T ］~OR［ %stream.`state$rS ~NEQ `readable^l ］ ⇒ ~RET ◎ If controller.[[closeRequested]] is true or stream.[[state]] is not "readable", return.

3. ~IF［ %controller.`queueTotalSize$rbsC ~GT 0 ］： ◎ If controller.[[queueTotalSize]] > 0,

   1. %controller.`closeRequested$rbsC ~SET ~T ◎ Set controller.[[closeRequested]] to true.
   2. ~RET ◎ Return.

4. ~IF［ %controller.`pendingPullIntos$rbsC は`空$でない ］： ◎ If controller.[[pendingPullIntos]] is not empty,

   1. %firstPendingPullInto ~LET %controller.`pendingPullIntos$rbsC[0] ◎ Let firstPendingPullInto be controller.[[pendingPullIntos]][0].

   2. ~IF［ `剰余$( %firstPendingPullInto の`埋まった~byte数$pD, %firstPendingPullInto の`要素~size$pD ) ~NEQ 0 ］： ◎ If the remainder after dividing firstPendingPullInto’s bytes filled by firstPendingPullInto’s element size is not 0,

      1. %e ~LET 新たな `TypeError$jE 例外 ◎ Let e be a new TypeError exception.
      2. ~NOABRUPT `ReadableByteStreamControllerError$A( %controller, %e ) ◎ Perform ! ReadableByteStreamControllerError(controller, e).
      3. ~THROW %e ◎ Throw e.
5. ~NOABRUPT `ReadableByteStreamControllerClearAlgorithms$A( %controller ) ◎ Perform ! ReadableByteStreamControllerClearAlgorithms(controller).
6. ~NOABRUPT `ReadableStreamClose$A( %stream ) ◎ Perform ! ReadableStreamClose(stream).

`ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor)@A は、 次の手続きを遂行する： ◎ ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor) performs the following steps:

1. ~Assert： %stream.`state$rS ~NEQ `errored^l ◎ Assert: stream.[[state]] is not "errored".
2. ~Assert： %pullIntoDescriptor の`読取器~型$pD ~NEQ `none^l ◎ Assert: pullIntoDescriptor.reader type is not "none".
3. %done ~LET ~F ◎ Let done be false.

4. ~IF［ %stream.`state$rS ~EQ `closed^l ］： ◎ If stream.[[state]] is "closed",

   1. ~Assert： `剰余$( %pullIntoDescriptor の`埋まった~byte数$pD, %pullIntoDescriptor の`要素~size$pD ) ~EQ 0 ◎ Assert: the remainder after dividing pullIntoDescriptor’s bytes filled by pullIntoDescriptor’s element size is 0.
   2. %done ~SET ~T ◎ Set done to true.
5. %filledView ~LET ~NOABRUPT `ReadableByteStreamControllerConvertPullIntoDescriptor$A( %pullIntoDescriptor ) ◎ Let filledView be ! ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor).

6. ~IF［ %pullIntoDescriptor の`読取器~型$pD ~EQ `default^l ］： ◎ If pullIntoDescriptor’s reader type is "default",

   1. ~NOABRUPT `ReadableStreamFulfillReadRequest$A( %stream, %filledView, %done ) ◎ Perform ! ReadableStreamFulfillReadRequest(stream, filledView, done).

7. ~ELSE： ◎ Otherwise,

   1. ~Assert： %pullIntoDescriptor の`読取器~型$pD ~EQ `byob^l ◎ Assert: pullIntoDescriptor’s reader type is "byob".
   2. ~NOABRUPT `ReadableStreamFulfillReadIntoRequest$A( %stream, %filledView, %done ) ◎ Perform ! ReadableStreamFulfillReadIntoRequest(stream, filledView, done).

`ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor)@A は、 次の手続きを遂行する： ◎ ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor) performs the following steps:

1. %bytesFilled ~LET %pullIntoDescriptor の`埋まった~byte数$pD ◎ Let bytesFilled be pullIntoDescriptor’s bytes filled.
2. %elementSize ~LET %pullIntoDescriptor の`要素~size$pD ◎ Let elementSize be pullIntoDescriptor’s element size.
3. ~Assert： %bytesFilled ~LTE %pullIntoDescriptor の`~byte長さ$pD ◎ Assert: bytesFilled ≤ pullIntoDescriptor’s byte length.
4. ~Assert： `剰余$( %bytesFilled, %elementSize ) ~EQ 0 ◎ Assert: the remainder after dividing bytesFilled by elementSize is 0.
5. %buffer ~LET ~NOABRUPT `TransferArrayBuffer$A( %pullIntoDescriptor の`~buffer$pD ) ◎ Let buffer be ! TransferArrayBuffer(pullIntoDescriptor’s buffer).
6. ~RET ~NOABRUPT `Construct$Ax( %pullIntoDescriptor の`~view構築子$pD, « %buffer, %pullIntoDescriptor の`~byte~offset$pD, %bytesFilled ~DIV %elementSize » ) ◎ Return ! Construct(pullIntoDescriptor’s view constructor, « buffer, pullIntoDescriptor’s byte offset, bytesFilled ÷ elementSize »).

`ReadableByteStreamControllerEnqueue(controller, chunk)@A は、 次の手続きを遂行する： ◎ ReadableByteStreamControllerEnqueue(controller, chunk) performs the following steps:

1. %stream ~LET %controller.`stream$rbsC ◎ Let stream be controller.[[stream]].
2. ~IF［ %controller.`closeRequested$rbsC ~EQ ~T ］~OR［ %stream.`state$rS ~NEQ `readable^l ］ ⇒ ~RET ◎ If controller.[[closeRequested]] is true or stream.[[state]] is not "readable", return.
3. %buffer ~LET %chunk.`ViewedArrayBuffer^sl ◎ Let buffer be chunk.[[ViewedArrayBuffer]].
4. %byteOffset ~LET %chunk.`ByteOffset^sl ◎ Let byteOffset be chunk.[[ByteOffset]].
5. %byteLength ~LET %chunk.`ByteLength^sl ◎ Let byteLength be chunk.[[ByteLength]].
6. ~IF［ ~NOABRUPT `IsDetachedBuffer$Ax( %buffer ) ~EQ ~T ］ ⇒ ~THROW `TypeError$jE ◎ If ! IsDetachedBuffer(buffer) is true, throw a TypeError exception.
7. %transferredBuffer ~LET ~ABRUPT `TransferArrayBuffer$A( %buffer ) ◎ Let transferredBuffer be ? TransferArrayBuffer(buffer).

8. ~IF［ %controller.`pendingPullIntos$rbsC は`空$でない ］： ◎ If controller.[[pendingPullIntos]] is not empty,

   1. %firstPendingPullInto ~LET %controller.`pendingPullIntos$rbsC[0] ◎ Let firstPendingPullInto be controller.[[pendingPullIntos]][0].
   2. ~IF［ ~NOABRUPT `IsDetachedBuffer$Ax( %firstPendingPullInto の`~buffer$pD ) ~EQ ~T ］ ⇒ ~THROW `TypeError$jE ◎ If ! IsDetachedBuffer(firstPendingPullInto’s buffer) is true, throw a TypeError exception.
   3. ~NOABRUPT `ReadableByteStreamControllerInvalidateBYOBRequest$A( %controller ) ◎ Perform ! ReadableByteStreamControllerInvalidateBYOBRequest(controller).
   4. %firstPendingPullInto の`~buffer$pD ~SET ~NOABRUPT `TransferArrayBuffer$A( %firstPendingPullInto の`~buffer$pD ) ◎ Set firstPendingPullInto’s buffer to ! TransferArrayBuffer(firstPendingPullInto’s buffer).
   5. ~IF［ %firstPendingPullInto の`読取器~型$pD ~EQ `none^l ］ ⇒ ~ABRUPT `ReadableByteStreamControllerEnqueueDetachedPullIntoToQueue$A( %controller, %firstPendingPullInto ) ◎ If firstPendingPullInto’s reader type is "none", perform ? ReadableByteStreamControllerEnqueueDetachedPullIntoToQueue(controller, firstPendingPullInto).

9. ~IF［ ~NOABRUPT `ReadableStreamHasDefaultReader$A( %stream ) ~EQ ~T ］： ◎ If ! ReadableStreamHasDefaultReader(stream) is true,

   1. ~NOABRUPT `ReadableByteStreamControllerProcessReadRequestsUsingQueue$A( %controller ) ◎ Perform ! ReadableByteStreamControllerProcessReadRequestsUsingQueue(controller).

   2. ~IF［ ~NOABRUPT `ReadableStreamGetNumReadRequests$A( %stream ) ~EQ 0 ］： ◎ If ! ReadableStreamGetNumReadRequests(stream) is 0,

      1. ~Assert： %controller.`pendingPullIntos$rbsC は`空$である ◎ Assert: controller.[[pendingPullIntos]] is empty.
      2. ~NOABRUPT `ReadableByteStreamControllerEnqueueChunkToQueue$A( %controller, %transferredBuffer, %byteOffset, %byteLength ) ◎ Perform ! ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength).

   3. ~ELSE： ◎ Otherwise,

      1. ~Assert： %controller.`queue$rbsC は`空$である ◎ Assert: controller.[[queue]] is empty.

      2. ~IF［ %controller.`pendingPullIntos$rbsC は`空$でない ］： ◎ If controller.[[pendingPullIntos]] is not empty,

         1. ~Assert： %controller.`pendingPullIntos$rbsC[0] の`読取器~型$pD ~EQ `default^l ◎ Assert: controller.[[pendingPullIntos]][0]'s reader type is "default".
         2. ~NOABRUPT `ReadableByteStreamControllerShiftPendingPullInto$A( %controller ) ◎ Perform ! ReadableByteStreamControllerShiftPendingPullInto(controller).
      3. %transferredView ~LET ~NOABRUPT `Construct$Ax( `Uint8Array$jI, « %transferredBuffer, %byteOffset, %byteLength » ) ◎ Let transferredView be ! Construct(%Uint8Array%, « transferredBuffer, byteOffset, byteLength »).
      4. ~NOABRUPT `ReadableStreamFulfillReadRequest$A( %stream, %transferredView, ~F ) ◎ Perform ! ReadableStreamFulfillReadRequest(stream, transferredView, false).

10. ~ELIF［ ~NOABRUPT `ReadableStreamHasBYOBReader$A( %stream ) ~EQ ~T ］： ◎ Otherwise, if ! ReadableStreamHasBYOBReader(stream) is true,

    1. ~NOABRUPT `ReadableByteStreamControllerEnqueueChunkToQueue$A( %controller, %transferredBuffer, %byteOffset, %byteLength ) ◎ Perform ! ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength).
    2. %filledPullIntos ~LET ~NOABRUPT `ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue$A( %controller ) ◎ Let filledPullIntos be the result of performing ! ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller).
    3. %filledPullIntos を成す ~EACH( %filledPullInto ) に対し ⇒ ~NOABRUPT `ReadableByteStreamControllerCommitPullIntoDescriptor$A( %stream, %filledPullInto ) ◎ For each filledPullInto of filledPullIntos, • Perform ! ReadableByteStreamControllerCommitPullIntoDescriptor(stream, filledPullInto).

11. ~ELSE： ◎ Otherwise,

    1. ~Assert： ~NOABRUPT `IsReadableStreamLocked$A( %stream ) ~EQ ~F ◎ Assert: ! IsReadableStreamLocked(stream) is false.
    2. ~NOABRUPT `ReadableByteStreamControllerEnqueueChunkToQueue$A( %controller, %transferredBuffer, %byteOffset, %byteLength ) ◎ Perform ! ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength).
12. ~NOABRUPT `ReadableByteStreamControllerCallPullIfNeeded$A( %controller ) ◎ Perform ! ReadableByteStreamControllerCallPullIfNeeded(controller).

`ReadableByteStreamControllerEnqueueChunkToQueue(controller, buffer, byteOffset, byteLength)@A は、 次の手続きを遂行する： ◎ ReadableByteStreamControllerEnqueueChunkToQueue(controller, buffer, byteOffset, byteLength) performs the following steps:

1. %controller.`queue$rbsC に［ 次を伴う，新たな`可読~byte~stream用の~queue~entry$ ］を`付加する$ ⇒＃ `~buffer$qE ~SET %buffer, `~byte~offset$qE ~SET %byteOffset, `~byte長さ$qE ~SET %byteLength ◎ Append a new readable byte stream queue entry with buffer buffer, byte offset byteOffset, and byte length byteLength to controller.[[queue]].
2. %controller.`queueTotalSize$rbsC ~INCBY %byteLength ◎ Set controller.[[queueTotalSize]] to controller.[[queueTotalSize]] + byteLength.

`ReadableByteStreamControllerEnqueueClonedChunkToQueue(controller, buffer, byteOffset, byteLength)@A は、 次の手続きを遂行する： ◎ ReadableByteStreamControllerEnqueueClonedChunkToQueue(controller, buffer, byteOffset, byteLength) performs the following steps:

1. %cloneResult ~LET `CloneArrayBuffer$Ax( %buffer, %byteOffset, %byteLength, `ArrayBuffer$jI ) ◎ Let cloneResult be CloneArrayBuffer(buffer, byteOffset, byteLength, %ArrayBuffer%).

2. ~IF［ %cloneResult は`中途完了^である ］： ◎ If cloneResult is an abrupt completion,

   1. ~NOABRUPT `ReadableByteStreamControllerError$A( %controller, %cloneResult.`Value^sl ) ◎ Perform ! ReadableByteStreamControllerError(controller, cloneResult.[[Value]]).
   2. ~RET %cloneResult ◎ Return cloneResult.
3. ~NOABRUPT `ReadableByteStreamControllerEnqueueChunkToQueue$A( %controller, %cloneResult.`Value^sl, 0, %byteLength ) ◎ Perform ! ReadableByteStreamControllerEnqueueChunkToQueue(controller, cloneResult.[[Value]], 0, byteLength).

`ReadableByteStreamControllerEnqueueDetachedPullIntoToQueue(controller, pullIntoDescriptor)@A は、 次の手続きを遂行する： ◎ ReadableByteStreamControllerEnqueueDetachedPullIntoToQueue(controller, pullIntoDescriptor) performs the following steps:

1. ~Assert： %pullIntoDescriptor の`読取器~型$pD ~EQ `none^l ◎ Assert: pullIntoDescriptor’s reader type is "none".
2. ~IF［ %pullIntoDescriptor の`埋まった~byte数$pD ~GT 0 ］ ⇒ ~ABRUPT `ReadableByteStreamControllerEnqueueClonedChunkToQueue$A( %controller, %pullIntoDescriptor の`~buffer$pD, %pullIntoDescriptor の`~byte~offset$pD, %pullIntoDescriptor の`埋まった~byte数$pD ) ◎ If pullIntoDescriptor’s bytes filled > 0, perform ? ReadableByteStreamControllerEnqueueClonedChunkToQueue(controller, pullIntoDescriptor’s buffer, pullIntoDescriptor’s byte offset, pullIntoDescriptor’s bytes filled).
3. ~NOABRUPT `ReadableByteStreamControllerShiftPendingPullInto$A( %controller ) ◎ Perform ! ReadableByteStreamControllerShiftPendingPullInto(controller).

`ReadableByteStreamControllerError(controller, e)@A は、 次の手続きを遂行する： ◎ ReadableByteStreamControllerError(controller, e) performs the following steps:

1. %stream ~LET %controller.`stream$rbsC ◎ Let stream be controller.[[stream]].
2. ~IF［ %stream.`state$rS ~NEQ `readable^l ］ ⇒ ~RET ◎ If stream.[[state]] is not "readable", return.
3. ~NOABRUPT `ReadableByteStreamControllerClearPendingPullIntos$A( %controller ) ◎ Perform ! ReadableByteStreamControllerClearPendingPullIntos(controller).
4. ~NOABRUPT `ResetQueue$A( %controller ) ◎ Perform ! ResetQueue(controller).
5. ~NOABRUPT `ReadableByteStreamControllerClearAlgorithms$A( %controller ) ◎ Perform ! ReadableByteStreamControllerClearAlgorithms(controller).
6. ~NOABRUPT `ReadableStreamError$A( %stream, %e ) ◎ Perform ! ReadableStreamError(stream, e).

`ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, size, pullIntoDescriptor)@A は、 次の手続きを遂行する： ◎ ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, size, pullIntoDescriptor) performs the following steps:

1. ~Assert：［ %controller.`pendingPullIntos$rbsC は`空$である ］~OR［ %controller.`pendingPullIntos$rbsC[0] ~EQ %pullIntoDescriptor ］ ◎ Assert: either controller.[[pendingPullIntos]] is empty, or controller.[[pendingPullIntos]][0] is pullIntoDescriptor.
2. ~Assert： %controller.`byobRequest$rbsC ~EQ ~NULL ◎ Assert: controller.[[byobRequest]] is null.
3. %pullIntoDescriptor の`埋まった~byte数$pD ~INCBY %size ◎ Set pullIntoDescriptor’s bytes filled to bytes filled + size.

`ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor)@A は、 次の手続きを遂行する： ◎ ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) performs the following steps:

1. %maxBytesToCopy ~LET `min^op( %controller.`queueTotalSize$rbsC, ( %pullIntoDescriptor の`~byte長さ$pD ~MINUS %pullIntoDescriptor の`埋まった~byte数$pD ) ) ◎ Let maxBytesToCopy be min(controller.[[queueTotalSize]], pullIntoDescriptor’s byte length − pullIntoDescriptor’s bytes filled).
2. %maxBytesFilled ~LET ( %pullIntoDescriptor の`埋まった~byte数$pD ~PLUS %maxBytesToCopy ) ◎ Let maxBytesFilled be pullIntoDescriptor’s bytes filled + maxBytesToCopy.
3. %totalBytesToCopyRemaining ~LET %maxBytesToCopy ◎ Let totalBytesToCopyRemaining be maxBytesToCopy.
4. %ready ~LET ~F ◎ Let ready be false.
5. ~Assert： ~NOABRUPT `IsDetachedBuffer$Ax( %pullIntoDescriptor の`~buffer$pD ) ~EQ ~F ◎ Assert: ! IsDetachedBuffer(pullIntoDescriptor’s buffer) is false.
6. ~Assert： %pullIntoDescriptor の`埋まった~byte数$pD ~LT %pullIntoDescriptor の`最小な埋n$pD ◎ Assert: pullIntoDescriptor’s bytes filled < pullIntoDescriptor’s minimum fill.
7. %remainderBytes ~LET `剰余$( %maxBytesFilled, %pullIntoDescriptor の`要素~size$pD ) ◎ Let remainderBytes be the remainder after dividing maxBytesFilled by pullIntoDescriptor’s element size.
8. %maxAlignedBytes ~LET %maxBytesFilled ~MINUS %remainderBytes ◎ Let maxAlignedBytes be maxBytesFilled − remainderBytes.

9. ~IF［ %maxAlignedBytes ~GTE %pullIntoDescriptor の`最小な埋n$pD ］： ◎ If maxAlignedBytes ≥ pullIntoDescriptor’s minimum fill,

   1. %totalBytesToCopyRemaining ~SET %maxAlignedBytes ~MINUS %pullIntoDescriptor の`埋まった~byte数$pD ◎ Set totalBytesToCopyRemaining to maxAlignedBytes − pullIntoDescriptor’s bytes filled.

   2. %ready ~SET ~T ◎ Set ready to true.

      注記： `read()$byob 要請~用の記述子【 %pullIntoDescriptor 】は、 まだ その最小~長さまで埋まってない間は，当の~queueを成す頭部に居続けることになる — なので、 `下層~source$は，それを埋め続けれる。 ◎ A descriptor for a read() request that is not yet filled up to its minimum length will stay at the head of the queue, so the underlying source can keep filling it.

10. %queue ~LET %controller.`queue$rbsC ◎ Let queue be controller.[[queue]].

11. ~WHILE［ %totalBytesToCopyRemaining ~GT 0 ］： ◎ While totalBytesToCopyRemaining > 0,

    1. %headOfQueue ~LET %queue[0] ◎ Let headOfQueue be queue[0].
    2. %bytesToCopy ~LET `min^op( %totalBytesToCopyRemaining, %headOfQueue の`~byte長さ$qE ) ◎ Let bytesToCopy be min(totalBytesToCopyRemaining, headOfQueue’s byte length).
    3. %destStart ~LET ( %pullIntoDescriptor の`~byte~offset$pD ~PLUS %pullIntoDescriptor の`埋まった~byte数$pD ) ◎ Let destStart be pullIntoDescriptor’s byte offset + pullIntoDescriptor’s bytes filled.
    4. %descriptorBuffer ~LET %pullIntoDescriptor の`~buffer$pD ◎ Let descriptorBuffer be pullIntoDescriptor’s buffer.
    5. %queueBuffer ~LET %headOfQueue の`~buffer$qE ◎ Let queueBuffer be headOfQueue’s buffer.
    6. %queueByteOffset ~LET %headOfQueue の`~byte~offset$qE ◎ Let queueByteOffset be headOfQueue’s byte offset.

    7. ~Assert： 次の結果 ~EQ ~T ⇒ ~NOABRUPT `CanCopyDataBlockBytes$A( ↓ ) ⇒＃ %descriptorBuffer, %destStart, %queueBuffer, %queueByteOffset, %bytesToCopy ◎ Assert: ! CanCopyDataBlockBytes(pullIntoDescriptor’s buffer, destStart, headOfQueue’s buffer, headOfQueue’s byte offset, bytesToCopy) is true.

       この表明に失敗した場合 （この仕様か その実装における~bugに因り）、 次の段は，無効な~memory［ から読取る／へ書込む ］ようになり得る。 ~UAは、 この表明を常に検査して， 失敗した場合には`実装定義$な方式で停止するべきである （例： 当の処理nを~crashするか， 当の~streamを`~errorにする＠#readable-byte-stream-controller-error$ことにより）。 ◎ If this assertion were to fail (due to a bug in this specification or its implementation), then the next step may read from or write to potentially invalid memory. The user agent should always check this assertion, and stop in an implementation-defined manner if it fails (e.g. by crashing the process, or by erroring the stream).

    8. ~NOABRUPT `CopyDataBlockBytes$Ax( ↓ ) ⇒＃ %descriptorBuffer.`ArrayBufferData^sl, %destStart, %queueBuffer.`ArrayBufferData^sl, %queueByteOffset, %bytesToCopy ◎ Perform ! CopyDataBlockBytes(descriptorBuffer.[[ArrayBufferData]], destStart, queueBuffer.[[ArrayBufferData]], queueByteOffset, bytesToCopy).

    9. ~IF［ %headOfQueue の`~byte長さ$qE ~EQ %bytesToCopy ］： ◎ If headOfQueue’s byte length is bytesToCopy,

       1. %queue[0] を`除去する$ ◎ Remove queue[0].

    10. ~ELSE： ◎ Otherwise,

        1. %headOfQueue の`~byte~offset$qE ~INCBY %bytesToCopy ◎ Set headOfQueue’s byte offset to headOfQueue’s byte offset + bytesToCopy.
        2. %headOfQueue の`~byte長さ$qE ~DECBY %bytesToCopy ◎ Set headOfQueue’s byte length to headOfQueue’s byte length − bytesToCopy.
    11. %controller.`queueTotalSize$rbsC ~DECBY %bytesToCopy ◎ Set controller.[[queueTotalSize]] to controller.[[queueTotalSize]] − bytesToCopy.
    12. ~NOABRUPT `ReadableByteStreamControllerFillHeadPullIntoDescriptor$A( %controller, %bytesToCopy, %pullIntoDescriptor ) ◎ Perform ! ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesToCopy, pullIntoDescriptor).
    13. %totalBytesToCopyRemaining ~DECBY %bytesToCopy ◎ Set totalBytesToCopyRemaining to totalBytesToCopyRemaining − bytesToCopy.

12. ~IF［ %ready ~EQ ~F ］： ◎ If ready is false,

    1. ~Assert： %controller.`queueTotalSize$rbsC ~EQ 0 ◎ Assert: controller.[[queueTotalSize]] is 0.
    2. ~Assert： %pullIntoDescriptor の`埋まった~byte数$pD ~GT 0 ◎ Assert: pullIntoDescriptor’s bytes filled > 0.
    3. ~Assert： %pullIntoDescriptor の`埋まった~byte数$pD ~LT %pullIntoDescriptor の`最小な埋n$pD ◎ Assert: pullIntoDescriptor’s bytes filled < pullIntoDescriptor’s minimum fill.
13. ~RET %ready ◎ Return ready.

`ReadableByteStreamControllerFillReadRequestFromQueue(controller, readRequest)@A は、 次の手続きを遂行する： ◎ ReadableByteStreamControllerFillReadRequestFromQueue(controller, readRequest) performs the following steps:

1. ~Assert： %controller.`queueTotalSize$rbsC ~GT 0 ◎ Assert: controller.[[queueTotalSize]] > 0.
2. %entry ~LET %controller.`queue$rbsC[ 0 ] ◎ Let entry be controller.[[queue]][0].
3. %controller.`queue$rbsC から %entry を`除去する$ ◎ Remove entry from controller.[[queue]].
4. %controller.`queueTotalSize$rbsC ~SET %controller.`queueTotalSize$rbsC ~MINUS %entry の`~byte長さ$qE ◎ Set controller.[[queueTotalSize]] to controller.[[queueTotalSize]] − entry’s byte length.
5. ~NOABRUPT `ReadableByteStreamControllerHandleQueueDrain$A( %controller ) ◎ Perform ! ReadableByteStreamControllerHandleQueueDrain(controller).
6. %view ~LET ~NOABRUPT `Construct$Ax( `Uint8Array$jI, « %entry の`~buffer$qE, %entry の`~byte~offset$qE, %entry の`~byte長さ$qE » ) ◎ Let view be ! Construct(%Uint8Array%, « entry’s buffer, entry’s byte offset, entry’s byte length »).
7. %readRequest の`~chunk手続き$rR( %view ) ◎ Perform readRequest’s chunk steps, given view.

`ReadableByteStreamControllerGetBYOBRequest(controller)@A は、 次の手続きを遂行する： ◎ ReadableByteStreamControllerGetBYOBRequest(controller) performs the following steps:

1. ~IF［ %controller.`byobRequest$rbsC ~EQ ~NULL ］~AND［ %controller.`pendingPullIntos$rbsC は`空$でない ］： ◎ If controller.[[byobRequest]] is null and controller.[[pendingPullIntos]] is not empty,

   1. %firstDescriptor ~LET %controller.`pendingPullIntos$rbsC[ 0 ] ◎ Let firstDescriptor be controller.[[pendingPullIntos]][0].
   2. %view ~LET ~NOABRUPT `Construct$Ax( `有型~配列$, « 次に挙げる~item » ) ⇒＃ %firstDescriptor の`~buffer$pD, %firstDescriptor の`~byte~offset$pD ~PLUS %firstDescriptor の`埋まった~byte数$pD, %firstDescriptor の`~byte長さ$pD ~MINUS %firstDescriptor の`埋まった~byte数$pD ◎ Let view be ! Construct(%Uint8Array%, « firstDescriptor’s buffer, firstDescriptor’s byte offset + firstDescriptor’s bytes filled, firstDescriptor’s byte length − firstDescriptor’s bytes filled »).
   3. %byobRequest ~LET `新たな~obj$( `ReadableStreamBYOBRequest$I ) ◎ Let byobRequest be a new ReadableStreamBYOBRequest.
   4. %byobRequest.`controller$bbrQ ~SET %controller ◎ Set byobRequest.[[controller]] to controller.
   5. %byobRequest.`view$bbrQ ~SET %view ◎ Set byobRequest.[[view]] to view.
   6. %controller.`byobRequest$rbsC ~SET %byobRequest ◎ Set controller.[[byobRequest]] to byobRequest.
2. ~RET %controller.`byobRequest$rbsC ◎ Return controller.[[byobRequest]].

`ReadableByteStreamControllerGetDesiredSize(controller)@A は、 次の手続きを遂行する： ◎ ReadableByteStreamControllerGetDesiredSize(controller) performs the following steps:

1. %state ~LET %controller.`stream$rbsC.`state$rS ◎ Let state be controller.[[stream]].[[state]].
2. ~IF［ %state ~EQ `errored^l ］ ⇒ ~RET ~NULL ◎ If state is "errored", return null.
3. ~IF［ %state ~EQ `closed^l ］ ⇒ ~RET 0 ◎ If state is "closed", return 0.
4. ~RET %controller.`strategyHWM$rbsC ~MINUS %controller.`queueTotalSize$rbsC ◎ Return controller.[[strategyHWM]] − controller.[[queueTotalSize]].

`ReadableByteStreamControllerHandleQueueDrain(controller)@A は、 次の手続きを遂行する： ◎ ReadableByteStreamControllerHandleQueueDrain(controller) performs the following steps:

1. ~Assert： %controller.`stream$rbsC.`state$rS ~EQ `readable^l ◎ Assert: controller.[[stream]].[[state]] is "readable".

2. ~IF［ %controller.`queueTotalSize$rbsC ~EQ 0 ］~AND［ %controller.`closeRequested$rbsC ~EQ ~T ］： ◎ If controller.[[queueTotalSize]] is 0 and controller.[[closeRequested]] is true,

   1. ~NOABRUPT `ReadableByteStreamControllerClearAlgorithms$A( %controller ) ◎ Perform ! ReadableByteStreamControllerClearAlgorithms(controller).
   2. ~NOABRUPT `ReadableStreamClose$A( %controller.`stream$rbsC ) ◎ Perform ! ReadableStreamClose(controller.[[stream]]).

3. ~ELSE： ◎ Otherwise,

   1. ~NOABRUPT `ReadableByteStreamControllerCallPullIfNeeded$A( %controller ) ◎ Perform ! ReadableByteStreamControllerCallPullIfNeeded(controller).

`ReadableByteStreamControllerInvalidateBYOBRequest(controller)@A は、 次の手続きを遂行する： ◎ ReadableByteStreamControllerInvalidateBYOBRequest(controller) performs the following steps:

1. ~IF［ %controller.`byobRequest$rbsC ~EQ ~NULL ］ ⇒ ~RET ◎ If controller.[[byobRequest]] is null, return.
2. %controller.`byobRequest$rbsC.`controller$bbrQ ~SET `undefined^jv ◎ Set controller.[[byobRequest]].[[controller]] to undefined.
3. %controller.`byobRequest$rbsC.`view$bbrQ ~SET ~NULL ◎ Set controller.[[byobRequest]].[[view]] to null.
4. %controller.`byobRequest$rbsC ~SET ~NULL ◎ Set controller.[[byobRequest]] to null.

`ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller)@A は、 次の手続きを遂行する： ◎ ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller) performs the following steps:

1. ~Assert： %controller.`closeRequested$rbsC ~EQ ~F ◎ Assert: controller.[[closeRequested]] is false.
2. %filledPullIntos ~LET 新たな`~list$ ◎ Let filledPullIntos be a new empty list.

3. ~WHILE［ %controller.`pendingPullIntos$rbsC は`空$でない ］： ◎ While controller.[[pendingPullIntos]] is not empty,

   1. ~IF［ %controller.`queueTotalSize$rbsC ~EQ 0 ］ ⇒ ~BREAK ◎ If controller.[[queueTotalSize]] is 0, then break.
   2. %pullIntoDescriptor ~LET %controller.`pendingPullIntos$rbsC[0] ◎ Let pullIntoDescriptor be controller.[[pendingPullIntos]][0].

   3. ~IF［ ~NOABRUPT `ReadableByteStreamControllerFillPullIntoDescriptorFromQueue$A( %controller, %pullIntoDescriptor ) ~EQ ~T ］： ◎ If ! ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) is true,

      1. ~NOABRUPT `ReadableByteStreamControllerShiftPendingPullInto$A( %controller ) ◎ Perform ! ReadableByteStreamControllerShiftPendingPullInto(controller).
      2. %filledPullIntos に %pullIntoDescriptor を`付加する$ ◎ Append pullIntoDescriptor to filledPullIntos.
4. ~RET %filledPullIntos ◎ Return filledPullIntos.

`ReadableByteStreamControllerProcessReadRequestsUsingQueue(controller)@A は、 次の手続きを遂行する： ◎ ReadableByteStreamControllerProcessReadRequestsUsingQueue(controller) performs the following steps:

1. %reader ~LET %controller.`stream$rbsC.`reader$rS ◎ Let reader be controller.[[stream]].[[reader]].
2. ~Assert： %reader は `ReadableStreamDefaultReader$I を`実装する$ ◎ Assert: reader implements ReadableStreamDefaultReader.

3. ~WHILE［ %reader.`readRequests$rsR は`空$でない ］： ◎ While reader.[[readRequests]] is not empty,

   1. ~IF［ %controller.`queueTotalSize$rbsC ~EQ 0 ］ ⇒ ~RET ◎ If controller.[[queueTotalSize]] is 0, return.
   2. %readRequest ~LET %reader.`readRequests$rsR[ 0 ] ◎ Let readRequest be reader.[[readRequests]][0].
   3. %reader.`readRequests$rsR から %readRequest を`除去する$ ◎ Remove readRequest from reader.[[readRequests]].
   4. ~NOABRUPT `ReadableByteStreamControllerFillReadRequestFromQueue$A( %controller, %readRequest ) ◎ Perform ! ReadableByteStreamControllerFillReadRequestFromQueue(controller, readRequest).

`ReadableByteStreamControllerPullInto(controller, view, min, readIntoRequest)@A は、 次の手続きを遂行する： ◎ ReadableByteStreamControllerPullInto(controller, view, min, readIntoRequest) performs the following steps:

1. %stream ~LET %controller.`stream$rbsC ◎ Let stream be controller.[[stream]].
2. %elementSizem ~LET 1 ◎ Let elementSize be 1.
3. %ctor ~LET `DataView$jI ◎ Let ctor be %DataView%.
4. ~IF［ %view は `TypedArrayName^sl 内部~slotを有する（すなわち， `DataView$I ではない） ］ ⇒ ( %elementSizem, %ctor ) ~SET `有型~配列 構築子 表t＠~TC39#sec-dataview-objects$ に指定される， %view.`TypedArrayName^sl 用の ( 要素~size, 構築子 ) ◎ If view has a [[TypedArrayName]] internal slot (i.e., it is not a DataView), ◎ Set elementSize to the element size specified in the typed array constructors table for view.[[TypedArrayName]]. ◎ Set ctor to the constructor specified in the typed array constructors table for view.[[TypedArrayName]].
5. %minimumFill ~LET %min ~MUL %elementSize ◎ Let minimumFill be min × elementSize.
6. ~Assert： %minimumFill ~GTE 0 ］~AND［ %minimumFill ~LTE %view.`ByteLength^sl ］ ◎ Assert: minimumFill ≥ 0 and minimumFill ≤ view.[[ByteLength]].
7. ~Assert： `剰余$( %minimumFill, %elementSize ) ~EQ 0 ◎ Assert: the remainder after dividing minimumFill by elementSize is 0.
8. %byteOffset ~LET %view.`ByteOffset^sl ◎ Let byteOffset be view.[[ByteOffset]].
9. %byteLength ~LET %view.`ByteLength^sl ◎ Let byteLength be view.[[ByteLength]].
10. %bufferResult ~LET `TransferArrayBuffer$A( %view.`ViewedArrayBuffer^sl ) ◎ Let bufferResult be TransferArrayBuffer(view.[[ViewedArrayBuffer]]).

11. ~IF［ %bufferResult は`中途完了^である ］： ◎ If bufferResult is an abrupt completion,

    1. %readIntoRequest の`~error手続き$riR( %bufferResult.`Value^sl ) ◎ Perform readIntoRequest’s error steps, given bufferResult.[[Value]].
    2. ~RET ◎ Return.
12. %buffer ~LET %bufferResult.`Value^sl ◎ Let buffer be bufferResult.[[Value]].
13. %pullIntoDescriptor ~LET 次を伴う，新たな`~pull~into記述子$ ⇒＃ `~buffer$pD ~SET %buffer, `~buffer~byte長さ$pD ~SET %buffer.`ArrayBufferByteLength^sl, `~byte~offset$pD ~SET %byteOffset, `~byte長さ$pD ~SET %byteLength, `埋まった~byte数$pD ~SET 0, `最小な埋n$pD ~SET %minimumFill, `要素~size$pD ~SET %elementSize, `~view構築子$pD ~SET %ctor, `読取器~型$pD ~SET `byob^l ◎ Let pullIntoDescriptor be a new pull-into descriptor with ◎ 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. ~IF［ %controller.`pendingPullIntos$rbsC は空でない ］： ◎ If controller.[[pendingPullIntos]] is not empty,

    1. %controller.`pendingPullIntos$rbsC に %pullIntoDescriptor を`付加する$ ◎ Append pullIntoDescriptor to controller.[[pendingPullIntos]].
    2. ~NOABRUPT `ReadableStreamAddReadIntoRequest$A( %stream, %readIntoRequest ) ◎ Perform ! ReadableStreamAddReadIntoRequest(stream, readIntoRequest).
    3. ~RET ◎ Return.

15. ~IF［ %stream.`state$rS ~EQ `closed^l ］： ◎ If stream.[[state]] is "closed",

    1. %emptyView ~LET ~NOABRUPT `Construct$Ax( %ctor, « %pullIntoDescriptor の`~buffer$pD, %pullIntoDescriptor の`~byte~offset$pD, 0 » ) ◎ Let emptyView be ! Construct(ctor, « pullIntoDescriptor’s buffer, pullIntoDescriptor’s byte offset, 0 »).
    2. %readIntoRequest の`~close手続き$riR( %emptyView ) ◎ Perform readIntoRequest’s close steps, given emptyView.
    3. ~RET ◎ Return.

16. ~IF［ %controller.`queueTotalSize$rbsC ~GT 0 ］： ◎ If controller.[[queueTotalSize]] > 0,

    1. ~IF［ ~NOABRUPT `ReadableByteStreamControllerFillPullIntoDescriptorFromQueue$A( %controller, %pullIntoDescriptor ) ~EQ ~T ］： ◎ If ! ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) is true,

       1. %filledView ~LET ~NOABRUPT `ReadableByteStreamControllerConvertPullIntoDescriptor$A( %pullIntoDescriptor ) ◎ Let filledView be ! ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor).
       2. ~NOABRUPT `ReadableByteStreamControllerHandleQueueDrain$A( %controller ) ◎ Perform ! ReadableByteStreamControllerHandleQueueDrain(controller).
       3. %readIntoRequest の`~chunk手続き$riR( %filledView ) ◎ Perform readIntoRequest’s chunk steps, given filledView.
       4. ~RET ◎ Return.

    2. ~IF［ %controller.`closeRequested$rbsC ~EQ ~T ］： ◎ If controller.[[closeRequested]] is true,

       1. %e ~LET `TypeError$jE 例外 ◎ Let e be a TypeError exception.
       2. ~NOABRUPT `ReadableByteStreamControllerError$A( %controller, %e ) ◎ Perform ! ReadableByteStreamControllerError(controller, e).
       3. %readIntoRequest の`~error手続き$riR( %e ) ◎ Perform readIntoRequest’s error steps, given e.
       4. ~RET ◎ Return.
17. %controller.`pendingPullIntos$rbsC に %pullIntoDescriptor を`付加する$ ◎ Append pullIntoDescriptor to controller.[[pendingPullIntos]].
18. ~NOABRUPT `ReadableStreamAddReadIntoRequest$A( %stream, %readIntoRequest ) ◎ Perform ! ReadableStreamAddReadIntoRequest(stream, readIntoRequest).
19. ~NOABRUPT `ReadableByteStreamControllerCallPullIfNeeded$A( %controller ) ◎ Perform ! ReadableByteStreamControllerCallPullIfNeeded(controller).

`ReadableByteStreamControllerRespond(controller, bytesWritten)@A は、 次の手続きを遂行する： ◎ ReadableByteStreamControllerRespond(controller, bytesWritten) performs the following steps:

1. ~Assert： %controller.`pendingPullIntos$rbsC は`空$でない ◎ Assert: controller.[[pendingPullIntos]] is not empty.
2. %firstDescriptor ~LET %controller.`pendingPullIntos$rbsC[0] ◎ Let firstDescriptor be controller.[[pendingPullIntos]][0].
3. %state ~LET %controller.`stream$rbsC.`state$rS ◎ Let state be controller.[[stream]].[[state]].

4. ~IF［ %state ~EQ `closed^l ］： ◎ If state is "closed",

   1. ~IF［ %bytesWritten ~NEQ 0 ］ ⇒ ~THROW `TypeError$jE ◎ If bytesWritten is not 0, throw a TypeError exception.

5. ~ELSE： ◎ Otherwise,

   1. ~Assert： %state ~EQ `readable^l ◎ Assert: state is "readable".
   2. ~IF［ %bytesWritten ~EQ 0 ］ ⇒ ~THROW `TypeError$jE ◎ If bytesWritten is 0, throw a TypeError exception.
   3. ~IF［ %firstDescriptor の`埋まった~byte数$pD ~PLUS %bytesWritten ~GT %firstDescriptor の`~byte長さ$pD ］ ⇒ ~THROW `RangeError$E ◎ If firstDescriptor’s bytes filled + bytesWritten > firstDescriptor’s byte length, throw a RangeError exception.
6. %firstDescriptor の`~buffer$pD ~SET ~NOABRUPT `TransferArrayBuffer$A( %firstDescriptor の`~buffer$pD ) ◎ Set firstDescriptor’s buffer to ! TransferArrayBuffer(firstDescriptor’s buffer).
7. ~ABRUPT `ReadableByteStreamControllerRespondInternal$A( %controller, %bytesWritten ) ◎ Perform ? ReadableByteStreamControllerRespondInternal(controller, bytesWritten).

`ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor)@A は、 次の手続きを遂行する： ◎ ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor) performs the following steps:

1. ~Assert： `剰余$( %firstDescriptor の`埋まった~byte数$pD, %firstDescriptor の`要素~size$pD ) ~EQ 0 ◎ Assert: the remainder after dividing firstDescriptor’s bytes filled by firstDescriptor’s element size is 0.
2. ~IF［ %firstDescriptor の`読取器~型$pD ~EQ `none^l ］ ⇒ ~NOABRUPT `ReadableByteStreamControllerShiftPendingPullInto$A( %controller ) ◎ If firstDescriptor’s reader type is "none", perform ! ReadableByteStreamControllerShiftPendingPullInto(controller).
3. %stream ~LET %controller.`stream$rbsC ◎ Let stream be controller.[[stream]].

4. ~IF［ ~NOABRUPT `ReadableStreamHasBYOBReader$A( %stream ) ~EQ ~T ］： ◎ If ! ReadableStreamHasBYOBReader(stream) is true,

   1. %filledPullIntos ~LET 新たな`~list$ ◎ Let filledPullIntos be a new empty list.

   2. ~WHILE［ %filledPullIntos の`~size$ ~LT ~NOABRUPT `ReadableStreamGetNumReadIntoRequests$A( %stream ) ］： ◎ While filledPullIntos’s size < ! ReadableStreamGetNumReadIntoRequests(stream),

      1. %pullIntoDescriptor ~LET ~NOABRUPT `ReadableByteStreamControllerShiftPendingPullInto$A( %controller ) ◎ Let pullIntoDescriptor be ! ReadableByteStreamControllerShiftPendingPullInto(controller).
      2. %filledPullIntos に %pullIntoDescriptor を`付加する$ ◎ Append pullIntoDescriptor to filledPullIntos.
   3. %filledPullIntos を成す ~EACH( %filledPullInto ) に対し ⇒ ~NOABRUPT `ReadableByteStreamControllerCommitPullIntoDescriptor$A( %stream, %filledPullInto ) ◎ For each filledPullInto of filledPullIntos, • Perform ! ReadableByteStreamControllerCommitPullIntoDescriptor(stream, filledPullInto).

`ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, pullIntoDescriptor)@A は、 次の手続きを遂行する： ◎ ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, pullIntoDescriptor) performs the following steps:

1. ~Assert： ( %pullIntoDescriptor の`埋まった~byte数$pD ~PLUS %bytesWritten ) ~LTE %pullIntoDescriptor の`~byte長さ$pD ◎ Assert: pullIntoDescriptor’s bytes filled + bytesWritten ≤ pullIntoDescriptor’s byte length.
2. ~NOABRUPT `ReadableByteStreamControllerFillHeadPullIntoDescriptor$A( %controller, %bytesWritten, %pullIntoDescriptor ) ◎ Perform ! ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesWritten, pullIntoDescriptor).

3. ~IF［ %pullIntoDescriptor の`読取器~型$pD ~EQ `none^l ］： ◎ If pullIntoDescriptor’s reader type is "none",

   1. ~ABRUPT `ReadableByteStreamControllerEnqueueDetachedPullIntoToQueue$A( %controller, %pullIntoDescriptor ) ◎ Perform ? ReadableByteStreamControllerEnqueueDetachedPullIntoToQueue(controller, pullIntoDescriptor).
   2. %filledPullIntos ~LET ~NOABRUPT `ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue$A( %controller ) ◎ Let filledPullIntos be the result of performing ! ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller).
   3. %filledPullIntos を成す ~EACH( %filledPullInto ) に対し ⇒ ~NOABRUPT `ReadableByteStreamControllerCommitPullIntoDescriptor$A( %controller.`stream$rbsC, %filledPullInto ) ◎ For each filledPullInto of filledPullIntos, • Perform ! ReadableByteStreamControllerCommitPullIntoDescriptor(controller.[[stream]], filledPullInto).
   4. ~RET ◎ Return.

4. ~IF［ %pullIntoDescriptor の`埋まった~byte数$pD ~LT %pullIntoDescriptor の`最小な埋n$pD ］ ⇒ ~RET ◎ If pullIntoDescriptor’s bytes filled < pullIntoDescriptor’s minimum fill, return.

   注記： `read()$byob 要請~用の記述子【 %pullIntoDescriptor 】は、 まだ その最小~長さまで埋まってない間は，当の~queueを成す頭部に居続けることになる — なので、 `下層~source$は，それを埋め続けれる。 ◎ A descriptor for a read() request that is not yet filled up to its minimum length will stay at the head of the queue, so the underlying source can keep filling it.

5. ~NOABRUPT `ReadableByteStreamControllerShiftPendingPullInto$A( %controller ) ◎ Perform ! ReadableByteStreamControllerShiftPendingPullInto(controller).
6. %remainderSize ~LET `剰余$( %pullIntoDescriptor の`埋まった~byte数$pD, %pullIntoDescriptor の`要素~size$pD ) ◎ Let remainderSize be the remainder after dividing pullIntoDescriptor’s bytes filled by pullIntoDescriptor’s element size.

7. ~IF［ %remainderSize ~GT 0 ］： ◎ If remainderSize > 0,

   1. %end ~LET ( %pullIntoDescriptor の`~byte~offset$pD ~PLUS %pullIntoDescriptor の`埋まった~byte数$pD ) ◎ Let end be pullIntoDescriptor’s byte offset + pullIntoDescriptor’s bytes filled.
   2. ~ABRUPT `ReadableByteStreamControllerEnqueueClonedChunkToQueue$A( %controller, %pullIntoDescriptor の`~buffer$pD, %end ~MINUS %remainderSize, %remainderSize ) ◎ Perform ? ReadableByteStreamControllerEnqueueClonedChunkToQueue(controller, pullIntoDescriptor’s buffer, end − remainderSize, remainderSize).
8. %pullIntoDescriptor の`埋まった~byte数$pD ~DECBY %remainderSize ◎ Set pullIntoDescriptor’s bytes filled to pullIntoDescriptor’s bytes filled − remainderSize.
9. %filledPullIntos ~LET ~NOABRUPT `ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue$A( %controller ) ◎ Let filledPullIntos be the result of performing ! ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller).
10. ~NOABRUPT `ReadableByteStreamControllerCommitPullIntoDescriptor$A( %controller.`stream$rbsC, %pullIntoDescriptor ) ◎ Perform ! ReadableByteStreamControllerCommitPullIntoDescriptor(controller.[[stream]], pullIntoDescriptor).
11. %filledPullIntos を成す ~EACH( %filledPullInto ) に対し ⇒ ~NOABRUPT `ReadableByteStreamControllerCommitPullIntoDescriptor$A( %controller.`stream$rbsC, %filledPullInto ) ◎ For each filledPullInto of filledPullIntos, • Perform ! ReadableByteStreamControllerCommitPullIntoDescriptor(controller.[[stream]], filledPullInto).

`ReadableByteStreamControllerRespondInternal(controller, bytesWritten)@A は、 次の手続きを遂行する： ◎ ReadableByteStreamControllerRespondInternal(controller, bytesWritten) performs the following steps:

1. %firstDescriptor ~LET %controller.`pendingPullIntos$rbsC[0] ◎ Let firstDescriptor be controller.[[pendingPullIntos]][0].
2. ~Assert： ~NOABRUPT `CanTransferArrayBuffer$A( %firstDescriptor の`~buffer$pD ) ~EQ ~T ◎ Assert: ! CanTransferArrayBuffer(firstDescriptor’s buffer) is true.
3. ~NOABRUPT `ReadableByteStreamControllerInvalidateBYOBRequest$A( %controller ) ◎ Perform ! ReadableByteStreamControllerInvalidateBYOBRequest(controller).
4. %state ~LET %controller.`stream$rbsC.`state$rS ◎ Let state be controller.[[stream]].[[state]].

5. ~IF［ %state ~EQ `closed^l ］： ◎ If state is "closed",

   1. ~Assert： %bytesWritten ~EQ 0 ◎ Assert: bytesWritten is 0.
   2. ~NOABRUPT `ReadableByteStreamControllerRespondInClosedState$A( %controller, %firstDescriptor ) ◎ Perform ! ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor).

6. ~ELSE： ◎ Otherwise,

   1. ~Assert： %state ~EQ `readable^l ◎ Assert: state is "readable".
   2. ~Assert： %bytesWritten ~GT 0 ◎ Assert: bytesWritten > 0.
   3. ~ABRUPT `ReadableByteStreamControllerRespondInReadableState$A( %controller, %bytesWritten, %firstDescriptor ) ◎ Perform ? ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, firstDescriptor).
7. ~NOABRUPT `ReadableByteStreamControllerCallPullIfNeeded$A( %controller ) ◎ Perform ! ReadableByteStreamControllerCallPullIfNeeded(controller).

`ReadableByteStreamControllerRespondWithNewView(controller, view)@A は、 次の手続きを遂行する： ◎ ReadableByteStreamControllerRespondWithNewView(controller, view) performs the following steps:

1. ~Assert： %controller.`pendingPullIntos$rbsC は`空$でない ◎ Assert: controller.[[pendingPullIntos]] is not empty.
2. ~Assert： ~NOABRUPT `IsDetachedBuffer$Ax( %view.`ViewedArrayBuffer^sl ) ~EQ F ◎ Assert: ! IsDetachedBuffer(view.[[ViewedArrayBuffer]]) is false.
3. %firstDescriptor ~LET %controller.`pendingPullIntos$rbsC[0] ◎ Let firstDescriptor be controller.[[pendingPullIntos]][0].
4. %state ~LET %controller.`stream$rbsC.`state$rS ◎ Let state be controller.[[stream]].[[state]].

5. ~IF［ %state ~EQ `closed^l ］： ◎ If state is "closed",

   1. ~IF［ %view.`ByteLength^sl ~NEQ 0 ］ ⇒ ~THROW `TypeError$jE ◎ If view.[[ByteLength]] is not 0, throw a TypeError exception.

6. ~ELSE： ◎ Otherwise,

   1. ~Assert： %state ~EQ `readable^l ◎ Assert: state is "readable".
   2. ~IF［ %view.`ByteLength^sl ~EQ 0 ］ ⇒ ~THROW `TypeError$jE ◎ If view.[[ByteLength]] is 0, throw a TypeError exception.
7. ~IF［ ( %firstDescriptor の`~byte~offset$pD ~PLUS %firstDescriptor の`埋まった~byte数$pD ) ~NEQ %view.`ByteOffset^sl ］ ⇒ ~THROW `RangeError$E ◎ If firstDescriptor’s byte offset + firstDescriptor’ bytes filled is not view.[[ByteOffset]], throw a RangeError exception.
8. ~IF［ %firstDescriptor の`~buffer~byte長さ$pD ~NEQ %view.`ViewedArrayBuffer^sl.`ByteLength^sl ］ ⇒ ~THROW `RangeError$E ◎ If firstDescriptor’s buffer byte length is not view.[[ViewedArrayBuffer]].[[ByteLength]], throw a RangeError exception.
9. ~IF［ %firstDescriptor の`埋まった~byte数$pD ~PLUS %view.`ByteLength^sl ~GT %firstDescriptor の`~byte長さ$pD ］ ⇒ ~THROW `RangeError$E ◎ If firstDescriptor’s bytes filled + view.[[ByteLength]] > firstDescriptor’s byte length, throw a RangeError exception.
10. %viewByteLength ~LET %view.`ByteLength^sl ◎ Let viewByteLength be view.[[ByteLength]].
11. %firstDescriptor の`~buffer$pD ~SET ~ABRUPT `TransferArrayBuffer$A( %view.`ViewedArrayBuffer^sl ) ◎ Set firstDescriptor’s buffer to ? TransferArrayBuffer(view.[[ViewedArrayBuffer]]).
12. ~ABRUPT `ReadableByteStreamControllerRespondInternal$A( %controller, %viewByteLength ) ◎ Perform ? ReadableByteStreamControllerRespondInternal(controller, viewByteLength).

`ReadableByteStreamControllerShiftPendingPullInto(controller)@A は、 次の手続きを遂行する： ◎ ReadableByteStreamControllerShiftPendingPullInto(controller) performs the following steps:

1. ~Assert： %controller.`byobRequest$rbsC ~EQ ~NULL ◎ Assert: controller.[[byobRequest]] is null.
2. %descriptor ~LET %controller.`pendingPullIntos$rbsC[0] ◎ Let descriptor be controller.[[pendingPullIntos]][0].
3. %controller.`pendingPullIntos$rbsC から %descriptor を`除去する$ ◎ Remove descriptor from controller.[[pendingPullIntos]].
4. ~RET %descriptor ◎ Return descriptor.

`ReadableByteStreamControllerShouldCallPull(controller)@A は、 次の手続きを遂行する： ◎ ReadableByteStreamControllerShouldCallPull(controller) performs the following steps:

1. %stream ~LET %controller.`stream$rbsC ◎ Let stream be controller.[[stream]].
2. ~IF［ %stream.`state$rS ~NEQ `readable^l ］ ⇒ ~RET ~F ◎ If stream.[[state]] is not "readable", return false.
3. ~IF［ %controller.`closeRequested$rbsC ~EQ ~T ］ ⇒ ~RET ~F ◎ If controller.[[closeRequested]] is true, return false.
4. ~IF［ %controller.`started$rbsC ~EQ ~F ］ ⇒ ~RET ~F ◎ If controller.[[started]] is false, return false.
5. ~IF［ ~NOABRUPT `ReadableStreamHasDefaultReader$A( %stream ) ~EQ ~T ］~AND［ ~NOABRUPT `ReadableStreamGetNumReadRequests$A( %stream ) ~GT 0 ］ ⇒ ~RET ~T ◎ If ! ReadableStreamHasDefaultReader(stream) is true and ! ReadableStreamGetNumReadRequests(stream) > 0, return true.
6. ~IF［ ~NOABRUPT `ReadableStreamHasBYOBReader$A( %stream ) ~EQ ~T ］~AND［ ~NOABRUPT `ReadableStreamGetNumReadIntoRequests$A( %stream ) ~GT 0 ］ ⇒ ~RET ~T ◎ If ! ReadableStreamHasBYOBReader(stream) is true and ! ReadableStreamGetNumReadIntoRequests(stream) > 0, return true.
7. %desiredSize ~LET ~NOABRUPT `ReadableByteStreamControllerGetDesiredSize$A( %controller ) ◎ Let desiredSize be ! ReadableByteStreamControllerGetDesiredSize(controller).
8. ~Assert： %desiredSize ~NEQ ~NULL ◎ Assert: desiredSize is not null.
9. ~IF［ %desiredSize ~GT 0 ］ ⇒ ~RET ~T ◎ If desiredSize > 0, return true.
10. ~RET ~F ◎ Return false.

`SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, autoAllocateChunkSize)@A は、 次の手続きを遂行する： ◎ SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, autoAllocateChunkSize) performs the following steps:

1. ~Assert： %stream.`controller$rS ~EQ `undefined^jv ◎ Assert: stream.[[controller]] is undefined.

2. ~IF［ %autoAllocateChunkSize ~NEQ `undefined^jv ］： ◎ If autoAllocateChunkSize is not undefined,

   1. ~Assert： ~NOABRUPT `IsInteger$Ax( %autoAllocateChunkSize ) ~EQ ~T ◎ Assert: ! IsInteger(autoAllocateChunkSize) is true.
   2. ~Assert： %autoAllocateChunkSize ~GT 0 ◎ Assert: autoAllocateChunkSize is positive.
3. %controller の ⇒＃ .`stream$rbsC ~SET %stream .`pullAgain$rbsC ~SET ~F, .`pulling$rbsC ~SET ~F, .`byobRequest$rbsC ~SET ~NULL ◎ Set controller.[[stream]] to stream. ◎ Set controller.[[pullAgain]] and controller.[[pulling]] to false. ◎ Set controller.[[byobRequest]] to null.
4. ~NOABRUPT `ResetQueue$A( %controller ) ◎ Perform ! ResetQueue(controller).
5. %controller の ⇒＃ .`closeRequested$rbsC ~SET ~F, .`started$rbsC ~SET ~F, .`strategyHWM$rbsC ~SET %highWaterMark, .`pullAlgorithm$rbsC ~SET %pullAlgorithm, .`cancelAlgorithm$rbsC ~SET %cancelAlgorithm, .`autoAllocateChunkSize$rbsC ~SET %autoAllocateChunkSize, .`pendingPullIntos$rbsC ~SET 新たな`~list$ ◎ Set controller.[[closeRequested]] and controller.[[started]] to false. ◎ Set controller.[[strategyHWM]] to highWaterMark. ◎ Set controller.[[pullAlgorithm]] to pullAlgorithm. ◎ Set controller.[[cancelAlgorithm]] to cancelAlgorithm. ◎ Set controller.[[autoAllocateChunkSize]] to autoAllocateChunkSize. ◎ Set controller.[[pendingPullIntos]] to a new empty list.
6. %stream.`controller$rS ~SET %controller ◎ Set stream.[[controller]] to controller.
7. %startResult ~LET %startAlgorithm() ◎ Let startResult be the result of performing startAlgorithm.

8. %startPromise ~LET `解決される~promise$( %startResult ) ◎ Let startPromise be a promise resolved with startResult.

   • %startPromise の`充足-時$には： ◎ Upon fulfillment of startPromise,

     1. %controller.`started$rbsC ~SET ~T ◎ Set controller.[[started]] to true.
     2. ~Assert： %controller.`pulling$rbsC ~EQ ~F ◎ Assert: controller.[[pulling]] is false.
     3. ~Assert： %controller.`pullAgain$rbsC ~EQ ~F ◎ Assert: controller.[[pullAgain]] is false.
     4. ~NOABRUPT `ReadableByteStreamControllerCallPullIfNeeded$A( %controller ) ◎ Perform ! ReadableByteStreamControllerCallPullIfNeeded(controller).

   • %startPromise の`却下-時$には、 所与の ( 事由 %r ) に対し： ◎ Upon rejection of startPromise with reason r,

     1. ~NOABRUPT `ReadableByteStreamControllerError$A( %controller, %r ) ◎ Perform ! ReadableByteStreamControllerError(controller, r).

`SetUpReadableByteStreamControllerFromUnderlyingSource(stream, underlyingSource, underlyingSourceDict, highWaterMark)@A は、 次の手続きを遂行する： ◎ SetUpReadableByteStreamControllerFromUnderlyingSource(stream, underlyingSource, underlyingSourceDict, highWaterMark) performs the following steps:

1. %controller ~LET `新たな~obj$( `ReadableByteStreamController$I ) ◎ Let controller be a new ReadableByteStreamController.
2. %startAlgorithm ~LET 次を走らす~algo ⇒ ~RET `undefined^jv ◎ Let startAlgorithm be an algorithm that returns undefined.
3. %pullAlgorithm ~LET 次を走らす~algo ⇒ ~RET `解決される~promise$( `undefined^jv ) ◎ Let pullAlgorithm be an algorithm that returns a promise resolved with undefined.
4. %cancelAlgorithm ~LET 次を走らす~algo ⇒ ~RET `解決される~promise$( `undefined^jv ) ◎ Let cancelAlgorithm be an algorithm that returns a promise resolved with undefined.
5. ~IF［ %underlyingSourceDict[ "`start$usc" ] ~NEQ ε ］ ⇒ %startAlgorithm ~SET 次を走らす~algo ⇒ ~RET `~callback関数を呼出す$( %underlyingSourceDict[ "`start$usc" ], « %controller »【, `投出し直す^i ？】, %underlyingSource ) ◎ If underlyingSourceDict["start"] exists, then set startAlgorithm to an algorithm which returns the result of invoking underlyingSourceDict["start"] with argument list « controller » and callback this value underlyingSource.
6. ~IF［ %underlyingSourceDict[ "`pull$usc" ] ~NEQ ε ］ ⇒ %pullAlgorithm ~SET 次を走らす~algo ⇒ ~RET `~callback関数を呼出す$( %underlyingSourceDict[ "`pull$usc" ], « %controller », ε, %underlyingSource ) ◎ If underlyingSourceDict["pull"] exists, then set pullAlgorithm to an algorithm which returns the result of invoking underlyingSourceDict["pull"] with argument list « controller » and callback this value underlyingSource.
7. ~IF［ %underlyingSourceDict[ "`cancel$usc" ] ~NEQ ε ］ ⇒ %cancelAlgorithm ~SET 所与の ( %reason ) に対し，次を走らす~algo ⇒ ~RET `~callback関数を呼出す$( %underlyingSourceDict[ "`cancel$usc" ], « %reason », ε, %underlyingSource ) ◎ If underlyingSourceDict["cancel"] exists, then set cancelAlgorithm to an algorithm which takes an argument reason and returns the result of invoking underlyingSourceDict["cancel"] with argument list « reason » and callback this value underlyingSource.
8. %autoAllocateChunkSize ~LET %underlyingSourceDict[ "`autoAllocateChunkSize$usc" ] ◎ Let autoAllocateChunkSize be underlyingSourceDict["autoAllocateChunkSize"], if it exists,＼
9. ~IF［ %autoAllocateChunkSize ~EQ ε ］ ⇒ %autoAllocateChunkSize ~SET `undefined^jv ◎ or undefined otherwise.
10. ~IF［ %autoAllocateChunkSize ~EQ 0 ］ ⇒ ~THROW `TypeError$jE ◎ If autoAllocateChunkSize is 0, then throw a TypeError exception.
11. ~ABRUPT `SetUpReadableByteStreamController$A( %stream, %controller, %startAlgorithm, %pullAlgorithm, %cancelAlgorithm, %highWaterMark, %autoAllocateChunkSize ) ◎ Perform ? SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, autoAllocateChunkSize).

`new WritableStream(underlyingSink, strategy)@m 構築子~手続きは： ◎ The new WritableStream(underlyingSink, strategy) constructor steps are:

1. ~IF［ %underlyingSink ~EQ ε ］ ⇒ %underlyingSink ~SET ~NULL ◎ If underlyingSink is missing, set it to null.

2. %underlyingSinkDict ~LET `~IDL値に変換する$( %underlyingSink, `UnderlyingSink$I ) ◎ Let underlyingSinkDict be underlyingSink, converted to an IDL value of type UnderlyingSink.

   注記： %underlyingSink 引数を `UnderlyingSink$I 型として直に宣言できないのは、 元の~objへの参照が失われるからである。 ~obj上の各種~methodを`~methodを呼出せる$よう，~objは維持する必要がある。 ◎ We cannot declare the underlyingSink argument as having the UnderlyingSink type directly, because doing so would lose the reference to the original object. We need to retain the object so we can invoke the various methods on it.

3. ~IF［ %underlyingSinkDict[ "`type$usk" ] ~NEQ ε ］ ⇒ ~THROW `RangeError$E ◎ If underlyingSinkDict["type"] exists, throw a RangeError exception.

   注記： これは、 将来に新たな型を［ 後方-互換性を懸念することなく，追加する ］ことを許容する。 ◎ This is to allow us to add new potential types in the future, without backward-compatibility concerns.

4. ~NOABRUPT `InitializeWritableStream$A( コレ ) ◎ Perform ! InitializeWritableStream(this).
5. %sizeAlgorithm ~LET ~ABRUPT `ExtractSizeAlgorithm$A( %strategy ) ◎ Let sizeAlgorithm be ! ExtractSizeAlgorithm(strategy).
6. %highWaterMark ~LET ~ABRUPT `ExtractHighWaterMark$A( %strategy, 1 ) ◎ Let highWaterMark be ? ExtractHighWaterMark(strategy, 1).
7. ~ABRUPT `SetUpWritableStreamDefaultControllerFromUnderlyingSink$A( コレ, %underlyingSink, %underlyingSinkDict, %highWaterMark, %sizeAlgorithm ) ◎ Perform ? SetUpWritableStreamDefaultControllerFromUnderlyingSink(this, underlyingSink, underlyingSinkDict, highWaterMark, sizeAlgorithm).

`locked@ws 取得子~手続きは： ◎ The locked getter steps are:

1. ~RET ~NOABRUPT `IsWritableStreamLocked$A( コレ ) ◎ Return ! IsWritableStreamLocked(this).

`abort(reason)@ws ~method手続きは： ◎ The abort(reason) method steps are:

1. ~IF［ ~NOABRUPT `IsWritableStreamLocked$A( コレ ) ~EQ ~T ］ ⇒ ~RET `却下される~promise$( `TypeError$jE 例外 ) ◎ If ! IsWritableStreamLocked(this) is true, return a promise rejected with a TypeError exception.
2. ~RET ~NOABRUPT `WritableStreamAbort$A( コレ, %reason ) ◎ Return ! WritableStreamAbort(this, reason).

`close()@ws ~method手続きは： ◎ The close() method steps are:

1. ~IF［ ~NOABRUPT `IsWritableStreamLocked$A( コレ ) ~EQ ~T ］ ⇒ ~RET `却下される~promise$( `TypeError$jE 例外 ) ◎ If ! IsWritableStreamLocked(this) is true, return a promise rejected with a TypeError exception.
2. ~IF［ ~NOABRUPT `WritableStreamCloseQueuedOrInFlight$A( コレ ) ~EQ ~T ］ ⇒ ~RET `却下される~promise$( `TypeError$jE 例外 ) ◎ If ! WritableStreamCloseQueuedOrInFlight(this) is true, return a promise rejected with a TypeError exception.
3. ~RET ~NOABRUPT `WritableStreamClose$A( コレ ) ◎ Return ! WritableStreamClose(this).

`getWriter()@ws ~method手続きは： ◎ The getWriter() method steps are:

1. ~RET ~ABRUPT `AcquireWritableStreamDefaultWriter$A( コレ ) ◎ Return ? AcquireWritableStreamDefaultWriter(this).

`new WritableStreamDefaultWriter(stream)@m 構築子~手続きは： ◎ The new WritableStreamDefaultWriter(stream) constructor steps are:

1. ~ABRUPT `SetUpWritableStreamDefaultWriter$A( コレ, %stream ) ◎ Perform ? SetUpWritableStreamDefaultWriter(this, stream).

`closed@dw 取得子~手続きは： ◎ The closed getter steps are:

1. ~RET コレ.`closedPromise$wsW ◎ Return this.[[closedPromise]].

`desiredSize@dw 取得子~手続きは： ◎ The desiredSize getter steps are:

1. ~IF［ コレ.`stream$wsW ~EQ `undefined^jv ］ ⇒ ~THROW `TypeError$jE ◎ If this.[[stream]] is undefined, throw a TypeError exception.
2. ~RET ~NOABRUPT `WritableStreamDefaultWriterGetDesiredSize$A( コレ ) ◎ Return ! WritableStreamDefaultWriterGetDesiredSize(this).

`ready@dw 取得子~手続きは： ◎ The ready getter steps are:

1. ~RET コレ.`readyPromise$wsW ◎ Return this.[[readyPromise]].

`abort(reason)@dw ~method手続きは： ◎ The abort(reason) method steps are:

1. ~IF［ コレ.`stream$wsW ~EQ `undefined^jv ］ ⇒ ~RET `却下される~promise$( `TypeError$jE 例外 ) ◎ If this.[[stream]] is undefined, return a promise rejected with a TypeError exception.
2. ~RET ~NOABRUPT `WritableStreamDefaultWriterAbort$A( コレ, %reason ) ◎ Return ! WritableStreamDefaultWriterAbort(this, reason).

`close()@dw ~method手続きは： ◎ The close() method steps are:

1. %stream ~LET コレ.`stream$wsW ◎ Let stream be this.[[stream]].
2. ~IF［ %stream ~EQ `undefined^jv ］ ⇒ ~RET `却下される~promise$( `TypeError$jE 例外 ) ◎ If stream is undefined, return a promise rejected with a TypeError exception.
3. ~IF［ ~NOABRUPT `WritableStreamCloseQueuedOrInFlight$A( %stream ) ~EQ ~T ］ ⇒ ~RET `却下される~promise$( `TypeError$jE 例外 ) ◎ If ! WritableStreamCloseQueuedOrInFlight(stream) is true, return a promise rejected with a TypeError exception.
4. ~RET ~NOABRUPT `WritableStreamDefaultWriterClose$A( コレ ) ◎ Return ! WritableStreamDefaultWriterClose(this).

`releaseLock()@dw ~method手続きは： ◎ The releaseLock() method steps are:

1. %stream ~LET コレ.`stream$wsW ◎ Let stream be this.[[stream]].
2. ~IF［ %stream ~EQ `undefined^jv ］ ⇒ ~RET ◎ If stream is undefined, return.
3. ~Assert： %stream.`writer$wS ~NEQ `undefined^jv ◎ Assert: stream.[[writer]] is not undefined.
4. ~NOABRUPT `WritableStreamDefaultWriterRelease$A( コレ ) ◎ Perform ! WritableStreamDefaultWriterRelease(this).

`write(chunk)@dw ~method手続きは： ◎ The write(chunk) method steps are:

1. ~IF［ コレ.`stream$wsW ~EQ `undefined^jv ］ ⇒ ~RET `却下される~promise$( `TypeError$jE 例外 ) ◎ If this.[[stream]] is undefined, return a promise rejected with a TypeError exception.
2. ~RET ~NOABRUPT `WritableStreamDefaultWriterWrite$A( コレ, %chunk ) ◎ Return ! WritableStreamDefaultWriterWrite(this, chunk).

`error(e)@wsdc ~method手続きは： ◎ The error(e) method steps are:

1. %state ~LET コレ.`stream$wsdC.`state$wS ◎ Let state be this.[[stream]].[[state]].
2. ~IF［ %state ~NEQ `writable^l ］ ⇒ ~RET ◎ If state is not "writable", return.
3. ~NOABRUPT `WritableStreamDefaultControllerError$A( コレ, %e ) ◎ Perform ! WritableStreamDefaultControllerError(this, e).

`[[AbortSteps]]( reason )@wsdc は、 `AbortSteps$sl の契約を実装する。 それは、 次の手続きを遂行する： ◎ [[AbortSteps]](reason) implements the [[AbortSteps]] contract. It performs the following steps:

1. %result ~LET コレ.`abortAlgorithm$wsdC( %reason ) ◎ Let result be the result of performing this.[[abortAlgorithm]], passing reason.
2. ~NOABRUPT `WritableStreamDefaultControllerClearAlgorithms$A( コレ ) ◎ Perform ! WritableStreamDefaultControllerClearAlgorithms(this).
3. ~RET %result ◎ Return result.

`[[ErrorSteps]]()@wsdc は `ErrorSteps$sl の契約を実装する。 それは、 次の手続きを遂行する： ◎ [[ErrorSteps]]() implements the [[ErrorSteps]] contract. It performs the following steps:

1. ~NOABRUPT `ResetQueue$A( コレ ) ◎ Perform ! ResetQueue(this).

`AcquireWritableStreamDefaultWriter(stream)@A は、 次の手続きを遂行する： ◎ AcquireWritableStreamDefaultWriter(stream) performs the following steps:

1. %writer ~LET `新たな~obj$( `WritableStreamDefaultWriter$I ) ◎ Let writer be a new WritableStreamDefaultWriter.
2. ~ABRUPT `SetUpWritableStreamDefaultWriter$A( %writer, %stream ) ◎ Perform ? SetUpWritableStreamDefaultWriter(writer, stream).
3. ~RET %writer ◎ Return writer.

`CreateWritableStream(startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm[, highWaterMark[, sizeAlgorithm ] ])@A は、 次の手続きを遂行する： ◎ CreateWritableStream(startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm) performs the following steps:

1. ~Assert： ~NOABRUPT `IsNonNegativeNumber$A( %highWaterMark ) ~EQ ~T ◎ Assert: ! IsNonNegativeNumber(highWaterMark) is true.
2. %stream ~LET `新たな~obj$( `WritableStream$I ) ◎ Let stream be a new WritableStream.
3. ~NOABRUPT `InitializeWritableStream$A( %stream ) ◎ Perform ! InitializeWritableStream(stream).
4. %controller ~LET `新たな~obj$( `WritableStreamDefaultController$I ) ◎ Let controller be a new WritableStreamDefaultController.
5. ~ABRUPT `SetUpWritableStreamDefaultController$A( ↓ ) ⇒＃ %stream, %controller, %startAlgorithm, %writeAlgorithm, %closeAlgorithm, %abortAlgorithm, %highWaterMark, %sizeAlgorithm ◎ Perform ? SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm).
6. ~RET %stream ◎ Return stream.

注記： この抽象-演算は、 給された %startAlgorithm が投出するとき, そのときに限り， 例外を投出することになる。 ◎ This abstract operation will throw an exception if and only if the supplied startAlgorithm throws.

`InitializeWritableStream(stream)@A は、 次の手続きを遂行する： ◎ InitializeWritableStream(stream) performs the following steps:

1. %stream の ⇒＃ .`state$wS ~SET `writable^l, .`storedError$wS ~SET `undefined^jv, .`writer$wS ~SET `undefined^jv, .`controller$wS ~SET `undefined^jv, .`inFlightWriteRequest$wS ~SET `undefined^jv, .`closeRequest$wS ~SET `undefined^jv, .`inFlightCloseRequest$wS ~SET `undefined^jv, .`pendingAbortRequest$wS ~SET `undefined^jv, .`writeRequests$wS ~SET 新たな`~list$, .`backpressure$wS ~SET ~F ◎ Set stream.[[state]] to "writable". ◎ Set stream.[[storedError]], stream.[[writer]], stream.[[controller]], stream.[[inFlightWriteRequest]], stream.[[closeRequest]], stream.[[inFlightCloseRequest]], and stream.[[pendingAbortRequest]] to undefined. ◎ Set stream.[[writeRequests]] to a new empty list. ◎ Set stream.[[backpressure]] to false.

`IsWritableStreamLocked(stream)@A は、 次の手続きを遂行する： ◎ IsWritableStreamLocked(stream) performs the following steps:

1. ~IF［ %stream.`writer$wS ~EQ `undefined^jv ］ ⇒ ~RET ~F ◎ If stream.[[writer]] is undefined, return false.
2. ~RET ~T ◎ Return true.

`SetUpWritableStreamDefaultWriter(writer, stream)@A は、 次の手続きを遂行する： ◎ SetUpWritableStreamDefaultWriter(writer, stream) performs the following steps:

1. ~IF［ ~NOABRUPT `IsWritableStreamLocked$A( %stream ) ~EQ ~T ］ ⇒ ~THROW `TypeError$jE ◎ If ! IsWritableStreamLocked(stream) is true, throw a TypeError exception.
2. %writer.`stream$wsW ~SET %stream ◎ Set writer.[[stream]] to stream.
3. %stream.`writer$wS ~SET %writer ◎ Set stream.[[writer]] to writer.
4. %state ~LET %stream.`state$wS ◎ Let state be stream.[[state]].

5. ~IF［ %state ~EQ `writable^l ］： ◎ If state is "writable",

   1. ~IF［ ~NOABRUPT `WritableStreamCloseQueuedOrInFlight$A( %stream ) ~EQ ~F ］~AND［ %stream.`backpressure$wS ~EQ ~T ］ ⇒ %writer.`readyPromise$wsW ~SET `新たな~promise$ ◎ If ! WritableStreamCloseQueuedOrInFlight(stream) is false and stream.[[backpressure]] is true, set writer.[[readyPromise]] to a new promise.
   2. ~ELSE ⇒ %writer.`readyPromise$wsW ~SET `解決される~promise$( `undefined^jv ) ◎ Otherwise, set writer.[[readyPromise]] to a promise resolved with undefined.
   3. %writer.`closedPromise$wsW ~SET `新たな~promise$ ◎ Set writer.[[closedPromise]] to a new promise.

6. ~ELIF［ %state ~EQ `erroring^l ］ ⇒ ◎ Otherwise, if state is "erroring",

   1. %writer.`readyPromise$wsW ~SET `却下される~promise$( %stream.`storedError$wS ) ◎ Set writer.[[readyPromise]] to a promise rejected with stream.[[storedError]].
   2. %writer.`readyPromise$wsW.`PromiseIsHandled^sl ~SET ~T ◎ Set writer.[[readyPromise]].[[PromiseIsHandled]] to true.
   3. %writer.`closedPromise$wsW ~SET `新たな~promise$ ◎ Set writer.[[closedPromise]] to a new promise.

7. ~ELIF［ %state ~EQ `closed^l ］ ⇒ ◎ Otherwise, if state is "closed",

   1. %writer.`readyPromise$wsW ~SET `解決される~promise$( `undefined^jv ) ◎ Set writer.[[readyPromise]] to a promise resolved with undefined.
   2. %writer.`closedPromise$wsW ~SET `解決される~promise$( `undefined^jv ) ◎ Set writer.[[closedPromise]] to a promise resolved with undefined.

8. ~ELSE： ◎ Otherwise,

   1. ~Assert： %state ~EQ `errored^l ◎ Assert: state is "errored".
   2. %storedError ~LET %stream.`storedError$wS ◎ Let storedError be stream.[[storedError]].
   3. %writer.`readyPromise$wsW ~SET `却下される~promise$( %storedError ) ◎ Set writer.[[readyPromise]] to a promise rejected with storedError.
   4. %writer.`readyPromise$wsW.`PromiseIsHandled^sl ~SET ~T ◎ Set writer.[[readyPromise]].[[PromiseIsHandled]] to true.
   5. %writer.`closedPromise$wsW ~SET `却下される~promise$( %storedError ) ◎ Set writer.[[closedPromise]] to a promise rejected with storedError.
   6. %writer.`closedPromise$wsW.`PromiseIsHandled^sl ~SET ~T ◎ Set writer.[[closedPromise]].[[PromiseIsHandled]] to true.

`WritableStreamAbort(stream, reason)@A は、 次の手続きを遂行する： ◎ WritableStreamAbort(stream, reason) performs the following steps:

1. ~IF［ %stream.`state$wS ~IN { `closed^l, `errored^l } ］ ⇒ ~RET `解決される~promise$( `undefined^jv ) ◎ If stream.[[state]] is "closed" or "errored", return a promise resolved with undefined.
2. `中止-を通達する$aC( %stream.`controller$wS.`abortController$wsdC, %reason ) ◎ Signal abort on stream.[[controller]].[[abortController]] with reason.
3. %state ~LET %stream.`state$wS ◎ Let state be stream.[[state]].

4. ~IF［ %state ~IN { `closed^l, `errored^l } ］ ⇒ ~RET `解決される~promise$( `undefined^jv ) ◎ If state is "closed" or "errored", return a promise resolved with undefined.

   注記： ここでは、 %state を検査し直す — `中止-を通達する$aCときに走らせた作者~codeは、 %state を変更したかもしれないので。 ◎ We re-check the state because signaling abort runs author code and that might have changed the state.

5. ~IF［ %stream.`pendingAbortRequest$wS ~NEQ `undefined^jv ］ ⇒ ~RET %stream.`pendingAbortRequest$wS の`~promise$aR ◎ If stream.[[pendingAbortRequest]] is not undefined, return stream.[[pendingAbortRequest]]’s promise.
6. ~Assert： %state ~IN { `writable^l, `erroring^l } ◎ Assert: state is "writable" or "erroring".
7. %wasAlreadyErroring ~LET ~F ◎ Let wasAlreadyErroring be false.

8. ~IF［ %state ~EQ `erroring^l ］： ◎ If state is "erroring",

   1. %wasAlreadyErroring ~SET ~T ◎ Set wasAlreadyErroring to true.
   2. %reason ~SET `undefined^jv ◎ Set reason to undefined.
9. %promise ~LET `新たな~promise$ ◎ Let promise be a new promise.
10. %stream.`pendingAbortRequest$wS ~SET 次を伴う，新たな`処理待ち中止-要請$ ⇒＃ `~promise$aR ~SET %promise, `事由$aR ~SET %reason, `すでに~errorしたか$aR ~SET %wasAlreadyErroring ◎ Set stream.[[pendingAbortRequest]] to a new pending abort request whose promise is promise, reason is reason, and was already erroring is wasAlreadyErroring.
11. ~IF［ %wasAlreadyErroring ~EQ ~F ］ ⇒ ~NOABRUPT `WritableStreamStartErroring$A( %stream, %reason ) ◎ If wasAlreadyErroring is false, perform ! WritableStreamStartErroring(stream, reason).
12. ~RET %promise ◎ Return promise.

`WritableStreamClose(stream)@A は、 次の手続きを遂行する： ◎ WritableStreamClose(stream) performs the following steps:

1. %state ~LET %stream.`state$wS ◎ Let state be stream.[[state]].
2. ~IF［ %state ~IN { `closed^l, `errored^l } ］ ⇒ ~RET `却下される~promise$( `TypeError$jE 例外 ) ◎ If state is "closed" or "errored", return a promise rejected with a TypeError exception.
3. ~Assert： %state ~IN { `writable^l, `erroring^l } ◎ Assert: state is "writable" or "erroring".
4. ~Assert： ~NOABRUPT `WritableStreamCloseQueuedOrInFlight$A( %stream ) ~EQ ~F ◎ Assert: ! WritableStreamCloseQueuedOrInFlight(stream) is false.
5. %promise ~LET `新たな~promise$ ◎ Let promise be a new promise.
6. %stream.`closeRequest$wS ~SET %promise ◎ Set stream.[[closeRequest]] to promise.
7. %writer ~LET %stream.`writer$wS ◎ Let writer be stream.[[writer]].
8. ~IF［ %writer ~NEQ `undefined^jv ］~AND［ %stream.`backpressure$wS ~EQ ~T ］~AND［ %state ~EQ `writable^l ］ ⇒ `~promiseを解決する$( %writer.`readyPromise$wsW, `undefined^jv ) ◎ If writer is not undefined, and stream.[[backpressure]] is true, and state is "writable", resolve writer.[[readyPromise]] with undefined.
9. ~NOABRUPT `WritableStreamDefaultControllerClose$A( %stream.`controller$wS ) ◎ Perform ! WritableStreamDefaultControllerClose(stream.[[controller]]).
10. ~RET %promise ◎ Return promise.

`WritableStreamAddWriteRequest(stream)@A は、 次の手続きを遂行する： ◎ WritableStreamAddWriteRequest(stream) performs the following steps:

1. ~Assert： ~NOABRUPT `IsWritableStreamLocked$A( %stream ) ~EQ ~T ◎ Assert: ! IsWritableStreamLocked(stream) is true.
2. ~Assert： %stream.`state$wS ~EQ `writable^l ◎ Assert: stream.[[state]] is "writable".
3. %promise ~LET `新たな~promise$ ◎ Let promise be a new promise.
4. %stream.`writeRequests$wS に %promise を`付加する$ ◎ Append promise to stream.[[writeRequests]].
5. ~RET %promise ◎ Return promise.

`WritableStreamCloseQueuedOrInFlight(stream)@A は、 次の手続きを遂行する： ◎ WritableStreamCloseQueuedOrInFlight(stream) performs the following steps:

1. ~IF［ %stream.`closeRequest$wS ~EQ `undefined^jv ］~AND［ %stream.`inFlightCloseRequest$wS ~EQ `undefined^jv ］ ⇒ ~RET ~F ◎ If stream.[[closeRequest]] is undefined and stream.[[inFlightCloseRequest]] is undefined, return false.
2. ~RET ~T ◎ Return true.

`WritableStreamDealWithRejection(stream, error)@A は、 次の手続きを遂行する： ◎ WritableStreamDealWithRejection(stream, error) performs the following steps:

1. %state ~LET %stream.`state$wS ◎ Let state be stream.[[state]].

2. ~IF［ %state ~EQ `writable^l ］： ◎ If state is "writable",

   1. ~NOABRUPT `WritableStreamStartErroring$A( %stream, %error ) ◎ Perform ! WritableStreamStartErroring(stream, error).
   2. ~RET ◎ Return.
3. ~Assert： %state ~EQ `erroring^l ◎ Assert: state is "erroring".
4. ~NOABRUPT `WritableStreamFinishErroring$A( %stream ) ◎ Perform ! WritableStreamFinishErroring(stream).

`WritableStreamFinishErroring(stream)@A は、 次の手続きを遂行する： ◎ WritableStreamFinishErroring(stream) performs the following steps:

1. ~Assert： %stream.`state$wS ~EQ `erroring^l ◎ Assert: stream.[[state]] is "erroring".
2. ~Assert： ~NOABRUPT `WritableStreamHasOperationMarkedInFlight$A( %stream ) ~EQ ~F ◎ Assert: ! WritableStreamHasOperationMarkedInFlight(stream) is false.
3. %stream.`state$wS ~SET `errored^l ◎ Set stream.[[state]] to "errored".
4. ~NOABRUPT %stream.`controller$wS.`ErrorSteps$sl() ◎ Perform ! stream.[[controller]].[[ErrorSteps]]().
5. %storedError ~LET %stream.`storedError$wS ◎ Let storedError be stream.[[storedError]].

6. %stream.`writeRequests$wS を成す ~EACH( %writeRequest ) に対し： ◎ For each writeRequest of stream.[[writeRequests]]:

   1. `~promiseを却下する$( %writeRequest, %storedError ) ◎ Reject writeRequest with storedError.
7. %stream.`writeRequests$wS ~SET 空`~list$ ◎ Set stream.[[writeRequests]] to an empty list.

8. ~IF［ %stream.`pendingAbortRequest$wS ~EQ `undefined^jv ］： ◎ If stream.[[pendingAbortRequest]] is undefined,

   1. ~NOABRUPT `WritableStreamRejectCloseAndClosedPromiseIfNeeded$A( %stream) ◎ Perform ! WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream).
   2. ~RET ◎ Return.
9. %abortRequest ~LET %stream.`pendingAbortRequest$wS ◎ Let abortRequest be stream.[[pendingAbortRequest]].
10. %stream.`pendingAbortRequest$wS ~SET `undefined^jv ◎ Set stream.[[pendingAbortRequest]] to undefined.

11. ~IF［ %abortRequest の`すでに~errorしたか$aR ~EQ ~T ］： ◎ If abortRequest’s was already erroring is true,

    1. `~promiseを却下する$( %abortRequest の`~promise$aR, %storedError ) ◎ Reject abortRequest’s promise with storedError.
    2. ~NOABRUPT `WritableStreamRejectCloseAndClosedPromiseIfNeeded$A( %stream) ◎ Perform ! WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream).
    3. ~RET ◎ Return.

12. %promise ~LET ~NOABRUPT %stream.`controller$wS.`AbortSteps$sl( %abortRequest の`事由$aR ) ◎ Let promise be ! stream.[[controller]].[[AbortSteps]](abortRequest’s reason).

    • %promise の`充足-時$には： ◎ Upon fulfillment of promise,

      1. `~promiseを解決する$( %abortRequest の`~promise$aR, `undefined^jv ) ◎ Resolve abortRequest’s promise with undefined.
      2. ~NOABRUPT `WritableStreamRejectCloseAndClosedPromiseIfNeeded$A( %stream) ◎ Perform ! WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream).

    • %promise の`却下-時$には、 所与の ( 事由 %reason ) に対し： ◎ Upon rejection of promise with reason reason,

      1. `~promiseを却下する$( %abortRequest の`~promise$aR, %reason ) ◎ Reject abortRequest’s promise with reason.
      2. ~NOABRUPT `WritableStreamRejectCloseAndClosedPromiseIfNeeded$A( %stream) ◎ Perform ! WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream).

`WritableStreamFinishInFlightClose(stream)@A は、 次の手続きを遂行する： ◎ WritableStreamFinishInFlightClose(stream) performs the following steps:

1. ~Assert： %stream.`inFlightCloseRequest$wS ~NEQ `undefined^jv ◎ Assert: stream.[[inFlightCloseRequest]] is not undefined.
2. `~promiseを解決する$( %stream.`inFlightCloseRequest$wS, `undefined^jv ) ◎ Resolve stream.[[inFlightCloseRequest]] with undefined.
3. %stream.`inFlightCloseRequest$wS ~SET `undefined^jv ◎ Set stream.[[inFlightCloseRequest]] to undefined.
4. %state ~LET %stream.`state$wS ◎ Let state be stream.[[state]].
5. ~Assert： %stream.`state$wS ~IN { `writable^l, `erroring^l } ◎ Assert: stream.[[state]] is "writable" or "erroring".

6. ~IF［ %state ~EQ `erroring^l ］： ◎ If state is "erroring",

   1. %stream.`storedError$wS ~SET `undefined^jv ◎ Set stream.[[storedError]] to undefined.

   2. ~IF［ %stream.`pendingAbortRequest$wS ~NEQ `undefined^jv ］： ◎ If stream.[[pendingAbortRequest]] is not undefined,

      1. `~promiseを解決する$( %stream.`pendingAbortRequest$wS の`~promise$aR, `undefined^jv ) ◎ Resolve stream.[[pendingAbortRequest]]’s promise with undefined.
      2. %stream.`pendingAbortRequest$wS ~SET `undefined^jv ◎ Set stream.[[pendingAbortRequest]] to undefined.
7. %stream.`state$wS ~SET `closed^l ◎ Set stream.[[state]] to "closed".
8. %writer ~LET %stream.`writer$wS ◎ Let writer be stream.[[writer]].
9. ~IF［ %writer ~NEQ `undefined^jv ］ ⇒ `~promiseを解決する$( %writer.`closedPromise$wsW, `undefined^jv ) ◎ If writer is not undefined, resolve writer.[[closedPromise]] with undefined.
10. ~Assert： %stream.`pendingAbortRequest$wS ~EQ `undefined^jv ◎ Assert: stream.[[pendingAbortRequest]] is undefined.
11. ~Assert： %stream.`storedError$wS ~EQ `undefined^jv ◎ Assert: stream.[[storedError]] is undefined.

`WritableStreamFinishInFlightCloseWithError(stream, error)@A は、 次の手続きを遂行する： ◎ WritableStreamFinishInFlightCloseWithError(stream, error) performs the following steps:

1. ~Assert： %stream.`inFlightCloseRequest$wS ~NEQ `undefined^jv ◎ Assert: stream.[[inFlightCloseRequest]] is not undefined.
2. `~promiseを却下する$( %stream.`inFlightCloseRequest$wS, %error ) ◎ Reject stream.[[inFlightCloseRequest]] with error.
3. %stream.`inFlightCloseRequest$wS ~SET `undefined^jv ◎ Set stream.[[inFlightCloseRequest]] to undefined.
4. ~Assert： %stream.`state$wS ~IN { `writable^l, `erroring^l } ◎ Assert: stream.[[state]] is "writable" or "erroring".

5. ~IF［ %stream.`pendingAbortRequest$wS ~NEQ `undefined^jv ］： ◎ If stream.[[pendingAbortRequest]] is not undefined,

   1. `~promiseを却下する$( %stream.`pendingAbortRequest$wS の`~promise$aR, %error ) ◎ Reject stream.[[pendingAbortRequest]]’s promise with error.
   2. %stream.`pendingAbortRequest$wS ~SET `undefined^jv ◎ Set stream.[[pendingAbortRequest]] to undefined.
6. ~NOABRUPT `WritableStreamDealWithRejection$A( %stream, %error ) ◎ Perform ! WritableStreamDealWithRejection(stream, error).

`WritableStreamFinishInFlightWrite(stream)@A は、 次の手続きを遂行する： ◎ WritableStreamFinishInFlightWrite(stream) performs the following steps:

1. ~Assert： %stream.`inFlightWriteRequest$wS ~NEQ `undefined^jv ◎ Assert: stream.[[inFlightWriteRequest]] is not undefined.
2. `~promiseを解決する$( %stream.`inFlightWriteRequest$wS, `undefined^jv ) ◎ Resolve stream.[[inFlightWriteRequest]] with undefined.
3. %stream.`inFlightWriteRequest$wS ~SET `undefined^jv ◎ Set stream.[[inFlightWriteRequest]] to undefined.

`WritableStreamFinishInFlightWriteWithError(stream, error)@A は、 次の手続きを遂行する： ◎ WritableStreamFinishInFlightWriteWithError(stream, error) performs the following steps:

1. ~Assert： %stream.`inFlightWriteRequest$wS ~NEQ `undefined^jv ◎ Assert: stream.[[inFlightWriteRequest]] is not undefined.
2. `~promiseを却下する$( %stream.`inFlightWriteRequest$wS, %error ) ◎ Reject stream.[[inFlightWriteRequest]] with error.
3. %stream.`inFlightWriteRequest$wS ~SET `undefined^jv ◎ Set stream.[[inFlightWriteRequest]] to undefined.
4. ~Assert： %stream.`state$wS ~IN { `writable^l, `erroring^l } ◎ Assert: stream.[[state]] is "writable" or "erroring".
5. ~NOABRUPT `WritableStreamDealWithRejection$A( %stream, %error ) ◎ Perform ! WritableStreamDealWithRejection(stream, error).

`WritableStreamHasOperationMarkedInFlight(stream)@A は、 次の手続きを遂行する： ◎ WritableStreamHasOperationMarkedInFlight(stream) performs the following steps:

1. ~IF［ %stream.`inFlightWriteRequest$wS ~EQ `undefined^jv ］~AND［ %stream.`inFlightCloseRequest$wS ~EQ `undefined^jv ］ ⇒ ~RET ~F ◎ If stream.[[inFlightWriteRequest]] is undefined and stream.[[inFlightCloseRequest]] is undefined, return false.
2. ~RET ~T ◎ Return true.

`WritableStreamMarkCloseRequestInFlight(stream)@A は、 次の手続きを遂行する： ◎ WritableStreamMarkCloseRequestInFlight(stream) performs the following steps:

1. ~Assert： %stream.`inFlightCloseRequest$wS ~EQ `undefined^jv ◎ Assert: stream.[[inFlightCloseRequest]] is undefined.
2. ~Assert： %stream.`closeRequest$wS ~NEQ `undefined^jv ◎ Assert: stream.[[closeRequest]] is not undefined.
3. %stream.`inFlightCloseRequest$wS ~SET %stream.`closeRequest$wS ◎ Set stream.[[inFlightCloseRequest]] to stream.[[closeRequest]].
4. %stream.`closeRequest$wS ~SET `undefined^jv ◎ Set stream.[[closeRequest]] to undefined.

`WritableStreamMarkFirstWriteRequestInFlight(stream)@A は、 次の手続きを遂行する： ◎ WritableStreamMarkFirstWriteRequestInFlight(stream) performs the following steps:

1. ~Assert： %stream.`inFlightWriteRequest$wS ~EQ `undefined^jv ◎ Assert: stream.[[inFlightWriteRequest]] is undefined.
2. ~Assert： %stream.`writeRequests$wS は`空$でない ◎ Assert: stream.[[writeRequests]] is not empty.
3. %writeRequest ~LET %stream.`writeRequests$wS[0] ◎ Let writeRequest be stream.[[writeRequests]][0].
4. %stream.`writeRequests$wS から %writeRequest を`除去する$ ◎ Remove writeRequest from stream.[[writeRequests]].
5. %stream.`inFlightWriteRequest$wS ~SET %writeRequest ◎ Set stream.[[inFlightWriteRequest]] to writeRequest.

`WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream)@A は、 次の手続きを遂行する： ◎ WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream) performs the following steps:

1. ~Assert： %stream.`state$wS ~EQ `errored^l ◎ Assert: stream.[[state]] is "errored".

2. ~IF［ %stream.`closeRequest$wS ~NEQ `undefined^jv ］： ◎ If stream.[[closeRequest]] is not undefined,

   1. ~Assert： %stream.`inFlightCloseRequest$wS ~EQ `undefined^jv ◎ Assert: stream.[[inFlightCloseRequest]] is undefined.
   2. `~promiseを却下する$( %stream.`closeRequest$wS, %stream.`storedError$wS ) ◎ Reject stream.[[closeRequest]] with stream.[[storedError]].
   3. %stream.`closeRequest$wS ~SET `undefined^jv ◎ Set stream.[[closeRequest]] to undefined.
3. %writer ~LET %stream.`writer$wS ◎ Let writer be stream.[[writer]].

4. ~IF［ %writer ~NEQ `undefined^jv ］： ◎ If writer is not undefined,

   1. `~promiseを却下する$( %writer.`closedPromise$wsW, %stream.`storedError$wS ) ◎ Reject writer.[[closedPromise]] with stream.[[storedError]].
   2. %writer.`closedPromise$wsW.`PromiseIsHandled^sl ~SET ~T ◎ Set writer.[[closedPromise]].[[PromiseIsHandled]] to true.

`WritableStreamStartErroring(stream, reason)@A は、 次の手続きを遂行する： ◎ WritableStreamStartErroring(stream, reason) performs the following steps:

1. ~Assert： %stream.`storedError$wS ~EQ `undefined^jv ◎ Assert: stream.[[storedError]] is undefined.
2. ~Assert： %stream.`state$wS ~EQ `writable^l ◎ Assert: stream.[[state]] is "writable".
3. %controller ~LET %stream.`controller$wS ◎ Let controller be stream.[[controller]].
4. ~Assert： %controller ~NEQ `undefined^jv ◎ Assert: controller is not undefined.
5. %stream.`state$wS ~SET `erroring^l ◎ Set stream.[[state]] to "erroring".
6. %stream.`storedError$wS ~SET %reason ◎ Set stream.[[storedError]] to reason.
7. %writer ~LET %stream.`writer$wS ◎ Let writer be stream.[[writer]].
8. ~IF［ %writer ~NEQ `undefined^jv ］ ⇒ ~NOABRUPT `WritableStreamDefaultWriterEnsureReadyPromiseRejected$A( %writer, %reason ) ◎ If writer is not undefined, perform ! WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, reason).
9. ~IF［ ~NOABRUPT `WritableStreamHasOperationMarkedInFlight$A( %stream ) ~EQ ~F ］~AND［ %controller.`started$wsdC ~EQ ~T ］ ⇒ ~NOABRUPT `WritableStreamFinishErroring$A( %stream ) ◎ If ! WritableStreamHasOperationMarkedInFlight(stream) is false and controller.[[started]] is true, perform ! WritableStreamFinishErroring(stream).

`WritableStreamUpdateBackpressure(stream, backpressure)@A は、 次の手続きを遂行する： ◎ WritableStreamUpdateBackpressure(stream, backpressure) performs the following steps:

1. ~Assert： %stream.`state$wS ~EQ `writable^l ◎ Assert: stream.[[state]] is "writable".
2. ~Assert： ~NOABRUPT `WritableStreamCloseQueuedOrInFlight$A( %stream ) ~EQ ~F ◎ Assert: ! WritableStreamCloseQueuedOrInFlight(stream) is false.
3. %writer ~LET %stream.`writer$wS ◎ Let writer be stream.[[writer]].

4. ~IF［ %writer ~NEQ `undefined^jv ］~AND［ %backpressure ~NEQ %stream.`backpressure$wS ］： ◎ If writer is not undefined and backpressure is not stream.[[backpressure]],

   1. ~IF［ %backpressure ~EQ ~T ］ ⇒ %writer.`readyPromise$wsW ~SET `新たな~promise$ ◎ If backpressure is true, set writer.[[readyPromise]] to a new promise.

   2. ~ELSE： ◎ Otherwise,

      1. ~Assert： %backpressure ~EQ ~F ◎ Assert: backpressure is false.
      2. `~promiseを解決する$( %writer.`readyPromise$wsW, `undefined^jv ) ◎ Resolve writer.[[readyPromise]] with undefined.
5. %stream.`backpressure$wS ~SET %backpressure ◎ Set stream.[[backpressure]] to backpressure.

`WritableStreamDefaultWriterAbort(writer, reason)@A は、 次の手続きを遂行する： ◎ WritableStreamDefaultWriterAbort(writer, reason) performs the following steps:

1. %stream ~LET %writer.`stream$wsW ◎ Let stream be writer.[[stream]].
2. ~Assert： %stream ~NEQ `undefined^jv ◎ Assert: stream is not undefined.
3. ~RET ~NOABRUPT `WritableStreamAbort$A( %stream, %reason ) ◎ Return ! WritableStreamAbort(stream, reason).

`WritableStreamDefaultWriterClose(writer)@A は、 次の手続きを遂行する： ◎ WritableStreamDefaultWriterClose(writer) performs the following steps:

1. %stream ~LET %writer.`stream$wsW ◎ Let stream be writer.[[stream]].
2. ~Assert： %stream ~NEQ `undefined^jv ◎ Assert: stream is not undefined.
3. ~RET ~NOABRUPT `WritableStreamClose$A( %stream ) ◎ Return ! WritableStreamClose(stream).

`WritableStreamDefaultWriterCloseWithErrorPropagation(writer)@A は、 次の手続きを遂行する： ◎ WritableStreamDefaultWriterCloseWithErrorPropagation(writer) performs the following steps:

1. %stream ~LET %writer.`stream$wsW ◎ Let stream be writer.[[stream]].
2. ~Assert： %stream ~NEQ `undefined^jv ◎ Assert: stream is not undefined.
3. %state ~LET %stream.`state$wS ◎ Let state be stream.[[state]].
4. ~IF［ ~NOABRUPT `WritableStreamCloseQueuedOrInFlight$A( %stream ) ~EQ ~T ］~OR［ %state ~EQ `closed^l ］ ⇒ ~RET `解決される~promise$( `undefined^jv ) ◎ If ! WritableStreamCloseQueuedOrInFlight(stream) is true or state is "closed", return a promise resolved with undefined.
5. ~IF［ %state ~EQ `errored^l ］ ⇒ ~RET `却下される~promise$( %stream.`storedError$wS ) ◎ If state is "errored", return a promise rejected with stream.[[storedError]].
6. ~Assert： %state ~IN { `writable^l, `erroring^l } ◎ Assert: state is "writable" or "erroring".
7. ~RET ~NOABRUPT `WritableStreamDefaultWriterClose$A( %writer ) ◎ Return ! WritableStreamDefaultWriterClose(writer).

注記： この抽象-演算は、［ `ReadableStream$I の `pipeTo()$rs における~error伝播の意味論 ］を実装し易くするためにある。 ◎ This abstract operation helps implement the error propagation semantics of ReadableStream’s pipeTo().

`WritableStreamDefaultWriterEnsureClosedPromiseRejected(writer, error)@A は、 次の手続きを遂行する： ◎ WritableStreamDefaultWriterEnsureClosedPromiseRejected(writer, error) performs the following steps:

1. ~IF［ %writer.`closedPromise$wsW.`PromiseState^sl ~EQ `pending^l ］ ⇒ `~promiseを却下する$( %writer.`closedPromise$wsW, %error ) ◎ If writer.[[closedPromise]].[[PromiseState]] is "pending", reject writer.[[closedPromise]] with error.
2. ~ELSE ⇒ %writer.`closedPromise$wsW ~SET `却下される~promise$( %error ) ◎ Otherwise, set writer.[[closedPromise]] to a promise rejected with error.
3. %writer.`closedPromise$wsW.`PromiseIsHandled^sl ~SET ~T ◎ Set writer.[[closedPromise]].[[PromiseIsHandled]] to true.

`WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, error)@A は、 次の手続きを遂行する： ◎ WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, error) performs the following steps:

1. ~IF［ %writer.`readyPromise$wsW.`PromiseState^sl ~EQ `pending^l ］ ⇒ `~promiseを却下する$( %writer.`readyPromise$wsW, %error ) ◎ If writer.[[readyPromise]].[[PromiseState]] is "pending", reject writer.[[readyPromise]] with error.
2. ~ELSE ⇒ %writer.`readyPromise$wsW ~SET `却下される~promise$( %error ) ◎ Otherwise, set writer.[[readyPromise]] to a promise rejected with error.
3. %writer.`readyPromise$wsW.`PromiseIsHandled^sl ~SET ~T ◎ Set writer.[[readyPromise]].[[PromiseIsHandled]] to true.

`WritableStreamDefaultWriterGetDesiredSize(writer)@A は、 次の手続きを遂行する： ◎ WritableStreamDefaultWriterGetDesiredSize(writer) performs the following steps:

1. %stream ~LET %writer.`stream$wsW ◎ Let stream be writer.[[stream]].
2. %state ~LET %stream.`state$wS ◎ Let state be stream.[[state]].
3. ~IF［ %state ~IN { `errored^l, `erroring^l } ］ ⇒ ~RET ~NULL ◎ If state is "errored" or "erroring", return null.
4. ~IF［ %state ~EQ `closed^l ］ ⇒ ~RET 0 ◎ If state is "closed", return 0.
5. ~RET ~NOABRUPT `WritableStreamDefaultControllerGetDesiredSize$A( %stream.`controller$wS ) ◎ Return ! WritableStreamDefaultControllerGetDesiredSize(stream.[[controller]]).

`WritableStreamDefaultWriterRelease(writer)@A は、 次の手続きを遂行する： ◎ WritableStreamDefaultWriterRelease(writer) performs the following steps:

1. %stream ~LET %writer.`stream$wsW ◎ Let stream be writer.[[stream]].
2. ~Assert： %stream ~NEQ `undefined^jv ◎ Assert: stream is not undefined.
3. ~Assert: %stream.`writer$wS ~EQ %writer ◎ Assert: stream.[[writer]] is writer.
4. %releasedError ~LET 新たな `TypeError$jE ◎ Let releasedError be a new TypeError.
5. ~NOABRUPT `WritableStreamDefaultWriterEnsureReadyPromiseRejected$A( %writer, %releasedError) ◎ Perform ! WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, releasedError).
6. ~NOABRUPT `WritableStreamDefaultWriterEnsureClosedPromiseRejected$A( %writer, %releasedError) ◎ Perform ! WritableStreamDefaultWriterEnsureClosedPromiseRejected(writer, releasedError).
7. %stream.`writer$wS ~SET `undefined^jv ◎ Set stream.[[writer]] to undefined.
8. %writer.`stream$wsW ~SET `undefined^jv ◎ Set writer.[[stream]] to undefined.

`WritableStreamDefaultWriterWrite(writer, chunk)@A は、 次の手続きを遂行する： ◎ WritableStreamDefaultWriterWrite(writer, chunk) performs the following steps:

1. %stream ~LET %writer.`stream$wsW ◎ Let stream be writer.[[stream]].
2. ~Assert： %stream ~NEQ `undefined^jv ◎ Assert: stream is not undefined.
3. %controller ~LET %stream.`controller$wS ◎ Let controller be stream.[[controller]].
4. %chunkSize ~LET ~NOABRUPT `WritableStreamDefaultControllerGetChunkSize$A(%controller, %chunk) ◎ Let chunkSize be ! WritableStreamDefaultControllerGetChunkSize(controller, chunk).
5. ~IF［ %stream ~NEQ %writer.`stream$wsW ］ ⇒ ~RET `却下される~promise$( `TypeError$jE 例外 ) ◎ If stream is not equal to writer.[[stream]], return a promise rejected with a TypeError exception.
6. %state ~LET %stream.`state$wS ◎ Let state be stream.[[state]].
7. ~IF［ %state ~EQ `errored^l ］ ⇒ ~RET `却下される~promise$( %stream.`storedError$wS ) ◎ If state is "errored", return a promise rejected with stream.[[storedError]].
8. ~IF［ ~NOABRUPT `WritableStreamCloseQueuedOrInFlight$A( %stream ) ~EQ ~T ］~OR［ %state ~NEQ `closed^l ］ ⇒ ~RET `却下される~promise$( `TypeError$jE 例外 ) — これは、 ~streamは［ ~close中にあるか, ~closeされた ］ことを指示する。 ◎ If ! WritableStreamCloseQueuedOrInFlight(stream) is true or state is "closed", return a promise rejected with a TypeError exception indicating that the stream is closing or closed.
9. ~IF［ %state ~EQ `erroring^l ］ ⇒ ~RET `却下される~promise$( %stream.`storedError$wS ) ◎ If state is "erroring", return a promise rejected with stream.[[storedError]].
10. ~Assert： %state ~EQ `writable^l ◎ Assert: state is "writable".
11. %promise ~LET ~NOABRUPT `WritableStreamAddWriteRequest$A( %stream ) ◎ Let promise be ! WritableStreamAddWriteRequest(stream).
12. ~NOABRUPT `WritableStreamDefaultControllerWrite$A( %controller, %chunk, %chunkSize ) ◎ Perform ! WritableStreamDefaultControllerWrite(controller, chunk, chunkSize).
13. ~RET %promise ◎ Return promise.

`SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm)@A は、 次の手続きを遂行する： ◎ SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm) performs the following steps:

1. ~Assert： %stream は `WritableStream$I を`実装する$ ◎ Assert: stream implements WritableStream.
2. ~Assert： %stream.`controller$wS ~EQ `undefined^jv ◎ Assert: stream.[[controller]] is undefined.
3. %controller.`stream$wsdC ~SET %stream ◎ Set controller.[[stream]] to stream.
4. %stream.`controller$wS ~SET %controller ◎ Set stream.[[controller]] to controller.
5. ~NOABRUPT `ResetQueue$A( %controller ) ◎ Perform ! ResetQueue(controller).
6. %controller.`abortController$wsdC ~SET `新たな~obj$( `AbortController$I ) — その ⇒＃ .`started$wsdC ~SET ~F, .`strategySizeAlgorithm$wsdC ~SET %sizeAlgorithm, .`strategyHWM$wsdC ~SET %highWaterMark, .`writeAlgorithm$wsdC ~SET %writeAlgorithm, .`closeAlgorithm$wsdC ~SET %closeAlgorithm, .`abortAlgorithm$wsdC ~SET %abortAlgorithm ◎ Set controller.[[abortController]] to a new AbortController. ◎ Set controller.[[started]] to false. ◎ Set controller.[[strategySizeAlgorithm]] to sizeAlgorithm. ◎ Set controller.[[strategyHWM]] to highWaterMark. ◎ Set controller.[[writeAlgorithm]] to writeAlgorithm. ◎ Set controller.[[closeAlgorithm]] to closeAlgorithm. ◎ Set controller.[[abortAlgorithm]] to abortAlgorithm.
7. %backpressure ~LET ~NOABRUPT `WritableStreamDefaultControllerGetBackpressure$A( %controller ) ◎ Let backpressure be ! WritableStreamDefaultControllerGetBackpressure(controller).
8. ~NOABRUPT `WritableStreamUpdateBackpressure$A( %stream, %backpressure ) ◎ Perform ! WritableStreamUpdateBackpressure(stream, backpressure).
9. %startResult ~LET %startAlgorithm() （これは、例外を投出するかもしれない） ◎ Let startResult be the result of performing startAlgorithm. (This may throw an exception.)

10. %startPromise ~LET `解決される~promise$( %startResult ) ◎ Let startPromise be a promise resolved with startResult.

    • %startPromise の`充足-時$には： ◎ Upon fulfillment of startPromise,

      1. ~Assert： %stream.`state$wS ~IN { `writable^l, `erroring^l } ◎ Assert: stream.[[state]] is "writable" or "erroring".
      2. %controller.`started$wsdC ~SET ~T ◎ Set controller.[[started]] to true.
      3. ~NOABRUPT `WritableStreamDefaultControllerAdvanceQueueIfNeeded$A( %controller ) ◎ Perform ! WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller).

    • %startPromise の`却下-時$には、 所与の ( 事由 %r ) に対し： ◎ Upon rejection of startPromise with reason r,

      1. ~Assert： %stream.`state$wS ~IN { `writable^l, `erroring^l } ◎ Assert: stream.[[state]] is "writable" or "erroring".
      2. %controller.`started$wsdC ~SET ~T ◎ Set controller.[[started]] to true.
      3. ~NOABRUPT `WritableStreamDealWithRejection$A( %stream, %r ) ◎ Perform ! WritableStreamDealWithRejection(stream, r).

`SetUpWritableStreamDefaultControllerFromUnderlyingSink(stream, underlyingSink, underlyingSinkDict, highWaterMark, sizeAlgorithm)@A は、 次の手続きを遂行する： ◎ SetUpWritableStreamDefaultControllerFromUnderlyingSink(stream, underlyingSink, underlyingSinkDict, highWaterMark, sizeAlgorithm) performs the following steps:

1. %controller ~LET `新たな~obj$( `WritableStreamDefaultController$I ) ◎ Let controller be a new WritableStreamDefaultController.
2. %startAlgorithm ~LET 次を走らす~algo ⇒ ~RET `undefined^jv ◎ Let startAlgorithm be an algorithm that returns undefined.
3. %writeAlgorithm ~LET 次を走らす~algo ⇒ ~RET `解決される~promise$( `undefined^jv ) ◎ Let writeAlgorithm be an algorithm that returns a promise resolved with undefined.
4. %closeAlgorithm ~LET 次を走らす~algo ⇒ ~RET `解決される~promise$( `undefined^jv ) ◎ Let closeAlgorithm be an algorithm that returns a promise resolved with undefined.
5. %abortAlgorithm ~LET 次を走らす~algo ⇒ ~RET `解決される~promise$( `undefined^jv ) ◎ Let abortAlgorithm be an algorithm that returns a promise resolved with undefined.
6. ~IF［ %underlyingSinkDict[ "`start$usk" ] ~NEQ ε ］ ⇒ %startAlgorithm ~SET 次を走らす~algo ⇒ ~RET `~callback関数を呼出す$( %underlyingSinkDict[ "`start$usk" ], « %controller », `投出し直す^i, %underlyingSink ) ◎ If underlyingSinkDict["start"] exists, then set startAlgorithm to an algorithm which returns the result of invoking underlyingSinkDict["start"] with argument list « controller », exception behavior "rethrow", and callback this value underlyingSink.
7. ~IF［ %underlyingSinkDict[ "`write$usk" ] ~NEQ ε ］ ⇒ %writeAlgorithm ~SET 所与の ( %chunk ) に対し，次を走らす~algo ⇒ ~RET `~callback関数を呼出す$( %underlyingSinkDict[ "`write$usk" ], « %chunk, %controller », ε, %underlyingSink ) ◎ If underlyingSinkDict["write"] exists, then set writeAlgorithm to an algorithm which takes an argument chunk and returns the result of invoking underlyingSinkDict["write"] with argument list « chunk, controller » and callback this value underlyingSink.
8. ~IF［ %underlyingSinkDict[ "`close$usk" ] ~NEQ ε ］ ⇒ %closeAlgorithm ~SET 次を走らす~algo ⇒ ~RET `~callback関数を呼出す$( %underlyingSinkDict[ "`close$usk" ], «», ε, %underlyingSink ) ◎ If underlyingSinkDict["close"] exists, then set closeAlgorithm to an algorithm which returns the result of invoking underlyingSinkDict["close"] with argument list «» and callback this value underlyingSink.
9. ~IF［ %underlyingSinkDict[ "`abort$usk" ] ~NEQ ε ］ ⇒ %abortAlgorithm ~SET 所与の ( %reason ) に対し，次を走らす~algo ⇒ ~RET `~callback関数を呼出す$( %underlyingSinkDict[ "`abort$usk" ], « %reason », ε, %underlyingSink ) ◎ If underlyingSinkDict["abort"] exists, then set abortAlgorithm to an algorithm which takes an argument reason and returns the result of invoking underlyingSinkDict["abort"] with argument list « reason » and callback this value underlyingSink.
10. ~ABRUPT `SetUpWritableStreamDefaultController$A( ↓ ) ⇒＃ %stream, %controller, %startAlgorithm, %writeAlgorithm, %closeAlgorithm, %abortAlgorithm, %highWaterMark, %sizeAlgorithm ◎ Perform ? SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm).

`WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller)@A は、 次の手続きを遂行する： ◎ WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller) performs the following steps:

1. %stream ~LET %controller.`stream$wsdC ◎ Let stream be controller.[[stream]].
2. ~IF［ %controller.`started$wsdC ~EQ ~F ］ ⇒ ~RET ◎ If controller.[[started]] is false, return.
3. ~IF［ %stream.`inFlightWriteRequest$wS ~NEQ `undefined^jv ］ ⇒ ~RET ◎ If stream.[[inFlightWriteRequest]] is not undefined, return.
4. %state ~LET %stream.`state$wS ◎ Let state be stream.[[state]].
5. ~Assert： %state ~NIN { `closed^l, `errored^l } ◎ Assert: state is not "closed" or "errored".

6. ~IF［ %state ~EQ `erroring^l ］： ◎ If state is "erroring",

   1. ~NOABRUPT `WritableStreamFinishErroring$A( %stream ) ◎ Perform ! WritableStreamFinishErroring(stream).
   2. ~RET ◎ Return.
7. ~IF［ %controller.`queue$wsdC は空である ］ ⇒ ~RET ◎ If controller.[[queue]] is empty, return.
8. %value ~LET ~NOABRUPT `PeekQueueValue$A( %controller ) ◎ Let value be ! PeekQueueValue(controller).
9. ~IF［ %value ~EQ `~close~sentinel$i ］ ⇒ ~NOABRUPT `WritableStreamDefaultControllerProcessClose$A( %controller ) ◎ If value is the close sentinel, perform ! WritableStreamDefaultControllerProcessClose(controller).
10. ~ELSE ⇒ ~NOABRUPT `WritableStreamDefaultControllerProcessWrite$A( %controller, %value ) ◎ Otherwise, perform ! WritableStreamDefaultControllerProcessWrite(controller, value).

`WritableStreamDefaultControllerClearAlgorithms(controller)@A は、［ ~streamが~closeされるか~errorして， 各種~algoが それ以上~実行されなくなったとき ］に~callされる。 これは、 各種~algoへの参照を除去することにより， `下層~sink$（ `WritableStream$I ~obj）自身が — まだ参照されていても — ~garbage収集されることを許可する。 ◎ WritableStreamDefaultControllerClearAlgorithms(controller) is called once the stream is closed or errored and the algorithms will not be executed any more. By removing the algorithm references it permits the underlying sink object to be garbage collected even if the WritableStream itself is still referenced.

注記： これは、 `弱い参照＠https://github.com/tc39/proposal-weakrefs/$を利用すると観測-可能になる。 詳細は `tc39/proposal-weakrefs#31＠https://github.com/tc39/proposal-weakrefs/issues/31$ を見よ。 ◎ This is observable using weak references. See tc39/proposal-weakrefs#31 for more detail.

それは、 次の手続きを遂行する： ◎ It performs the following steps:

1. %controller の ⇒＃ .`writeAlgorithm$wsdC ~SET `undefined^jv, .`closeAlgorithm$wsdC ~SET `undefined^jv, .`abortAlgorithm$wsdC ~SET `undefined^jv, .`strategySizeAlgorithm$wsdC ~SET `undefined^jv ◎ Set controller.[[writeAlgorithm]] to undefined. ◎ Set controller.[[closeAlgorithm]] to undefined. ◎ Set controller.[[abortAlgorithm]] to undefined. ◎ Set controller.[[strategySizeAlgorithm]] to undefined.

注記： この~algoは、［ 一部の~~際どい事例では複数回 遂行される ］ことになるが， 2 回目~以降は何もしない。 ◎ This algorithm will be performed multiple times in some edge cases. After the first time it will do nothing.

`WritableStreamDefaultControllerClose(controller)@A は、 次の手続きを遂行する： ◎ WritableStreamDefaultControllerClose(controller) performs the following steps:

1. ~NOABRUPT `EnqueueValueWithSize$A( %controller, `~close~sentinel$i, 0 ) ◎ Perform ! EnqueueValueWithSize(controller, close sentinel, 0).
2. ~NOABRUPT `WritableStreamDefaultControllerAdvanceQueueIfNeeded$A( %controller ) ◎ Perform ! WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller).

`WritableStreamDefaultControllerError(controller, error)@A は、 次の手続きを遂行する： ◎ WritableStreamDefaultControllerError(controller, error) performs the following steps:

1. %stream ~LET %controller.`stream$wsdC ◎ Let stream be controller.[[stream]].
2. ~Assert： %stream.`state$wS ~EQ `writable^l ◎ Assert: stream.[[state]] is "writable".
3. ~NOABRUPT `WritableStreamDefaultControllerClearAlgorithms$A( %controller ) ◎ Perform ! WritableStreamDefaultControllerClearAlgorithms(controller).
4. ~NOABRUPT `WritableStreamStartErroring$A( %stream, %error ) ◎ Perform ! WritableStreamStartErroring(stream, error).

`WritableStreamDefaultControllerErrorIfNeeded(controller, error)@A は、 次の手続きを遂行する： ◎ WritableStreamDefaultControllerErrorIfNeeded(controller, error) performs the following steps:

1. ~IF［ %controller.`stream$wsdC.`state$wS ~EQ `writable^l ］ ⇒ ~NOABRUPT `WritableStreamDefaultControllerError$A( %controller, %error ) ◎ If controller.[[stream]].[[state]] is "writable", perform ! WritableStreamDefaultControllerError(controller, error).

`WritableStreamDefaultControllerGetBackpressure(controller)@A は、 次の手続きを遂行する： ◎ WritableStreamDefaultControllerGetBackpressure(controller) performs the following steps:

1. %desiredSize ~LET ~NOABRUPT `WritableStreamDefaultControllerGetDesiredSize$A( %controller ) ◎ Let desiredSize be ! WritableStreamDefaultControllerGetDesiredSize(controller).
2. ~RET ~IS［ %desiredSize ~LTE 0 ］ ◎ Return true if desiredSize ≤ 0, or false otherwise.

`WritableStreamDefaultControllerGetChunkSize(controller, chunk)@A は、 次の手続きを遂行する： ◎ WritableStreamDefaultControllerGetChunkSize(controller, chunk) performs the following steps:

1. ~IF［ %controller.`strategySizeAlgorithm$wsdC ~EQ `undefined^jv ］： ◎ If controller.[[strategySizeAlgorithm]] is undefined, then:

   1. ~Assert： %controller.`stream$wsdC.`state$wS ~NEQ `writable^l ◎ Assert: controller.[[stream]].[[state]] is not "writable".
   2. ~RET 1 ◎ Return 1.
2. %returnValue ~LET 次を遂行した結果を`完了~record$として解釈した結果 ⇒ %controller.`strategySizeAlgorithm$wsdC( %chunk ) ◎ Let returnValue be the result of performing controller.[[strategySizeAlgorithm]], passing in chunk, and interpreting the result as a completion record.

3. ~IF［ %returnValue は`中途完了^である ］： ◎ If returnValue is an abrupt completion,

   1. ~NOABRUPT `WritableStreamDefaultControllerErrorIfNeeded$A( %controller, %returnValue.`Value^sl ) ◎ Perform ! WritableStreamDefaultControllerErrorIfNeeded(controller, returnValue.[[Value]]).
   2. ~RET 1 ◎ Return 1.
4. ~RET %returnValue.`Value^sl ◎ Return returnValue.[[Value]].

`WritableStreamDefaultControllerGetDesiredSize(controller)@A は、 次の手続きを遂行する： ◎ WritableStreamDefaultControllerGetDesiredSize(controller) performs the following steps:

1. ~RET %controller.`strategyHWM$wsdC ~MINUS %controller.`queueTotalSize$wsdC ◎ Return controller.[[strategyHWM]] − controller.[[queueTotalSize]].

`WritableStreamDefaultControllerProcessClose(controller)@A は、 次の手続きを遂行する： ◎ WritableStreamDefaultControllerProcessClose(controller) performs the following steps:

1. %stream ~LET %controller.`stream$wsdC ◎ Let stream be controller.[[stream]].
2. ~NOABRUPT `WritableStreamMarkCloseRequestInFlight$A( %stream ) ◎ Perform ! WritableStreamMarkCloseRequestInFlight(stream).
3. ~NOABRUPT `DequeueValue$A( %controller ) ◎ Perform ! DequeueValue(controller).
4. ~Assert： %controller.`queue$wsdC は空である ◎ Assert: controller.[[queue]] is empty.
5. %sinkClosePromise ~LET %controller.`closeAlgorithm$wsdC() ◎ Let sinkClosePromise be the result of performing controller.[[closeAlgorithm]].
6. ~NOABRUPT `WritableStreamDefaultControllerClearAlgorithms$A( %controller ) ◎ Perform ! WritableStreamDefaultControllerClearAlgorithms(controller).

7. • %sinkClosePromise の`充足-時$には： ◎ Upon fulfillment of sinkClosePromise,

     1. ~NOABRUPT `WritableStreamFinishInFlightClose$A( %stream ) ◎ Perform ! WritableStreamFinishInFlightClose(stream).

   • %sinkClosePromise の`却下-時$には、 所与の ( 事由 %reason ) に対し： ◎ Upon rejection of sinkClosePromise with reason reason,

     1. ~NOABRUPT `WritableStreamFinishInFlightCloseWithError$A( %stream, %reason ) ◎ Perform ! WritableStreamFinishInFlightCloseWithError(stream, reason).

`WritableStreamDefaultControllerProcessWrite(controller, chunk)@A は、 次の手続きを遂行する： ◎ WritableStreamDefaultControllerProcessWrite(controller, chunk) performs the following steps:

1. %stream ~LET %controller.`stream$wsdC ◎ Let stream be controller.[[stream]].
2. ~NOABRUPT `WritableStreamMarkFirstWriteRequestInFlight$A( %stream ) ◎ Perform ! WritableStreamMarkFirstWriteRequestInFlight(stream).

3. %sinkWritePromise ~LET %controller.`writeAlgorithm$wsdC( %chunk ) ◎ Let sinkWritePromise be the result of performing controller.[[writeAlgorithm]], passing in chunk.

   • %sinkWritePromise の`充足-時$には： ◎ Upon fulfillment of sinkWritePromise,

     1. ~NOABRUPT `WritableStreamFinishInFlightWrite$A( %stream ) ◎ Perform ! WritableStreamFinishInFlightWrite(stream).
     2. %state ~LET %stream.`state$wS ◎ Let state be stream.[[state]].
     3. ~Assert： %state ~IN { `writable^l, `erroring^l } ◎ Assert: state is "writable" or "erroring".
     4. ~NOABRUPT `DequeueValue$A( %controller ) ◎ Perform ! DequeueValue(controller).

     5. ~IF［ ~NOABRUPT `WritableStreamCloseQueuedOrInFlight$A( %stream ) ~EQ ~F ］~AND［ %state ~EQ `writable^l ］： ◎ If ! WritableStreamCloseQueuedOrInFlight(stream) is false and state is "writable",

        1. %backpressure ~LET ~NOABRUPT `WritableStreamDefaultControllerGetBackpressure$A( %controller ) ◎ Let backpressure be ! WritableStreamDefaultControllerGetBackpressure(controller).
        2. ~NOABRUPT `WritableStreamUpdateBackpressure$A( %stream, %backpressure ) ◎ Perform ! WritableStreamUpdateBackpressure(stream, backpressure).
     6. ~NOABRUPT `WritableStreamDefaultControllerAdvanceQueueIfNeeded$A( %controller ) ◎ Perform ! WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller).

   • %sinkWritePromise の`却下-時$には、 所与の ( 事由 %reason ) に対し： ◎ Upon rejection of sinkWritePromise with reason,

     1. ~IF［ %stream.`state$wS ~EQ `writable^l ］ ⇒ ~NOABRUPT `WritableStreamDefaultControllerClearAlgorithms$A( %controller ) ◎ If stream.[[state]] is "writable", perform ! WritableStreamDefaultControllerClearAlgorithms(controller).
     2. ~NOABRUPT `WritableStreamFinishInFlightWriteWithError$A( %stream, %reason ) ◎ Perform ! WritableStreamFinishInFlightWriteWithError(stream, reason).

`WritableStreamDefaultControllerWrite(controller, chunk, chunkSize)@A は、 次の手続きを遂行する： ◎ WritableStreamDefaultControllerWrite(controller, chunk, chunkSize) performs the following steps:

1. %enqueueResult ~LET `EnqueueValueWithSize$A( %controller, %chunk, %chunkSize ) ◎ Let enqueueResult be EnqueueValueWithSize(controller, chunk, chunkSize).

2. ~IF［ %enqueueResult は`中途完了^である ］： ◎ If enqueueResult is an abrupt completion,

   1. ~NOABRUPT `WritableStreamDefaultControllerErrorIfNeeded$A( %controller, %enqueueResult.`Value^sl ) ◎ Perform ! WritableStreamDefaultControllerErrorIfNeeded(controller, enqueueResult.[[Value]]).
   2. ~RET ◎ Return.
3. %stream ~LET %controller.`stream$wsdC ◎ Let stream be controller.[[stream]].

4. ~IF［ ~NOABRUPT `WritableStreamCloseQueuedOrInFlight$A( %stream ) ~EQ ~F ］~AND［ %stream.`state$wS ~EQ `writable^l ］ ： ◎ If ! WritableStreamCloseQueuedOrInFlight(stream) is false and stream.[[state]] is "writable",

   1. %backpressure ~LET ~NOABRUPT `WritableStreamDefaultControllerGetBackpressure$A( %controller ) ◎ Let backpressure be ! WritableStreamDefaultControllerGetBackpressure(controller).
   2. ~NOABRUPT `WritableStreamUpdateBackpressure$A( %stream, %backpressure ) ◎ Perform ! WritableStreamUpdateBackpressure(stream, backpressure).
5. ~NOABRUPT `WritableStreamDefaultControllerAdvanceQueueIfNeeded$A( %controller ) ◎ Perform ! WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller).

`new TransformStream(transformer, writableStrategy, readableStrategy)@m 構築子~手続きは： ◎ The new TransformStream(transformer, writableStrategy, readableStrategy) constructor steps are:

1. ~IF［ %transformer ~EQ ε ］ ⇒ %transformer ~SET ~NULL ◎ If transformer is missing, set it to null.

2. %transformerDict ~LET `~IDL値に変換する$( %transformer, `Transformer$I ) ◎ Let transformerDict be transformer, converted to an IDL value of type Transformer.

   注記： %transformer 引数を `Transformer$I 型として直に宣言できないのは、 元の~objへの参照が失われるからである。 ~obj上の各種`~methodを呼出せる$よう，~objは維持する必要がある。 ◎ We cannot declare the transformer argument as having the Transformer type directly, because doing so would lose the reference to the original object. We need to retain the object so we can invoke the various methods on it.

3. ~IF［ %transformerDict[ "`readableType$tf" ] ~NEQ ε ］ ⇒ ~THROW `RangeError$E ◎ If transformerDict["readableType"] exists, throw a RangeError exception.
4. ~IF［ %transformerDict[ "`writableType$tf" ] ~NEQ ε ］ ⇒ ~THROW `RangeError$E ◎ If transformerDict["writableType"] exists, throw a RangeError exception.
5. %readableHighWaterMark ~LET ~ABRUPT `ExtractHighWaterMark$A( %readableStrategy, 0) ◎ Let readableHighWaterMark be ? ExtractHighWaterMark(readableStrategy, 0).
6. %readableSizeAlgorithm ~LET ~NOABRUPT `ExtractSizeAlgorithm$A( %readableStrategy ) ◎ Let readableSizeAlgorithm be ! ExtractSizeAlgorithm(readableStrategy).
7. %writableHighWaterMark ~LET ~ABRUPT `ExtractHighWaterMark$A( %writableStrategy, 1) ◎ Let writableHighWaterMark be ? ExtractHighWaterMark(writableStrategy, 1).
8. %writableSizeAlgorithm ~LET ~NOABRUPT `ExtractSizeAlgorithm$A( %writableStrategy ) ◎ Let writableSizeAlgorithm be ! ExtractSizeAlgorithm(writableStrategy).
9. %startPromise ~LET `新たな~promise$ ◎ Let startPromise be a new promise.
10. ~NOABRUPT `InitializeTransformStream$A( ↓ ) ⇒＃ コレ, %startPromise, %writableHighWaterMark, %writableSizeAlgorithm, %readableHighWaterMark, %readableSizeAlgorithm ◎ Perform ! InitializeTransformStream(this, startPromise, writableHighWaterMark, writableSizeAlgorithm, readableHighWaterMark, readableSizeAlgorithm).
11. ~ABRUPT `SetUpTransformStreamDefaultControllerFromTransformer$A( コレ, %transformer, %transformerDict ) ◎ Perform ? SetUpTransformStreamDefaultControllerFromTransformer(this, transformer, transformerDict).
12. %結果 ~LET `undefined^jv ◎ ↓
13. ~IF［ %transformerDict[ "`start$tf" ] ~NEQ ε ］ ⇒ %結果 ~SET `~callback関数を呼出す$( %transformerDict[ "`start$tf" ], « コレ.`controller$tS », ε, %transformer ) ◎ If transformerDict["start"] exists, then resolve startPromise with the result of invoking transformerDict["start"] with argument list « this.[[controller]] » and callback this value transformer.
14. `~promiseを解決する$( %startPromise, %結果 ) ◎ Otherwise, resolve startPromise with undefined.

`readable@ts 取得子~手続きは： ◎ The readable getter steps are:

1. ~RET コレ.`readable$tS ◎ Return this.[[readable]].

`writable@ts 取得子~手続きは： ◎ The writable getter steps are:

1. ~RET コレ.`writable$tS ◎ Return this.[[writable]].

`desiredSize@tsdc 取得子~手続きは： ◎ The desiredSize getter steps are:

1. %readableController ~LET コレ.`stream$tsdC.`readable$tS.`controller$rS ◎ Let readableController be this.[[stream]].[[readable]].[[controller]].
2. ~RET ~NOABRUPT `ReadableStreamDefaultControllerGetDesiredSize$A( %readableController ) ◎ Return ! ReadableStreamDefaultControllerGetDesiredSize(readableController).

`enqueue(chunk)@tsdc ~method手続きは： ◎ The enqueue(chunk) method steps are:

1. ~ABRUPT `TransformStreamDefaultControllerEnqueue$A( コレ, %chunk ) ◎ Perform ? TransformStreamDefaultControllerEnqueue(this, chunk).

`error(e)@tsdc ~method手続きは： ◎ The error(e) method steps are:

1. ~ABRUPT `TransformStreamDefaultControllerError$A( コレ, %e ) ◎ Perform ? TransformStreamDefaultControllerError(this, e).

`terminate()@tsdc ~method手続きは： ◎ The terminate() method steps are:

1. ~ABRUPT `TransformStreamDefaultControllerTerminate$A( コレ ) ◎ Perform ? TransformStreamDefaultControllerTerminate(this).

`InitializeTransformStream(stream, startPromise, writableHighWaterMark, writableSizeAlgorithm, readableHighWaterMark, readableSizeAlgorithm)@A は、 次の手続きを遂行する： ◎ InitializeTransformStream(stream, startPromise, writableHighWaterMark, writableSizeAlgorithm, readableHighWaterMark, readableSizeAlgorithm) performs the following steps:

1. %startAlgorithm ~LET 次を走らす~algo ⇒ ~RET %startPromise ◎ Let startAlgorithm be an algorithm that returns startPromise.
2. %writeAlgorithm ~LET 所与の ( %chunk ) に対し，次を走らす~algo ⇒ ~RET ~NOABRUPT `TransformStreamDefaultSinkWriteAlgorithm$A( %stream, %chunk ) ◎ Let writeAlgorithm be the following steps, taking a chunk argument: • Return ! TransformStreamDefaultSinkWriteAlgorithm(stream, chunk).
3. %abortAlgorithm ~LET 所与の ( %reason ) に対し，次を走らす~algo ⇒ ~RET ~NOABRUPT `TransformStreamDefaultSinkAbortAlgorithm$A( %stream, %reason ) ◎ Let abortAlgorithm be the following steps, taking a reason argument: • Return ! TransformStreamDefaultSinkAbortAlgorithm(stream, reason).
4. %closeAlgorithm ~LET 次を走らす~algo ⇒ ~RET ~NOABRUPT `TransformStreamDefaultSinkCloseAlgorithm$A( %stream ) ◎ Let closeAlgorithm be the following steps: • Return ! TransformStreamDefaultSinkCloseAlgorithm(stream).
5. %stream.`writable$tS ~SET ~NOABRUPT `CreateWritableStream$A( %startAlgorithm, %writeAlgorithm, %closeAlgorithm, %abortAlgorithm, %writableHighWaterMark, %writableSizeAlgorithm ) ◎ Set stream.[[writable]] to ! CreateWritableStream(startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, writableHighWaterMark, writableSizeAlgorithm).
6. %pullAlgorithm ~LET 次を走らす~algo ⇒ ~RET ~NOABRUPT `TransformStreamDefaultSourcePullAlgorithm$A( %stream ) ◎ Let pullAlgorithm be the following steps: • Return ! TransformStreamDefaultSourcePullAlgorithm(stream).
7. %cancelAlgorithm ~LET 所与の ( %reason ) に対し，次を走らす~algo ⇒ ~RET ~NOABRUPT `TransformStreamDefaultSourceCancelAlgorithm$A( %stream, %reason ) ◎ Let cancelAlgorithm be the following steps, taking a reason argument: • Return ! TransformStreamDefaultSourceCancelAlgorithm(stream, reason).
8. %stream.`readable$tS ~SET ~NOABRUPT `CreateReadableStream$A( %startAlgorithm, %pullAlgorithm, %cancelAlgorithm, %readableHighWaterMark, %readableSizeAlgorithm ) ◎ Set stream.[[readable]] to ! CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, readableHighWaterMark, readableSizeAlgorithm).

9. %stream の ⇒＃ .`backpressure$tS ~SET `undefined^jv, .`backpressureChangePromise$tS ~SET `undefined^jv ◎ Set stream.[[backpressure]] and stream.[[backpressureChangePromise]] to undefined.

   注記： `backpressure$tS ~slotは、 `TransformStreamSetBackpressure$A により初期化できるよう， `undefined^jv に設定される。 別法として，実装は、 `backpressure$tS 用に厳密な真偽-値を利用して，初期化される仕方を変更できる。 これは、 初期化が［ 当の形式変換器の `start()$tf ~methodが~callされる前 ］に正しく完了される限り，利用元~codeからは可視にならない。 ◎ The [[backpressure]] slot is set to undefined so that it can be initialized by TransformStreamSetBackpressure. Alternatively, implementations can use a strictly boolean value for [[backpressure]] and change the way it is initialized. This will not be visible to user code so long as the initialization is correctly completed before the transformer’s start() method is called.

10. ~NOABRUPT `TransformStreamSetBackpressure$A( %stream, ~T ) ◎ Perform ! TransformStreamSetBackpressure(stream, true).
11. %stream.`controller$tS ~SET `undefined^jv ◎ Set stream.[[controller]] to undefined.

`TransformStreamError(stream, e)@A は、 次の手続きを遂行する： ◎ TransformStreamError(stream, e) performs the following steps:

1. ~NOABRUPT `ReadableStreamDefaultControllerError$A( %stream.`readable$tS.`controller$rS, %e ) ◎ Perform ! ReadableStreamDefaultControllerError(stream.[[readable]].[[controller]], e).
2. ~NOABRUPT `TransformStreamErrorWritableAndUnblockWrite$A( %stream, %e ) ◎ Perform ! TransformStreamErrorWritableAndUnblockWrite(stream, e).

`TransformStreamErrorWritableAndUnblockWrite(stream, e)@A は、 次の手続きを遂行する： ◎ TransformStreamErrorWritableAndUnblockWrite(stream, e) performs the following steps:

1. ~NOABRUPT `TransformStreamDefaultControllerClearAlgorithms$A( %stream.`controller$tS) ◎ Perform ! TransformStreamDefaultControllerClearAlgorithms(stream.[[controller]]).
2. ~NOABRUPT `WritableStreamDefaultControllerErrorIfNeeded$A( %stream.`writable$tS.`controller$wS, %e ) ◎ Perform ! WritableStreamDefaultControllerErrorIfNeeded(stream.[[writable]].[[controller]], e).
3. ~NOABRUPT `TransformStreamUnblockWrite$A( %stream ) ◎ Perform ! TransformStreamUnblockWrite(stream).

`TransformStreamSetBackpressure(stream, backpressure)@A は、 次の手続きを遂行する： ◎ TransformStreamSetBackpressure(stream, backpressure) performs the following steps:

1. ~Assert： %stream.`backpressure$tS ~NEQ %backpressure ◎ Assert: stream.[[backpressure]] is not backpressure.
2. ~IF［ %stream.`backpressureChangePromise$tS ~NEQ `undefined^jv ］ ⇒ `~promiseを解決する$( %stream.`backpressureChangePromise$tS, `undefined^jv ) ◎ If stream.[[backpressureChangePromise]] is not undefined, resolve stream.[[backpressureChangePromise]] with undefined.
3. %stream.`backpressureChangePromise$tS ~SET `新たな~promise$ ◎ Set stream.[[backpressureChangePromise]] to a new promise.
4. %stream.`backpressure$tS ~SET %backpressure ◎ Set stream.[[backpressure]] to backpressure.

`TransformStreamUnblockWrite@A は、 次の手続きを遂行する： ◎ TransformStreamUnblockWrite(stream) performs the following steps:

1. ~IF［ %stream.`backpressure$tS ~EQ ~T ］ ⇒ ~NOABRUPT `TransformStreamSetBackpressure$A( %stream, ~F ) ◎ If stream.[[backpressure]] is true, perform ! TransformStreamSetBackpressure(stream, false).

注記： `TransformStreamDefaultSinkWriteAlgorithm$A 抽象-演算は、 `backpressureChangePromise$tS ~slotに格納された~promiseが解決されるまで待機することもある。 `TransformStreamSetBackpressure$A への~callは、 ~promiseが常に解決されることを確保する。 ◎ The TransformStreamDefaultSinkWriteAlgorithm abstract operation could be waiting for the promise stored in the [[backpressureChangePromise]] slot to resolve. The call to TransformStreamSetBackpressure ensures that the promise always resolves.

`SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm, cancelAlgorithm)@A は、 次の手続きを遂行する： ◎ SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm, cancelAlgorithm) performs the following steps:

1. ~Assert： %stream は `TransformStream$I を`実装する$ ◎ Assert: stream implements TransformStream.
2. ~Assert： %stream.`controller$tS ~EQ `undefined^jv ◎ Assert: stream.[[controller]] is undefined.
3. %controller.`stream$tsdC ~SET %stream ◎ Set controller.[[stream]] to stream.
4. %stream.`controller$tS ~SET %controller ◎ Set stream.[[controller]] to controller.
5. %controller.`transformAlgorithm$tsdC ~SET %transformAlgorithm ◎ Set controller.[[transformAlgorithm]] to transformAlgorithm.
6. %controller.`flushAlgorithm$tsdC ~SET %flushAlgorithm ◎ Set controller.[[flushAlgorithm]] to flushAlgorithm.
7. %controller.`cancelAlgorithm$tsdC ~SET %cancelAlgorithm ◎ Set controller.[[cancelAlgorithm]] to cancelAlgorithm.

`SetUpTransformStreamDefaultControllerFromTransformer(stream, transformer, transformerDict)@A は、 次の手続きを遂行する： ◎ SetUpTransformStreamDefaultControllerFromTransformer(stream, transformer, transformerDict) performs the following steps:

1. %controller ~LET `新たな~obj$( `TransformStreamDefaultController$I ) ◎ Let controller be a new TransformStreamDefaultController.

2. %transformAlgorithm ~LET 所与の ( %chunk ) に対し，次を走らす~algo： ◎ Let transformAlgorithm be the following steps, taking a chunk argument:

   1. %result ~LET `TransformStreamDefaultControllerEnqueue$A( %controller, %chunk ) ◎ Let result be TransformStreamDefaultControllerEnqueue(controller, chunk).
   2. ~IF［ %result は`中途完了^である ］ ⇒ ~RET `却下される~promise$( %result.`Value^sl ) ◎ If result is an abrupt completion, return a promise rejected with result.[[Value]].
   3. ~RET `解決される~promise$( `undefined^jv ) ◎ Otherwise, return a promise resolved with undefined.
3. %flushAlgorithm ~LET 次を走らす~algo ⇒ ~RET `解決される~promise$( `undefined^jv ) ◎ Let flushAlgorithm be an algorithm which returns a promise resolved with undefined.
4. %cancelAlgorithm ~LET 次を走らす~algo ⇒ ~RET `解決される~promise$( `undefined^jv ) ◎ Let cancelAlgorithm be an algorithm which returns a promise resolved with undefined.
5. ~IF［ %transformerDict[ "`transform$tf" ] ~NEQ ε ］ ⇒ %transformAlgorithm ~SET 所与の ( %chunk ) に対し，次を走らす~algo ⇒ ~RET `~callback関数を呼出す$( %transformerDict[ "`transform$tf" ], « %chunk, %controller », ε, %transformer ) ◎ If transformerDict["transform"] exists, set transformAlgorithm to an algorithm which takes an argument chunk and returns the result of invoking transformerDict["transform"] with argument list « chunk, controller » and callback this value transformer.
6. ~IF［ %transformerDict[ "`flush$tf" ] ~NEQ ε ］ ⇒ %flushAlgorithm ~SET 次を走らす~algo ⇒ ~RET `~callback関数を呼出す$( %transformerDict[ "`flush$tf" ], « %controller », ε, %transformer ) ◎ If transformerDict["flush"] exists, set flushAlgorithm to an algorithm which returns the result of invoking transformerDict["flush"] with argument list « controller » and callback this value transformer.
7. ~IF［ %transformerDict[ "`cancel$tf" ] ~NEQ ε ］ ⇒ %cancelAlgorithm ~SET 所与の ( %reason ) に対し，次を走らす~algo ⇒ ~RET `~callback関数を呼出す$( %transformerDict[ "`cancel$tf" ], « %reason », ε, %transformer ) ◎ If transformerDict["cancel"] exists, set cancelAlgorithm to an algorithm which takes an argument reason and returns the result of invoking transformerDict["cancel"] with argument list « reason » and callback this value transformer.
8. ~NOABRUPT `SetUpTransformStreamDefaultController$A( ↓ ) ⇒＃ %stream, %controller, %transformAlgorithm, %flushAlgorithm, %cancelAlgorithm ◎ Perform ! SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm, cancelAlgorithm).

`TransformStreamDefaultControllerClearAlgorithms(controller)@A は、［ ~streamが~closeされるか~errorして， 各種~algoが それ以上~実行されなくなったとき ］に~callされる。 これは、 各種~algoへの参照を除去することにより， `形式変換器$（ `TransformStream$I ~obj）自身が — まだ参照されていても — ~garbage収集されることを許可する。 ◎ TransformStreamDefaultControllerClearAlgorithms(controller) is called once the stream is closed or errored and the algorithms will not be executed any more. By removing the algorithm references it permits the transformer object to be garbage collected even if the TransformStream itself is still referenced.

注記： これは、 `弱い参照＠https://github.com/tc39/proposal-weakrefs/$を利用すると観測-可能になる。 詳細は `tc39/proposal-weakrefs#31＠https://github.com/tc39/proposal-weakrefs/issues/31$ を見よ。 ◎ This is observable using weak references. See tc39/proposal-weakrefs#31 for more detail.

それは、 次の手続きを遂行する： ◎ It performs the following steps:

1. %controller.`transformAlgorithm$tsdC ~SET `undefined^jv ◎ Set controller.[[transformAlgorithm]] to undefined.
2. %controller.`flushAlgorithm$tsdC ~SET `undefined^jv ◎ Set controller.[[flushAlgorithm]] to undefined.
3. %controller.`cancelAlgorithm$tsdC ~SET `undefined^jv ◎ Set controller.[[cancelAlgorithm]] to undefined.

`TransformStreamDefaultControllerEnqueue(controller, chunk)@A は、 次の手続きを遂行する： ◎ TransformStreamDefaultControllerEnqueue(controller, chunk) performs the following steps:

1. %stream ~LET %controller.`stream$tsdC ◎ Let stream be controller.[[stream]].
2. %readableController ~LET %stream.`readable$tS.`controller$rS ◎ Let readableController be stream.[[readable]].[[controller]].
3. ~IF［ ~NOABRUPT `ReadableStreamDefaultControllerCanCloseOrEnqueue$A( %readableController ) ~EQ ~F ］ ⇒ ~THROW `TypeError$jE ◎ If ! ReadableStreamDefaultControllerCanCloseOrEnqueue(readableController) is false, throw a TypeError exception.
4. %enqueueResult ~LET `ReadableStreamDefaultControllerEnqueue$A( %readableController, %chunk ) ◎ Let enqueueResult be ReadableStreamDefaultControllerEnqueue(readableController, chunk).

5. ~IF［ %enqueueResult は`中途完了^である ］： ◎ If enqueueResult is an abrupt completion,

   1. ~NOABRUPT `TransformStreamErrorWritableAndUnblockWrite$A( %stream, %enqueueResult.`Value^sl ) ◎ Perform ! TransformStreamErrorWritableAndUnblockWrite(stream, enqueueResult.[[Value]]).
   2. ~THROW %stream.`readable$tS.`storedError$rS ◎ Throw stream.[[readable]].[[storedError]].
6. %backpressure ~LET ~NOABRUPT `ReadableStreamDefaultControllerHasBackpressure$A( %readableController ) ◎ Let backpressure be ! ReadableStreamDefaultControllerHasBackpressure(readableController).

7. ~IF［ %backpressure ~NEQ %stream.`backpressure$tS ］： ◎ If backpressure is not stream.[[backpressure]],

   1. ~Assert： %backpressure ~EQ ~T ◎ Assert: backpressure is true.
   2. ~NOABRUPT `TransformStreamSetBackpressure$A( %stream, ~T ) ◎ Perform ! TransformStreamSetBackpressure(stream, true).

`TransformStreamDefaultControllerError(controller, e)@A は、 次の手続きを遂行する： ◎ TransformStreamDefaultControllerError(controller, e) performs the following steps:

1. ~NOABRUPT `TransformStreamError$A( %controller.`stream$tsdC, %e ) ◎ Perform ! TransformStreamError(controller.[[stream]], e).

`TransformStreamDefaultControllerPerformTransform(controller, chunk)@A は、 次の手続きを遂行する： ◎ TransformStreamDefaultControllerPerformTransform(controller, chunk) performs the following steps:

1. %transformPromise ~LET %controller.`transformAlgorithm$tsdC( %chunk ) ◎ Let transformPromise be the result of performing controller.[[transformAlgorithm]], passing chunk.

2. ~RET `~promiseに反応する$( %transformPromise ) — 次を与える下で： ◎ Return the result of reacting to transformPromise with＼

   • `却下~手続き^i は、 所与の ( %r ) に対し： ◎ the following rejection steps given the argument r:

     1. ~NOABRUPT `TransformStreamError$A( %controller.`stream$tsdC, %r ) ◎ Perform ! TransformStreamError(controller.[[stream]], r).
     2. ~THROW %r ◎ Throw r.

`TransformStreamDefaultControllerTerminate(controller)@A は、 次の手続きを遂行する： ◎ TransformStreamDefaultControllerTerminate(controller) performs the following steps:

1. %stream ~LET %controller.`stream$tsdC ◎ Let stream be controller.[[stream]].
2. %readableController ~LET %stream.`readable$tS.`controller$rS ◎ Let readableController be stream.[[readable]].[[controller]].
3. ~NOABRUPT `ReadableStreamDefaultControllerClose$A( %readableController ) ◎ Perform ! ReadableStreamDefaultControllerClose(readableController).
4. %error ~LET ~streamは終了されたことを指示する， `TypeError$jE 例外 ◎ Let error be a TypeError exception indicating that the stream has been terminated.
5. ~NOABRUPT `TransformStreamErrorWritableAndUnblockWrite$A( %stream, %error ) ◎ Perform ! TransformStreamErrorWritableAndUnblockWrite(stream, error).

`TransformStreamDefaultSinkWriteAlgorithm(stream, chunk)@A は、 次の手続きを遂行する： ◎ TransformStreamDefaultSinkWriteAlgorithm(stream, chunk) performs the following steps:

1. ~Assert： %stream.`writable$tS.`state$wS ~EQ `writable^l ◎ Assert: stream.[[writable]].[[state]] is "writable".
2. %controller ~LET %stream.`controller$tS ◎ Let controller be stream.[[controller]].

3. ~IF［ %stream.`backpressure$tS ~EQ ~T ］： ◎ If stream.[[backpressure]] is true,

   1. %backpressureChangePromise ~LET %stream.`backpressureChangePromise$tS ◎ Let backpressureChangePromise be stream.[[backpressureChangePromise]].
   2. ~Assert： %backpressureChangePromise ~NEQ `undefined^jv ◎ Assert: backpressureChangePromise is not undefined.

   3. ~RET `~promiseに反応する$( %backpressureChangePromise ) — `充足~手続き^i として次を与える下で： ◎ Return the result of reacting to backpressureChangePromise with＼

      • `充足~手続き^i は： ◎ the following fulfillment steps:

        1. %writable ~LET %stream.`writable$tS ◎ Let writable be stream.[[writable]].
        2. %state ~LET %writable.`state$wS ◎ Let state be writable.[[state]].
        3. ~IF［ %state ~EQ `erroring^l ］ ⇒ ~THROW %writable.`storedError$wS ◎ If state is "erroring", throw writable.[[storedError]].
        4. ~Assert： %state ~EQ `writable^l ◎ Assert: state is "writable".
        5. ~RET ~NOABRUPT `TransformStreamDefaultControllerPerformTransform$A( %controller, %chunk ) ◎ Return ! TransformStreamDefaultControllerPerformTransform(controller, chunk).
4. ~RET ~NOABRUPT `TransformStreamDefaultControllerPerformTransform$A( %controller, %chunk ) ◎ Return ! TransformStreamDefaultControllerPerformTransform(controller, chunk).

`TransformStreamDefaultSinkAbortAlgorithm(stream, reason)@A は、 次の手続きを遂行する： ◎ TransformStreamDefaultSinkAbortAlgorithm(stream, reason) performs the following steps:

1. %controller ~LET %stream.`controller$wS ◎ Let controller be stream.[[controller]].
2. ~IF［ %controller.`finishPromise$tsdC ~NEQ `undefined^jv ］ ⇒ ~RET %controller.`finishPromise$tsdC ◎ If controller.[[finishPromise]] is not undefined, return controller.[[finishPromise]].
3. %readable ~LET %stream.`readable$tS ◎ Let readable be stream.[[readable]].
4. %controller.`finishPromise$tsdC ~LET `新たな~promise$ ◎ Let controller.[[finishPromise]] be a new promise.
5. %cancelPromise ~LET %controller.`cancelAlgorithm$tsdC( %reason ) ◎ Let cancelPromise be the result of performing controller.[[cancelAlgorithm]], passing reason.
6. ~NOABRUPT `TransformStreamDefaultControllerClearAlgorithms$A( %controller ) ◎ Perform ! TransformStreamDefaultControllerClearAlgorithms(controller).

7. `~promiseに反応する$( %cancelPromise ) — 次を与える下で： ◎ React to cancelPromise:

   • `充足~手続き^i は： ◎ If cancelPromise was fulfilled, then:

     1. ~IF［ %readable.`state$rS ~EQ `errored^l ］ ⇒ `~promiseを却下する$( %controller.`finishPromise$tsdC, %readable.`storedError$rS ) ◎ If readable.[[state]] is "errored", reject controller.[[finishPromise]] with readable.[[storedError]].

     2. ~ELSE： ◎ Otherwise:

        1. ~NOABRUPT `ReadableStreamDefaultControllerError$A( %readable.`controller$rS, %reason ) ◎ Perform ! ReadableStreamDefaultControllerError(readable.[[controller]], reason).
        2. `~promiseを解決する$( %controller.`finishPromise$tsdC, `undefined^jv ) ◎ Resolve controller.[[finishPromise]] with undefined.

   • `却下~手続き^i は、 所与の ( 事由 %r ) に対し： ◎ If cancelPromise was rejected with reason r, then:

     1. ~NOABRUPT `ReadableStreamDefaultControllerError$A( %readable.`controller$rS, %r ) ◎ Perform ! ReadableStreamDefaultControllerError(readable.[[controller]], r).
     2. `~promiseを却下する$( %controller.`finishPromise$tsdC, %r ) ◎ Reject controller.[[finishPromise]] with r.
8. ~RET %controller.`finishPromise$tsdC ◎ Return controller.[[finishPromise]].

`TransformStreamDefaultSinkCloseAlgorithm(stream)@A は、 次の手続きを遂行する： ◎ TransformStreamDefaultSinkCloseAlgorithm(stream) performs the following steps:

1. %controller ~LET %stream.`controller$wS ◎ Let controller be stream.[[controller]].
2. ~IF［ %controller.`finishPromise$tsdC ~NEQ `undefined^jv ］ ⇒ ~RET %controller.`finishPromise$tsdC ◎ If controller.[[finishPromise]] is not undefined, return controller.[[finishPromise]].
3. %readable ~LET %stream.`readable$tS ◎ Let readable be stream.[[readable]].
4. %controller.`finishPromise$tsdC ~LET `新たな~promise$ ◎ Let controller.[[finishPromise]] be a new promise.
5. %flushPromise ~LET %controller.`flushAlgorithm$tsdC() ◎ Let flushPromise be the result of performing controller.[[flushAlgorithm]].
6. ~NOABRUPT `TransformStreamDefaultControllerClearAlgorithms$A( %controller ) ◎ Perform ! TransformStreamDefaultControllerClearAlgorithms(controller).

7. `~promiseに反応する$( %flushPromise ) — 次を与える下で： ◎ React to flushPromise:

   • `充足~手続き^i は： ◎ If flushPromise was fulfilled, then:

     1. ~IF［ %readable.`state$rS ~EQ `errored^l ］ ⇒ `~promiseを却下する$( %controller.`finishPromise$tsdC, %readable.`storedError$rS ) ◎ If readable.[[state]] is "errored", reject controller.[[finishPromise]] with readable.[[storedError]].

     2. ~ELSE： ◎ Otherwise:

        1. ~NOABRUPT `ReadableStreamDefaultControllerClose$A( %readable.`controller$rS ) ◎ Perform ! ReadableStreamDefaultControllerClose(readable.[[controller]]).
        2. `~promiseを解決する$( %controller.`finishPromise$tsdC, `undefined^jv ) ◎ Resolve controller.[[finishPromise]] with undefined.

   • `却下~手続き^i は、 所与の ( 事由 %r ) に対し： ◎ If flushPromise was rejected with reason r, then:

     1. ~NOABRUPT `ReadableStreamDefaultControllerError$A( %readable.`controller$rS, %r ) ◎ Perform ! ReadableStreamDefaultControllerError(readable.[[controller]], r).
     2. `~promiseを却下する$( %controller.`finishPromise$tsdC, %r ) ◎ Reject controller.[[finishPromise]] with r.
8. ~RET %controller.`finishPromise$tsdC ◎ Return controller.[[finishPromise]].

`TransformStreamDefaultSourceCancelAlgorithm(stream, reason)@A は、 次の手続きを遂行する： ◎ TransformStreamDefaultSourceCancelAlgorithm(stream, reason) performs the following steps:

1. %controller ~LET %stream.`controller$wS ◎ Let controller be stream.[[controller]].
2. ~IF［ %controller.`finishPromise$tsdC ~NEQ `undefined^jv ］ ⇒ ~RET %controller.`finishPromise$tsdC ◎ If controller.[[finishPromise]] is not undefined, return controller.[[finishPromise]].
3. %writable ~LET %stream.`writable$tS ◎ Let writable be stream.[[writable]].
4. %controller.`finishPromise$tsdC ~LET `新たな~promise$ ◎ Let controller.[[finishPromise]] be a new promise.
5. %cancelPromise ~LET %controller.`cancelAlgorithm$tsdC( %reason ) ◎ Let cancelPromise be the result of performing controller.[[cancelAlgorithm]], passing reason.
6. ~NOABRUPT `TransformStreamDefaultControllerClearAlgorithms$A( %controller ) ◎ Perform ! TransformStreamDefaultControllerClearAlgorithms(controller).

7. `~promiseに反応する$( %cancelPromise ) — 次を与える下で： ◎ React to cancelPromise:

   • `充足~手続き^i は： ◎ If cancelPromise was fulfilled, then:

     1. ~IF［ %writable.`state$wS ~EQ `errored^l ］ ⇒ `~promiseを却下する$( %controller.`finishPromise$tsdC, %writable.`storedError$wS ) ◎ If writable.[[state]] is "errored", reject controller.[[finishPromise]] with writable.[[storedError]].

     2. ~ELSE： ◎ Otherwise:

        1. ~NOABRUPT `WritableStreamDefaultControllerErrorIfNeeded$A( %writable.`controller$wS, %reason ) ◎ Perform ! WritableStreamDefaultControllerErrorIfNeeded(writable.[[controller]], reason).
        2. ~NOABRUPT `TransformStreamUnblockWrite$A( %stream ) ◎ Perform ! TransformStreamUnblockWrite(stream).
        3. `~promiseを解決する$( %controller.`finishPromise$tsdC, `undefined^jv ) ◎ Resolve controller.[[finishPromise]] with undefined.

   • `却下~手続き^i は、 所与の ( 事由 %r ) に対し： ◎ If cancelPromise was rejected with reason r, then:

     1. ~NOABRUPT `WritableStreamDefaultControllerErrorIfNeeded$A( %writable.`controller$wS, %r ) ◎ Perform ! WritableStreamDefaultControllerErrorIfNeeded(writable.[[controller]], r).
     2. ~NOABRUPT `TransformStreamUnblockWrite$A( %stream ) ◎ Perform ! TransformStreamUnblockWrite(stream).
     3. `~promiseを却下する$( %controller.`finishPromise$tsdC, %r ) ◎ Reject controller.[[finishPromise]] with r.
8. ~RET %controller.`finishPromise$tsdC ◎ Return controller.[[finishPromise]].

`TransformStreamDefaultSourcePullAlgorithm(stream)@A は、 次の手続きを遂行する： ◎ TransformStreamDefaultSourcePullAlgorithm(stream) performs the following steps:

1. ~Assert： %stream.`backpressure$tS ~EQ ~T ◎ Assert: stream.[[backpressure]] is true.
2. ~Assert： %stream.`backpressureChangePromise$tS ~NEQ `undefined^jv ◎ Assert: stream.[[backpressureChangePromise]] is not undefined.
3. ~NOABRUPT `TransformStreamSetBackpressure$A( %stream, ~F ) ◎ Perform ! TransformStreamSetBackpressure(stream, false).
4. ~RET %stream.`backpressureChangePromise$tS ◎ Return stream.[[backpressureChangePromise]].

加えて，どの`大域~obj$ %大域~obj にも `~byte長さ~queuing策~size関数@ が結付けられる。 その値は `Function$I であり、 次に従って初期化するモノトスル： ◎ Additionally, every global object globalObject has an associated byte length queuing strategy size function, which is a Function whose value must be initialized as follows:

1. %手続き ~LET 所与の ( %chunk ) に対し，次を走らす~algo ⇒ ~RET ~ABRUPT `GetV$Ax( %chunk, `byteLength^l ) ◎ Let steps be the following steps, given chunk: • Return ? GetV(chunk, "byteLength").
2. %F ~LET ~NOABRUPT `CreateBuiltinFunction$Ax( %手続き, 1, `size^l, « », %大域~obj に`関連な~realm$ ) ◎ Let F be ! CreateBuiltinFunction(steps, 1, "size", « », globalObject’s relevant Realm).
3. %大域~obj の`~byte長さ~queuing策~size関数$ ~SET %F への参照を表現する `Function$I — その`~callback文脈$は、 %大域~obj に`関連な設定群~obj$になるとする ◎ Set globalObject’s byte length queuing strategy size function to a Function that represents a reference to F, with callback context equal to globalObject’s relevant settings object.

注記： この設計は、 いくぶん歴史的である。 その動機は、 `size$blqs は関数であって~methodではない — すなわち，その `this^jv 値を検査しない — ことを確保するよう欲されることにある。 更なる背景0は、 `課題 #1005＠https://github.com/whatwg/streams/issues/1005$, `whatwg/webidl 課題 #819＠https://github.com/whatwg/webidl/issues/819$ を見よ。 ◎ This design is somewhat historical. It is motivated by the desire to ensure that size is a function, not a method, i.e. it does not check its this value. See whatwg/streams#1005 and heycam/webidl#819 for more background.

`new ByteLengthQueuingStrategy(init)@m 構築子~手続きは： ◎ The new ByteLengthQueuingStrategy(init) constructor steps are:

1. コレ.`highWaterMark$blQS ~SET %init[ "`highWaterMark$qsi" ] ◎ Set this.[[highWaterMark]] to init["highWaterMark"].

`highWaterMark@blqs 取得子~手続きは： ◎ The highWaterMark getter steps are:

1. ~RET コレ.`highWaterMark$blQS ◎ Return this.[[highWaterMark]].

`size@blqs 取得子~手続きは： ◎ The size getter steps are:

1. ~RET コレに`関連な大域~obj$の`~byte長さ~queuing策~size関数$ 。 ◎ Return this’s relevant global object’s byte length queuing strategy size function.

加えて，どの`大域~obj$ %大域~obj にも `~count~queuing策~size関数@ が結付けられる。 その値は `Function$I であり、 次に従って初期化するモノトスル： ◎ Additionally, every global object globalObject has an associated count queuing strategy size function, which is a Function whose value must be initialized as follows:

1. %手続き ~LET 次を走らす~algo ⇒ ~RET 1 ◎ Let steps be the following steps: • Return 1.
2. %F ~LET ~NOABRUPT `CreateBuiltinFunction$Ax( %手続き, 0, `size^l, « », %大域~obj に`関連な~realm$ ) ◎ Let F be ! CreateBuiltinFunction(steps, 0, "size", « », globalObject’s relevant Realm).
3. %大域~obj の`~count~queuing策~size関数$ ~SET %F への参照を表現する `Function$I — その`~callback文脈$は、 %大域~obj に`関連な設定群~obj$になるとする ◎ Set globalObject’s count queuing strategy size function to a Function that represents a reference to F, with callback context equal to globalObject’s relevant settings object.

注記： この設計は、 いくぶん歴史的である。 その動機は、 `size$cqs は関数であって~methodではない — すなわち，その `this^jv 値を検査しない — ことを確保するよう欲されることにある。 更なる背景0は、 `課題 #1005＠https://github.com/whatwg/streams/issues/1005$, `whatwg/webidl 課題 #819＠https://github.com/whatwg/webidl/issues/819$ を見よ。 ◎ This design is somewhat historical. It is motivated by the desire to ensure that size is a function, not a method, i.e. it does not check its this value. See whatwg/streams#1005 and heycam/webidl#819 for more background.

`new CountQueuingStrategy(init)@m 構築子~手続きは： ◎ The new CountQueuingStrategy(init) constructor steps are:

1. コレ.`highWaterMark$cQS ~SET %init[ "`highWaterMark$qsi" ] ◎ Set this.[[highWaterMark]] to init["highWaterMark"].

`highWaterMark@cqs 取得子~手続きは： ◎ The highWaterMark getter steps are:

1. ~RET コレ.`highWaterMark$cQS ◎ Return this.[[highWaterMark]].

`size@cqs 取得子~手続きは： ◎ The size getter steps are:

1. ~RET コレに`関連な大域~obj$の`~count~queuing策~size関数$ ◎ Return this’s relevant global object’s count queuing strategy size function.

1. ~Assert： %~stream は`~Web~IDLを介して新たに作成した$ものである。 ◎ ↑
2. %開始~algo ~LET 次を走らす~algo ⇒ ~RET `undefined^jv ◎ Let startAlgorithm be an algorithm that returns undefined.

3. %~pull~algo包装体 ~LET 次を走らす~algo： ◎ Let pullAlgorithmWrapper be an algorithm that runs these steps:

   1. %結果 ~LET ~NULL ◎ ↓
   2. ~IF［ %~pull~algo ~NEQ ε ］ ⇒ %結果 ~SET %~pull~algo() ⇒ 例外 %e が投出されたときは ⇒ ~RET `却下される~promise$( %e ) ◎ Let result be the result of running pullAlgorithm, if pullAlgorithm was given, or null otherwise. If this throws an exception e, return a promise rejected with e.
   3. ~RET %結果 に応じて ⇒＃ `Promise$I であるならば %結果 ／ ~ELSE_ `解決される~promise$( `undefined^jv ) ◎ If result is a Promise, then return result. ◎ Return a promise resolved with undefined.

4. %取消~algo包装体 ~LET 次を走らす~algo： ◎ Let cancelAlgorithmWrapper be an algorithm that runs these steps:

   1. %結果 ~LET ~NULL ◎ ↓
   2. ~IF［ %取消~algo ~NEQ ε ］ ⇒ %結果 ~SET %取消~algo() ⇒ 例外 %e が投出されたときは ⇒ ~RET `却下される~promise$( %e ) ◎ Let result be the result of running cancelAlgorithm, if cancelAlgorithm was given, or null otherwise. If this throws an exception e, return a promise rejected with e.
   3. ~RET %結果 に応じて ⇒＃ `Promise$I であるならば %結果 ／ ~ELSE_ `解決される~promise$( `undefined^jv ) ◎ If result is a Promise, then return result. ◎ Return a promise resolved with undefined.
5. ~IF［ %~size~algo ~EQ ε ］ ⇒ %~size~algo ~SET 次を走らす~algo ⇒ ~RET 1 ◎ If sizeAlgorithm was not given, then set it to an algorithm that returns 1.
6. ~NOABRUPT `InitializeReadableStream$A( %~stream ) ◎ Perform ! InitializeReadableStream(stream).
7. %制御器 ~LET `新たな~obj$( `ReadableStreamDefaultController$I ) ◎ Let controller be a new ReadableStreamDefaultController.
8. ~NOABRUPT `SetUpReadableStreamDefaultController$A( ↓ ) ⇒＃ %~stream, %制御器, %開始~algo, %~pull~algo包装体, %取消~algo包装体, %限界水位, %~size~algo ◎ Perform ! SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithmWrapper, cancelAlgorithmWrapper, highWaterMark, sizeAlgorithm).

1. ~Assert： %~stream は`~Web~IDLを介して新たに作成した$ものである。 ◎ ↑
2. %開始~algo ~LET 次を走らす~algo ⇒ ~RET `undefined^jv ◎ Let startAlgorithm be an algorithm that returns undefined.

3. %~pull~algo包装体 ~LET 次を走らす~algo： ◎ Let pullAlgorithmWrapper be an algorithm that runs these steps:

   1. %結果 ~LET ~NULL ◎ ↓
   2. ~IF［ %~pull~algo ~NEQ ε ］ ⇒ %結果 ~SET %~pull~algo() ⇒ 例外 %e が投出されたときは ⇒ ~RET `却下される~promise$( %e ) ◎ Let result be the result of running pullAlgorithm, if pullAlgorithm was given, or null otherwise. If this throws an exception e, return a promise rejected with e.
   3. ~RET %結果 に応じて ⇒＃ `Promise$I であるならば %結果 ／ ~ELSE_ `解決される~promise$( `undefined^jv ) ◎ If result is a Promise, then return result. ◎ Return a promise resolved with undefined.

4. %取消~algo包装体 ~LET 所与の ( %事由 ) に対し， 次を走らす~algo： ◎ Let cancelAlgorithmWrapper be an algorithm that runs these steps given reason:

   1. %結果 ~LET ~NULL ◎ ↓
   2. ~IF［ %取消~algo ~NEQ ε ］ ⇒ %結果 ~SET %取消~algo( %事由 ) ⇒ 例外 %e が投出されたときは ⇒ ~RET `却下される~promise$( %e ) ◎ Let result be the result of running cancelAlgorithm given reason, if cancelAlgorithm was given, or null otherwise. If this throws an exception e, return a promise rejected with e.
   3. ~RET %結果 に応じて ⇒＃ `Promise$I であるならば %結果 ／ ~ELSE_ `解決される~promise$( `undefined^jv ) ◎ If result is a Promise, then return result. ◎ Return a promise resolved with undefined.
5. ~NOABRUPT `InitializeReadableStream$A( %~stream ) ◎ Perform ! InitializeReadableStream(stream).
6. %制御器 ~LET `新たな~obj$( `ReadableByteStreamController$I ) ◎ Let controller be a new ReadableByteStreamController.
7. ~NOABRUPT `SetUpReadableByteStreamController$A( ↓ ) ⇒＃ %~stream, %制御器, %開始~algo, %~pull~algo包装体, %取消~algo包装体, %限界水位, `undefined^jv ◎ Perform ! SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithmWrapper, cancelAlgorithmWrapper, highWaterMark, undefined).

`ReadableStream$I %~stream の `限界水位までの~queueの残り~size@RS （ `desired size to fill up to the high water mark^en ） を得る ~algoは： ◎ A ReadableStream stream’s desired size to fill up to the high water mark is the result of running the following steps:

1. ~IF［ %~stream は`読取n可能$RSでない ］ ⇒ ~RET 0 ◎ If stream is not readable, then return 0.
2. ~IF［ %~stream.`controller$rS は `ReadableByteStreamController$I を`実装する$ ］ ⇒ ~RET ~NOABRUPT `ReadableByteStreamControllerGetDesiredSize$A( %~stream.`controller$rS ) ◎ If stream.[[controller]] implements ReadableByteStreamController, then return ! ReadableByteStreamControllerGetDesiredSize(stream.[[controller]]).
3. ~RET ~NOABRUPT `ReadableStreamDefaultControllerGetDesiredSize$A( %~stream.`controller$rS ) ◎ Return ! ReadableStreamDefaultControllerGetDesiredSize(stream.[[controller]]).

`ReadableStream$I %~stream を `~closeする@RS ~algoは： ◎ To close a ReadableStream stream:

1. ~IF［ %~stream.`controller$rS は `ReadableByteStreamController$I を`実装する$ ］： ◎ If stream.[[controller]] implements ReadableByteStreamController,

   1. ~NOABRUPT `ReadableByteStreamControllerClose$A( %~stream.`controller$rS ) ◎ Perform ! ReadableByteStreamControllerClose(stream.[[controller]]).
   2. ~IF［ %~stream.`controller$rS.`pendingPullIntos$rbsC は`空$でない ］ ⇒ ~NOABRUPT `ReadableByteStreamControllerRespond$A( %~stream.`controller$rS, 0 ) ◎ If stream.[[controller]].[[pendingPullIntos]] is not empty, perform ! ReadableByteStreamControllerRespond(stream.[[controller]], 0).
2. ~ELSE ⇒ ~NOABRUPT `ReadableStreamDefaultControllerClose$A( %~stream.`controller$rS ) ◎ Otherwise, perform ! ReadableStreamDefaultControllerClose(stream.[[controller]]).

`ReadableStream$I %~stream を `~errorにする@RS ~algoは、 所与の ( ~JS値 %e ) に対し： ◎ To error a ReadableStream stream given a JavaScript value e:

1. ~IF［ %~stream.`controller$rS は `ReadableByteStreamController$I を`実装する$ ］ ⇒ ~NOABRUPT `ReadableByteStreamControllerError$A( %~stream.`controller$rS, %e ) ◎ If stream.[[controller]] implements ReadableByteStreamController, then perform ! ReadableByteStreamControllerError(stream.[[controller]], e).
2. ~ELSE ⇒ ~NOABRUPT `ReadableStreamDefaultControllerError$A( %~stream.`controller$rS, %e ) ◎ Otherwise, perform ! ReadableStreamDefaultControllerError(stream.[[controller]], e).

`ReadableStream$I %~stream に `~chunkを~enqueueする@RS ~algoは、 所与の ( ~JS値 %~chunk ) に対し： ◎ To enqueue the JavaScript value chunk into a ReadableStream stream:

1. ~IF［ %~stream.`controller$rS は `ReadableStreamDefaultController$I を`実装する$ ］： ◎ If stream.[[controller]] implements ReadableStreamDefaultController,

   1. ~NOABRUPT `ReadableStreamDefaultControllerEnqueue$A( %~stream.`controller$rS, %~chunk ) ◎ Perform ! ReadableStreamDefaultControllerEnqueue(stream.[[controller]], chunk).

2. ~ELSE： ◎ Otherwise,

   1. ~Assert： %~stream.`controller$rS は `ReadableByteStreamController$I を`実装する$ ◎ Assert: stream.[[controller]] implements ReadableByteStreamController.
   2. ~Assert： %~chunk は `ArrayBufferView$I である ◎ Assert: chunk is an ArrayBufferView.
   3. %~BYOB~view ~LET %~stream 用の`現在の~BYOB要請~view$RS ◎ Let byobView be the current BYOB request view for stream.

   4. ~IF［ %~BYOB~view ~NEQ ~NULL ］~AND［ %~chunk.`ViewedArrayBuffer^sl ~EQ %~BYOB~view.`ViewedArrayBuffer^sl ］： ◎ If byobView is non-null, and chunk.[[ViewedArrayBuffer]] is byobView.[[ViewedArrayBuffer]], then:

      1. ~Assert： %~chunk.`ByteOffset^sl ~EQ %~BYOB~view.`ByteOffset^sl ◎ Assert: chunk.[[ByteOffset]] is byobView.[[ByteOffset]].

      2. ~Assert： %~chunk.`ByteLength^sl ~LTE %~BYOB~view.`ByteLength^sl ◎ Assert: chunk.[[ByteLength]] ≤ byobView.[[ByteLength]].

         注記： これらの ~Assert は、 次を確保する ⇒ ~call元は、［ `現在の~BYOB要請~view$RS内の要請された範囲 ］の外側には書込まない ◎ These asserts ensure that the caller does not write outside the requested range in the current BYOB request view.

      3. ~ABRUPT `ReadableByteStreamControllerRespond$A( %~stream.`controller$rS, %~chunk.`ByteLength^sl ) ◎ Perform ? ReadableByteStreamControllerRespond(stream.[[controller]], chunk.[[ByteLength]]).
   5. ~ELSE ⇒ ~ABRUPT `ReadableByteStreamControllerEnqueue$A( %~stream.`controller$rS, %~chunk ) ◎ Otherwise, perform ? ReadableByteStreamControllerEnqueue(stream.[[controller]], chunk).

`ReadableStream$I %~stream 用の `現在の~BYOB要請~view@RS は、［ `ArrayBufferView$I ／ ~NULL ］であり，次の手続きにより決定される： ◎ The current BYOB request view for a ReadableStream stream is either an ArrayBufferView or null, determined by the following steps:

1. ~Assert： %~stream.`controller$rS は `ReadableByteStreamController$I を`実装する$ ◎ Assert: stream.[[controller]] implements ReadableByteStreamController.
2. %~BYOB要請 ~LET ~NOABRUPT `ReadableByteStreamControllerGetBYOBRequest$A( %~stream.`controller$rS ) ◎ Let byobRequest be ! ReadableByteStreamControllerGetBYOBRequest(stream.[[controller]]).
3. ~RET %~BYOB要請 に応じて ⇒＃ ~NULL ならば ~NULL ／ ~ELSE_ %~BYOB要請.`view$bbrQ ◎ If byobRequest is null, then return null. ◎ Return byobRequest.[[view]].

`ReadableStream$I %~stream の中へ `~byte列から~pullする@RS ~algoは、 所与の ( `~byte列$ %~byte列 ) に対し： ◎ To pull from bytes with a byte sequence bytes into a ReadableStream stream:

【 この~algoは、 入力 %~byte列 を改変する。 】

1. ~Assert： %~stream.`controller$rS は `ReadableByteStreamController$I を`実装する$。 ◎ Assert: stream.[[controller]] implements ReadableByteStreamController.
2. %可用な~size ~LET %~byte列 の`長さ$byte ◎ Let available be bytes’s length.
3. %現在の要請~view ~LET %~stream の`現在の~BYOB要請~view$RS ◎ ↓
4. %欲される~size ~LET %現在の要請~view に応じて ⇒＃ ~NULL ならば %可用な~size ／ ~ELSE_ %現在の要請~view の`~byte長さ$BS ◎ Let desiredSize be available. ◎ If stream’s current BYOB request view is non-null, then set desiredSize to stream’s current BYOB request view’s byte length.
5. %~pullする~size ~LET `min^op( %可用な~size, %欲される~size ) ◎ Let pullSize be the smaller value of available and desiredSize.
6. %~pullした~byte列 ~LET %~byte列 を成す最初の %~pullする~size 個の~byte ◎ Let pulled be the first pullSize bytes of bytes.
7. %~byte列 から最初の %~pullする~size 個の~byteを除去する ◎ Remove the first pullSize bytes from bytes.

8. ~IF［ %現在の要請~view ~NEQ ~NULL ］： ◎ If stream’s current BYOB request view is non-null, then:

   1. `配列~buffer~viewの中へ~byte列を書込む$( %現在の要請~view, %~pullした~byte列 ) ◎ Write pulled into stream’s current BYOB request view.
   2. ~ABRUPT `ReadableByteStreamControllerRespond$A( %~stream.`controller$rS, %~pullする~size ) ◎ Perform ? ReadableByteStreamControllerRespond(stream.[[controller]], pullSize).

9. ~ELSE： ◎ Otherwise,

   1. %~view ~SET `~buffer~sourceを作成する$( `Uint8Array$I, %~pullした~byte列, %~stream に`関連な~realm$ ) ◎ Set view to the result of creating a Uint8Array from pulled in stream’s relevant Realm.
   2. ~ABRUPT `ReadableByteStreamControllerEnqueue$A( %~stream.`controller$rS, %~view ) ◎ Perform ? ReadableByteStreamControllerEnqueue(stream.[[controller]], view).

`ReadableStream$I %~stream 用の `読取器を取得する@RS ~algoは ⇒ ~RET ~ABRUPT `AcquireReadableStreamDefaultReader$A( %~stream ) ◎ To get a reader for a ReadableStream stream, return ? AcquireReadableStreamDefaultReader(stream).＼

結果は `ReadableStreamDefaultReader$I になる。 ◎ The result will be a ReadableStreamDefaultReader.

注記： これは、 %~stream がすでに`~lockされて$RSいるときは， 例外を投出することになる。 ◎ This will throw an exception if stream is already locked.

`ReadableStreamDefaultReader$I %読取器 から `すべての~byteを読取る@RSR ~algoは、 所与の ⇒＃ `~byte列$を受容する~algo %成功~手続き, ~JS値を受容する~algo %失敗~手続き ◎終 に対し ⇒ `読取n~loop$( %読取器, 新たな`~byte列$, %成功~手続き, %失敗~手続き ) ◎ To read all bytes from a ReadableStreamDefaultReader reader, given successSteps, which is an algorithm accepting a byte sequence, and failureSteps, which is an algorithm accepting a JavaScript value: read-loop given reader, a new byte sequence, successSteps, and failureSteps.

注記： %読取器 は，それに対応している `ReadableStream$I に対し排他的な~accessを是認するので、 読取る方法を成す実際の仕組みは，観測され得ない。 実装は、 自身に好都合な もっと直な仕組みも利用できる。 `ReadableStreamDefaultReader$I に代えて `ReadableStreamBYOBReader$I を獲得して利用するか， 各~chunkに対し直に~accessするなど。 ◎ Because reader grants exclusive access to its corresponding ReadableStream, the actual mechanism of how to read cannot be observed. Implementations could use a more direct mechanism if convenient, such as acquiring and using a ReadableStreamBYOBReader instead of a ReadableStreamDefaultReader, or accessing the chunks directly.

`ReadableStreamDefaultReader$I %読取器 を `取消す@RSR ~algoは、 所与の ( %事由 ) に対し ⇒ 【~RET】 ~NOABRUPT `ReadableStreamReaderGenericCancel$A( %読取器, %事由 ) ◎ To cancel a ReadableStreamDefaultReader reader with reason, perform ! ReadableStreamReaderGenericCancel(reader, reason).＼

返り値は、［ `undefined^jv で充足されるか, ある失敗~事由で却下される ］~promiseになる。 ◎ The return value will be a promise that either fulfills with undefined, or rejects with a failure reason.

`ReadableStream$I %~stream を `取消す@RS ~algoは、 所与の %事由 に対し ⇒ ~RET ~NOABRUPT `ReadableStreamCancel$A( %~stream, %事由 ) ◎ To cancel a ReadableStream stream with reason, return ! ReadableStreamCancel(stream, reason).＼

返り値は、［ `undefined^jv で充足されるか, ある失敗~事由で却下される ］~promiseになる。 ◎ The return value will be a promise that either fulfills with undefined, or rejects with a failure reason.

`ReadableStream$I %~stream を `二又化する@RS ~algoは ⇒ ~RET ~ABRUPT `ReadableStreamTee$A( %~stream, ~T ) ◎ To tee a ReadableStream stream, return ? ReadableStreamTee(stream, true).

注記： `ReadableStreamTee$A の 2 個目の引数に ~T を渡すので、 返される 2 個目の`分岐$の`~chunk$は， 1 個目の`分岐$の`~chunk$から （~HTMLによる`直列化-可能$な~objの~frameworkを利用して） ~cloneされることになる。 これは、 一方の分岐の消費が他方に干渉することを防止する。 ◎ Because we pass true as the second argument to ReadableStreamTee, the second branch returned will have its chunks cloned (using HTML’s serializable objects framework) from those of the first branch. This prevents consumption of one of the branches from interfering with the other.

1. ~Assert： %~stream は`~Web~IDLを介して新たに作成した$ものである。 ◎ ↑
2. %開始~algo ~LET 次を走らす~algo ⇒ ~RET `undefined^jv ◎ Let startAlgorithm be an algorithm that returns undefined.

3. %~close~algo包装体 ~LET 次を走らす~algo： ◎ Let closeAlgorithmWrapper be an algorithm that runs these steps:

   1. %結果 ~LET ~NULL ◎ ↓
   2. ~IF［ %~close~algo ~NEQ ε ］ ⇒ %結果 ~SET %~close~algo() ⇒ 例外 %e が投出されたときは ⇒ ~RET `却下される~promise$( %e ) ◎ Let result be the result of running closeAlgorithm, if closeAlgorithm was given, or null otherwise. If this throws an exception e, return a promise rejected with e.
   3. ~RET %結果 に応じて ⇒＃ `Promise$I であるならば %結果 ／ ~ELSE_ `解決される~promise$( `undefined^jv ) ◎ If result is a Promise, then return result. ◎ Return a promise resolved with undefined.

4. %中止-~algo包装体 ~LET 所与の ( %事由 ) に対し，次を走らす~algo： ◎ Let abortAlgorithmWrapper be an algorithm that runs these steps given reason:

   1. %結果 ~LET ~NULL ◎ ↓
   2. ~IF［ %中止-~algo ~NEQ ε ］ ⇒ %結果 ~SET %中止-~algo( %事由 ) ⇒ 例外 %e が投出されたときは ⇒ ~RET `却下される~promise$( %e ) ◎ Let result be the result of running abortAlgorithm given reason, if abortAlgorithm was given, or null otherwise. If this throws an exception e, return a promise rejected with e.
   3. ~RET %結果 に応じて ⇒＃ `Promise$I であるならば %結果 ／ ~ELSE_ `解決される~promise$( `undefined^jv ) ◎ If result is a Promise, then return result. ◎ Return a promise resolved with undefined.
5. ~IF［ %~size~algo ~EQ ε ］ ⇒ %~size~algo ~SET 次を走らす~algo ⇒ ~RET 1 ◎ If sizeAlgorithm was not given, then set it to an algorithm that returns 1.
6. ~NOABRUPT `InitializeWritableStream$A( %~stream ) ◎ Perform ! InitializeWritableStream(stream).
7. %制御器 ~LET `新たな~obj$( `WritableStreamDefaultController$I ) ◎ Let controller be a new WritableStreamDefaultController.
8. ~NOABRUPT `SetUpWritableStreamDefaultController$A( ↓ ) ⇒＃ %~stream, %制御器, %開始~algo, %書込n~algo, %~close~algo包装体, %中止-~algo包装体, %限界水位, %~size~algo ◎ Perform ! SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithmWrapper, abortAlgorithmWrapper, highWaterMark, sizeAlgorithm).

他の仕様は、［ 自身による `書込n~algo$V を構築するときに， 所与の`~chunk$から`並列的$に読取ることを避ける ］よう気を付けるベキである — そのような読取nは、 ~JSの “`完了まで走る$” 意味論に違反し得るので。 これは、［ `StructuredSerializeWithTransfer$A／ 当の~buffer~sourceにより`保持された~byte列の複製を取得する$／ `ArrayBuffer$I を`転送する＠~WEBIDLjs#arraybuffer-transfer$ ］などの演算を利用して，所与の値の同期的な［ 複製または転送 ］を為すことで避けれる。 例外は，当の`~chunk$が `SharedArrayBuffer$I の場合であり、 そこでの並列的な変異は，~~避けようのない事実であると解される。 ◎ Other specifications should be careful when constructing their writeAlgorithm to avoid in parallel reads from the given chunk, as such reads can violate the run-to-completion semantics of JavaScript. To avoid this, they can make a synchronous copy or transfer of the given value, using operations such as StructuredSerializeWithTransfer, get a copy of the bytes held by the buffer source, or transferring an ArrayBuffer. An exception is when the chunk is a SharedArrayBuffer, for which it is understood that parallel mutations are a fact of life.

注記： `WritableStream$I の下位classは、 その構築子~手続きの内側にて，コレを`設定しておく$WS演算を直に利用することになる。 ◎ Subclasses of WritableStream will use the set up operation directly on the this value inside their constructor steps.

`WritableStream$I %~stream 用の `書込器を取得する@WS ~algoは ⇒ ~RET ~ABRUPT `AcquireWritableStreamDefaultWriter$A( %~stream ) ◎ To get a writer for a WritableStream stream, return ? AcquireWritableStreamDefaultWriter(stream).＼

結果は `WritableStreamDefaultWriter$I になる。 ◎ The result will be a WritableStreamDefaultWriter.

注記： これは、 %~stream がすでに~lockされている場合には， 例外を投出することになる。 ◎ This will throw an exception if stream is already locked.

`WritableStream$I %~stream を `~closeする@WS ~algoは ⇒ ~RET ~NOABRUPT `WritableStreamClose$A( %~stream ) ◎ To close a WritableStream stream, return ! WritableStreamClose(stream).＼

返り値は、［ `undefined^jv で充足されるか, ある失敗~事由で却下される ］~promiseになる。 ◎ The return value will be a promise that either fulfills with undefined, or rejects with a failure reason.

`WritableStream$I %~stream を `中止する@WS ~algoは、 所与の ( %事由 ) に対し ⇒ ~RET ~NOABRUPT `WritableStreamAbort$A( %~stream, %事由 ) ◎ To abort a WritableStream stream with reason, return ! WritableStreamAbort(stream, reason).＼

返り値は、［ `undefined^jv で充足されるか, ある失敗~事由で却下される ］~promiseになる。 ◎ The return value will be a promise that either fulfills with undefined, or rejects with a failure reason.

1. ~Assert： %~stream は`~Web~IDLを介して新たに作成した$ものである。 ◎ ↑
2. %可読~側の限界水位 ~LET 1 ◎ Let writableHighWaterMark be 1.
3. %可読~側の~size~algo ~LET 次を走らす~algo ⇒ ~RET 1 ◎ Let writableSizeAlgorithm be an algorithm that returns 1.
4. %可書~側の限界水位 ~LET 0 ◎ Let readableHighWaterMark be 0.
5. %可書~側の~size~algo ~LET 次を走らす~algo ⇒ ~RET 1 ◎ Let readableSizeAlgorithm be an algorithm that returns 1.

6. %形式変換~algo包装体 ~LET 所与の ( 値 %~chunk ) に対し，次を走らす~algo： ◎ Let transformAlgorithmWrapper be an algorithm that runs these steps given a value chunk:

   1. %結果 ~LET %形式変換~algo( %~chunk ) ⇒ 例外 %e が投出されたときは ⇒ ~RET `却下される~promise$( %e ) ◎ Let result be the result of running transformAlgorithm given chunk. If this throws an exception e, return a promise rejected with e.
   2. ~RET %結果 に応じて ⇒＃ `Promise$I であるならば %結果 ／ ~ELSE_ `解決される~promise$( `undefined^jv ) ◎ If result is a Promise, then return result. ◎ Return a promise resolved with undefined.

7. %書出n~algo包装体 ~LET 次を走らす~algo： ◎ Let flushAlgorithmWrapper be an algorithm that runs these steps:

   1. %結果 ~LET ~NULL ◎ ↓
   2. ~IF［ %書出n~algo ~NEQ ε ］ ⇒ %結果 ~SET %書出n~algo() ⇒ 例外 %e が投出されたときは ⇒ ~RET `却下される~promise$( %e ) ◎ Let result be the result of running flushAlgorithm, if flushAlgorithm was given, or null otherwise. If this throws an exception e, return a promise rejected with e.
   3. ~RET %結果 に応じて ⇒＃ `Promise$I であるならば %結果 ／ ~ELSE_ `解決される~promise$( `undefined^jv ) ◎ If result is a Promise, then return result. ◎ Return a promise resolved with undefined.

8. %取消~algo包装体 ~LET 所与の ( %事由 ) に対し，次を走らす~algo： ◎ Let cancelAlgorithmWrapper be an algorithm that runs these steps given a value reason:

   1. %結果 ~LET ~NULL ◎ ↓
   2. ~IF［ %取消~algo ~NEQ ε ］ ⇒ %結果 ~SET %取消~algo( %事由 ) ⇒ 例外 %e が投出されたときは ⇒ ~RET `却下される~promise$( %e ) ◎ Let result be the result of running cancelAlgorithm given reason, if cancelAlgorithm was given, or null otherwise. If this throws an exception e, return a promise rejected with e.
   3. ~RET %結果 に応じて ⇒＃ `Promise$I であるならば %結果 ／ ~ELSE_ `解決される~promise$( `undefined^jv ) ◎ If result is a Promise, then return result. ◎ Return a promise resolved with undefined.
9. %開始~promise ~LET `解決される~promise$( `undefined^jv ) ◎ Let startPromise be a promise resolved with undefined.
10. ~NOABRUPT `InitializeTransformStream$A( ↓ ) ⇒＃ %~stream, %開始~promise, %可読~側の限界水位, %可読~側の~size~algo, %可書~側の限界水位, %可書~側の~size~algo ◎ Perform ! InitializeTransformStream(stream, startPromise, writableHighWaterMark, writableSizeAlgorithm, readableHighWaterMark, readableSizeAlgorithm).
11. %制御器 ~LET `新たな~obj$( `TransformStreamDefaultController$I ) ◎ Let controller be a new TransformStreamDefaultController.
12. ~NOABRUPT `SetUpTransformStreamDefaultController$A( ↓ ) ⇒＃ %~stream, %制御器, %形式変換~algo包装体, %書出n~algo包装体, %取消~algo包装体 ◎ Perform ! SetUpTransformStreamDefaultController(stream, controller, transformAlgorithmWrapper, flushAlgorithmWrapper, cancelAlgorithmWrapper).

他の仕様は、［ 自身による `形式変換~algo$V を構築するときに， 所与の`~chunk$から`並列的$に読取ることを避ける ］よう気を付けるベキである — そのような読取nは、 ~JSの “`完了まで走る$” 意味論に違反し得るので。 これは、［ `StructuredSerializeWithTransfer$A／ 当の~buffer~sourceにより`保持された~byte列の複製を取得する$／ `ArrayBuffer$I を`転送する＠~WEBIDLjs#arraybuffer-transfer$ ］などの演算を利用して，所与の値の同期的な［ 複製または転送 ］を為すことで避けれる。 例外は，当の`~chunk$が `SharedArrayBuffer$I の場合であり、 そこでの並列的な変異は，~~避けようのない事実であると解される。 ◎ Other specifications should be careful when constructing their transformAlgorithm to avoid in parallel reads from the given chunk, as such reads can violate the run-to-completion semantics of JavaScript. To avoid this, they can make a synchronous copy or transfer of the given value, using operations such as StructuredSerializeWithTransfer, get a copy of the bytes held by the buffer source, or transferring an ArrayBuffer. An exception is when the chunk is a SharedArrayBuffer, for which it is understood that parallel mutations are a fact of life.

注記： `TransformStream$I の下位classは、 その構築子~手続きの内側にて，コレを`設定しておく$TS演算を直に利用することになる。 ◎ Subclasses of TransformStream will use the set up operation directly on the this value inside their constructor steps.

`恒等変換~streamを作成する@ ~algoは： ◎ To create an identity TransformStream:

1. %形式変換~stream ~LET `新たな~obj$( `TransformStream$I ) ◎ Let transformStream be a new TransformStream.
2. %形式変換~algo ~LET 所与の ( %~chunk ) に対し，次を走らす~algo ⇒ %形式変換~stream に`~chunkを~enqueueする$TS( %~chunk ) ◎ ↓
3. %形式変換~stream を`設定しておく$TS( %形式変換~algo ) ◎ Set up transformStream with transformAlgorithm set to an algorithm which, given chunk, enqueues chunk in transformStream.
4. ~RET %形式変換~stream ◎ Return transformStream.