### Hierarchy

- Duplex
  - BufferBuilder

### Implements

- ReadWriteStream
- ReadableStream
- WritableStream

## Index

### Constructors

- constructor

### Properties

- allowHalfOpen
- chunks
- closed
- destroyed
- errored
- readable
- readableAborted
- readableDidRead
- readableEncoding
- readableEnded
- readableFlowing
- readableHighWaterMark
- readableLength
- readableObjectMode
- writable
- writableAborted
- writableCorked
- writableEnded
- writableFinished
- writableHighWaterMark
- writableLength
- writableNeedDrain
- writableObjectMode

### Methods

- [Symbol.asyncDispose]
- [Symbol.asyncIterator]
- _construct
- _destroy
- _final
- _read
- _write
- _writev
- addListener
- compose
- cork
- destroy
- drop
- emit
- end
- every
- filter
- find
- flatMap
- forEach
- isPaused
- iterator
- listenerCount
- listeners
- map
- off
- on
- once
- pause
- pipe
- prependListener
- prependOnceListener
- push
- rawListeners
- read
- reduce
- removeAllListeners
- removeListener
- resume
- setDefaultEncoding
- setEncoding
- some
- take
- toArray
- uncork
- unpipe
- unshift
- wrap
- write
- from
- fromWeb
- isDisturbed
- toWeb

## Constructors

### constructor

- new BufferBuilder(): BufferBuilder

- Overrides Duplex.__constructor

  - Defined in @zowe/imperative/src/utilities/src/BufferBuilder.ts:15

  #### Returns BufferBuilder

## Properties

### allowHalfOpen

allowHalfOpen: boolean

Inherited from BufferBuilder.allowHalfOpen

- Defined in @types/node/stream.d.ts:1133

If `false` then the stream will automatically end the writable side when the readable side ends. Set initially by the `allowHalfOpen` constructor option, which defaults to `true`.

This can be changed manually to change the half-open behavior of an existing `Duplex` stream instance, but must be changed before the `'end'` event is emitted.

since

  v0.9.4

### Private chunks

chunks: Uint8Array[]

- Defined in @zowe/imperative/src/utilities/src/BufferBuilder.ts:15

### Readonly closed

closed: boolean

Inherited from BufferBuilder.closed

Overrides Writable.closed

- Defined in @types/node/stream.d.ts:185

Is `true` after `'close'` has been emitted.

since

  v18.0.0

### destroyed

destroyed: boolean

Inherited from BufferBuilder.destroyed

Overrides Writable.destroyed

- Defined in @types/node/stream.d.ts:180

Is `true` after `readable.destroy()` has been called.

since

  v8.0.0

### Readonly errored

errored: Error | null

Inherited from BufferBuilder.errored

Overrides Writable.errored

- Defined in @types/node/stream.d.ts:190

Returns error if the stream has been destroyed with an error.

since

  v18.0.0

### readable

readable: boolean

Inherited from BufferBuilder.readable

- Defined in @types/node/stream.d.ts:137

Is `true` if it is safe to call read, which means the stream has not been destroyed or emitted `'error'` or `'end'`.

since

  v11.4.0

### Readonly readableAborted

readableAborted: boolean

Inherited from BufferBuilder.readableAborted

- Defined in @types/node/stream.d.ts:131

Returns whether the stream was destroyed or errored before emitting `'end'`.

since

  v16.8.0

### Readonly readableDidRead

readableDidRead: boolean

Inherited from BufferBuilder.readableDidRead

- Defined in @types/node/stream.d.ts:142

Returns whether `'data'` has been emitted.

since

  v16.7.0, v14.18.0

### Readonly readableEncoding

readableEncoding: BufferEncoding | null

Inherited from BufferBuilder.readableEncoding

- Defined in @types/node/stream.d.ts:147

Getter for the property `encoding` of a given `Readable` stream. The `encoding` property can be set using the setEncoding method.

since

  v12.7.0

### Readonly readableEnded

readableEnded: boolean

Inherited from BufferBuilder.readableEnded

- Defined in @types/node/stream.d.ts:152

Becomes `true` when `'end'` event is emitted.

since

  v12.9.0

### readableFlowing

readableFlowing: boolean | null

Inherited from BufferBuilder.readableFlowing

- Defined in @types/node/stream.d.ts:158

This property reflects the current state of a `Readable` stream as described in the Three states section.

since

  v9.4.0

### Readonly readableHighWaterMark

readableHighWaterMark: number

Inherited from BufferBuilder.readableHighWaterMark

- Defined in @types/node/stream.d.ts:163

Returns the value of `highWaterMark` passed when creating this `Readable`.

since

  v9.3.0

### Readonly readableLength

readableLength: number

Inherited from BufferBuilder.readableLength

- Defined in @types/node/stream.d.ts:170

This property contains the number of bytes (or objects) in the queue ready to be read. The value provides introspection data regarding the status of the `highWaterMark`.

since

  v9.4.0

### Readonly readableObjectMode

readableObjectMode: boolean

Inherited from BufferBuilder.readableObjectMode

- Defined in @types/node/stream.d.ts:175

Getter for the property `objectMode` of a given `Readable` stream.

since

  v12.3.0

### writable

writable: boolean

Inherited from BufferBuilder.writable

- Defined in @types/node/stream.d.ts:773

Is `true` if it is safe to call `writable.write()`, which means the stream has not been destroyed, errored, or ended.

since

  v11.4.0

### Readonly writableAborted

writableAborted: boolean

Inherited from BufferBuilder.writableAborted

- Defined in @types/node/stream.d.ts:778

Returns whether the stream was destroyed or errored before emitting `'finish'`.

since

  v18.0.0, v16.17.0

### Readonly writableCorked

writableCorked: number

Inherited from BufferBuilder.writableCorked

- Defined in @types/node/stream.d.ts:812

Number of times `writable.uncork()` needs to be called in order to fully uncork the stream.

since

  v13.2.0, v12.16.0

### Readonly writableEnded

writableEnded: boolean

Inherited from BufferBuilder.writableEnded

- Defined in @types/node/stream.d.ts:784

Is `true` after `writable.end()` has been called. This property does not indicate whether the data has been flushed, for this use `writable.writableFinished` instead.

since

  v12.9.0

### Readonly writableFinished

writableFinished: boolean

Inherited from BufferBuilder.writableFinished

- Defined in @types/node/stream.d.ts:789

Is set to `true` immediately before the `'finish'` event is emitted.

since

  v12.6.0

### Readonly writableHighWaterMark

writableHighWaterMark: number

Inherited from BufferBuilder.writableHighWaterMark

- Defined in @types/node/stream.d.ts:794

Return the value of `highWaterMark` passed when creating this `Writable`.

since

  v9.3.0

### Readonly writableLength

writableLength: number

Inherited from BufferBuilder.writableLength

- Defined in @types/node/stream.d.ts:801

This property contains the number of bytes (or objects) in the queue ready to be written. The value provides introspection data regarding the status of the `highWaterMark`.

since

  v9.4.0

### Readonly writableNeedDrain

writableNeedDrain: boolean

Inherited from BufferBuilder.writableNeedDrain

- Defined in @types/node/stream.d.ts:832

Is `true` if the stream's buffer has been full and stream will emit `'drain'`.

since

  v15.2.0, v14.17.0

### Readonly writableObjectMode

writableObjectMode: boolean

Inherited from BufferBuilder.writableObjectMode

- Defined in @types/node/stream.d.ts:806

Getter for the property `objectMode` of a given `Writable` stream.

since

  v12.3.0

## Methods

### [Symbol.asyncDispose]

- [Symbol.asyncDispose](): Promise<void>

- Inherited from BufferBuilder.[Symbol.asyncDispose]

  Overrides Writable.[Symbol.asyncDispose]

  - Defined in @types/node/stream.d.ts:672

  Calls `readable.destroy()` with an `AbortError` and returns a promise that fulfills when the stream is finished.

  since

    v20.4.0

  #### Returns Promise<void>

### [Symbol.asyncIterator]

- [Symbol.asyncIterator](): AsyncIterator<any>

- Inherited from BufferBuilder.[Symbol.asyncIterator]

  - Defined in @types/node/stream.d.ts:666
  since

    v10.0.0

  #### Returns AsyncIterator<any>

  `AsyncIterator` to fully consume the stream.

### Optional _construct

- _construct(callback: (error?: Error | null) => void): void

- Inherited from BufferBuilder._construct

  Overrides Writable._construct

  - Defined in @types/node/stream.d.ts:191

  #### Parameters

  - ##### callback: (error?: Error | null) => void

    - - (error?: Error | null): void

      - #### Parameters

        - ##### Optional error: Error | null

        #### Returns void

### _destroy

- _destroy(error: Error | null, callback: (error?: Error | null) => void): void

- Inherited from BufferBuilder._destroy

  Overrides Writable._destroy

  - Defined in @types/node/stream.d.ts:649

  #### Parameters

  - ##### error: Error | null

  - ##### callback: (error?: Error | null) => void

    - - (error?: Error | null): void

      - #### Parameters

        - ##### Optional error: Error | null

        #### Returns void

### _final

- _final(callback: (error?: Error | null) => void): void

- Inherited from BufferBuilder._final

  - Defined in @types/node/stream.d.ts:843

  #### Parameters

  - ##### callback: (error?: Error | null) => void

    - - (error?: Error | null): void

      - #### Parameters

        - ##### Optional error: Error | null

        #### Returns void

### _read

- _read(_size: number): void

- Overrides Readable._read

  - Defined in @zowe/imperative/src/utilities/src/BufferBuilder.ts:27

  #### Parameters

  - ##### _size: number

  #### Returns void

### _write

- _write(chunk: any, _encoding: BufferEncoding, callback: (error?: Error) => void): void

- Overrides Writable._write

  - Defined in @zowe/imperative/src/utilities/src/BufferBuilder.ts:22

  #### Parameters

  - ##### chunk: any

  - ##### _encoding: BufferEncoding

  - ##### callback: (error?: Error) => void

    - - (error?: Error): void

      - #### Parameters

        - ##### Optional error: Error

        #### Returns void

### Optional _writev

- _writev(chunks: { chunk: any; encoding: BufferEncoding }[], callback: (error?: Error | null) => void): void

- Inherited from BufferBuilder._writev

  - Defined in @types/node/stream.d.ts:834

  #### Parameters

  - ##### chunks: { chunk: any; encoding: BufferEncoding }[]

  - ##### callback: (error?: Error | null) => void

    - - (error?: Error | null): void

      - #### Parameters

        - ##### Optional error: Error | null

        #### Returns void

### addListener

- addListener<E>(eventName: E, listener: (...args: DuplexEventMap[E]) => void): this
- addListener(eventName: string | symbol, listener: (...args: any[]) => void): this

- Inherited from BufferBuilder.addListener

  Overrides Readable.addListener

  - Defined in @types/node/stream.d.ts:1135

  #### Type parameters

  - #### E: keyof DuplexEventMap

  #### Parameters

  - ##### eventName: E

  - ##### listener: (...args: DuplexEventMap[E]) => void

    - - (...args: DuplexEventMap[E]): void

      - #### Parameters

        - ##### Rest ...args: DuplexEventMap[E]

        #### Returns void

  #### Returns this

- Inherited from BufferBuilder.addListener

  Overrides Readable.addListener

  - Defined in @types/node/stream.d.ts:1139

  #### Parameters

  - ##### eventName: string | symbol

  - ##### listener: (...args: any[]) => void

    - - (...args: any[]): void

      - #### Parameters

        - ##### Rest ...args: any[]

        #### Returns void

  #### Returns this

### compose

- compose(stream: WritableStream | WritableStream | TransformStream | ((source: any) => void), options?: Abortable): Duplex

- Inherited from BufferBuilder.compose

  - Defined in @types/node/stream.d.ts:498

  ```js import { Readable } from 'node:stream';

  async function* splitToWords(source) { for await (const chunk of source) { const words = String(chunk).split(' ');

      for (const word of words) {
        yield word;
      }

  } }

  const wordsStream = Readable.from(['this is', 'compose as operator']).compose(splitToWords); const words = await wordsStream.toArray();

  console.log(words); // prints ['this', 'is', 'compose', 'as', 'operator']

  ```

  See `stream.compose` for more information.

  since

    v19.1.0, v18.13.0

  #### Parameters

  - ##### stream: WritableStream | WritableStream | TransformStream | ((source: any) => void)

  - ##### Optional options: Abortable

  #### Returns Duplex

  a stream composed with the stream `stream`.

### cork

- cork(): void

- Inherited from BufferBuilder.cork

  - Defined in @types/node/stream.d.ts:947

  The `writable.cork()` method forces all written data to be buffered in memory. The buffered data will be flushed when either the uncork or end methods are called.

  The primary intent of `writable.cork()` is to accommodate a situation in which several small chunks are written to the stream in rapid succession. Instead of immediately forwarding them to the underlying destination, `writable.cork()` buffers all the chunks until `writable.uncork()` is called, which will pass them all to `writable._writev()`, if present. This prevents a head-of-line blocking situation where data is being buffered while waiting for the first small chunk to be processed. However, use of `writable.cork()` without implementing `writable._writev()` may have an adverse effect on throughput.

  See also: `writable.uncork()`, `writable._writev()`.

  since

    v0.11.2

  #### Returns void

### destroy

- destroy(error?: Error): this

- Inherited from BufferBuilder.destroy

  Overrides Writable.destroy

  - Defined in @types/node/stream.d.ts:661

  Destroy the stream. Optionally emit an `'error'` event, and emit a `'close'` event (unless `emitClose` is set to `false`). After this call, the readable stream will release any internal resources and subsequent calls to `push()` will be ignored.

  Once `destroy()` has been called any further calls will be a no-op and no further errors except from `_destroy()` may be emitted as `'error'`.

  Implementors should not override this method, but instead implement `readable._destroy()`.

  since

    v8.0.0

  #### Parameters

  - ##### Optional error: Error

    Error which will be passed as payload in `'error'` event

  #### Returns this

### drop

- drop(limit: number, options?: Abortable): Readable

- Inherited from BufferBuilder.drop

  - Defined in @types/node/stream.d.ts:621

  This method returns a new stream with the first limit chunks dropped from the start.

  since

    v17.5.0

  #### Parameters

  - ##### limit: number

    the number of chunks to drop from the readable.

  - ##### Optional options: Abortable

  #### Returns Readable

  a stream with limit chunks dropped from the start.

### emit

- emit<E>(eventName: E, ...args: DuplexEventMap[E]): boolean
- emit(eventName: string | symbol, ...args: any[]): boolean

- Inherited from BufferBuilder.emit

  Overrides Readable.emit

  - Defined in @types/node/stream.d.ts:1140

  #### Type parameters

  - #### E: keyof DuplexEventMap

  #### Parameters

  - ##### eventName: E

  - ##### Rest ...args: DuplexEventMap[E]

  #### Returns boolean

- Inherited from BufferBuilder.emit

  Overrides Readable.emit

  - Defined in @types/node/stream.d.ts:1141

  #### Parameters

  - ##### eventName: string | symbol

  - ##### Rest ...args: any[]

  #### Returns boolean

### end

- end(cb?: () => void): this
- end(chunk: any, cb?: () => void): this
- end(chunk: any, encoding: BufferEncoding, cb?: () => void): this

- Inherited from BufferBuilder.end

  - Defined in @types/node/stream.d.ts:930

  Calling the `writable.end()` method signals that no more data will be written to the `Writable`. The optional `chunk` and `encoding` arguments allow one final additional chunk of data to be written immediately before closing the stream.

  Calling the write method after calling end will raise an error.

      // Write 'hello, ' and then end with 'world!'.
      import fs from 'node:fs';
      const file = fs.createWriteStream('example.txt');
      file.write('hello, ');
      file.end('world!');
      // Writing more now is not allowed!

  since

    v0.9.4

  #### Parameters

  - ##### Optional cb: () => void

    - - (): void

      - #### Returns void

  #### Returns this

- Inherited from BufferBuilder.end

  - Defined in @types/node/stream.d.ts:931

  #### Parameters

  - ##### chunk: any

  - ##### Optional cb: () => void

    - - (): void

      - #### Returns void

  #### Returns this

- Inherited from BufferBuilder.end

  - Defined in @types/node/stream.d.ts:932

  #### Parameters

  - ##### chunk: any

  - ##### encoding: BufferEncoding

  - ##### Optional cb: () => void

    - - (): void

      - #### Returns void

  #### Returns this

### every

- every(fn: (data: any, options?: Abortable) => boolean | Promise<boolean>, options?: Pick<ReadableOperatorOptions, "concurrency" | "signal">): Promise<boolean>

- Inherited from BufferBuilder.every

  - Defined in @types/node/stream.d.ts:597

  This method is similar to `Array.prototype.every` and calls fn on each chunk in the stream to check if all awaited return values are truthy value for fn. Once an fn call on a chunk `await`ed return value is falsy, the stream is destroyed and the promise is fulfilled with `false`. If all of the fn calls on the chunks return a truthy value, the promise is fulfilled with `true`.

  since

    v17.5.0

  #### Parameters

  - ##### fn: (data: any, options?: Abortable) => boolean | Promise<boolean>

    a function to call on each chunk of the stream. Async or not.

    - - (data: any, options?: Abortable): boolean | Promise<boolean>

      - #### Parameters

        - ##### data: any

        - ##### Optional options: Abortable

        #### Returns boolean | Promise<boolean>

  - ##### Optional options: Pick<ReadableOperatorOptions, "concurrency" | "signal">

  #### Returns Promise<boolean>

  a promise evaluating to `true` if fn returned a truthy value for every one of the chunks.

### filter

- filter(fn: (data: any, options?: Abortable) => boolean | Promise<boolean>, options?: ReadableOperatorOptions): Readable

- Inherited from BufferBuilder.filter

  - Defined in @types/node/stream.d.ts:525

  This method allows filtering the stream. For each chunk in the stream the fn function will be called and if it returns a truthy value, the chunk will be passed to the result stream. If the fn function returns a promise - that promise will be `await`ed.

  since

    v17.4.0, v16.14.0

  #### Parameters

  - ##### fn: (data: any, options?: Abortable) => boolean | Promise<boolean>

    a function to filter chunks from the stream. Async or not.

    - - (data: any, options?: Abortable): boolean | Promise<boolean>

      - #### Parameters

        - ##### data: any

        - ##### Optional options: Abortable

        #### Returns boolean | Promise<boolean>

  - ##### Optional options: ReadableOperatorOptions

  #### Returns Readable

  a stream filtered with the predicate fn.

### find

- find<T>(fn: (data: any, options?: Abortable) => data is T, options?: Pick<ReadableOperatorOptions, "concurrency" | "signal">): Promise<T | undefined>
- find(fn: (data: any, options?: Abortable) => boolean | Promise<boolean>, options?: Pick<ReadableOperatorOptions, "concurrency" | "signal">): Promise<any>

- Inherited from BufferBuilder.find

  - Defined in @types/node/stream.d.ts:580

  This method is similar to `Array.prototype.find` and calls fn on each chunk in the stream to find a chunk with a truthy value for fn. Once an fn call's awaited return value is truthy, the stream is destroyed and the promise is fulfilled with value for which fn returned a truthy value. If all of the fn calls on the chunks return a falsy value, the promise is fulfilled with `undefined`.

  since

    v17.5.0

  #### Type parameters

  - #### T

  #### Parameters

  - ##### fn: (data: any, options?: Abortable) => data is T

    a function to call on each chunk of the stream. Async or not.

    - - (data: any, options?: Abortable): data is T

      - #### Parameters

        - ##### data: any

        - ##### Optional options: Abortable

        #### Returns data is T

  - ##### Optional options: Pick<ReadableOperatorOptions, "concurrency" | "signal">

  #### Returns Promise<T | undefined>

  a promise evaluating to the first chunk for which fn evaluated with a truthy value, or `undefined` if no element was found.

- Inherited from BufferBuilder.find

  - Defined in @types/node/stream.d.ts:584

  #### Parameters

  - ##### fn: (data: any, options?: Abortable) => boolean | Promise<boolean>

    - - (data: any, options?: Abortable): boolean | Promise<boolean>

      - #### Parameters

        - ##### data: any

        - ##### Optional options: Abortable

        #### Returns boolean | Promise<boolean>

  - ##### Optional options: Pick<ReadableOperatorOptions, "concurrency" | "signal">

  #### Returns Promise<any>

### flatMap

- flatMap(fn: (data: any, options?: Abortable) => any, options?: Pick<ReadableOperatorOptions, "concurrency" | "signal">): Readable

- Inherited from BufferBuilder.flatMap

  - Defined in @types/node/stream.d.ts:611

  This method returns a new stream by applying the given callback to each chunk of the stream and then flattening the result.

  It is possible to return a stream or another iterable or async iterable from fn and the result streams will be merged (flattened) into the returned stream.

  since

    v17.5.0

  #### Parameters

  - ##### fn: (data: any, options?: Abortable) => any

    a function to map over every chunk in the stream. May be async. May be a stream or generator.

    - - (data: any, options?: Abortable): any

      - #### Parameters

        - ##### data: any

        - ##### Optional options: Abortable

        #### Returns any

  - ##### Optional options: Pick<ReadableOperatorOptions, "concurrency" | "signal">

  #### Returns Readable

  a stream flat-mapped with the function fn.

### forEach

- forEach(fn: (data: any, options?: Abortable) => void | Promise<void>, options?: Pick<ReadableOperatorOptions, "concurrency" | "signal">): Promise<void>

- Inherited from BufferBuilder.forEach

  - Defined in @types/node/stream.d.ts:544

  This method allows iterating a stream. For each chunk in the stream the fn function will be called. If the fn function returns a promise - that promise will be `await`ed.

  This method is different from `for await...of` loops in that it can optionally process chunks concurrently. In addition, a `forEach` iteration can only be stopped by having passed a `signal` option and aborting the related AbortController while `for await...of` can be stopped with `break` or `return`. In either case the stream will be destroyed.

  This method is different from listening to the `'data'` event in that it uses the `readable` event in the underlying machinary and can limit the number of concurrent fn calls.

  since

    v17.5.0

  #### Parameters

  - ##### fn: (data: any, options?: Abortable) => void | Promise<void>

    a function to call on each chunk of the stream. Async or not.

    - - (data: any, options?: Abortable): void | Promise<void>

      - #### Parameters

        - ##### data: any

        - ##### Optional options: Abortable

        #### Returns void | Promise<void>

  - ##### Optional options: Pick<ReadableOperatorOptions, "concurrency" | "signal">

  #### Returns Promise<void>

  a promise for when the stream has finished.

### isPaused

- isPaused(): boolean

- Inherited from BufferBuilder.isPaused

  - Defined in @types/node/stream.d.ts:353

  The `readable.isPaused()` method returns the current operating state of the `Readable`. This is used primarily by the mechanism that underlies the `readable.pipe()` method. In most typical cases, there will be no reason to use this method directly.

      const readable = new stream.Readable();

      readable.isPaused(); // === false
      readable.pause();
      readable.isPaused(); // === true
      readable.resume();
      readable.isPaused(); // === false

  since

    v0.11.14

  #### Returns boolean

### iterator

- iterator(options?: ReadableIteratorOptions): AsyncIterator<any>

- Inherited from BufferBuilder.iterator

  - Defined in @types/node/stream.d.ts:508

  The iterator created by this method gives users the option to cancel the destruction of the stream if the `for await...of` loop is exited by `return`, `break`, or `throw`, or if the iterator should destroy the stream if the stream emitted an error during iteration.

  since

    v16.3.0

  #### Parameters

  - ##### Optional options: ReadableIteratorOptions

  #### Returns AsyncIterator<any>

### listenerCount

- listenerCount<E>(eventName: E, listener?: (...args: DuplexEventMap[E]) => void): number
- listenerCount(eventName: string | symbol, listener?: (...args: any[]) => void): number

- Inherited from BufferBuilder.listenerCount

  Overrides Readable.listenerCount

  - Defined in @types/node/stream.d.ts:1142

  #### Type parameters

  - #### E: keyof DuplexEventMap

  #### Parameters

  - ##### eventName: E

  - ##### Optional listener: (...args: DuplexEventMap[E]) => void

    - - (...args: DuplexEventMap[E]): void

      - #### Parameters

        - ##### Rest ...args: DuplexEventMap[E]

        #### Returns void

  #### Returns number

- Inherited from BufferBuilder.listenerCount

  Overrides Readable.listenerCount

  - Defined in @types/node/stream.d.ts:1146

  #### Parameters

  - ##### eventName: string | symbol

  - ##### Optional listener: (...args: any[]) => void

    - - (...args: any[]): void

      - #### Parameters

        - ##### Rest ...args: any[]

        #### Returns void

  #### Returns number

### listeners

- listeners<E>(eventName: E): ((...args: DuplexEventMap[E]) => void)[]
- listeners(eventName: string | symbol): ((...args: any[]) => void)[]

- Inherited from BufferBuilder.listeners

  Overrides Readable.listeners

  - Defined in @types/node/stream.d.ts:1147

  #### Type parameters

  - #### E: keyof DuplexEventMap

  #### Parameters

  - ##### eventName: E

  #### Returns ((...args: DuplexEventMap[E]) => void)[]

- Inherited from BufferBuilder.listeners

  Overrides Readable.listeners

  - Defined in @types/node/stream.d.ts:1148

  #### Parameters

  - ##### eventName: string | symbol

  #### Returns ((...args: any[]) => void)[]

### map

- map(fn: (data: any, options?: Abortable) => any, options?: ReadableOperatorOptions): Readable

- Inherited from BufferBuilder.map

  - Defined in @types/node/stream.d.ts:516

  This method allows mapping over the stream. The fn function will be called for every chunk in the stream. If the fn function returns a promise - that promise will be `await`ed before being passed to the result stream.

  since

    v17.4.0, v16.14.0

  #### Parameters

  - ##### fn: (data: any, options?: Abortable) => any

    a function to map over every chunk in the stream. Async or not.

    - - (data: any, options?: Abortable): any

      - #### Parameters

        - ##### data: any

        - ##### Optional options: Abortable

        #### Returns any

  - ##### Optional options: ReadableOperatorOptions

  #### Returns Readable

  a stream mapped with the function fn.

### off

- off<E>(eventName: E, listener: (...args: DuplexEventMap[E]) => void): this
- off(eventName: string | symbol, listener: (...args: any[]) => void): this

- Inherited from BufferBuilder.off

  Overrides Readable.off

  - Defined in @types/node/stream.d.ts:1149

  #### Type parameters

  - #### E: keyof DuplexEventMap

  #### Parameters

  - ##### eventName: E

  - ##### listener: (...args: DuplexEventMap[E]) => void

    - - (...args: DuplexEventMap[E]): void

      - #### Parameters

        - ##### Rest ...args: DuplexEventMap[E]

        #### Returns void

  #### Returns this

- Inherited from BufferBuilder.off

  Overrides Readable.off

  - Defined in @types/node/stream.d.ts:1150

  #### Parameters

  - ##### eventName: string | symbol

  - ##### listener: (...args: any[]) => void

    - - (...args: any[]): void

      - #### Parameters

        - ##### Rest ...args: any[]

        #### Returns void

  #### Returns this

### on

- on<E>(eventName: E, listener: (...args: DuplexEventMap[E]) => void): this
- on(eventName: string | symbol, listener: (...args: any[]) => void): this

- Inherited from BufferBuilder.on

  Overrides Readable.on

  - Defined in @types/node/stream.d.ts:1151

  #### Type parameters

  - #### E: keyof DuplexEventMap

  #### Parameters

  - ##### eventName: E

  - ##### listener: (...args: DuplexEventMap[E]) => void

    - - (...args: DuplexEventMap[E]): void

      - #### Parameters

        - ##### Rest ...args: DuplexEventMap[E]

        #### Returns void

  #### Returns this

- Inherited from BufferBuilder.on

  Overrides Readable.on

  - Defined in @types/node/stream.d.ts:1152

  #### Parameters

  - ##### eventName: string | symbol

  - ##### listener: (...args: any[]) => void

    - - (...args: any[]): void

      - #### Parameters

        - ##### Rest ...args: any[]

        #### Returns void

  #### Returns this

### once

- once<E>(eventName: E, listener: (...args: DuplexEventMap[E]) => void): this
- once(eventName: string | symbol, listener: (...args: any[]) => void): this

- Inherited from BufferBuilder.once

  Overrides Readable.once

  - Defined in @types/node/stream.d.ts:1153

  #### Type parameters

  - #### E: keyof DuplexEventMap

  #### Parameters

  - ##### eventName: E

  - ##### listener: (...args: DuplexEventMap[E]) => void

    - - (...args: DuplexEventMap[E]): void

      - #### Parameters

        - ##### Rest ...args: DuplexEventMap[E]

        #### Returns void

  #### Returns this

- Inherited from BufferBuilder.once

  Overrides Readable.once

  - Defined in @types/node/stream.d.ts:1154

  #### Parameters

  - ##### eventName: string | symbol

  - ##### listener: (...args: any[]) => void

    - - (...args: any[]): void

      - #### Parameters

        - ##### Rest ...args: any[]

        #### Returns void

  #### Returns this

### pause

- pause(): this

- Inherited from BufferBuilder.pause

  - Defined in @types/node/stream.d.ts:317

  The `readable.pause()` method will cause a stream in flowing mode to stop emitting `'data'` events, switching out of flowing mode. Any data that becomes available will remain in the internal buffer.

      const readable = getReadableStreamSomehow();
      readable.on('data', (chunk) => {
        console.log(`Received ${chunk.length} bytes of data.`);
        readable.pause();
        console.log('There will be no additional data for 1 second.');
        setTimeout(() => {
          console.log('Now data will start flowing again.');
          readable.resume();
        }, 1000);
      });

  The `readable.pause()` method has no effect if there is a `'readable'` event listener.

  since

    v0.9.4

  #### Returns this

### pipe

- pipe<T>(destination: T, options?: PipeOptions): T

- Inherited from BufferBuilder.pipe

  Overrides BufferBuilder.pipe

  - Defined in @types/node/stream.d.ts:29
  since

    v0.9.4

  #### Type parameters

  - #### T: WritableStream

  #### Parameters

  - ##### destination: T

  - ##### Optional options: PipeOptions

  #### Returns T

### prependListener

- prependListener<E>(eventName: E, listener: (...args: DuplexEventMap[E]) => void): this
- prependListener(eventName: string | symbol, listener: (...args: any[]) => void): this

- Inherited from BufferBuilder.prependListener

  Overrides Readable.prependListener

  - Defined in @types/node/stream.d.ts:1155

  #### Type parameters

  - #### E: keyof DuplexEventMap

  #### Parameters

  - ##### eventName: E

  - ##### listener: (...args: DuplexEventMap[E]) => void

    - - (...args: DuplexEventMap[E]): void

      - #### Parameters

        - ##### Rest ...args: DuplexEventMap[E]

        #### Returns void

  #### Returns this

- Inherited from BufferBuilder.prependListener

  Overrides Readable.prependListener

  - Defined in @types/node/stream.d.ts:1159

  #### Parameters

  - ##### eventName: string | symbol

  - ##### listener: (...args: any[]) => void

    - - (...args: any[]): void

      - #### Parameters

        - ##### Rest ...args: any[]

        #### Returns void

  #### Returns this

### prependOnceListener

- prependOnceListener<E>(eventName: E, listener: (...args: DuplexEventMap[E]) => void): this
- prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): this

- Inherited from BufferBuilder.prependOnceListener

  Overrides Readable.prependOnceListener

  - Defined in @types/node/stream.d.ts:1160

  #### Type parameters

  - #### E: keyof DuplexEventMap

  #### Parameters

  - ##### eventName: E

  - ##### listener: (...args: DuplexEventMap[E]) => void

    - - (...args: DuplexEventMap[E]): void

      - #### Parameters

        - ##### Rest ...args: DuplexEventMap[E]

        #### Returns void

  #### Returns this

- Inherited from BufferBuilder.prependOnceListener

  Overrides Readable.prependOnceListener

  - Defined in @types/node/stream.d.ts:1164

  #### Parameters

  - ##### eventName: string | symbol

  - ##### listener: (...args: any[]) => void

    - - (...args: any[]): void

      - #### Parameters

        - ##### Rest ...args: any[]

        #### Returns void

  #### Returns this

### push

- push(chunk: any, encoding?: BufferEncoding): boolean

- Inherited from BufferBuilder.push

  - Defined in @types/node/stream.d.ts:473

  #### Parameters

  - ##### chunk: any

  - ##### Optional encoding: BufferEncoding

  #### Returns boolean

### rawListeners

- rawListeners<E>(eventName: E): ((...args: DuplexEventMap[E]) => void)[]
- rawListeners(eventName: string | symbol): ((...args: any[]) => void)[]

- Inherited from BufferBuilder.rawListeners

  Overrides Readable.rawListeners

  - Defined in @types/node/stream.d.ts:1165

  #### Type parameters

  - #### E: keyof DuplexEventMap

  #### Parameters

  - ##### eventName: E

  #### Returns ((...args: DuplexEventMap[E]) => void)[]

- Inherited from BufferBuilder.rawListeners

  Overrides Readable.rawListeners

  - Defined in @types/node/stream.d.ts:1166

  #### Parameters

  - ##### eventName: string | symbol

  #### Returns ((...args: any[]) => void)[]

### read

- read(size?: number): any

- Inherited from BufferBuilder.read

  - Defined in @types/node/stream.d.ts:270

  The `readable.read()` method reads data out of the internal buffer and returns it. If no data is available to be read, `null` is returned. By default, the data is returned as a `Buffer` object unless an encoding has been specified using the `readable.setEncoding()` method or the stream is operating in object mode.

  The optional `size` argument specifies a specific number of bytes to read. If `size` bytes are not available to be read, `null` will be returned unless the stream has ended, in which case all of the data remaining in the internal buffer will be returned.

  If the `size` argument is not specified, all of the data contained in the internal buffer will be returned.

  The `size` argument must be less than or equal to 1 GiB.

  The `readable.read()` method should only be called on `Readable` streams operating in paused mode. In flowing mode, `readable.read()` is called automatically until the internal buffer is fully drained.

      const readable = getReadableStreamSomehow();

      // 'readable' may be triggered multiple times as data is buffered in
      readable.on('readable', () => {
        let chunk;
        console.log('Stream is readable (new data received in buffer)');
        // Use a loop to make sure we read all currently available data
        while (null !== (chunk = readable.read())) {
          console.log(`Read ${chunk.length} bytes of data...`);
        }
      });

      // 'end' will be triggered once when there is no more data available
      readable.on('end', () => {
        console.log('Reached end of stream.');
      });

  Each call to `readable.read()` returns a chunk of data, or `null`. The chunks are not concatenated. A `while` loop is necessary to consume all data currently in the buffer. When reading a large file `.read()` may return `null`, having consumed all buffered content so far, but there is still more data to come not yet buffered. In this case a new `'readable'` event will be emitted when there is more data in the buffer. Finally the `'end'` event will be emitted when there is no more data to come.

  Therefore to read a file's whole contents from a `readable`, it is necessary to collect chunks across multiple `'readable'` events:

      const chunks = [];

      readable.on('readable', () => {
        let chunk;
        while (null !== (chunk = readable.read())) {
          chunks.push(chunk);
        }
      });

      readable.on('end', () => {
        const content = chunks.join('');
      });

  A `Readable` stream in object mode will always return a single item from a call to `readable.read(size)`, regardless of the value of the `size` argument.

  If the `readable.read()` method returns a chunk of data, a `'data'` event will also be emitted.

  Calling read after the `'end'` event has been emitted will return `null`. No runtime error will be raised.

  since

    v0.9.4

  #### Parameters

  - ##### Optional size: number

    Optional argument to specify how much data to read.

  #### Returns any

### reduce

- reduce<T>(fn: (previous: any, data: any, options?: Abortable) => T): Promise<T>
- reduce<T>(fn: (previous: T, data: any, options?: Abortable) => T, initial: T, options?: Abortable): Promise<T>

- Inherited from BufferBuilder.reduce

  - Defined in @types/node/stream.d.ts:643

  This method calls fn on each chunk of the stream in order, passing it the result from the calculation on the previous element. It returns a promise for the final value of the reduction.

  If no initial value is supplied the first chunk of the stream is used as the initial value. If the stream is empty, the promise is rejected with a `TypeError` with the `ERR_INVALID_ARGS` code property.

  The reducer function iterates the stream element-by-element which means that there is no concurrency parameter or parallelism. To perform a reduce concurrently, you can extract the async function to `readable.map` method.

  since

    v17.5.0

  #### Type parameters

  - #### T

  #### Parameters

  - ##### fn: (previous: any, data: any, options?: Abortable) => T

    a reducer function to call over every chunk in the stream. Async or not.

    - - (previous: any, data: any, options?: Abortable): T

      - #### Parameters

        - ##### previous: any

        - ##### data: any

        - ##### Optional options: Abortable

        #### Returns T

  #### Returns Promise<T>

  a promise for the final value of the reduction.

- Inherited from BufferBuilder.reduce

  - Defined in @types/node/stream.d.ts:644

  #### Type parameters

  - #### T

  #### Parameters

  - ##### fn: (previous: T, data: any, options?: Abortable) => T

    - - (previous: T, data: any, options?: Abortable): T

      - #### Parameters

        - ##### previous: T

        - ##### data: any

        - ##### Optional options: Abortable

        #### Returns T

  - ##### initial: T

  - ##### Optional options: Abortable

  #### Returns Promise<T>

### removeAllListeners

- removeAllListeners<E>(eventName?: E): this
- removeAllListeners(eventName?: string | symbol): this

- Inherited from BufferBuilder.removeAllListeners

  Overrides Readable.removeAllListeners

  - Defined in @types/node/stream.d.ts:1168

  #### Type parameters

  - #### E: keyof DuplexEventMap

  #### Parameters

  - ##### Optional eventName: E

  #### Returns this

- Inherited from BufferBuilder.removeAllListeners

  Overrides Readable.removeAllListeners

  - Defined in @types/node/stream.d.ts:1169

  #### Parameters

  - ##### Optional eventName: string | symbol

  #### Returns this

### removeListener

- removeListener<E>(eventName: E, listener: (...args: DuplexEventMap[E]) => void): this
- removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this

- Inherited from BufferBuilder.removeListener

  Overrides Readable.removeListener

  - Defined in @types/node/stream.d.ts:1170

  #### Type parameters

  - #### E: keyof DuplexEventMap

  #### Parameters

  - ##### eventName: E

  - ##### listener: (...args: DuplexEventMap[E]) => void

    - - (...args: DuplexEventMap[E]): void

      - #### Parameters

        - ##### Rest ...args: DuplexEventMap[E]

        #### Returns void

  #### Returns this

- Inherited from BufferBuilder.removeListener

  Overrides Readable.removeListener

  - Defined in @types/node/stream.d.ts:1174

  #### Parameters

  - ##### eventName: string | symbol

  - ##### listener: (...args: any[]) => void

    - - (...args: any[]): void

      - #### Parameters

        - ##### Rest ...args: any[]

        #### Returns void

  #### Returns this

### resume

- resume(): this

- Inherited from BufferBuilder.resume

  - Defined in @types/node/stream.d.ts:336

  The `readable.resume()` method causes an explicitly paused `Readable` stream to resume emitting `'data'` events, switching the stream into flowing mode.

  The `readable.resume()` method can be used to fully consume the data from a stream without actually processing any of that data:

      getReadableStreamSomehow()
        .resume()
        .on('end', () => {
          console.log('Reached the end, but did not read anything.');
        });

  The `readable.resume()` method has no effect if there is a `'readable'` event listener.

  since

    v0.9.4

  #### Returns this

### setDefaultEncoding

- setDefaultEncoding(encoding: BufferEncoding): this

- Inherited from BufferBuilder.setDefaultEncoding

  - Defined in @types/node/stream.d.ts:907

  The `writable.setDefaultEncoding()` method sets the default `encoding` for a `Writable` stream.

  since

    v0.11.15

  #### Parameters

  - ##### encoding: BufferEncoding

    The new default encoding

  #### Returns this

### setEncoding

- setEncoding(encoding: BufferEncoding): this

- Inherited from BufferBuilder.setEncoding

  - Defined in @types/node/stream.d.ts:295

  The `readable.setEncoding()` method sets the character encoding for data read from the `Readable` stream.

  By default, no encoding is assigned and stream data will be returned as `Buffer` objects. Setting an encoding causes the stream data to be returned as strings of the specified encoding rather than as `Buffer` objects. For instance, calling `readable.setEncoding('utf8')` will cause the output data to be interpreted as UTF-8 data, and passed as strings. Calling `readable.setEncoding('hex')` will cause the data to be encoded in hexadecimal string format.

  The `Readable` stream will properly handle multi-byte characters delivered through the stream that would otherwise become improperly decoded if simply pulled from the stream as `Buffer` objects.

      const readable = getReadableStreamSomehow();
      readable.setEncoding('utf8');
      readable.on('data', (chunk) => {
        assert.equal(typeof chunk, 'string');
        console.log('Got %d characters of string data:', chunk.length);
      });

  since

    v0.9.4

  #### Parameters

  - ##### encoding: BufferEncoding

    The encoding to use.

  #### Returns this

### some

- some(fn: (data: any, options?: Abortable) => boolean | Promise<boolean>, options?: Pick<ReadableOperatorOptions, "concurrency" | "signal">): Promise<boolean>

- Inherited from BufferBuilder.some

  - Defined in @types/node/stream.d.ts:566

  This method is similar to `Array.prototype.some` and calls fn on each chunk in the stream until the awaited return value is `true` (or any truthy value). Once an fn call on a chunk `await`ed return value is truthy, the stream is destroyed and the promise is fulfilled with `true`. If none of the fn calls on the chunks return a truthy value, the promise is fulfilled with `false`.

  since

    v17.5.0

  #### Parameters

  - ##### fn: (data: any, options?: Abortable) => boolean | Promise<boolean>

    a function to call on each chunk of the stream. Async or not.

    - - (data: any, options?: Abortable): boolean | Promise<boolean>

      - #### Parameters

        - ##### data: any

        - ##### Optional options: Abortable

        #### Returns boolean | Promise<boolean>

  - ##### Optional options: Pick<ReadableOperatorOptions, "concurrency" | "signal">

  #### Returns Promise<boolean>

  a promise evaluating to `true` if fn returned a truthy value for at least one of the chunks.

### take

- take(limit: number, options?: Abortable): Readable

- Inherited from BufferBuilder.take

  - Defined in @types/node/stream.d.ts:628

  This method returns a new stream with the first limit chunks.

  since

    v17.5.0

  #### Parameters

  - ##### limit: number

    the number of chunks to take from the readable.

  - ##### Optional options: Abortable

  #### Returns Readable

  a stream with limit chunks taken.

### toArray

- toArray(options?: Abortable): Promise<any[]>

- Inherited from BufferBuilder.toArray

  - Defined in @types/node/stream.d.ts:556

  This method allows easily obtaining the contents of a stream.

  As this method reads the entire stream into memory, it negates the benefits of streams. It's intended for interoperability and convenience, not as the primary way to consume streams.

  since

    v17.5.0

  #### Parameters

  - ##### Optional options: Abortable

  #### Returns Promise<any[]>

  a promise containing an array with the contents of the stream.

### uncork

- uncork(): void

- Inherited from BufferBuilder.uncork

  - Defined in @types/node/stream.d.ts:981

  The `writable.uncork()` method flushes all data buffered since cork was called.

  When using `writable.cork()` and `writable.uncork()` to manage the buffering of writes to a stream, defer calls to `writable.uncork()` using `process.nextTick()`. Doing so allows batching of all `writable.write()` calls that occur within a given Node.js event loop phase.

      stream.cork();
      stream.write('some ');
      stream.write('data ');
      process.nextTick(() => stream.uncork());

  If the `writable.cork()` method is called multiple times on a stream, the same number of calls to `writable.uncork()` must be called to flush the buffered data.

      stream.cork();
      stream.write('some ');
      stream.cork();
      stream.write('data ');
      process.nextTick(() => {
        stream.uncork();
        // The data will not be flushed until uncork() is called a second time.
        stream.uncork();
      });

  See also: `writable.cork()`.

  since

    v0.11.2

  #### Returns void

### unpipe

- unpipe(destination?: WritableStream): this

- Inherited from BufferBuilder.unpipe

  - Defined in @types/node/stream.d.ts:380

  The `readable.unpipe()` method detaches a `Writable` stream previously attached using the pipe method.

  If the `destination` is not specified, then all pipes are detached.

  If the `destination` is specified, but no pipe is set up for it, then the method does nothing.

      import fs from 'node:fs';
      const readable = getReadableStreamSomehow();
      const writable = fs.createWriteStream('file.txt');
      // All the data from readable goes into 'file.txt',
      // but only for the first second.
      readable.pipe(writable);
      setTimeout(() => {
        console.log('Stop writing to file.txt.');
        readable.unpipe(writable);
        console.log('Manually close the file stream.');
        writable.end();
      }, 1000);

  since

    v0.9.4

  #### Parameters

  - ##### Optional destination: WritableStream

    Optional specific stream to unpipe

  #### Returns this

### unshift

- unshift(chunk: any, encoding?: BufferEncoding): void

- Inherited from BufferBuilder.unshift

  - Defined in @types/node/stream.d.ts:446

  Passing `chunk` as `null` signals the end of the stream (EOF) and behaves the same as `readable.push(null)`, after which no more data can be written. The EOF signal is put at the end of the buffer and any buffered data will still be flushed.

  The `readable.unshift()` method pushes a chunk of data back into the internal buffer. This is useful in certain situations where a stream is being consumed by code that needs to "un-consume" some amount of data that it has optimistically pulled out of the source, so that the data can be passed on to some other party.

  The `stream.unshift(chunk)` method cannot be called after the `'end'` event has been emitted or a runtime error will be thrown.

  Developers using `stream.unshift()` often should consider switching to use of a `Transform` stream instead. See the `API for stream implementers` section for more information.

      // Pull off a header delimited by \n\n.
      // Use unshift() if we get too much.
      // Call the callback with (error, header, stream).
      import { StringDecoder } from 'node:string_decoder';
      function parseHeader(stream, callback) {
        stream.on('error', callback);
        stream.on('readable', onReadable);
        const decoder = new StringDecoder('utf8');
        let header = '';
        function onReadable() {
          let chunk;
          while (null !== (chunk = stream.read())) {
            const str = decoder.write(chunk);
            if (str.includes('\n\n')) {
              // Found the header boundary.
              const split = str.split(/\n\n/);
              header += split.shift();
              const remaining = split.join('\n\n');
              const buf = Buffer.from(remaining, 'utf8');
              stream.removeListener('error', callback);
              // Remove the 'readable' listener before unshifting.
              stream.removeListener('readable', onReadable);
              if (buf.length)
                stream.unshift(buf);
              // Now the body of the message can be read from the stream.
              callback(null, header, stream);
              return;
            }
            // Still reading the header.
            header += str;
          }
        }
      }

  Unlike push, `stream.unshift(chunk)` will not end the reading process by resetting the internal reading state of the stream. This can cause unexpected results if `readable.unshift()` is called during a read (i.e. from within a _read implementation on a custom stream). Following the call to `readable.unshift()` with an immediate push will reset the reading state appropriately, however it is best to simply avoid calling `readable.unshift()` while in the process of performing a read.

  since

    v0.9.11

  #### Parameters

  - ##### chunk: any

    Chunk of data to unshift onto the read queue. For streams not operating in object mode, `chunk` must be a {string}, {Buffer}, {TypedArray}, {DataView} or `null`. For object mode streams, `chunk` may be any JavaScript value.

  - ##### Optional encoding: BufferEncoding

    Encoding of string chunks. Must be a valid `Buffer` encoding, such as `'utf8'` or `'ascii'`.

  #### Returns void

### wrap

- wrap(stream: ReadableStream): this

- Inherited from BufferBuilder.wrap

  - Defined in @types/node/stream.d.ts:472

  Prior to Node.js 0.10, streams did not implement the entire `node:stream` module API as it is currently defined. (See `Compatibility` for more information.)

  When using an older Node.js library that emits `'data'` events and has a pause method that is advisory only, the `readable.wrap()` method can be used to create a `Readable` stream that uses the old stream as its data source.

  It will rarely be necessary to use `readable.wrap()` but the method has been provided as a convenience for interacting with older Node.js applications and libraries.

      import { OldReader } from './old-api-module.js';
      import { Readable } from 'node:stream';
      const oreader = new OldReader();
      const myReader = new Readable().wrap(oreader);

      myReader.on('readable', () => {
        myReader.read(); // etc.
      });

  since

    v0.9.4

  #### Parameters

  - ##### stream: ReadableStream

    An "old style" readable stream

  #### Returns this

### write

- write(chunk: any, callback?: (error: Error | null | undefined) => void): boolean
- write(chunk: any, encoding: BufferEncoding, callback?: (error: Error | null | undefined) => void): boolean

- Inherited from BufferBuilder.write

  - Defined in @types/node/stream.d.ts:900

  The `writable.write()` method writes some data to the stream, and calls the supplied `callback` once the data has been fully handled. If an error occurs, the `callback` will be called with the error as its first argument. The `callback` is called asynchronously and before `'error'` is emitted.

  The return value is `true` if the internal buffer is less than the `highWaterMark` configured when the stream was created after admitting `chunk`. If `false` is returned, further attempts to write data to the stream should stop until the `'drain'` event is emitted.

  While a stream is not draining, calls to `write()` will buffer `chunk`, and return false. Once all currently buffered chunks are drained (accepted for delivery by the operating system), the `'drain'` event will be emitted. Once `write()` returns false, do not write more chunks until the `'drain'` event is emitted. While calling `write()` on a stream that is not draining is allowed, Node.js will buffer all written chunks until maximum memory usage occurs, at which point it will abort unconditionally. Even before it aborts, high memory usage will cause poor garbage collector performance and high RSS (which is not typically released back to the system, even after the memory is no longer required). Since TCP sockets may never drain if the remote peer does not read the data, writing a socket that is not draining may lead to a remotely exploitable vulnerability.

  Writing data while the stream is not draining is particularly problematic for a `Transform`, because the `Transform` streams are paused by default until they are piped or a `'data'` or `'readable'` event handler is added.

  If the data to be written can be generated or fetched on demand, it is recommended to encapsulate the logic into a `Readable` and use pipe. However, if calling `write()` is preferred, it is possible to respect backpressure and avoid memory issues using the `'drain'` event:

      function write(data, cb) {
        if (!stream.write(data)) {
          stream.once('drain', cb);
        } else {
          process.nextTick(cb);
        }
      }

      // Wait for cb to be called before doing any other write.
      write('hello', () => {
        console.log('Write completed, do more writes now.');
      });

  A `Writable` stream in object mode will always ignore the `encoding` argument.

  since

    v0.9.4

  #### Parameters

  - ##### chunk: any

    Optional data to write. For streams not operating in object mode, `chunk` must be a {string}, {Buffer}, {TypedArray} or {DataView}. For object mode streams, `chunk` may be any JavaScript value other than `null`.

  - ##### Optional callback: (error: Error | null | undefined) => void

    Callback for when this chunk of data is flushed.

    - - (error: Error | null | undefined): void

      - #### Parameters

        - ##### error: Error | null | undefined

        #### Returns void

  #### Returns boolean

  `false` if the stream wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.

- Inherited from BufferBuilder.write

  - Defined in @types/node/stream.d.ts:901

  #### Parameters

  - ##### chunk: any

  - ##### encoding: BufferEncoding

  - ##### Optional callback: (error: Error | null | undefined) => void

    - - (error: Error | null | undefined): void

      - #### Parameters

        - ##### error: Error | null | undefined

        #### Returns void

  #### Returns boolean

### Static from

- from(src: ReadableStream | WritableStream | Blob | string | Iterable<any> | AsyncIterable<any> | ((source: AsyncIterable<any>) => AsyncIterable<any>) | ((source: AsyncIterable<any>) => Promise<void>) | Promise<any> | ReadableWritablePair | ReadableStream | WritableStream): Duplex

- Inherited from BufferBuilder.from

  Overrides Readable.from

  - Defined in @types/node/stream.d.ts:1093

  A utility method for creating duplex streams.

  - `Stream` converts writable stream into writable `Duplex` and readable stream to `Duplex`.
  - `Blob` converts into readable `Duplex`.
  - `string` converts into readable `Duplex`.
  - `ArrayBuffer` converts into readable `Duplex`.
  - `AsyncIterable` converts into a readable `Duplex`. Cannot yield `null`.
  - `AsyncGeneratorFunction` converts into a readable/writable transform `Duplex`. Must take a source `AsyncIterable` as first parameter. Cannot yield `null`.
  - `AsyncFunction` converts into a writable `Duplex`. Must return either `null` or `undefined`
  - `Object ({ writable, readable })` converts `readable` and `writable` into `Stream` and then combines them into `Duplex` where the `Duplex` will write to the `writable` and read from the `readable`.
  - `Promise` converts into readable `Duplex`. Value `null` is ignored.
  since

    v16.8.0

  #### Parameters

  - ##### src: ReadableStream | WritableStream | Blob | string | Iterable<any> | AsyncIterable<any> | ((source: AsyncIterable<any>) => AsyncIterable<any>) | ((source: AsyncIterable<any>) => Promise<void>) | Promise<any> | ReadableWritablePair | ReadableStream | WritableStream

  #### Returns Duplex

### Static fromWeb

- fromWeb(duplexStream: ReadableWritablePair, options?: Pick<DuplexOptions, "allowHalfOpen" | "decodeStrings" | "encoding" | "highWaterMark" | "objectMode" | "signal">): Duplex

- Inherited from BufferBuilder.fromWeb

  Overrides Readable.fromWeb

  - Defined in @types/node/stream.d.ts:1117

  A utility method for creating a `Duplex` from a web `ReadableStream` and `WritableStream`.

  since

    v17.0.0

  #### Parameters

  - ##### duplexStream: ReadableWritablePair

  - ##### Optional options: Pick<DuplexOptions, "allowHalfOpen" | "decodeStrings" | "encoding" | "highWaterMark" | "objectMode" | "signal">

  #### Returns Duplex

### Static isDisturbed

- isDisturbed(stream: ReadableStream | ReadableStream): boolean

- Inherited from BufferBuilder.isDisturbed

  - Defined in @types/node/stream.d.ts:126

  Returns whether the stream has been read from or cancelled.

  since

    v16.8.0

  #### Parameters

  - ##### stream: ReadableStream | ReadableStream

  #### Returns boolean

### Static toWeb

- toWeb(streamDuplex: ReadWriteStream): ReadableWritablePair

- Inherited from BufferBuilder.toWeb

  Overrides Readable.toWeb

  - Defined in @types/node/stream.d.ts:1112

  A utility method for creating a web `ReadableStream` and `WritableStream` from a `Duplex`.

  since

    v17.0.0

  #### Parameters

  - ##### streamDuplex: ReadWriteStream

  #### Returns ReadableWritablePair

Generated using TypeDoc