'use strict';

const {

ArrayBuffer,

ArrayBufferPrototypeGetByteLength,

ArrayBufferPrototypeGetDetached,

ArrayBufferPrototypeSlice,

ArrayBufferPrototypeTransfer,

ArrayPrototypePush,

ArrayPrototypeShift,

DataView,

FunctionPrototypeBind,

FunctionPrototypeCall,

MathMin,

NumberIsInteger,

ObjectDefineProperties,

ObjectSetPrototypeOf,

Promise,

PromisePrototypeThen,

PromiseReject,

PromiseResolve,

PromiseWithResolvers,

SafePromiseAll,

Symbol,

SymbolAsyncIterator,

SymbolDispose,

SymbolIterator,

SymbolToStringTag,

TypedArrayPrototypeGetLength,

Uint8Array,

} = primordials;

const {

AbortError,

codes: {

ERR_ARG_NOT_ITERABLE,

ERR_ILLEGAL_CONSTRUCTOR,

ERR_INVALID_ARG_TYPE,

ERR_INVALID_ARG_VALUE,

ERR_INVALID_STATE,

ERR_INVALID_THIS,

ERR_OUT_OF_RANGE,

},

} = require('internal/errors');

const {

DOMException,

} = internalBinding('messaging');

const {

isArrayBufferView,

isDataView,

isSharedArrayBuffer,

} = require('internal/util/types');

const {

customInspectSymbol: kInspect,

kEmptyObject,

kEnumerableProperty,

SideEffectFreeRegExpPrototypeSymbolReplace,

} = require('internal/util');

const {

validateAbortSignal,

validateBuffer,

validateObject,

kValidateObjectAllowObjects,

kValidateObjectAllowObjectsAndNull,

} = require('internal/validators');

const {

MessageChannel,

} = require('internal/worker/io');

const {

kDeserialize,

kTransfer,

kTransferList,

markTransferMode,

structuredClone,

} = require('internal/worker/js_transferable');

const {

queueMicrotask,

} = require('internal/process/task_queues');

const {

kIsDisturbed,

kIsErrored,

kIsReadable,

kIsClosedPromise,

kControllerErrorFunction,

} = require('internal/streams/utils');

const {

ArrayBufferViewGetBuffer,

ArrayBufferViewGetByteLength,

ArrayBufferViewGetByteOffset,

AsyncIterator,

canCopyArrayBuffer,

cloneAsUint8Array,

copyArrayBuffer,

createPromiseCallback,

customInspect,

dequeueValue,

enqueueValueWithSize,

extractHighWaterMark,

extractSizeAlgorithm,

lazyTransfer,

isBrandCheck,

resetQueue,

setPromiseHandled,

nonOpCancel,

nonOpPull,

nonOpStart,

kType,

kState,

} = require('internal/webstreams/util');

const {

WritableStreamDefaultWriter,

isWritableStream,

isWritableStreamLocked,

isWritableStreamDefaultController,

isWritableStreamDefaultWriter,

writableStreamAbort,

writableStreamCloseQueuedOrInFlight,

writableStreamDefaultWriterCloseWithErrorPropagation,

writableStreamDefaultWriterRelease,

writableStreamDefaultWriterWrite,

} = require('internal/webstreams/writablestream');

const { Buffer } = require('buffer');

const assert = require('internal/assert');

const kCancel = Symbol('kCancel');

const kClose = Symbol('kClose');

const kChunk = Symbol('kChunk');

const kError = Symbol('kError');

const kPull = Symbol('kPull');

const kRelease = Symbol('kRelease');

const kSkipThrow = Symbol('kSkipThrow');

let releasedError;

let releasingError;

let addAbortListener;

const userModuleRegExp = /^ {4}at (?:[^/\\(]+ \()(?!node:(.+):\d+:\d+\)$).*/gm;

function lazyReadableReleasedError() {

if (releasedError) {

return releasedError;

}

releasedError = new ERR_INVALID_STATE.TypeError('Reader released');

// Avoid V8 leak and remove userland stackstrace

releasedError.stack = SideEffectFreeRegExpPrototypeSymbolReplace(userModuleRegExp, releasedError.stack, '');

return releasedError;

}

function lazyReadableReleasingError() {

if (releasingError) {

return releasingError;

}

releasingError = new ERR_INVALID_STATE.TypeError('Releasing reader');

// Avoid V8 leak and remove userland stackstrace

releasingError.stack = SideEffectFreeRegExpPrototypeSymbolReplace(userModuleRegExp, releasingError.stack, '');

return releasingError;

}

const getNonWritablePropertyDescriptor = (value) => {

return {

__proto__: null,

configurable: true,

value,

};

};

/**

* @typedef {import('../abort_controller').AbortSignal} AbortSignal

* @typedef {import('./queuingstrategies').QueuingStrategy} QueuingStrategy

* @typedef {import('./queuingstrategies').QueuingStrategySize

* } QueuingStrategySize

* @typedef {import('./writablestream').WritableStream} WritableStream

*/

/**

* @typedef {ReadableStreamDefaultController | ReadableByteStreamController

* } ReadableStreamController

*/

/**

* @typedef {ReadableStreamDefaultReader | ReadableStreamBYOBReader

* } ReadableStreamReader

*/

/**

* @callback UnderlyingSourceStartCallback

* @param {ReadableStreamController} controller

* @returns { any | Promise<void> }

*/

/**

* @callback UnderlyingSourcePullCallback

* @param {ReadableStreamController} controller

* @returns { Promise<void> }

*/

/**

* @callback UnderlyingSourceCancelCallback

* @param {any} reason

* @returns { Promise<void> }

*/

/**

* @typedef {{

* readable: ReadableStream,

* writable: WritableStream,

* }} ReadableWritablePair

*/

/**

* @typedef {{

* preventClose? : boolean,

* preventAbort? : boolean,

* preventCancel? : boolean,

* signal? : AbortSignal,

* }} StreamPipeOptions

*/

/**

* @typedef {{

* start? : UnderlyingSourceStartCallback,

* pull? : UnderlyingSourcePullCallback,

* cancel? : UnderlyingSourceCancelCallback,

* type? : "bytes",

* autoAllocateChunkSize? : number

* }} UnderlyingSource

*/

class ReadableStream {

[kType] = 'ReadableStream';

/**

* @param {UnderlyingSource} [source]

* @param {QueuingStrategy} [strategy]

*/

constructor(source = kEmptyObject, strategy = kEmptyObject) {

markTransferMode(this, false, true);

validateObject(source, 'source', kValidateObjectAllowObjects);

validateObject(strategy, 'strategy', kValidateObjectAllowObjectsAndNull);

this[kState] = createReadableStreamState();

this[kIsClosedPromise] = PromiseWithResolvers();

this[kControllerErrorFunction] = () => {};

// The spec requires handling of the strategy first

// here. Specifically, if getting the size and

// highWaterMark from the strategy fail, that has

// to trigger a throw before getting the details

// from the source. So be sure to keep these in

// this order.

const size = strategy?.size;

const highWaterMark = strategy?.highWaterMark;

const type = source.type;

if (`${type}` === 'bytes') {

if (size !== undefined)

throw new ERR_INVALID_ARG_VALUE.RangeError('strategy.size', size);

setupReadableByteStreamControllerFromSource(

this,

source,

extractHighWaterMark(highWaterMark, 0));

} else {

if (type !== undefined)

throw new ERR_INVALID_ARG_VALUE('source.type', type);

setupReadableStreamDefaultControllerFromSource(

this,

source,

extractHighWaterMark(highWaterMark, 1),

extractSizeAlgorithm(size));

}

}

get [kIsDisturbed]() {

return this[kState].disturbed;

}

get [kIsErrored]() {

return this[kState].state === 'errored';

}

get [kIsReadable]() {

return this[kState].state === 'readable';

}

/**

* @readonly

* @type {boolean}

*/

get locked() {

if (!isReadableStream(this))

throw new ERR_INVALID_THIS('ReadableStream');

return isReadableStreamLocked(this);

}

static from(iterable) {

return readableStreamFromIterable(iterable);

}

/**

* @param {any} [reason]

* @returns { Promise<void> }

*/

cancel(reason = undefined) {

if (!isReadableStream(this))

return PromiseReject(new ERR_INVALID_THIS('ReadableStream'));

if (isReadableStreamLocked(this)) {

return PromiseReject(

new ERR_INVALID_STATE.TypeError('ReadableStream is locked'));

}

return readableStreamCancel(this, reason);

}

/**

* @param {{

* mode? : "byob"

* }} [options]

* @returns {ReadableStreamReader}

*/

getReader(options = kEmptyObject) {

if (!isReadableStream(this))

throw new ERR_INVALID_THIS('ReadableStream');

validateObject(options, 'options', kValidateObjectAllowObjectsAndNull);

const mode = options?.mode;

if (mode === undefined)

// eslint-disable-next-line no-use-before-define

return new ReadableStreamDefaultReader(this);

if (`${mode}` !== 'byob')

throw new ERR_INVALID_ARG_VALUE('options.mode', mode);

// eslint-disable-next-line no-use-before-define

return new ReadableStreamBYOBReader(this);

}

/**

* @param {ReadableWritablePair} transform

* @param {StreamPipeOptions} [options]

* @returns {ReadableStream}

*/

pipeThrough(transform, options = kEmptyObject) {

if (!isReadableStream(this))

throw new ERR_INVALID_THIS('ReadableStream');

const readable = transform?.readable;

if (!isReadableStream(readable)) {

throw new ERR_INVALID_ARG_TYPE(

'transform.readable',

'ReadableStream',

readable);

}

const writable = transform?.writable;

if (!isWritableStream(writable)) {

throw new ERR_INVALID_ARG_TYPE(

'transform.writable',

'WritableStream',

writable);

}

// The web platform tests require that these be handled one at a

// time and in a specific order. options can be null or undefined.

validateObject(options, 'options', kValidateObjectAllowObjectsAndNull);

const preventAbort = options?.preventAbort;

const preventCancel = options?.preventCancel;

const preventClose = options?.preventClose;

const signal = options?.signal;

if (signal !== undefined) {

validateAbortSignal(signal, 'options.signal');

}

if (isReadableStreamLocked(this))

throw new ERR_INVALID_STATE.TypeError('The ReadableStream is locked');

if (isWritableStreamLocked(writable))

throw new ERR_INVALID_STATE.TypeError('The WritableStream is locked');

const promise = readableStreamPipeTo(

this,

writable,

!!preventClose,

!!preventAbort,

!!preventCancel,

signal);

setPromiseHandled(promise);

return readable;

}

/**

* @param {WritableStream} destination

* @param {StreamPipeOptions} [options]

* @returns {Promise<void>}

*/

pipeTo(destination, options = kEmptyObject) {

try {

if (!isReadableStream(this))

throw new ERR_INVALID_THIS('ReadableStream');

if (!isWritableStream(destination)) {

throw new ERR_INVALID_ARG_TYPE(

'transform.writable',

'WritableStream',

destination);

}

validateObject(options, 'options', kValidateObjectAllowObjectsAndNull);

const preventAbort = options?.preventAbort;

const preventCancel = options?.preventCancel;

const preventClose = options?.preventClose;

const signal = options?.signal;

if (signal !== undefined) {

validateAbortSignal(signal, 'options.signal');

}

if (isReadableStreamLocked(this))

throw new ERR_INVALID_STATE.TypeError('The ReadableStream is locked');

if (isWritableStreamLocked(destination))

throw new ERR_INVALID_STATE.TypeError('The WritableStream is locked');

return readableStreamPipeTo(

this,

destination,

!!preventClose,

!!preventAbort,

!!preventCancel,

signal);

} catch (error) {

return PromiseReject(error);

}

}

/**

* @returns {ReadableStream[]}

*/

tee() {

if (!isReadableStream(this))

throw new ERR_INVALID_THIS('ReadableStream');

return readableStreamTee(this, false);

}

/**

* @param {{

* preventCancel? : boolean,

* }} [options]

* @returns {AsyncIterable}

*/

values(options = kEmptyObject) {

if (!isReadableStream(this))

throw new ERR_INVALID_THIS('ReadableStream');

validateObject(options, 'options', kValidateObjectAllowObjectsAndNull);

const preventCancel = !!(options?.preventCancel);

// eslint-disable-next-line no-use-before-define

const reader = new ReadableStreamDefaultReader(this);

// No __proto__ here to avoid the performance hit.

const state = {

done: false,

current: undefined,

};

let started = false;

// The nextSteps function is not an async function in order

// to make it more efficient. Because nextSteps explicitly

// creates a Promise and returns it in the common case,

// making it an async function just causes two additional

// unnecessary Promise allocations to occur, which just add

// cost.

function nextSteps() {

if (state.done)

return PromiseResolve({ done: true, value: undefined });

if (reader[kState].stream === undefined) {

return PromiseReject(

new ERR_INVALID_STATE.TypeError(

'The reader is not bound to a ReadableStream'));

}

const promise = PromiseWithResolvers();

// eslint-disable-next-line no-use-before-define

readableStreamDefaultReaderRead(reader, new ReadableStreamAsyncIteratorReadRequest(reader, state, promise));

return promise.promise;

}

async function returnSteps(value) {

if (state.done)

return { done: true, value }; // eslint-disable-line node-core/avoid-prototype-pollution

state.done = true;

if (reader[kState].stream === undefined) {

throw new ERR_INVALID_STATE.TypeError(

'The reader is not bound to a ReadableStream');

}

assert(!reader[kState].readRequests.length);

if (!preventCancel) {

const result = readableStreamReaderGenericCancel(reader, value);

readableStreamReaderGenericRelease(reader);

await result;

return { done: true, value }; // eslint-disable-line node-core/avoid-prototype-pollution

}

readableStreamReaderGenericRelease(reader);

return { done: true, value }; // eslint-disable-line node-core/avoid-prototype-pollution

}

// TODO(@jasnell): Explore whether an async generator

// can be used here instead of a custom iterator object.

return ObjectSetPrototypeOf({

// Changing either of these functions (next or return)

// to async functions causes a failure in the streams

// Web Platform Tests that check for use of a modified

// Promise.prototype.then. Since the await keyword

// uses Promise.prototype.then, it is open to prototype

// pollution, which causes the test to fail. The other

// await uses here do not trigger that failure because

// the test that fails does not trigger those code paths.

next() {

// If this is the first read, delay by one microtask

// to ensure that the controller has had an opportunity

// to properly start and perform the initial pull.

// TODO(@jasnell): The spec doesn't call this out so

// need to investigate if it's a bug in our impl or

// the spec.

if (!started) {

state.current = PromiseResolve();

started = true;

}

state.current = state.current !== undefined ?

PromisePrototypeThen(state.current, nextSteps, nextSteps) :

nextSteps();

return state.current;

},

return(error) {

started = true;

state.current = state.current !== undefined ?

PromisePrototypeThen(

state.current,

() => returnSteps(error),

() => returnSteps(error)) :

returnSteps(error);

return state.current;

},

[SymbolAsyncIterator]() { return this; },

}, AsyncIterator);

}

[kInspect](depth, options) {

return customInspect(depth, options, this[kType], {

locked: this.locked,

state: this[kState].state,

supportsBYOB:

// eslint-disable-next-line no-use-before-define

this[kState].controller instanceof ReadableByteStreamController,

});

}

[kTransfer]() {

if (!isReadableStream(this))

throw new ERR_INVALID_THIS('ReadableStream');

if (this.locked) {

this[kState].transfer.port1?.close();

this[kState].transfer.port1 = undefined;

this[kState].transfer.port2 = undefined;

throw new DOMException(

'Cannot transfer a locked ReadableStream',

'DataCloneError');

}

const {

writable,

promise,

} = lazyTransfer().newCrossRealmWritableSink(

this,

this[kState].transfer.port1);

this[kState].transfer.writable = writable;

this[kState].transfer.promise = promise;

return {

data: { port: this[kState].transfer.port2 },

deserializeInfo:

'internal/webstreams/readablestream:TransferredReadableStream',

};

}

[kTransferList]() {

const { port1, port2 } = new MessageChannel();

this[kState].transfer.port1 = port1;

this[kState].transfer.port2 = port2;

return [ port2 ];

}

[kDeserialize]({ port }) {

const transfer = lazyTransfer();

setupReadableStreamDefaultControllerFromSource(

this,

// The MessagePort is set to be referenced when reading.

// After two MessagePorts are closed, there is a problem with

// lingering promise not being properly resolved.

// https://github.com/nodejs/node/issues/51486

new transfer.CrossRealmTransformReadableSource(port, true),

0, () => 1);

}

}

ObjectDefineProperties(ReadableStream.prototype, {

[SymbolAsyncIterator]: {

__proto__: null,

configurable: true,

enumerable: false,

writable: true,

value: ReadableStream.prototype.values,

},

locked: kEnumerableProperty,

cancel: kEnumerableProperty,

getReader: kEnumerableProperty,

pipeThrough: kEnumerableProperty,

pipeTo: kEnumerableProperty,

tee: kEnumerableProperty,

values: kEnumerableProperty,

[SymbolToStringTag]: getNonWritablePropertyDescriptor(ReadableStream.name),

});

ObjectDefineProperties(ReadableStream, {

from: kEnumerableProperty,

});

function InternalTransferredReadableStream() {

ObjectSetPrototypeOf(this, ReadableStream.prototype);

markTransferMode(this, false, true);

this[kType] = 'ReadableStream';

this[kState] = createReadableStreamState();

this[kIsClosedPromise] = PromiseWithResolvers();

}

ObjectSetPrototypeOf(InternalTransferredReadableStream.prototype, ReadableStream.prototype);

ObjectSetPrototypeOf(InternalTransferredReadableStream, ReadableStream);

function TransferredReadableStream() {

const stream = new InternalTransferredReadableStream();

stream.constructor = ReadableStream;

return stream;

}

TransferredReadableStream.prototype[kDeserialize] = () => {};

class ReadableStreamBYOBRequest {

[kType] = 'ReadableStreamBYOBRequest';

constructor(skipThrowSymbol = undefined) {

if (skipThrowSymbol !== kSkipThrow) {

throw new ERR_ILLEGAL_CONSTRUCTOR();

}

}

/**

* @readonly

* @type {ArrayBufferView}

*/

get view() {

if (!isReadableStreamBYOBRequest(this))

throw new ERR_INVALID_THIS('ReadableStreamBYOBRequest');

return this[kState].view;

}

/**

* @param {number} bytesWritten

*/

respond(bytesWritten) {

if (!isReadableStreamBYOBRequest(this))

throw new ERR_INVALID_THIS('ReadableStreamBYOBRequest');

const {

view,

controller,

} = this[kState];

if (controller === undefined) {

throw new ERR_INVALID_STATE.TypeError(

'This BYOB request has been invalidated');

}

const viewByteLength = ArrayBufferViewGetByteLength(view);

const viewBuffer = ArrayBufferViewGetBuffer(view);

const viewBufferByteLength = ArrayBufferPrototypeGetByteLength(viewBuffer);

if (ArrayBufferPrototypeGetDetached(viewBuffer)) {

throw new ERR_INVALID_STATE.TypeError('Viewed ArrayBuffer is detached');

}

assert(viewByteLength > 0);

assert(viewBufferByteLength > 0);

readableByteStreamControllerRespond(controller, bytesWritten);

}

/**

* @param {ArrayBufferView} view

*/

respondWithNewView(view) {

if (!isReadableStreamBYOBRequest(this))

throw new ERR_INVALID_THIS('ReadableStreamBYOBRequest');

const {

controller,

} = this[kState];

if (controller === undefined) {

throw new ERR_INVALID_STATE.TypeError(

'This BYOB request has been invalidated');

}

validateBuffer(view, 'view');

if (ArrayBufferPrototypeGetDetached(view.buffer)) {

throw new ERR_INVALID_STATE.TypeError('Viewed ArrayBuffer is detached');

}

readableByteStreamControllerRespondWithNewView(controller, view);

}

[kInspect](depth, options) {

return customInspect(depth, options, this[kType], {

view: this.view,

controller: this[kState].controller,

});

}

}

ObjectDefineProperties(ReadableStreamBYOBRequest.prototype, {

view: kEnumerableProperty,

respond: kEnumerableProperty,

respondWithNewView: kEnumerableProperty,

[SymbolToStringTag]: getNonWritablePropertyDescriptor(ReadableStreamBYOBRequest.name),

});

function createReadableStreamBYOBRequest(controller, view) {

const stream = new ReadableStreamBYOBRequest(kSkipThrow);

stream[kState] = {

controller,

view,

};

return stream;

}

class ReadableStreamAsyncIteratorReadRequest {

constructor(reader, state, promise) {

this.reader = reader;

this.state = state;

this.promise = promise;

}

[kChunk](chunk) {

this.state.current = undefined;

this.promise.resolve({ value: chunk, done: false });

}

[kClose]() {

this.state.current = undefined;

this.state.done = true;

readableStreamReaderGenericRelease(this.reader);

this.promise.resolve({ done: true, value: undefined });

}

[kError](error) {

this.state.current = undefined;

this.state.done = true;

readableStreamReaderGenericRelease(this.reader);

this.promise.reject(error);

}

}

class DefaultReadRequest {

constructor() {

this[kState] = PromiseWithResolvers();

}

[kChunk](value) {

this[kState].resolve?.({ value, done: false });

}

[kClose]() {

this[kState].resolve?.({ value: undefined, done: true });

}

[kError](error) {

this[kState].reject?.(error);

}

get promise() { return this[kState].promise; }

}

class ReadIntoRequest {

constructor() {

this[kState] = PromiseWithResolvers();

}

[kChunk](value) {

this[kState].resolve?.({ value, done: false });

}

[kClose](value) {

this[kState].resolve?.({ value, done: true });

}

[kError](error) {

this[kState].reject?.(error);

}

get promise() { return this[kState].promise; }

}

class ReadableStreamDefaultReader {

[kType] = 'ReadableStreamDefaultReader';

/**

* @param {ReadableStream} stream

*/

constructor(stream) {

if (!isReadableStream(stream))

throw new ERR_INVALID_ARG_TYPE('stream', 'ReadableStream', stream);

this[kState] = {

readRequests: [],

stream: undefined,

close: {

promise: undefined,

resolve: undefined,

reject: undefined,

},

};

setupReadableStreamDefaultReader(this, stream);

}

/**

* @returns {Promise<{

* value : any,

* done : boolean

* }>}

*/

read() {

if (!isReadableStreamDefaultReader(this))

return PromiseReject(new ERR_INVALID_THIS('ReadableStreamDefaultReader'));

if (this[kState].stream === undefined) {

return PromiseReject(

new ERR_INVALID_STATE.TypeError(

'The reader is not attached to a stream'));

}

const stream = this[kState].stream;

const controller = stream[kState].controller;

// Fast path: if data is already buffered in a default controller,

// return a resolved promise immediately without creating a read request.

// This is spec-compliant because read() returns a Promise, and

// Promise.resolve() callbacks still run in the microtask queue.

if (stream[kState].state === 'readable' &&

isReadableStreamDefaultController(controller) &&

controller[kState].queue.length > 0) {

stream[kState].disturbed = true;

const chunk = dequeueValue(controller);

if (controller[kState].closeRequested && !controller[kState].queue.length) {

readableStreamDefaultControllerClearAlgorithms(controller);

readableStreamClose(stream);

} else {

readableStreamDefaultControllerCallPullIfNeeded(controller);

}

return PromiseResolve({ value: chunk, done: false });

}

// Slow path: create request and go through normal flow

const readRequest = new DefaultReadRequest();

readableStreamDefaultReaderRead(this, readRequest);

return readRequest.promise;

}

releaseLock() {

if (!isReadableStreamDefaultReader(this))

throw new ERR_INVALID_THIS('ReadableStreamDefaultReader');

if (this[kState].stream === undefined)

return;

readableStreamDefaultReaderRelease(this);

}

/**

* @readonly

* @type {Promise<void>}

*/

get closed() {

if (!isReadableStreamDefaultReader(this))

return PromiseReject(new ERR_INVALID_THIS('ReadableStreamDefaultReader'));

return this[kState].close.promise;

}

/**

* @param {any} [reason]

* @returns {Promise<void>}

*/

cancel(reason = undefined) {

if (!isReadableStreamDefaultReader(this))

return PromiseReject(new ERR_INVALID_THIS('ReadableStreamDefaultReader'));

if (this[kState].stream === undefined) {

return PromiseReject(new ERR_INVALID_STATE.TypeError(

'The reader is not attached to a stream'));

}

return readableStreamReaderGenericCancel(this, reason);

}

[kInspect](depth, options) {

return customInspect(depth, options, this[kType], {

stream: this[kState].stream,

readRequests: this[kState].readRequests.length,

close: this[kState].close.promise,

});

}

}

ObjectDefineProperties(ReadableStreamDefaultReader.prototype, {

closed: kEnumerableProperty,

read: kEnumerableProperty,

releaseLock: kEnumerableProperty,

cancel: kEnumerableProperty,

[SymbolToStringTag]: getNonWritablePropertyDescriptor(ReadableStreamDefaultReader.name),

});

class ReadableStreamBYOBReader {

[kType] = 'ReadableStreamBYOBReader';

/**

* @param {ReadableStream} stream

*/

constructor(stream) {

if (!isReadableStream(stream))

throw new ERR_INVALID_ARG_TYPE('stream', 'ReadableStream', stream);

this[kState] = {

stream: undefined,

readIntoRequests: [],

close: {

promise: undefined,

resolve: undefined,

reject: undefined,

},

};

setupReadableStreamBYOBReader(this, stream);

}

/**

* @param {ArrayBufferView} view

* @param {{

* min? : number

* }} [options]

* @returns {Promise<{

* value : ArrayBufferView,

* done : boolean,

* }>}

*/

async read(view, options = kEmptyObject) {

if (!isReadableStreamBYOBReader(this))

throw new ERR_INVALID_THIS('ReadableStreamBYOBReader');

if (!isArrayBufferView(view)) {

throw new ERR_INVALID_ARG_TYPE(

'view',

[

'Buffer',

'TypedArray',

'DataView',

],

view,

);

}

validateObject(options, 'options', kValidateObjectAllowObjectsAndNull);

const viewByteLength = ArrayBufferViewGetByteLength(view);

const viewBuffer = ArrayBufferViewGetBuffer(view);

if (isSharedArrayBuffer(viewBuffer)) {

throw new ERR_INVALID_ARG_VALUE(

'view',

view,

'must not be backed by a SharedArrayBuffer',

);

}