validateInteger,

validateObject,

validateOneOf,

validateString,

kValidateObjectAllowNullable,

} = require('internal/validators');

const pathModule = require('path');

/**

* @typedef {import('../webstreams/readablestream').ReadableStream

* } ReadableStream

* @param {{ type?: 'bytes', autoClose?: boolean }} [options]

* @returns {ReadableStream}

*/

readableWebStream(options = { __proto__: null, type: 'bytes' }) {

readableWebStream(options = kEmptyObject) {

if (this[kFd] === -1)

throw new ERR_INVALID_STATE('The FileHandle is closed');

if (this[kClosePromise])

throw new ERR_INVALID_STATE('The FileHandle is locked');

this[kLocked] = true;

if (options.type !== undefined) {

validateString(options.type, 'options.type');

}

if (options.type !== 'bytes') {

validateObject(options, 'options');

const {

type = 'bytes',

autoClose = false,

} = options;

validateBoolean(autoClose, 'options.autoClose');

if (type !== 'bytes') {

process.emitWarning(

'A non-"bytes" options.type has no effect. A byte-oriented steam is ' +

'always created.',

'ExperimentalWarning',

);

}

const readFn = FunctionPrototypeBind(this.read, this);

const ondone = FunctionPrototypeBind(this[kUnref], this);

const ondone = async () => {

this[kUnref]();

if (autoClose) await this.close();

};

const ReadableStream = lazyReadableStream();

const readable = new ReadableStream({

const { bytesRead } = await readFn(view, view.byteOffset, view.byteLength);

if (bytesRead === 0) {

ondone();

controller.close();

await ondone();

}

controller.byobRequest.respond(bytesRead);

},

cancel() {

ondone();

async cancel() {

await ondone();

},

});