스트림스

1. underlyingSource가 없으면 null로 설정합니다.

2. underlyingSourceDict를 underlyingSource의 IDL 값으로 변환하여 UnderlyingSource 타입으로 만듭니다.

   underlyingSource 인자를 직접 UnderlyingSource 타입으로 선언할 수 없는 이유는 원래 객체의 참조가 사라지기 때문입니다. 원래 객체를 보존해야 다양한 메서드를 호출(invoke)할 수 있습니다.

3. ! InitializeReadableStream(this)를 수행합니다.

4. underlyingSourceDict["type"] 값이 "bytes"라면:

   1. strategy["size"] 존재하면 RangeError 예외를 throw합니다.

   2. highWaterMark를 ? ExtractHighWaterMark(strategy, 0)로 설정합니다.

   3. ? SetUpReadableByteStreamControllerFromUnderlyingSource(this, underlyingSource, underlyingSourceDict, highWaterMark)를 수행합니다.

5. 그 외의 경우,

   1. Assert: underlyingSourceDict["type"] 값이 존재하지 않음을 단언합니다.

   2. sizeAlgorithm을 ! ExtractSizeAlgorithm(strategy)로 설정합니다.

   3. highWaterMark를 ? ExtractHighWaterMark(strategy, 1)로 설정합니다.

   4. ? SetUpReadableStreamDefaultControllerFromUnderlyingSource(this, underlyingSource, underlyingSourceDict, highWaterMark, sizeAlgorithm)을 수행합니다.

1. ? ReadableStreamFromIterable(asyncIterable)을 반환합니다.

1. ! IsReadableStreamLocked(this)를 반환합니다.

1. ! IsReadableStreamLocked(this)가 true이면 TypeError 예외로 거부된 프로미스(promise)를 반환합니다.

2. ! ReadableStreamCancel(this, reason)을 반환합니다.

1. options["mode"] 값이 존재하지 않으면 ? AcquireReadableStreamDefaultReader(this)를 반환합니다.

2. Assert: options["mode"] 값은 "byob"입니다.

3. ? AcquireReadableStreamBYOBReader(this)를 반환합니다.

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

  return pump();

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

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

1. ! IsReadableStreamLocked(this)가 true이면 TypeError 예외를 throw합니다.

2. ! IsWritableStreamLocked(transform["writable"]) 가 true이면 TypeError 예외를 throw합니다.

3. signal을 options["signal"] 값이 존재하면, 그 값으로, 아니면 undefined로 설정합니다.

4. promise를 ! ReadableStreamPipeTo(this, transform["writable"], options["preventClose"], options["preventAbort"], options["preventCancel"], signal)로 설정합니다.

5. promise.[[PromiseIsHandled]]를 true로 설정합니다.

6. transform["readable"]를 반환합니다.

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

1. ! IsReadableStreamLocked(this)가 true이면 TypeError 예외로 거부된 프로미스(promise)를 반환합니다.

2. ! IsWritableStreamLocked(destination) 가 true이면 TypeError 예외로 거부된 프로미스를 반환합니다.

3. signal을 options["signal"] 값이 존재하면, 그 값으로, 아니면 undefined로 설정합니다.

4. ! ReadableStreamPipeTo(this, destination, options["preventClose"], options["preventAbort"], options["preventCancel"], signal)를 반환합니다.

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

// ... 어느 시점에 ...
controller.abort();

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

// ... 어느 시점에 ...
controller.abort();

// 파이프가 완료될 때까지 기다린 뒤 새 파이프 시작:
try {
 await pipePromise;
} catch (e) {
 // "AbortError" DOMException은 정상적으로 처리하고, 예기치 않은 오류는 재throw
 if (e.name !== "AbortError") {
  throw e;
 }
}

// 새 파이프 시작!
readable2.pipeTo(writable);

1. ? ReadableStreamTee(this, false)를 반환합니다.

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

Promise.all([
  forLocal.pipeTo(cacheEntry),
  forRemote.pipeTo(httpRequestBody)
])
.then(() => console.log("스트림을 캐시에 저장하고 업로드도 완료!"))
.catch(e => console.error("캐싱 또는 업로드 실패: ", e));

1. reader를 ? AcquireReadableStreamDefaultReader(stream)로 설정합니다.

2. iterator의 reader를 reader로 설정합니다.

3. preventCancel을 args[0]["preventCancel"]로 설정합니다.

4. iterator의 취소 방지를 preventCancel로 설정합니다.

1. reader를 iterator의 reader로 설정합니다.

2. Assert: reader.[[stream]]이 undefined가 아님을 단언합니다.

3. promise를 새 프로미스로 설정합니다.

4. readRequest를 다음 읽기 요청으로 설정하며, 다음 항목을 포함합니다:

   청크 단계, chunk 기준

   1. Resolve promise을 chunk로 해결합니다.

   닫기 단계

   1. ! ReadableStreamDefaultReaderRelease(reader)를 수행합니다.

   2. Resolve promise을 end of iteration으로 해결합니다.

   오류 단계, e 기준

   1. ! ReadableStreamDefaultReaderRelease(reader)를 수행합니다.

   2. Reject promise을 e로 거부합니다.

5. ! ReadableStreamDefaultReaderRead(this, readRequest)를 수행합니다.

6. promise를 반환합니다.

1. reader를 iterator의 reader로 설정합니다.

2. Assert: reader.[[stream]]이 undefined가 아님을 단언합니다.

3. Assert: reader.[[readRequests]]가 비어 있음(empty)을 단언합니다. async iterator는 이전 next() 호출이 정산된 후에만 호출되도록 보장합니다.

4. iterator의 취소 방지가 false라면:

   1. result를 ! ReadableStreamReaderGenericCancel(reader, arg)로 설정합니다.

   2. ! ReadableStreamDefaultReaderRelease(reader)를 수행합니다.

   3. result를 반환합니다.

5. ! ReadableStreamDefaultReaderRelease(reader)를 수행합니다.

6. 프로미스(resolve)된 undefined를 반환합니다.

1. ! IsReadableStreamLocked(value)가 true이면 "DataCloneError" DOMException을 throw합니다.

2. port1을 새로운 MessagePort로 현재 Realm에서 생성합니다.

3. port2를 새로운 MessagePort로 현재 Realm에서 생성합니다.

4. Entangle port1과 port2를 연결(entangle)합니다.

5. writable을 새로운 WritableStream으로 현재 Realm에서 생성합니다.

6. ! SetUpCrossRealmTransformWritable(writable, port1)를 수행합니다.

7. promise를 ! ReadableStreamPipeTo(value, writable, false, false, false)로 설정합니다.

8. promise.[[PromiseIsHandled]]를 true로 설정합니다.

9. dataHolder.[[port]]를 ! StructuredSerializeWithTransfer(port2, « port2 »)로 설정합니다.

1. deserializedRecord를 ! StructuredDeserializeWithTransfer(dataHolder.[[port]], 현재 Realm)로 설정합니다.

2. port를 deserializedRecord.[[Deserialized]]로 설정합니다.

3. ! SetUpCrossRealmTransformReadable(value, port)를 수행합니다.

1. this.[[closedPromise]]를 반환합니다.

1. this.[[stream]]이 undefined이면 TypeError 예외로 거부된 프로미스(promise)를 반환합니다.

2. ! ReadableStreamReaderGenericCancel(this, reason)을 반환합니다.

1. ? SetUpReadableStreamDefaultReader(this, stream)을 수행합니다.

1. this.[[stream]]이 undefined이면, a promise rejected with TypeError exception을 반환합니다.

2. promise를 a new promise로 둡니다.

3. readRequest를 다음 read request와 items로 둡니다:

   chunk steps, chunk이 주어진 경우

   1. Resolve promise를 «[ "value" → chunk, "done" → false ]»로 해결합니다.

   close steps

   1. Resolve promise를 «[ "value" → undefined, "done" → true ]»로 해결합니다.

   error steps, e가 주어진 경우

   1. Reject promise를 e로 거부합니다.

4. ! ReadableStreamDefaultReaderRead(this, readRequest)를 수행합니다.

5. promise를 반환합니다.

1. this.[[stream]]이 undefined이면 반환합니다.

2. ! ReadableStreamDefaultReaderRelease(this)를 수행합니다.

1. ? SetUpReadableStreamBYOBReader(this, stream)을 수행합니다.

1. view.[[ByteLength]]가 0이면, a promise rejected with TypeError 예외를 반환합니다.

2. view.[[ViewedArrayBuffer]].[[ByteLength]]가 0이면, a promise rejected with TypeError 예외를 반환합니다.

3. ! IsDetachedBuffer(view.[[ViewedArrayBuffer]])가 true이면, a promise rejected with TypeError 예외를 반환합니다.

4. options["min"] 값이 0이면, a promise rejected with TypeError 예외를 반환합니다.

5. view에 [[TypedArrayName]] 내부 슬롯이 있다면,

   1. options["min"] 값이 view.[[ArrayLength]]보다 크면, a promise rejected with RangeError 예외를 반환합니다.

6. 그 외(DataView인 경우),

   1. options["min"] 값이 view.[[ByteLength]]보다 크면, a promise rejected with RangeError 예외를 반환합니다.

7. this.[[stream]]이 undefined이면, a promise rejected with TypeError 예외를 반환합니다.

8. promise를 a new promise로 둡니다.

9. readIntoRequest를 다음 read-into 요청과 항목으로 둡니다:

   chunk steps, chunk가 주어진 경우

   1. Resolve promise를 «[ "value" → chunk, "done" → false ]»로 해결합니다.

   close steps, chunk가 주어진 경우

   1. Resolve promise를 «[ "value" → chunk, "done" → true ]»로 해결합니다.

   error steps, e가 주어진 경우

   1. Reject promise를 e로 거부합니다.

10. ! ReadableStreamBYOBReaderRead(this, view, options["min"], readIntoRequest)를 수행합니다.

11. promise를 반환합니다.

1. this.[[stream]]이 undefined이면 반환합니다.

2. ! ReadableStreamBYOBReaderRelease(this)를 수행합니다.

1. ! ReadableStreamDefaultControllerGetDesiredSize(this)를 반환합니다.

1. ! ReadableStreamDefaultControllerCanCloseOrEnqueue(this)가 false이면, TypeError 예외를 throw 합니다.

2. ! ReadableStreamDefaultControllerClose(this)를 수행합니다.

1. ! ReadableStreamDefaultControllerCanCloseOrEnqueue(this)가 false이면, TypeError 예외를 throw 합니다.

2. ? ReadableStreamDefaultControllerEnqueue(this, chunk)를 수행합니다.

1. ! ReadableStreamDefaultControllerError(this, e)를 수행합니다.

1. ! ResetQueue(this)를 수행합니다.

2. result를 this.[[cancelAlgorithm]]를 reason을 전달하여 실행한 결과로 둡니다.

3. ! ReadableStreamDefaultControllerClearAlgorithms(this)를 수행합니다.

4. result를 반환합니다.

1. stream을 this.[[stream]]으로 둡니다.

2. this.[[queue]]가 비어있지 않다면,

   1. chunk를 ! DequeueValue(this)로 둡니다.

   2. this.[[closeRequested]] 가 true이고 this.[[queue]]가 비어 있다면,

      1. ! ReadableStreamDefaultControllerClearAlgorithms(this)를 수행합니다.

      2. ! ReadableStreamClose(stream)을 수행합니다.

   3. 그 외에는, ! ReadableStreamDefaultControllerCallPullIfNeeded(this)를 수행합니다.

   4. readRequest의 chunk steps를 chunk를 인자로 하여 수행합니다.

3. 그 외에는,

   1. ! ReadableStreamAddReadRequest(stream, readRequest)를 수행합니다.

   2. ! ReadableStreamDefaultControllerCallPullIfNeeded(this)를 수행합니다.

1. 반환합니다.

1. ! ReadableByteStreamControllerGetBYOBRequest(this)를 반환합니다.

1. ! ReadableByteStreamControllerGetDesiredSize(this)를 반환합니다.

1. this.[[closeRequested]]가 true이면, TypeError 예외를 throw합니다.

2. this.[[stream]].[[state]]가 "readable"가 아니면 TypeError 예외를 throw합니다.

3. ? ReadableByteStreamControllerClose(this)를 수행합니다.

1. chunk.[[ByteLength]]가 0이면 TypeError 예외를 throw합니다.

2. chunk.[[ViewedArrayBuffer]].[[ByteLength]]가 0이면 TypeError 예외를 throw합니다.

3. this.[[closeRequested]]가 true이면 TypeError 예외를 throw합니다.

4. this.[[stream]].[[state]]가 "readable"가 아니면 TypeError 예외를 throw합니다.

5. ? ReadableByteStreamControllerEnqueue(this, chunk)를 반환합니다.

1. ! ReadableByteStreamControllerError(this, e)를 수행합니다.

1. ! ReadableByteStreamControllerClearPendingPullIntos(this)를 수행합니다.

2. ! ResetQueue(this)를 수행합니다.

3. result를 this.[[cancelAlgorithm]]를 reason을 전달하여 실행한 결과로 둡니다.

4. ! ReadableByteStreamControllerClearAlgorithms(this)를 수행합니다.

5. result를 반환합니다.

1. stream을 this.[[stream]]으로 둡니다.

2. Assert: ! ReadableStreamHasDefaultReader(stream) 가 true임을 보장합니다.

3. this.[[queueTotalSize]] > 0이라면,

   1. Assert: ! ReadableStreamGetNumReadRequests(stream) 가 0임을 보장합니다.

   2. ! ReadableByteStreamControllerFillReadRequestFromQueue(this, readRequest)를 수행합니다.

   3. 반환합니다.

4. autoAllocateChunkSize를 this.[[autoAllocateChunkSize]]로 둡니다.

5. autoAllocateChunkSize가 undefined가 아니라면,

   1. buffer를 Construct(%ArrayBuffer%, « autoAllocateChunkSize »)로 둡니다.

   2. buffer가 abrupt completion이라면,

      1. readRequest의 error steps를 buffer.[[Value]]로 실행합니다.

      2. 반환합니다.

   3. pullIntoDescriptor를 다음 속성으로 새 pull-into descriptor로 둡니다.

      buffer

      buffer.[[Value]]

      buffer byte length

      autoAllocateChunkSize

      byte offset

      0

      byte length

      autoAllocateChunkSize

      bytes filled

      0

      minimum fill

      1

      element size

      1

      view constructor

      %Uint8Array%

      reader type

      "default"

   4. Append pullIntoDescriptor를 this.[[pendingPullIntos]]에 추가합니다.

6. ! ReadableStreamAddReadRequest(stream, readRequest)를 수행합니다.

7. ! ReadableByteStreamControllerCallPullIfNeeded(this)를 수행합니다.

1. this.[[pendingPullIntos]]가 비어 있지 않다면,

   1. firstPendingPullInto를 this.[[pendingPullIntos]][0]로 둡니다.

   2. firstPendingPullInto의 reader type을 "none"으로 설정합니다.

   3. this.[[pendingPullIntos]]를 리스트 « firstPendingPullInto »로 설정합니다.

1. this.[[view]]를 반환합니다.

1. this.[[controller]]가 undefined이면, TypeError 예외를 throw합니다.

2. ! IsDetachedBuffer(this.[[view]].[[ArrayBuffer]]) 가 true이면 TypeError 예외를 throw합니다.

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

4. Assert: this.[[view]].[[ViewedArrayBuffer]].[[ByteLength]] > 0.

5. ? ReadableByteStreamControllerRespond(this.[[controller]], bytesWritten)를 수행합니다.

1. this.[[controller]]가 undefined이면, TypeError 예외를 throw합니다.

2. ! IsDetachedBuffer(view.[[ViewedArrayBuffer]]) 가 true이면, TypeError 예외를 throw합니다.

3. ? ReadableByteStreamControllerRespondWithNewView(this.[[controller]], view)를 반환합니다.

1. reader를 new ReadableStreamBYOBReader로 둡니다.

2. ? SetUpReadableStreamBYOBReader(reader, stream)를 수행합니다.

3. reader를 반환합니다.

1. reader를 new ReadableStreamDefaultReader로 둡니다.

2. ? SetUpReadableStreamDefaultReader(reader, stream)를 수행합니다.

3. reader를 반환합니다.

1. highWaterMark가 전달되지 않았다면, 1로 설정합니다.

2. sizeAlgorithm가 전달되지 않았다면, 1을 반환하는 알고리즘으로 설정합니다.

3. Assert: ! IsNonNegativeNumber(highWaterMark)가 true임을 보장합니다.

4. stream을 new ReadableStream로 둡니다.

5. ! InitializeReadableStream(stream)을 수행합니다.

6. controller를 new ReadableStreamDefaultController로 둡니다.

7. ? SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm)를 수행합니다.

8. stream을 반환합니다.

이 추상 연산은 전달된 startAlgorithm이 예외를 발생시킬 경우에만 예외를 throw합니다.

1. stream을 new ReadableStream로 둡니다.

2. ! InitializeReadableStream(stream)을 수행합니다.

3. controller를 new ReadableByteStreamController로 둡니다.

4. ? SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, 0, undefined)를 수행합니다.

5. stream을 반환합니다.

이 추상 연산은 전달된 startAlgorithm이 예외를 발생시킬 경우에만 예외를 throw합니다.

1. stream.[[state]]를 "readable"로 설정합니다.

2. stream.[[reader]]와 stream.[[storedError]]를 undefined로 설정합니다.

3. stream.[[disturbed]]를 false로 설정합니다.

1. stream.[[reader]]가 undefined이면 false를 반환합니다.

2. true를 반환합니다.

1. stream을 undefined로 둡니다.

2. iteratorRecord를 ? GetIterator(asyncIterable, async)로 둡니다.

3. startAlgorithm을 undefined를 반환하는 알고리즘으로 둡니다.

4. pullAlgorithm을 다음 단계로 둡니다:

   1. nextResult를 IteratorNext(iteratorRecord)로 둡니다.

   2. nextResult가 abrupt completion이면 a promise rejected with nextResult.[[Value]]를 반환합니다.

   3. nextPromise를 a promise resolved with nextResult.[[Value]]로 둡니다.

   4. nextPromise에 대해 reacting을 아래 fulfillment 단계로 수행한 결과를 반환합니다. iterResult가 주어집니다:

      1. iterResult가 Object가 아니면 TypeError를 throw합니다.

      2. done을 ? IteratorComplete(iterResult)로 둡니다.

      3. done이 true이면:

         1. ! ReadableStreamDefaultControllerClose(stream.[[controller]])를 수행합니다.

      4. 그 외에는:

         1. value를 ? IteratorValue(iterResult)로 둡니다.

         2. ! ReadableStreamDefaultControllerEnqueue(stream.[[controller]], value)를 수행합니다.

5. cancelAlgorithm을 다음 단계로 둡니다. reason이 주어집니다:

   1. iterator를 iteratorRecord.[[Iterator]]로 둡니다.

   2. returnMethod를 GetMethod(iterator, "return")로 둡니다.

   3. returnMethod가 abrupt completion이면 a promise rejected with returnMethod.[[Value]]를 반환합니다.

   4. returnMethod.[[Value]]가 undefined이면 a promise resolved with undefined를 반환합니다.

   5. returnResult를 Call(returnMethod.[[Value]], iterator, « reason »)로 둡니다.

   6. returnResult가 abrupt completion이면 a promise rejected with returnResult.[[Value]]를 반환합니다.

   7. returnPromise를 a promise resolved with returnResult.[[Value]]로 둡니다.

   8. returnPromise에 대해 reacting을 아래 fulfillment 단계로 수행한 결과를 반환합니다. iterResult가 주어집니다:

      1. iterResult가 Object가 아니면 TypeError를 throw합니다.

      2. undefined를 반환합니다.

6. stream을 ! CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, 0)로 설정합니다.

7. stream을 반환합니다.

1. Assert: source가 구현하는 ReadableStream임을 보장합니다.

2. Assert: dest가 구현하는 WritableStream임을 보장합니다.

3. Assert: preventClose, preventAbort, preventCancel 모두 boolean임을 보장합니다.

4. signal이 주어지지 않았다면 signal을 undefined로 둡니다.

5. Assert: signal이 undefined이거나, signal이 구현하는 AbortSignal임을 보장합니다.

6. Assert: ! IsReadableStreamLocked(source)가 false임을 보장합니다.

7. Assert: ! IsWritableStreamLocked(dest)가 false임을 보장합니다.

8. source.[[controller]]가 구현하는 ReadableByteStreamController인 경우, reader를 ! AcquireReadableStreamBYOBReader(source) 또는 ! AcquireReadableStreamDefaultReader(source)로 둡니다(사용자 에이전트의 재량).

9. 그 외에는 reader를 ! AcquireReadableStreamDefaultReader(source)로 둡니다.

10. writer를 ! AcquireWritableStreamDefaultWriter(dest)로 둡니다.

11. source.[[disturbed]]를 true로 설정합니다.

12. shuttingDown을 false로 둡니다.

13. promise를 a new promise로 둡니다.

14. signal이 undefined가 아니라면,

    1. abortAlgorithm을 다음 단계로 둡니다:

       1. error를 signal의 abort reason으로 둡니다.

       2. actions를 빈 ordered set으로 둡니다.

       3. preventAbort가 false이면 append 아래 액션을 actions에 추가합니다:

          1. dest.[[state]]가 "writable"이면 ! WritableStreamAbort(dest, error)를 반환합니다.

          2. 그 외에는 a promise resolved with undefined를 반환합니다.

       4. preventCancel가 false이면 append 아래 액션을 actions에 추가합니다:

          1. source.[[state]]가 "readable"이면 ! ReadableStreamCancel(source, error)를 반환합니다.

          2. 그 외에는 a promise resolved with undefined를 반환합니다.

       5. Shutdown with an action 으로 actions의 모든 액션을 기다리는 promise와 error를 전달합니다.

    2. signal이 aborted이면 abortAlgorithm을 수행하고 promise를 반환합니다.

    3. Add abortAlgorithm을 signal에 추가합니다.

15. 병렬로 (실제로는 아님; #905 참고), reader와 writer를 사용하여 source에서 모든 chunk를 읽어 dest에 씁니다. reader와 writer의 locking 때문에, 실제 어떻게 동작하는지는 작성자 코드로 관찰할 수 없으므로 구현 방식에 융통성이 있습니다. 아래 제약사항은 알고리즘이 어떻게 구현되든 적용됩니다:

    • 공개 API를 사용하지 말 것: 읽기/쓰기 또는 아래 연산을 수행하는 동안, JavaScript로 수정 가능한 reader, writer, stream API(적절한 prototype의 메서드)들은 사용하지 않고 stream을 직접 조작해야 합니다.

    • 역압(backpressure)을 준수할 것:

      • WritableStreamDefaultWriterGetDesiredSize(writer) 값이 ≤ 0 또는 null일 때, user agent는 reader로부터 읽으면 안 됩니다.

      • reader가 BYOB reader인 경우, WritableStreamDefaultWriterGetDesiredSize(writer)를 chunk 크기 결정의 근거로 사용해야 합니다.

        너무 작거나 큰 chunk를 읽는 것은 자주 비효율적입니다. 최적 chunk 크기 판단에 다른 정보도 활용할 수 있습니다.

      • backpressure 이외의 이유로 읽기/쓰기를 지연해서는 안 됩니다.

        각 write가 완료될 때까지 다음 읽기/쓰기를 기다리는 구현은 이 권고를 위반합니다. 이런 구현은 dest의 내부 큐가 항상 1개 이하 chunk만 가지게 되어 쓸모없게 만듭니다.

    • 종료 시 동작 중지: shuttingDown이 true가 되면, user agent는 더 이상 reader에서 읽기를 시작하지 말고, 이미 읽은 chunk만 아래에 따라 써야 합니다. 모든 읽기/쓰기 전에 즉시 종료 조건을 체크해야 합니다.

    • 에러 및 close 전파: 아래 조건을 순서대로 적용합니다.

      1. 에러는 앞으로 전파: source.[[state]] 값이 "errored"가 되거나 이미 그렇다면,

         1. preventAbort가 false이면, shutdown with an action으로 ! WritableStreamAbort(dest, source.[[storedError]])와 source.[[storedError]]를 전달합니다.

         2. 그 외에는 shutdown으로 source.[[storedError]]를 전달합니다.

      2. 에러는 뒤로 전파: dest.[[state]] 값이 "errored"가 되거나 이미 그렇다면,

         1. preventCancel가 false이면, shutdown with an action으로 ! ReadableStreamCancel(source, dest.[[storedError]])와 dest.[[storedError]]를 전달합니다.

         2. 그 외에는 shutdown으로 dest.[[storedError]]를 전달합니다.

      3. 닫힘은 앞으로 전파: source.[[state]] 값이 "closed"가 되거나 이미 그렇다면,

         1. preventClose가 false이면, shutdown with an action으로 ! WritableStreamDefaultWriterCloseWithErrorPropagation(writer)를 전달합니다.

         2. 그 외에는 shutdown을 수행합니다.

      4. 닫힘은 뒤로 전파: ! WritableStreamCloseQueuedOrInFlight(dest) 값이 true이거나 dest.[[state]] 값이 "closed"라면

         1. Assert: 아직 읽거나 쓴 chunk가 없어야 합니다.

         2. destClosed를 TypeError로 둡니다.

         3. preventCancel가 false이면, shutdown with an action으로 ! ReadableStreamCancel(source, destClosed)와 destClosed를 전달합니다.

         4. 그 외에는 shutdown으로 destClosed를 전달합니다.

    • Shutdown with an action: 위 요구사항 중 액션 action으로 종료(옵션으로 originalError와 함께)하라고 하면 다음을 수행합니다:

      1. shuttingDown이 true면 하위 단계를 중단합니다.

      2. shuttingDown을 true로 설정합니다.

      3. dest.[[state]]가 "writable"이고 ! WritableStreamCloseQueuedOrInFlight(dest) 값이 false라면

         1. 아직 쓰지 않은 읽은 chunk가 있다면 dest에 씁니다.

         2. 모든 읽은 chunk가 써질 때까지 기다립니다(즉, 해당 promise가 settle됨).

      4. p를 action을 수행한 결과로 둡니다.

      5. Upon fulfillment of p, finalize로 originalError를 전달합니다(있으면).

      6. Upon rejection of p (newError), finalize로 newError를 전달합니다.

    • Shutdown: 위 요구 또는 단계에서 종료(옵션으로 error와 함께)하라고 하면 다음 수행:

      1. shuttingDown이 true면 하위 단계를 중단합니다.

      2. shuttingDown을 true로 설정합니다.

      3. dest.[[state]]가 "writable"이고 ! WritableStreamCloseQueuedOrInFlight(dest) 값이 false라면

         1. 아직 쓰지 않은 읽은 chunk가 있다면 dest에 씁니다.

         2. 모든 읽은 chunk가 써질 때까지 기다립니다(즉, 해당 promise가 settle됨).

      4. Finalize로 error를 전달합니다(있으면).

    • Finalize: 두 종료 방식 모두 결국 finalize(옵션으로 error와 함께)를 요청합니다. 아래 단계 수행:

      1. ! WritableStreamDefaultWriterRelease(writer)를 수행합니다.

      2. reader가 구현하는 ReadableStreamBYOBReader이면, ! ReadableStreamBYOBReaderRelease(reader)를 수행합니다.

      3. 그 외에는 ! ReadableStreamDefaultReaderRelease(reader)를 수행합니다.

      4. signal이 undefined가 아니면 remove abortAlgorithm을 signal에서 제거합니다.

      5. error가 주어진 경우, promise를 error로 reject합니다.

      6. 그렇지 않으면, promise를 undefined로 resolve합니다.

16. promise를 반환합니다.

두 번째 인자인 cloneForBranch2는 원본 스트림의 데이터가 반환된 두 번째 브랜치에 나타나기 전에 복제(HTML의 직렬화 가능한 객체 프레임워크 사용)를 수행할지 여부를 결정합니다. 이는 두 브랜치 모두가 서로 영향을 줄 수 있는 상황(예: transfer를 통해 chunk를 전달하는 경우 등)에서 유용합니다. 하지만 두 브랜치 간에 뚜렷한 비대칭성이 생기며, 가능한 chunk가 직렬화 가능한 것으로 제한됩니다. [HTML]

stream이 readable byte stream인 경우 cloneForBranch2는 무시되며 chunk가 항상 복제됩니다.

현행 표준에서는 ReadableStreamTee가 항상 cloneForBranch2를 false로 호출하며, 다른 명세에서는 tee 래퍼 알고리즘을 통해 true를 전달할 수 있습니다.

다음 단계를 수행합니다:

1. Assert: stream이 구현하는 ReadableStream임을 보장합니다.

2. Assert: cloneForBranch2는 boolean입니다.

3. stream.[[controller]]가 구현하는 ReadableByteStreamController이면, ? ReadableByteStreamTee(stream)를 반환합니다.

4. ? ReadableStreamDefaultTee(stream, cloneForBranch2)를 반환합니다.

1. Assert: stream이 구현하는 ReadableStream임을 보장합니다.

2. Assert: cloneForBranch2는 boolean입니다.

3. reader를 ? AcquireReadableStreamDefaultReader(stream)로 둡니다.

4. reading을 false로 둡니다.

5. readAgain을 false로 둡니다.

6. canceled1을 false로 둡니다.

7. canceled2을 false로 둡니다.

8. reason1을 undefined로 둡니다.

9. reason2을 undefined로 둡니다.

10. branch1을 undefined로 둡니다.

11. branch2을 undefined로 둡니다.

12. cancelPromise를 새 promise로 둡니다.

13. pullAlgorithm을 다음 단계로 둡니다:

    1. reading이 true이면,

       1. readAgain을 true로 설정합니다.

       2. promise resolved with undefined를 반환합니다.

    2. reading을 true로 설정합니다.

    3. readRequest를 다음 read request로 둡니다(아래 항목 포함):

       chunk steps, chunk 전달시

       1. 마이크로태스크 큐를 이용해 다음 단계 실행:

          1. readAgain을 false로 설정합니다.

          2. chunk1과 chunk2를 chunk로 둡니다.

          3. canceled2가 false이고 cloneForBranch2가 true이면,

             1. cloneResult를 StructuredClone(chunk2)로 둡니다.

             2. cloneResult가 abrupt completion이면,

                1. ! ReadableStreamDefaultControllerError(branch1.[[controller]], cloneResult.[[Value]])를 수행합니다.

                2. ! ReadableStreamDefaultControllerError(branch2.[[controller]], cloneResult.[[Value]])를 수행합니다.

                3. Resolve cancelPromise를 ! ReadableStreamCancel(stream, cloneResult.[[Value]])로 처리합니다.

                4. Return.

             3. 그 외에는 chunk2를 cloneResult.[[Value]]로 설정합니다.

          4. canceled1가 false이면, ! ReadableStreamDefaultControllerEnqueue(branch1.[[controller]], chunk1)를 수행합니다.

          5. canceled2가 false이면, ! ReadableStreamDefaultControllerEnqueue(branch2.[[controller]], chunk2)를 수행합니다.

          6. reading을 false로 설정합니다.

          7. readAgain이 true이면 pullAlgorithm을 수행합니다.

       여기서의 마이크로태스크 지연은, 아래 reader.[[closedPromise]] 처리를 통해 에러를 감지하는 데 최소 마이크로태스크가 필요하기 때문에 요구됩니다. stream의 에러가 두 브랜치 모두에 즉시 전파되길 원하므로, 비동기적으로 에러가 발생하기 전에 동기적으로 읽기가 성공하는 일이 없도록 합니다.

       close steps

       1. reading을 false로 설정합니다.

       2. canceled1가 false이면, ! ReadableStreamDefaultControllerClose(branch1.[[controller]])를 수행합니다.

       3. canceled2가 false이면, ! ReadableStreamDefaultControllerClose(branch2.[[controller]])를 수행합니다.

       4. canceled1가 false이거나 canceled2가 false이면, resolve cancelPromise를 undefined로 처리합니다.

       error steps

       1. reading을 false로 설정합니다.

    4. ! ReadableStreamDefaultReaderRead(reader, readRequest)를 수행합니다.

    5. promise resolved with undefined를 반환합니다.

14. cancel1Algorithm을 다음 단계로 둡니다(reason 인자 사용):

    1. canceled1을 true로 설정합니다.

    2. reason1을 reason으로 설정합니다.

    3. canceled2가 true이면,

       1. compositeReason를 ! CreateArrayFromList(« reason1, reason2 »)로 둡니다.

       2. cancelResult를 ! ReadableStreamCancel(stream, compositeReason)로 둡니다.

       3. Resolve cancelPromise를 cancelResult로 처리합니다.

    4. cancelPromise를 반환합니다.

15. cancel2Algorithm을 다음 단계로 둡니다(reason 인자 사용):

    1. canceled2을 true로 설정합니다.

    2. reason2을 reason으로 설정합니다.

    3. canceled1가 true이면,

       1. compositeReason를 ! CreateArrayFromList(« reason1, reason2 »)로 둡니다.

       2. cancelResult를 ! ReadableStreamCancel(stream, compositeReason)로 둡니다.

       3. Resolve cancelPromise를 cancelResult로 처리합니다.

    4. cancelPromise를 반환합니다.

16. startAlgorithm을 undefined를 반환하는 알고리즘으로 둡니다.

17. branch1을 ! CreateReadableStream(startAlgorithm, pullAlgorithm, cancel1Algorithm)로 설정합니다.

18. branch2을 ! CreateReadableStream(startAlgorithm, pullAlgorithm, cancel2Algorithm)로 설정합니다.

19. upon rejection of reader.[[closedPromise]] with reason r:

    1. ! ReadableStreamDefaultControllerError(branch1.[[controller]], r)를 수행합니다.

    2. ! ReadableStreamDefaultControllerError(branch2.[[controller]], r)를 수행합니다.

    3. canceled1가 false이거나 canceled2가 false이면, resolve cancelPromise를 undefined로 처리합니다.

20. « branch1, branch2 »를 반환합니다.

1. Assert: stream이 구현하는 ReadableStream임을 보장합니다.

2. Assert: stream.[[controller]]가 구현하는 ReadableByteStreamController임을 보장합니다.

3. reader를 ? AcquireReadableStreamDefaultReader(stream)로 둡니다.

4. reading을 false로 둡니다.

5. readAgainForBranch1을 false로 둡니다.

6. readAgainForBranch2을 false로 둡니다.

7. canceled1을 false로 둡니다.

8. canceled2을 false로 둡니다.

9. reason1을 undefined로 둡니다.

10. reason2을 undefined로 둡니다.

11. branch1을 undefined로 둡니다.

12. branch2을 undefined로 둡니다.

13. cancelPromise를 새 promise로 둡니다.

14. forwardReaderError를 다음 단계로 둡니다(thisReader 인자 사용):

    1. upon rejection of thisReader.[[closedPromise]] with reason r:

       1. thisReader가 reader가 아니라면 return.

       2. ! ReadableByteStreamControllerError(branch1.[[controller]], r)를 수행합니다.

       3. ! ReadableByteStreamControllerError(branch2.[[controller]], r)를 수행합니다.

       4. canceled1가 false이거나 canceled2가 false이면 resolve cancelPromise를 undefined로 처리합니다.

15. pullWithDefaultReader를 다음 단계로 둡니다:

    1. reader가 구현하는 ReadableStreamBYOBReader이면,

       1. Assert: reader.[[readIntoRequests]]가 비어 있음을 보장합니다.

       2. ! ReadableStreamBYOBReaderRelease(reader)를 수행합니다.

       3. reader를 ! AcquireReadableStreamDefaultReader(stream)로 둡니다.

       4. forwardReaderError를 reader에 대해 수행합니다.

    2. readRequest를 다음 read request로 둡니다(아래 항목 포함):

       chunk steps, chunk 전달시

       1. 마이크로태스크 큐를 이용해 다음 단계 실행:

          1. readAgainForBranch1을 false로 설정합니다.

          2. readAgainForBranch2을 false로 설정합니다.

          3. chunk1과 chunk2를 chunk로 둡니다.

          4. canceled1가 false이고 canceled2가 false이면,

             1. cloneResult를 CloneAsUint8Array(chunk)로 둡니다.

             2. cloneResult가 abrupt completion이면,

                1. ! ReadableByteStreamControllerError(branch1.[[controller]], cloneResult.[[Value]])를 수행합니다.

                2. ! ReadableByteStreamControllerError(branch2.[[controller]], cloneResult.[[Value]])를 수행합니다.

                3. Resolve cancelPromise를 ! ReadableStreamCancel(stream, cloneResult.[[Value]])로 처리합니다.

                4. Return.

             3. 그 외에는 chunk2를 cloneResult.[[Value]]로 설정합니다.

          5. canceled1가 false이면, ! ReadableByteStreamControllerEnqueue(branch1.[[controller]], chunk1)를 수행합니다.

          6. canceled2가 false이면, ! ReadableByteStreamControllerEnqueue(branch2.[[controller]], chunk2)를 수행합니다.

          7. reading을 false로 설정합니다.

          8. readAgainForBranch1이 true이면 pull1Algorithm을 수행합니다.

          9. 그 외에는 readAgainForBranch2가 true이면 pull2Algorithm을 수행합니다.

       여기서의 마이크로태스크 지연은, 아래 reader.[[closedPromise]] 처리를 통해 에러를 감지하는 데 최소 마이크로태스크가 필요하기 때문에 요구됩니다. stream의 에러가 두 브랜치 모두에 즉시 전파되길 원하므로, 비동기적으로 에러가 발생하기 전에 동기적으로 읽기가 성공하는 일이 없도록 합니다.

       close steps

       1. reading을 false로 설정합니다.

       2. canceled1가 false이면, ! ReadableByteStreamControllerClose(branch1.[[controller]])를 수행합니다.

       3. canceled2가 false이면, ! ReadableByteStreamControllerClose(branch2.[[controller]])를 수행합니다.

       4. branch1.[[controller]].[[pendingPullIntos]] 가 비어 있지 않으면, ! ReadableByteStreamControllerRespond(branch1.[[controller]], 0)을 수행합니다.

       5. branch2.[[controller]].[[pendingPullIntos]] 가 비어 있지 않으면, ! ReadableByteStreamControllerRespond(branch2.[[controller]], 0)을 수행합니다.

       6. canceled1가 false이거나 canceled2가 false이면 resolve cancelPromise를 undefined로 처리합니다.

       error steps

       1. reading을 false로 설정합니다.

    3. ! ReadableStreamDefaultReaderRead(reader, readRequest)를 수행합니다.

16. pullWithBYOBReader를 다음 단계로 둡니다(view, forBranch2 인자 사용):

    1. reader가 구현하는 ReadableStreamDefaultReader이면,

       1. Assert: reader.[[readRequests]]가 비어 있음을 보장합니다.

       2. ! ReadableStreamDefaultReaderRelease(reader)를 수행합니다.

       3. reader를 ! AcquireReadableStreamBYOBReader(stream)로 둡니다.

       4. forwardReaderError를 reader에 대해 수행합니다.

    2. byobBranch를 forBranch2가 true이면 branch2, 아니면 branch1로 둡니다.

    3. otherBranch를 forBranch2가 false이면 branch2, 아니면 branch1로 둡니다.

    4. readIntoRequest를 다음 read-into request로 둡니다(아래 항목 포함):

       chunk steps, chunk 전달시

       1. 마이크로태스크 큐를 이용해 다음 단계 실행:

          1. readAgainForBranch1을 false로 설정합니다.

          2. readAgainForBranch2을 false로 설정합니다.

          3. byobCanceled를 forBranch2가 true이면 canceled2, 아니면 canceled1로 둡니다.

          4. otherCanceled를 forBranch2가 false이면 canceled2, 아니면 canceled1로 둡니다.

          5. otherCanceled가 false이면,

             1. cloneResult를 CloneAsUint8Array(chunk)로 둡니다.

             2. cloneResult가 abrupt completion이면,

                1. ! ReadableByteStreamControllerError(byobBranch.[[controller]], cloneResult.[[Value]])를 수행합니다.

                2. ! ReadableByteStreamControllerError(otherBranch.[[controller]], cloneResult.[[Value]])를 수행합니다.

                3. Resolve cancelPromise를 ! ReadableStreamCancel(stream, cloneResult.[[Value]])로 처리합니다.

                4. Return.

             3. 그 외에는 clonedChunk를 cloneResult.[[Value]]로 둡니다.

             4. byobCanceled가 false이면, ! ReadableByteStreamControllerRespondWithNewView(byobBranch.[[controller]], chunk)를 수행합니다.

             5. ! ReadableByteStreamControllerEnqueue(otherBranch.[[controller]], clonedChunk)를 수행합니다.

          6. 그 외에는 byobCanceled가 false이면, ! ReadableByteStreamControllerRespondWithNewView(byobBranch.[[controller]], chunk)를 수행합니다.

          7. reading을 false로 설정합니다.

          8. readAgainForBranch1이 true이면 pull1Algorithm을 수행합니다.

          9. 그 외에는 readAgainForBranch2가 true이면 pull2Algorithm을 수행합니다.

       여기서의 마이크로태스크 지연은, 아래 reader.[[closedPromise]] 처리를 통해 에러를 감지하는 데 최소 마이크로태스크가 필요하기 때문에 요구됩니다. stream의 에러가 두 브랜치 모두에 즉시 전파되길 원하므로, 비동기적으로 에러가 발생하기 전에 동기적으로 읽기가 성공하는 일이 없도록 합니다.

       close steps, chunk 전달시

       1. reading을 false로 설정합니다.

       2. byobCanceled를 forBranch2가 true이면 canceled2, 아니면 canceled1로 둡니다.

       3. otherCanceled를 forBranch2가 false이면 canceled2, 아니면 canceled1로 둡니다.

       4. byobCanceled가 false이면, ! ReadableByteStreamControllerClose(byobBranch.[[controller]])를 수행합니다.

       5. otherCanceled가 false이면, ! ReadableByteStreamControllerClose(otherBranch.[[controller]])를 수행합니다.

       6. chunk가 undefined가 아니면,

          1. Assert: chunk.[[ByteLength]]가 0임을 보장합니다.

          2. byobCanceled가 false이면, ! ReadableByteStreamControllerRespondWithNewView(byobBranch.[[controller]], chunk)를 수행합니다.

          3. otherCanceled가 false이고 otherBranch.[[controller]].[[pendingPullIntos]] 가 비어 있지 않으면, ! ReadableByteStreamControllerRespond(otherBranch.[[controller]], 0)을 수행합니다.

       7. byobCanceled가 false이거나 otherCanceled가 false이면 resolve cancelPromise를 undefined로 처리합니다.

       error steps

       1. reading을 false로 설정합니다.

    5. ! ReadableStreamBYOBReaderRead(reader, view, 1, readIntoRequest)를 수행합니다.

17. pull1Algorithm을 다음 단계로 둡니다:

    1. reading이 true이면,

       1. readAgainForBranch1을 true로 설정합니다.

       2. promise resolved with undefined를 반환합니다.

    2. reading을 true로 설정합니다.

    3. byobRequest를 ! ReadableByteStreamControllerGetBYOBRequest(branch1.[[controller]])로 둡니다.

    4. byobRequest가 null이면 pullWithDefaultReader를 수행합니다.

    5. 그 외에는 pullWithBYOBReader를 byobRequest.[[view]]와 false 인자를 전달하여 수행합니다.

    6. promise resolved with undefined를 반환합니다.

18. pull2Algorithm을 다음 단계로 둡니다:

    1. reading이 true이면,

       1. readAgainForBranch2을 true로 설정합니다.

       2. promise resolved with undefined를 반환합니다.

    2. reading을 true로 설정합니다.

    3. byobRequest를 ! ReadableByteStreamControllerGetBYOBRequest(branch2.[[controller]])로 둡니다.

    4. byobRequest가 null이면 pullWithDefaultReader를 수행합니다.

    5. 그 외에는 pullWithBYOBReader를 byobRequest.[[view]]와 true 인자를 전달하여 수행합니다.

    6. promise resolved with undefined를 반환합니다.

19. cancel1Algorithm을 다음 단계로 둡니다(reason 인자 사용):

    1. canceled1을 true로 설정합니다.

    2. reason1을 reason으로 설정합니다.

    3. canceled2가 true이면,

       1. compositeReason를 ! CreateArrayFromList(« reason1, reason2 »)로 둡니다.

       2. cancelResult를 ! ReadableStreamCancel(stream, compositeReason)로 둡니다.

       3. Resolve cancelPromise를 cancelResult로 처리합니다.

    4. cancelPromise를 반환합니다.

20. cancel2Algorithm을 다음 단계로 둡니다(reason 인자 사용):

    1. canceled2을 true로 설정합니다.

    2. reason2을 reason으로 설정합니다.

    3. canceled1가 true이면,

       1. compositeReason를 ! CreateArrayFromList(« reason1, reason2 »)로 둡니다.

       2. cancelResult를 ! ReadableStreamCancel(stream, compositeReason)로 둡니다.

       3. Resolve cancelPromise를 cancelResult로 처리합니다.

    4. cancelPromise를 반환합니다.

21. startAlgorithm을 undefined를 반환하는 알고리즘으로 둡니다.

22. branch1을 ! CreateReadableByteStream(startAlgorithm, pull1Algorithm, cancel1Algorithm)로 설정합니다.

23. branch2을 ! CreateReadableByteStream(startAlgorithm, pull2Algorithm, cancel2Algorithm)로 설정합니다.

24. reader를 인자로 하여 forwardReaderError를 수행합니다.

25. « branch1, branch2 »를 반환합니다.

1. Assert: stream.[[reader]]가 구현하는 ReadableStreamBYOBReader임을 보장합니다.

2. Assert: stream.[[state]]가 "readable" 또는 "closed"임을 보장합니다.

3. Append readRequest를 stream.[[reader]].[[readIntoRequests]]에 추가합니다.

1. Assert: stream.[[reader]]가 구현하는 ReadableStreamDefaultReader임을 보장합니다.

2. Assert: stream.[[state]]가 "readable"임을 보장합니다.

3. Append readRequest를 stream.[[reader]].[[readRequests]]에 추가합니다.

1. stream.[[disturbed]]를 true로 설정합니다.

2. stream.[[state]]가 "closed"라면 promise resolved with undefined를 반환합니다.

3. stream.[[state]]가 "errored"라면 promise rejected with stream.[[storedError]]를 반환합니다.

4. ! ReadableStreamClose(stream)을 수행합니다.

5. reader를 stream.[[reader]]로 둡니다.

6. reader가 undefined가 아니고 reader가 구현하는 ReadableStreamBYOBReader라면,

   1. readIntoRequests를 reader.[[readIntoRequests]]로 둡니다.

   2. reader.[[readIntoRequests]]를 빈 리스트로 설정합니다.

   3. 각 readIntoRequest에 대해, readIntoRequests의 요소,

      1. readIntoRequest의 close steps를 undefined로 실행합니다.

7. sourceCancelPromise를 ! stream.[[controller]].[[CancelSteps]](reason)로 둡니다.

8. reacting을 통해 sourceCancelPromise의 이행 단계에서 undefined를 반환합니다.

1. Assert: stream.[[state]]가 "readable"임을 보장합니다.

2. stream.[[state]]를 "closed"로 설정합니다.

3. reader를 stream.[[reader]]로 둡니다.

4. reader가 undefined라면 반환합니다.

5. Resolve reader.[[closedPromise]]에 undefined를 전달합니다.

6. reader가 구현하는 ReadableStreamDefaultReader라면,

   1. readRequests를 reader.[[readRequests]]로 둡니다.

   2. reader.[[readRequests]]를 빈 리스트로 설정합니다.

   3. 각 readRequest에 대해, readRequests의 요소,

      1. readRequest의 close steps를 실행합니다.

1. Assert: stream.[[state]]가 "readable"임을 보장합니다.

2. stream.[[state]]를 "errored"로 설정합니다.

3. stream.[[storedError]]를 e로 설정합니다.

4. reader를 stream.[[reader]]로 둡니다.

5. reader가 undefined라면 반환합니다.

6. Reject reader.[[closedPromise]]에 e를 전달합니다.

7. reader.[[closedPromise]].[[PromiseIsHandled]]를 true로 설정합니다.

8. reader가 구현하는 ReadableStreamDefaultReader라면,

   1. ! ReadableStreamDefaultReaderErrorReadRequests(reader, e)를 수행합니다.

9. 그 외에는,

   1. Assert: reader가 구현하는 ReadableStreamBYOBReader임을 보장합니다.

   2. ! ReadableStreamBYOBReaderErrorReadIntoRequests(reader, e)를 수행합니다.

1. Assert: ! ReadableStreamHasBYOBReader(stream) 가 true임을 보장합니다.

2. reader를 stream.[[reader]]로 둡니다.

3. Assert: reader.[[readIntoRequests]]가 비어 있지 않음을 보장합니다.

4. readIntoRequest를 reader.[[readIntoRequests]][0]로 둡니다.

5. Remove readIntoRequest를 reader.[[readIntoRequests]]에서 제거합니다.

6. done이 true라면 readIntoRequest의 close steps를 chunk로 실행합니다.

7. 그 외에는 readIntoRequest의 chunk steps를 chunk로 실행합니다.

1. Assert: ! ReadableStreamHasDefaultReader(stream) 가 true임을 보장합니다.

2. reader를 stream.[[reader]]로 둡니다.

3. Assert: reader.[[readRequests]]가 비어 있지 않음을 보장합니다.

4. readRequest를 reader.[[readRequests]][0]로 둡니다.

5. Remove readRequest를 reader.[[readRequests]]에서 제거합니다.

6. done이 true라면 readRequest의 close steps를 실행합니다.

7. 그 외에는 readRequest의 chunk steps를 chunk로 실행합니다.

1. Assert: ! ReadableStreamHasBYOBReader(stream) 가 true임을 보장합니다.

2. stream.[[reader]].[[readIntoRequests]]의 크기를 반환합니다.

1. Assert: ! ReadableStreamHasDefaultReader(stream) 가 true임을 보장합니다.

2. stream.[[reader]].[[readRequests]]의 크기를 반환합니다.

1. reader를 stream.[[reader]]로 둡니다.

2. reader가 undefined라면 false를 반환합니다.

3. reader가 구현하는 ReadableStreamBYOBReader라면 true를 반환합니다.

4. false를 반환합니다.

1. reader를 stream.[[reader]]로 둡니다.

2. reader가 undefined라면 false를 반환합니다.

3. reader가 구현하는 ReadableStreamDefaultReader라면 true를 반환합니다.

4. false를 반환합니다.

1. stream을 reader.[[stream]]로 둡니다.

2. Assert: stream이 undefined가 아님을 보장합니다.

3. ! ReadableStreamCancel(stream, reason)를 반환합니다.

1. reader.[[stream]]을 stream으로 설정합니다.

2. stream.[[reader]]를 reader로 설정합니다.

3. stream.[[state]]가 "readable"이면,

   1. reader.[[closedPromise]]를 새 promise로 설정합니다.

4. 그 외에, stream.[[state]]가 "closed"이면,

   1. reader.[[closedPromise]]를 promise resolved with undefined로 설정합니다.

5. 그 외에는,

   1. Assert: stream.[[state]]가 "errored"임을 보장합니다.

   2. reader.[[closedPromise]]를 promise rejected with stream.[[storedError]]로 설정합니다.

   3. reader.[[closedPromise]].[[PromiseIsHandled]] 를 true로 설정합니다.

1. stream을 reader.[[stream]]로 둡니다.

2. Assert: stream이 undefined가 아님을 보장합니다.

3. Assert: stream.[[reader]]가 reader임을 보장합니다.

4. stream.[[state]]가 "readable"이면, reject reader.[[closedPromise]]에 TypeError 예외를 전달합니다.

5. 그 외에는 reader.[[closedPromise]]를 promise rejected with TypeError 예외로 설정합니다.

6. reader.[[closedPromise]].[[PromiseIsHandled]] 를 true로 설정합니다.

7. ! stream.[[controller]].[[ReleaseSteps]]()를 수행합니다.

8. stream.[[reader]]를 undefined로 설정합니다.

9. reader.[[stream]]를 undefined로 설정합니다.

1. readIntoRequests를 reader.[[readIntoRequests]]로 둡니다.

2. reader.[[readIntoRequests]]를 새 빈 리스트로 설정합니다.

3. 각 readIntoRequest에 대해, readIntoRequests의 요소,

   1. readIntoRequest의 error steps를 e로 실행합니다.

1. stream을 reader.[[stream]]로 둡니다.

2. Assert: stream이 undefined가 아님을 보장합니다.

3. stream.[[disturbed]]를 true로 설정합니다.

4. stream.[[state]]가 "errored"이면, readIntoRequest의 error steps를 stream.[[storedError]]로 실행합니다.

5. 그 외에는 ! ReadableByteStreamControllerPullInto(stream.[[controller]], view, min, readIntoRequest)를 수행합니다.

1. ! ReadableStreamReaderGenericRelease(reader)를 수행합니다.

2. e를 TypeError 예외로 둡니다.

3. ! ReadableStreamBYOBReaderErrorReadIntoRequests(reader, e)를 수행합니다.

1. readRequests를 reader.[[readRequests]]로 둡니다.

2. reader.[[readRequests]]를 새 빈 리스트로 설정합니다.

3. 각 readRequest에 대해, readRequests의 요소,

   1. readRequest의 error steps를 e로 실행합니다.

1. stream을 reader.[[stream]]로 둡니다.

2. Assert: stream이 undefined가 아님을 보장합니다.

3. stream.[[disturbed]]를 true로 설정합니다.

4. stream.[[state]]가 "closed"이면, readRequest의 close steps를 실행합니다.

5. 그 외에, stream.[[state]]가 "errored"이면, readRequest의 error steps를 stream.[[storedError]]로 실행합니다.

6. 그 외에는,

   1. Assert: stream.[[state]]가 "readable"임을 보장합니다.

   2. ! stream.[[controller]].[[PullSteps]](readRequest)를 수행합니다.

1. ! ReadableStreamReaderGenericRelease(reader)를 수행합니다.

2. e를 TypeError 예외로 둡니다.

3. ! ReadableStreamDefaultReaderErrorReadRequests(reader, e)를 수행합니다.

1. ! IsReadableStreamLocked(stream)가 true면, TypeError 예외를 throw합니다.

2. stream.[[controller]]가 구현하는 ReadableByteStreamController가 아니면, TypeError 예외를 throw합니다.

3. ! ReadableStreamReaderGenericInitialize(reader, stream)를 수행합니다.

4. reader.[[readIntoRequests]]를 새 빈 리스트로 설정합니다.

1. ! IsReadableStreamLocked(stream)가 true면, TypeError 예외를 throw합니다.

2. ! ReadableStreamReaderGenericInitialize(reader, stream)를 수행합니다.

3. reader.[[readRequests]]를 새 빈 리스트로 설정합니다.

1. shouldPull을 ! ReadableStreamDefaultControllerShouldCallPull(controller)로 둡니다.

2. shouldPull이 false면, 반환합니다.

3. controller.[[pulling]]이 true라면,

   1. controller.[[pullAgain]]을 true로 설정합니다.

   2. 반환합니다.

4. Assert: controller.[[pullAgain]]이 false임을 보장합니다.

5. controller.[[pulling]]을 true로 설정합니다.

6. pullPromise를 controller.[[pullAlgorithm]]의 실행 결과로 둡니다.

7. pullPromise가 이행될 때,

   1. controller.[[pulling]]을 false로 설정합니다.

   2. controller.[[pullAgain]]이 true라면,

      1. controller.[[pullAgain]]을 false로 설정합니다.

      2. ! ReadableStreamDefaultControllerCallPullIfNeeded(controller)를 수행합니다.

8. pullPromise가 거부될 때, reason e로,

   1. ! ReadableStreamDefaultControllerError(controller, e)를 수행합니다.

1. stream을 controller.[[stream]]로 둡니다.

2. ! ReadableStreamDefaultControllerCanCloseOrEnqueue(controller) 가 false이면 false를 반환합니다.

3. controller.[[started]]가 false이면 false를 반환합니다.

4. ! IsReadableStreamLocked(stream)이 true이고, !ReadableStreamGetNumReadRequests(stream) > 0이면 true를 반환합니다.

5. desiredSize를 ! ReadableStreamDefaultControllerGetDesiredSize(controller)로 둡니다.

6. Assert: desiredSize가 null이 아님을 보장합니다.

7. desiredSize > 0이면 true를 반환합니다.

8. false를 반환합니다.

이것은 약한 참조(weak references)를 통해 관찰할 수 있습니다. 자세한 내용은 tc39/proposal-weakrefs#31를 참고하세요.

다음 단계를 수행합니다:

1. controller.[[pullAlgorithm]]을 undefined로 설정합니다.

2. controller.[[cancelAlgorithm]]을 undefined로 설정합니다.

3. controller.[[strategySizeAlgorithm]] 을 undefined로 설정합니다.

1. ! ReadableStreamDefaultControllerCanCloseOrEnqueue(controller) 가 false이면 반환합니다.

2. stream을 controller.[[stream]]로 둡니다.

3. controller.[[closeRequested]]를 true로 설정합니다.

4. controller.[[queue]]가 비어 있다면,

   1. ! ReadableStreamDefaultControllerClearAlgorithms(controller)를 수행합니다.

   2. ! ReadableStreamClose(stream)를 수행합니다.

1. ! ReadableStreamDefaultControllerCanCloseOrEnqueue(controller) 가 false이면 반환합니다.

2. stream을 controller.[[stream]]로 둡니다.

3. ! IsReadableStreamLocked(stream)이 true이고, !ReadableStreamGetNumReadRequests(stream) > 0이면, !ReadableStreamFulfillReadRequest(stream, chunk, false)를 수행합니다.

4. 그 외에는,

   1. result를 controller.[[strategySizeAlgorithm]]을 chunk에 전달하여 실행한 결과로 둡니다. 결과를 completion record로 해석합니다.

   2. result가 abrupt completion이면,

      1. ! ReadableStreamDefaultControllerError(controller, result.[[Value]])를 수행합니다.

      2. result를 반환합니다.

   3. chunkSize를 result.[[Value]]로 둡니다.

   4. enqueueResult를 EnqueueValueWithSize(controller, chunk, chunkSize)의 실행 결과로 둡니다.

   5. enqueueResult가 abrupt completion이면,

      1. ! ReadableStreamDefaultControllerError(controller, enqueueResult.[[Value]])를 수행합니다.

      2. enqueueResult를 반환합니다.

5. ! ReadableStreamDefaultControllerCallPullIfNeeded(controller)를 수행합니다.

1. stream을 controller.[[stream]]로 둡니다.

2. stream.[[state]]가 "readable"가 아니면 반환합니다.

3. ! ResetQueue(controller)를 수행합니다.

4. ! ReadableStreamDefaultControllerClearAlgorithms(controller)를 수행합니다.

5. ! ReadableStreamError(stream, e)를 수행합니다.

1. state를 controller.[[stream]].[[state]]로 둡니다.

2. state가 "errored"면 null을 반환합니다.

3. state가 "closed"면 0을 반환합니다.

4. controller.[[strategyHWM]] − controller.[[queueTotalSize]]를 반환합니다.

1. ! ReadableStreamDefaultControllerShouldCallPull(controller) 가 true이면 false를 반환합니다.

2. 그 외에는 true를 반환합니다.

1. state를 controller.[[stream]].[[state]]로 둡니다.

2. controller.[[closeRequested]]가 false이고 state가 "readable"이면 true를 반환합니다.

3. 그 외에는 false를 반환합니다.

controller.[[closeRequested]]가 false이지만 state가 "readable"가 아닌 경우는, controller.error()를 통해 스트림에 오류가 발생했거나, 컨트롤러의 controller.close() 메서드가 호출되지 않은 상태에서 스트림이 닫힌 경우(예: stream.cancel() 호출 등)입니다.

1. Assert: stream.[[controller]]가 undefined임을 보장합니다.

2. controller.[[stream]]을 stream으로 설정합니다.

3. ! ResetQueue(controller)를 수행합니다.

4. controller.[[started]], controller.[[closeRequested]], controller.[[pullAgain]], controller.[[pulling]]을 모두 false로 설정합니다.

5. controller.[[strategySizeAlgorithm]] 을 sizeAlgorithm으로, controller.[[strategyHWM]]을 highWaterMark로 설정합니다.

6. controller.[[pullAlgorithm]]을 pullAlgorithm으로 설정합니다.

7. controller.[[cancelAlgorithm]]을 cancelAlgorithm으로 설정합니다.

8. stream.[[controller]]를 controller로 설정합니다.

9. startResult를 startAlgorithm을 실행한 결과로 둡니다. (예외를 발생시킬 수 있음)

10. startPromise를 promise resolved with startResult로 둡니다.

11. startPromise가 이행될 때,

    1. controller.[[started]]를 true로 설정합니다.

    2. Assert: controller.[[pulling]]이 false임을 보장합니다.

    3. Assert: controller.[[pullAgain]]이 false임을 보장합니다.

    4. ! ReadableStreamDefaultControllerCallPullIfNeeded(controller)를 수행합니다.

12. startPromise가 거부될 때, reason r로,

    1. ! ReadableStreamDefaultControllerError(controller, r)를 수행합니다.

1. controller를 new ReadableStreamDefaultController로 둡니다.

2. startAlgorithm을 undefined를 반환하는 알고리즘으로 둡니다.

3. pullAlgorithm을 promise resolved with undefined를 반환하는 알고리즘으로 둡니다.

4. cancelAlgorithm을 promise resolved with undefined를 반환하는 알고리즘으로 둡니다.

5. underlyingSourceDict["start"] exists하면, startAlgorithm을 invoke를 통해 underlyingSourceDict["start"] 에 인자 « controller »와 callback this value underlyingSource를 전달하여 실행 결과를 반환하는 알고리즘으로 설정합니다.

6. underlyingSourceDict["pull"] exists하면, pullAlgorithm을 invoke를 통해 underlyingSourceDict["pull"] 에 인자 « controller »와 callback this value underlyingSource를 전달하여 실행 결과를 반환하는 알고리즘으로 설정합니다.

7. underlyingSourceDict["cancel"] exists하면, cancelAlgorithm을 reason 인자를 받아, invoke를 통해 underlyingSourceDict["cancel"] 에 인자 « reason »와 callback this value underlyingSource를 전달하여 실행 결과를 반환하는 알고리즘으로 설정합니다.

8. ? SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm)를 수행합니다.

1. shouldPull을 ! ReadableByteStreamControllerShouldCallPull(controller)의 값으로 둔다.

2. shouldPull이 false이면, 반환한다.

3. controller.[[pulling]]이 true라면,

   1. controller.[[pullAgain]]을 true로 설정한다.

   2. 반환한다.

4. 단언: controller.[[pullAgain]]이 false이다.

5. controller.[[pulling]]을 true로 설정한다.

6. pullPromise를 controller.[[pullAlgorithm]]을 수행한 결과로 둔다.

7. 이행 시 pullPromise에 대해,

   1. controller.[[pulling]]을 false로 설정한다.

   2. controller.[[pullAgain]]이 true라면,

      1. controller.[[pullAgain]]을 false로 설정한다.

      2. ! ReadableByteStreamControllerCallPullIfNeeded(controller)를 수행한다.

8. 거부 시 pullPromise에 대해, 이유 e와 함께,

   1. ! ReadableByteStreamControllerError(controller, e)를 수행한다.

이는 약한 참조를 통해 관측할 수 있다. 자세한 내용은 tc39/proposal-weakrefs#31를 참고하라.

다음 단계들을 수행한다:

1. controller.[[pullAlgorithm]]을 undefined로 설정한다.

2. controller.[[cancelAlgorithm]]을 undefined로 설정한다.

1. ! ReadableByteStreamControllerInvalidateBYOBRequest(controller)를 수행한다.

2. controller.[[pendingPullIntos]]를 새로운 빈 리스트로 설정한다.

1. stream을 controller.[[stream]]의 값으로 둔다.

2. controller.[[closeRequested]]가 true이거나 stream.[[state]]가 "readable"이 아니라면, 반환한다.

3. controller.[[queueTotalSize]] > 0이라면,

   1. controller.[[closeRequested]]를 true로 설정한다.

   2. 반환한다.

4. controller.[[pendingPullIntos]]가 비어 있지 않다면,

   1. firstPendingPullInto를 controller.[[pendingPullIntos]][0]의 값으로 둔다.

   2. firstPendingPullInto의 bytes filled 값을 firstPendingPullInto의 element size로 나눈 나머지가 0이 아니라면,

      1. e를 새로운 TypeError 예외로 둔다.

      2. ! ReadableByteStreamControllerError(controller, e)를 수행한다.

      3. e를 throw 한다.

5. ! ReadableByteStreamControllerClearAlgorithms(controller)를 수행한다.

6. ! ReadableStreamClose(stream)를 수행한다.

1. 단언: stream.[[state]]가 "errored"가 아니다.

2. 단언: pullIntoDescriptor.reader type이 "none"가 아니다.

3. done을 false로 둔다.

4. stream.[[state]]가 "closed"라면,

   1. 단언: pullIntoDescriptor의 bytes filled 값을 pullIntoDescriptor의 element size로 나눈 나머지가 0이다.

   2. done을 true로 설정한다.

5. filledView를 ! ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor)의 값으로 둔다.

6. pullIntoDescriptor의 reader type이 "default"라면,

   1. ! ReadableStreamFulfillReadRequest(stream, filledView, done)를 수행한다.

7. 그 밖의 경우,

   1. 단언: pullIntoDescriptor의 reader type이 "byob"이다.

   2. ! ReadableStreamFulfillReadIntoRequest(stream, filledView, done)를 수행한다.

1. bytesFilled을 pullIntoDescriptor의 bytes filled 값으로 둔다.

2. elementSize를 pullIntoDescriptor의 element size 값으로 둔다.

3. 단언: bytesFilled ≤ pullIntoDescriptor의 byte length 값이다.

4. 단언: bytesFilled을 elementSize로 나눈 나머지가 0이다.

5. buffer를 ! TransferArrayBuffer(pullIntoDescriptor의 buffer)의 값으로 둔다.

6. ! Construct(pullIntoDescriptor의 view constructor, « buffer, pullIntoDescriptor의 byte offset, bytesFilled ÷ elementSize »)를 반환한다.

1. stream을 controller.[[stream]]의 값으로 둔다.

2. controller.[[closeRequested]]가 true이거나 stream.[[state]]가 "readable"이 아니라면, 반환한다.

3. buffer를 chunk.[[ViewedArrayBuffer]]의 값으로 둔다.

4. byteOffset을 chunk.[[ByteOffset]]의 값으로 둔다.

5. byteLength를 chunk.[[ByteLength]]의 값으로 둔다.

6. ! IsDetachedBuffer(buffer)가 true라면, TypeError 예외를 throw 한다.

7. transferredBuffer를 ? TransferArrayBuffer(buffer)의 값으로 둔다.

8. controller.[[pendingPullIntos]]가 비어있지 않다면,

   1. firstPendingPullInto를 controller.[[pendingPullIntos]][0]의 값으로 둔다.

   2. ! IsDetachedBuffer(firstPendingPullInto의 buffer) 가 true라면 TypeError 예외를 throw 한다.

   3. ! ReadableByteStreamControllerInvalidateBYOBRequest(controller)를 수행한다.

   4. firstPendingPullInto의 buffer를 ! TransferArrayBuffer(firstPendingPullInto의 buffer)로 설정한다.

   5. firstPendingPullInto의 reader type이 "none"이라면, ? ReadableByteStreamControllerEnqueueDetachedPullIntoToQueue(controller, firstPendingPullInto)를 수행한다.

9. ! ReadableStreamHasDefaultReader(stream) 가 true라면,

   1. ! ReadableByteStreamControllerProcessReadRequestsUsingQueue(controller)를 수행한다.

   2. ! ReadableStreamGetNumReadRequests(stream) 가 0이라면,

      1. 단언: controller.[[pendingPullIntos]] 가 비어있다.

      2. ! ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength)를 수행한다.

   3. 그 밖의 경우,

      1. 단언: controller.[[queue]]가 비어있다.

      2. controller.[[pendingPullIntos]] 가 비어있지 않다면,

         1. 단언: controller.[[pendingPullIntos]][0]의 reader type이 "default"이다.

         2. ! ReadableByteStreamControllerShiftPendingPullInto(controller)를 수행한다.

      3. transferredView를 ! Construct(%Uint8Array%, « transferredBuffer, byteOffset, byteLength »)로 둔다.

      4. ! ReadableStreamFulfillReadRequest(stream, transferredView, false)를 수행한다.

10. 그 밖의 경우, ! ReadableStreamHasBYOBReader(stream) 가 true라면,

    1. ! ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength)를 수행한다.

    2. filledPullIntos를 ! ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller)의 결과로 둔다.

    3. 각 filledPullInto를 filledPullIntos에서,

       1. ! ReadableByteStreamControllerCommitPullIntoDescriptor(stream, filledPullInto)를 수행한다.

11. 그 밖의 경우,

    1. 단언: ! IsReadableStreamLocked(stream) 가 false이다.

    2. ! ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength)를 수행한다.

12. ! ReadableByteStreamControllerCallPullIfNeeded(controller)를 수행한다.

1. 새로운 readable byte stream queue entry를 buffer buffer, byte offset byteOffset, 그리고 byte length byteLength와 함께 controller.[[queue]]에 Append한다.

2. controller.[[queueTotalSize]]를 controller.[[queueTotalSize]] + byteLength로 설정한다.

1. cloneResult를 CloneArrayBuffer(buffer, byteOffset, byteLength, %ArrayBuffer%)의 값으로 둔다.

2. cloneResult가 abrupt completion이면,

   1. ! ReadableByteStreamControllerError(controller, cloneResult.[[Value]])를 수행한다.

   2. cloneResult를 반환한다.

3. ! ReadableByteStreamControllerEnqueueChunkToQueue(controller, cloneResult.[[Value]], 0, byteLength)를 수행한다.

1. 단언: pullIntoDescriptor의 reader type이 "none"이다.

2. pullIntoDescriptor의 bytes filled > 0이면, ? ReadableByteStreamControllerEnqueueClonedChunkToQueue(controller, pullIntoDescriptor의 buffer, pullIntoDescriptor의 byte offset, pullIntoDescriptor의 bytes filled)를 수행한다.

3. ! ReadableByteStreamControllerShiftPendingPullInto(controller)를 수행한다.

1. stream을 controller.[[stream]]의 값으로 둔다.

2. stream.[[state]]가 "readable"이 아니면, 반환한다.

3. ! ReadableByteStreamControllerClearPendingPullIntos(controller)를 수행한다.

4. ! ResetQueue(controller)를 수행한다.

5. ! ReadableByteStreamControllerClearAlgorithms(controller)를 수행한다.

6. ! ReadableStreamError(stream, e)를 수행한다.

1. 단언: controller.[[pendingPullIntos]] 가 비어있거나, controller.[[pendingPullIntos]][0] 이 pullIntoDescriptor이다.

2. 단언: controller.[[byobRequest]]가 null이다.

3. pullIntoDescriptor의 bytes filled를 bytes filled + size로 설정한다.

1. maxBytesToCopy를 min(controller.[[queueTotalSize]], pullIntoDescriptor의 byte length − pullIntoDescriptor의 bytes filled)로 둔다.

2. maxBytesFilled를 pullIntoDescriptor의 bytes filled + maxBytesToCopy로 둔다.

3. totalBytesToCopyRemaining을 maxBytesToCopy로 둔다.

4. ready를 false로 둔다.

5. 단언: ! IsDetachedBuffer(pullIntoDescriptor의 buffer)가 false이다.

6. 단언: pullIntoDescriptor의 bytes filled < pullIntoDescriptor의 minimum fill이다.

7. remainderBytes를 maxBytesFilled를 pullIntoDescriptor의 element size로 나눈 나머지로 둔다.

8. maxAlignedBytes를 maxBytesFilled − remainderBytes로 둔다.

9. maxAlignedBytes ≥ pullIntoDescriptor의 minimum fill이라면,

   1. totalBytesToCopyRemaining을 maxAlignedBytes − pullIntoDescriptor의 bytes filled로 설정한다.

   2. ready를 true로 설정한다.

      아직 최소 길이까지 채워지지 않은 read() 요청의 descriptor는 큐의 앞에 남아 있게 되므로 기저 소스가 계속 채울 수 있다.

10. queue를 controller.[[queue]]의 값으로 둔다.

11. 반복하여 totalBytesToCopyRemaining > 0인 동안,

    1. headOfQueue를 queue[0]의 값으로 둔다.

    2. bytesToCopy를 min(totalBytesToCopyRemaining, headOfQueue의 byte length)로 둔다.

    3. destStart를 pullIntoDescriptor의 byte offset + pullIntoDescriptor의 bytes filled로 둔다.

    4. descriptorBuffer를 pullIntoDescriptor의 buffer의 값으로 둔다.

    5. queueBuffer를 headOfQueue의 buffer의 값으로 둔다.

    6. queueByteOffset을 headOfQueue의 byte offset의 값으로 둔다.

    7. 단언: ! CanCopyDataBlockBytes(descriptorBuffer, destStart, queueBuffer, queueByteOffset, bytesToCopy)가 true이다.

       이 단언이 실패하면(이 명세나 구현에 버그가 있을 경우), 다음 단계에서 잠재적으로 잘못된 메모리를 읽거나 쓸 수 있다. 사용자 에이전트는 항상 이 단언을 검사하고, 실패 시 구현 정의 방식으로 중단해야 한다(예: 프로세스를 크래시시키거나, 스트림을 에러로 처리).

    8. ! CopyDataBlockBytes(descriptorBuffer.[[ArrayBufferData]], destStart, queueBuffer.[[ArrayBufferData]], queueByteOffset, bytesToCopy)를 수행한다.

    9. headOfQueue의 byte length가 bytesToCopy와 같다면,

       1. queue[0]을 제거한다.

    10. 그 밖의 경우,

        1. headOfQueue의 byte offset 을 headOfQueue의 byte offset + bytesToCopy로 설정한다.

        2. headOfQueue의 byte length 를 headOfQueue의 byte length − bytesToCopy로 설정한다.

    11. controller.[[queueTotalSize]]를 controller.[[queueTotalSize]] − bytesToCopy로 설정한다.

    12. ! ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesToCopy, pullIntoDescriptor)를 수행한다.

    13. totalBytesToCopyRemaining을 totalBytesToCopyRemaining − bytesToCopy로 설정한다.

12. ready가 false라면,

    1. 단언: controller.[[queueTotalSize]]가 0이다.

    2. 단언: pullIntoDescriptor의 bytes filled > 0이다.

    3. 단언: pullIntoDescriptor의 bytes filled < pullIntoDescriptor의 minimum fill이다.

13. ready를 반환한다.

1. 단언: controller.[[queueTotalSize]] > 0이다.

2. entry를 controller.[[queue]][0]의 값으로 둔다.

3. entry를 제거한다 controller.[[queue]]에서.

4. controller.[[queueTotalSize]]를 controller.[[queueTotalSize]] − entry의 byte length로 설정한다.

5. ! ReadableByteStreamControllerHandleQueueDrain(controller)를 수행한다.

6. view를 ! Construct(%Uint8Array%, « entry의 buffer, entry의 byte offset, entry의 byte length »)로 둔다.

7. readRequest의 chunk steps를 view를 넘겨 수행한다.

1. controller.[[byobRequest]]가 null이고 controller.[[pendingPullIntos]]가 비어있지 않다면,

   1. firstDescriptor를 controller.[[pendingPullIntos]][0]의 값으로 둔다.

   2. view를 ! Construct(%Uint8Array%, « firstDescriptor의 buffer, firstDescriptor의 byte offset + firstDescriptor의 bytes filled, firstDescriptor의 byte length − firstDescriptor의 bytes filled »)로 둔다.

   3. byobRequest를 new ReadableStreamBYOBRequest로 둔다.

   4. byobRequest.[[controller]]를 controller로 설정한다.

   5. byobRequest.[[view]]를 view로 설정한다.

   6. controller.[[byobRequest]]를 byobRequest로 설정한다.

2. controller.[[byobRequest]]를 반환한다.

1. state를 controller.[[stream]].[[state]]의 값으로 둔다.

2. state가 "errored"이면, null을 반환한다.

3. state가 "closed"이면, 0을 반환한다.

4. controller.[[strategyHWM]] − controller.[[queueTotalSize]] 값을 반환한다.

1. 단언: controller.[[stream]].[[state]]가 "readable"이다.

2. controller.[[queueTotalSize]]가 0이고 controller.[[closeRequested]]가 true라면,

   1. ! ReadableByteStreamControllerClearAlgorithms(controller)를 수행한다.

   2. ! ReadableStreamClose(controller.[[stream]])를 수행한다.

3. 그 밖의 경우,

   1. ! ReadableByteStreamControllerCallPullIfNeeded(controller)를 수행한다.

1. controller.[[byobRequest]]가 null이면, 반환한다.

2. controller.[[byobRequest]].[[controller]] 를 undefined로 설정한다.

3. controller.[[byobRequest]].[[view]] 를 null로 설정한다.

4. controller.[[byobRequest]]를 null로 설정한다.

1. 단언: controller.[[closeRequested]]가 false이다.

2. filledPullIntos를 새로운 빈 리스트로 둔다.

3. 반복하여 controller.[[pendingPullIntos]]가 비어있지 않다면,

   1. controller.[[queueTotalSize]]가 0이면, break한다.

   2. pullIntoDescriptor를 controller.[[pendingPullIntos]][0]의 값으로 둔다.

   3. ! ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor)가 true라면,

      1. ! ReadableByteStreamControllerShiftPendingPullInto(controller)를 수행한다.

      2. pullIntoDescriptor를 filledPullIntos에 추가한다.

4. filledPullIntos를 반환한다.

1. reader를 controller.[[stream]].[[reader]]의 값으로 둔다.

2. 단언: reader가 구현 ReadableStreamDefaultReader를 한다.

3. reader.[[readRequests]]가 비어있지 않은 동안,

   1. controller.[[queueTotalSize]]가 0이면, 반환한다.

   2. readRequest를 reader.[[readRequests]][0]의 값으로 둔다.

   3. readRequest를 제거한다 reader.[[readRequests]]에서.

   4. ! ReadableByteStreamControllerFillReadRequestFromQueue(controller, readRequest)를 수행한다.

1. stream을 controller.[[stream]]의 값으로 둔다.

2. elementSize를 1로 둔다.

3. ctor를 %DataView%로 둔다.

4. view가 [[TypedArrayName]] 내부 슬롯을 가지고 있다면(즉, DataView가 아니라면),

   1. elementSize를 typed array 생성자 표에서 view.[[TypedArrayName]]에 대해 지정된 element size로 설정한다.

   2. ctor를 typed array 생성자 표에서 view.[[TypedArrayName]]에 대해 지정된 생성자로 설정한다.

5. minimumFill을 min × elementSize로 둔다.

6. 단언: minimumFill ≥ 0 이고 minimumFill ≤ view.[[ByteLength]]이다.

7. 단언: minimumFill을 elementSize로 나눈 나머지가 0이다.

8. byteOffset을 view.[[ByteOffset]]로 둔다.

9. byteLength를 view.[[ByteLength]]로 둔다.

10. bufferResult를 TransferArrayBuffer(view.[[ViewedArrayBuffer]])의 결과로 둔다.

11. bufferResult가 abrupt completion이면,

    1. readIntoRequest의 error steps를 bufferResult.[[Value]]를 넘겨 수행한다.

    2. 반환한다.

12. buffer를 bufferResult.[[Value]]로 둔다.

13. pullIntoDescriptor를 새로운 pull-into descriptor로 만드는데

    buffer

    buffer

    buffer byte length

    buffer.[[ArrayBufferByteLength]]

    byte offset

    byteOffset

    byte length

    byteLength

    bytes filled

    0

    minimum fill

    minimumFill

    element size

    elementSize

    view constructor

    ctor

    reader type

    "byob"

14. controller.[[pendingPullIntos]]가 비어있지 않다면,

    1. 추가한다 pullIntoDescriptor를 controller.[[pendingPullIntos]]에.

    2. ! ReadableStreamAddReadIntoRequest(stream, readIntoRequest)를 수행한다.

    3. 반환한다.

15. stream.[[state]]가 "closed"라면,

    1. emptyView를 ! Construct(ctor, « pullIntoDescriptor의 buffer, pullIntoDescriptor의 byte offset, 0 »)로 둔다.

    2. readIntoRequest의 close steps를 emptyView를 넘겨 수행한다.

    3. 반환한다.

16. controller.[[queueTotalSize]] > 0이라면,

    1. ! ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor)가 true라면,

       1. filledView를 ! ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor)의 값으로 둔다.

       2. ! ReadableByteStreamControllerHandleQueueDrain(controller)를 수행한다.

       3. readIntoRequest의 chunk steps를 filledView를 넘겨 수행한다.

       4. 반환한다.

    2. controller.[[closeRequested]]가 true라면,

       1. e를 TypeError 예외로 둔다.

       2. ! ReadableByteStreamControllerError(controller, e)를 수행한다.

       3. readIntoRequest의 error steps를 e를 넘겨 수행한다.

       4. 반환한다.

17. 추가한다 pullIntoDescriptor를 controller.[[pendingPullIntos]]에.

18. ! ReadableStreamAddReadIntoRequest(stream, readIntoRequest)를 수행한다.

19. ! ReadableByteStreamControllerCallPullIfNeeded(controller)를 수행한다.