@node-red/editor-client 3.1.8 → 4.0.0-beta.2

package/public/types/node/stream/web.d.ts

@@ -1,10 +1,9 @@
 
-/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
+/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/node-red/nr-monaco-build */
 
 declare module 'stream/web' {
     // stub module, pending copy&paste from .d.ts or manual impl
     // copy from lib.dom.d.ts
-
     interface ReadableWritablePair<R = any, W = any> {
         readable: ReadableStream<R>;
         /**
@@ -18,7 +17,6 @@ declare module 'stream/web' {
          */
         writable: WritableStream<W>;
     }
-
     interface StreamPipeOptions {
         preventAbort?: boolean;
         preventCancel?: boolean;
@@ -66,70 +64,53 @@ declare module 'stream/web' {
         preventClose?: boolean;
         signal?: AbortSignal;
     }
-
     interface ReadableStreamGenericReader {
         readonly closed: Promise<undefined>;
         cancel(reason?: any): Promise<void>;
     }
-
     interface ReadableStreamDefaultReadValueResult<T> {
         done: false;
         value: T;
     }
-
     interface ReadableStreamDefaultReadDoneResult {
         done: true;
         value?: undefined;
     }
     type ReadableStreamController<T> = ReadableStreamDefaultController<T>;
-    type ReadableStreamDefaultReadResult<T> =
-        | ReadableStreamDefaultReadValueResult<T>
-        | ReadableStreamDefaultReadDoneResult;
-
+    type ReadableStreamDefaultReadResult<T> = ReadableStreamDefaultReadValueResult<T> | ReadableStreamDefaultReadDoneResult;
     interface ReadableByteStreamControllerCallback {
         (controller: ReadableByteStreamController): void | PromiseLike<void>;
     }
-
     interface UnderlyingSinkAbortCallback {
         (reason?: any): void | PromiseLike<void>;
     }
-
     interface UnderlyingSinkCloseCallback {
         (): void | PromiseLike<void>;
     }
-
     interface UnderlyingSinkStartCallback {
         (controller: WritableStreamDefaultController): any;
     }
-
     interface UnderlyingSinkWriteCallback<W> {
         (chunk: W, controller: WritableStreamDefaultController): void | PromiseLike<void>;
     }
-
     interface UnderlyingSourceCancelCallback {
         (reason?: any): void | PromiseLike<void>;
     }
-
     interface UnderlyingSourcePullCallback<R> {
         (controller: ReadableStreamController<R>): void | PromiseLike<void>;
     }
-
     interface UnderlyingSourceStartCallback<R> {
         (controller: ReadableStreamController<R>): any;
     }
-
     interface TransformerFlushCallback<O> {
         (controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
     }
-
     interface TransformerStartCallback<O> {
         (controller: TransformStreamDefaultController<O>): any;
     }
-
     interface TransformerTransformCallback<I, O> {
         (chunk: I, controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
     }
-
     interface UnderlyingByteSource {
         autoAllocateChunkSize?: number;
         cancel?: ReadableStreamErrorCallback;
@@ -137,14 +118,12 @@ declare module 'stream/web' {
         start?: ReadableByteStreamControllerCallback;
         type: 'bytes';
     }
-
     interface UnderlyingSource<R = any> {
         cancel?: UnderlyingSourceCancelCallback;
         pull?: UnderlyingSourcePullCallback<R>;
         start?: UnderlyingSourceStartCallback<R>;
         type?: undefined;
     }
-
     interface UnderlyingSink<W = any> {
         abort?: UnderlyingSinkAbortCallback;
         close?: UnderlyingSinkCloseCallback;
@@ -152,11 +131,9 @@ declare module 'stream/web' {
         type?: undefined;
         write?: UnderlyingSinkWriteCallback<W>;
     }
-
     interface ReadableStreamErrorCallback {
         (reason: any): void | PromiseLike<void>;
     }
-
     /** This Streams API interface represents a readable stream of byte data. */
     interface ReadableStream<R = any> {
         readonly locked: boolean;
@@ -168,29 +145,21 @@ declare module 'stream/web' {
         values(options?: { preventCancel?: boolean }): AsyncIterableIterator<R>;
         [Symbol.asyncIterator](): AsyncIterableIterator<R>;
     }
-
     const ReadableStream: {
         prototype: ReadableStream;
-        new (
-            underlyingSource: UnderlyingByteSource,
-            strategy?: QueuingStrategy<Uint8Array>,
-        ): ReadableStream<Uint8Array>;
+        new (underlyingSource: UnderlyingByteSource, strategy?: QueuingStrategy<Uint8Array>): ReadableStream<Uint8Array>;
         new <R = any>(underlyingSource?: UnderlyingSource<R>, strategy?: QueuingStrategy<R>): ReadableStream<R>;
     };
-
     interface ReadableStreamDefaultReader<R = any> extends ReadableStreamGenericReader {
         read(): Promise<ReadableStreamDefaultReadResult<R>>;
         releaseLock(): void;
     }
-
     const ReadableStreamDefaultReader: {
         prototype: ReadableStreamDefaultReader;
         new <R = any>(stream: ReadableStream<R>): ReadableStreamDefaultReader<R>;
     };
-
     const ReadableStreamBYOBReader: any;
     const ReadableStreamBYOBRequest: any;
-
     interface ReadableByteStreamController {
         readonly byobRequest: undefined;
         readonly desiredSize: number | null;
@@ -198,24 +167,20 @@ declare module 'stream/web' {
         enqueue(chunk: ArrayBufferView): void;
         error(error?: any): void;
     }
-
     const ReadableByteStreamController: {
         prototype: ReadableByteStreamController;
         new (): ReadableByteStreamController;
     };
-
     interface ReadableStreamDefaultController<R = any> {
         readonly desiredSize: number | null;
         close(): void;
         enqueue(chunk?: R): void;
         error(e?: any): void;
     }
-
     const ReadableStreamDefaultController: {
         prototype: ReadableStreamDefaultController;
         new (): ReadableStreamDefaultController;
     };
-
     interface Transformer<I = any, O = any> {
         flush?: TransformerFlushCallback<O>;
         readableType?: undefined;
@@ -223,33 +188,24 @@ declare module 'stream/web' {
         transform?: TransformerTransformCallback<I, O>;
         writableType?: undefined;
     }
-
     interface TransformStream<I = any, O = any> {
         readonly readable: ReadableStream<O>;
         readonly writable: WritableStream<I>;
     }
-
     const TransformStream: {
         prototype: TransformStream;
-        new <I = any, O = any>(
-            transformer?: Transformer<I, O>,
-            writableStrategy?: QueuingStrategy<I>,
-            readableStrategy?: QueuingStrategy<O>,
-        ): TransformStream<I, O>;
+        new <I = any, O = any>(transformer?: Transformer<I, O>, writableStrategy?: QueuingStrategy<I>, readableStrategy?: QueuingStrategy<O>): TransformStream<I, O>;
     };
-
     interface TransformStreamDefaultController<O = any> {
         readonly desiredSize: number | null;
         enqueue(chunk?: O): void;
         error(reason?: any): void;
         terminate(): void;
     }
-
     const TransformStreamDefaultController: {
         prototype: TransformStreamDefaultController;
         new (): TransformStreamDefaultController;
     };
-
     /**
      * This Streams API interface provides a standard abstraction for writing
      * streaming data to a destination, known as a sink. This object comes with
@@ -261,12 +217,10 @@ declare module 'stream/web' {
         close(): Promise<void>;
         getWriter(): WritableStreamDefaultWriter<W>;
     }
-
     const WritableStream: {
         prototype: WritableStream;
         new <W = any>(underlyingSink?: UnderlyingSink<W>, strategy?: QueuingStrategy<W>): WritableStream<W>;
     };
-
     /**
      * This Streams API interface is the object returned by
      * WritableStream.getWriter() and once created locks the < writer to the
@@ -282,12 +236,10 @@ declare module 'stream/web' {
         releaseLock(): void;
         write(chunk?: W): Promise<void>;
     }
-
     const WritableStreamDefaultWriter: {
         prototype: WritableStreamDefaultWriter;
         new <W = any>(stream: WritableStream<W>): WritableStreamDefaultWriter<W>;
     };
-
     /**
      * This Streams API interface represents a controller allowing control of a
      * WritableStream's state. When constructing a WritableStream, the
@@ -297,21 +249,17 @@ declare module 'stream/web' {
     interface WritableStreamDefaultController {
         error(e?: any): void;
     }
-
     const WritableStreamDefaultController: {
         prototype: WritableStreamDefaultController;
         new (): WritableStreamDefaultController;
     };
-
     interface QueuingStrategy<T = any> {
         highWaterMark?: number;
         size?: QueuingStrategySize<T>;
     }
-
     interface QueuingStrategySize<T = any> {
         (chunk?: T): number;
     }
-
     interface QueuingStrategyInit {
         /**
          * Creates a new ByteLengthQueuingStrategy with the provided high water
@@ -324,7 +272,6 @@ declare module 'stream/web' {
          */
         highWaterMark: number;
     }
-
     /**
      * This Streams API interface provides a built-in byte length queuing
      * strategy that can be used when constructing streams.
@@ -333,12 +280,10 @@ declare module 'stream/web' {
         readonly highWaterMark: number;
         readonly size: QueuingStrategySize<ArrayBufferView>;
     }
-
     const ByteLengthQueuingStrategy: {
         prototype: ByteLengthQueuingStrategy;
         new (init: QueuingStrategyInit): ByteLengthQueuingStrategy;
     };
-
     /**
      * This Streams API interface provides a built-in byte length queuing
      * strategy that can be used when constructing streams.
@@ -347,12 +292,10 @@ declare module 'stream/web' {
         readonly highWaterMark: number;
         readonly size: QueuingStrategySize;
     }
-
     const CountQueuingStrategy: {
         prototype: CountQueuingStrategy;
         new (init: QueuingStrategyInit): CountQueuingStrategy;
     };
-
     interface TextEncoderStream {
         /** Returns "utf-8". */
         readonly encoding: 'utf-8';
@@ -360,19 +303,15 @@ declare module 'stream/web' {
         readonly writable: WritableStream<string>;
         readonly [Symbol.toStringTag]: string;
     }
-
     const TextEncoderStream: {
         prototype: TextEncoderStream;
         new (): TextEncoderStream;
     };
-
     interface TextDecoderOptions {
         fatal?: boolean;
         ignoreBOM?: boolean;
     }
-
     type BufferSource = ArrayBufferView | ArrayBuffer;
-
     interface TextDecoderStream {
         /** Returns encoding's name, lower cased. */
         readonly encoding: string;
@@ -384,7 +323,6 @@ declare module 'stream/web' {
         readonly writable: WritableStream<BufferSource>;
         readonly [Symbol.toStringTag]: string;
     }
-
     const TextDecoderStream: {
         prototype: TextDecoderStream;
         new (label?: string, options?: TextDecoderOptions): TextDecoderStream;

package/public/types/node/stream.d.ts

@@ -1,5 +1,5 @@
 
-/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
+/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/node-red/nr-monaco-build */
 
 /**
  * A stream is an abstract interface for working with streaming data in Node.js.
@@ -17,13 +17,14 @@
  *
  * The `stream` module is useful for creating new types of stream instances. It is
  * usually not necessary to use the `stream` module to consume streams.
- * @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/stream.js)
+ * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/stream.js)
  */
 declare module 'stream' {
     import { EventEmitter, Abortable } from 'node:events';
-    import { Blob as NodeBlob } from 'node:buffer';
+    import { Blob as NodeBlob } from "node:buffer";
     import * as streamPromises from 'node:stream/promises';
     import * as streamConsumers from 'node:stream/consumers';
+    import * as streamWeb from 'node:stream/web';
     class internal extends EventEmitter {
         pipe<T extends NodeJS.WritableStream>(
             destination: T,
@@ -56,11 +57,23 @@ declare module 'stream' {
              * A utility method for creating Readable Streams out of iterators.
              */
             static from(iterable: Iterable<any> | AsyncIterable<any>, options?: ReadableOptions): Readable;
+            /**
+             * A utility method for creating a `Readable` from a web `ReadableStream`.
+             * @since v17.0.0
+             * @experimental
+             */
+            static fromWeb(readableStream: streamWeb.ReadableStream, options?: Pick<ReadableOptions, 'encoding' | 'highWaterMark' | 'objectMode' | 'signal'>): Readable;
             /**
              * Returns whether the stream has been read from or cancelled.
              * @since v16.8.0
              */
             static isDisturbed(stream: Readable | NodeJS.ReadableStream): boolean;
+            /**
+             * A utility method for creating a web `ReadableStream` from a `Readable`.
+             * @since v17.0.0
+             * @experimental
+             */
+            static toWeb(streamReadable: Readable): streamWeb.ReadableStream;
             /**
              * Returns whether the stream was destroyed or errored before emitting `'end'`.
              * @since v16.8.0
@@ -75,7 +88,7 @@ declare module 'stream' {
             readable: boolean;
             /**
              * Returns whether `'data'` has been emitted.
-             * @since v16.7.0
+             * @since v16.7.0, v14.18.0
              * @experimental
              */
             readonly readableDidRead: boolean;
@@ -117,13 +130,23 @@ declare module 'stream' {
              * @since v8.0.0
              */
             destroyed: boolean;
+            /**
+             * Is true after 'close' has been emitted.
+             * @since v18.0.0
+             */
+            readonly closed: boolean;
+            /**
+             * Returns error if the stream has been destroyed with an error.
+             * @since v18.0.0
+             */
+            readonly errored: Error | null;
             constructor(opts?: ReadableOptions);
             _construct?(callback: (error?: Error | null) => void): void;
             _read(size: number): void;
             /**
-             * The `readable.read()` method pulls some data out of the internal buffer and
-             * returns it. If no data available to be read, `null` is returned. By default,
-             * the data will be returned as a `Buffer` object unless an encoding has been
+             * 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.
              *
@@ -338,7 +361,7 @@ declare module 'stream' {
              *     let chunk;
              *     while (null !== (chunk = stream.read())) {
              *       const str = decoder.write(chunk);
-             *       if (str.match(/\n\n/)) {
+             *       if (str.includes('\n\n')) {
              *         // Found the header boundary.
              *         const split = str.split(/\n\n/);
              *         header += split.shift();
@@ -351,10 +374,10 @@ declare module 'stream' {
              *           stream.unshift(buf);
              *         // Now the body of the message can be read from the stream.
              *         callback(null, header, stream);
-             *       } else {
-             *         // Still reading the header.
-             *         header += str;
+             *         return;
              *       }
+             *       // Still reading the header.
+             *       header += str;
              *     }
              *   }
              * }
@@ -500,6 +523,18 @@ declare module 'stream' {
          * @since v0.9.4
          */
         class Writable extends Stream implements NodeJS.WritableStream {
+            /**
+             * A utility method for creating a `Writable` from a web `WritableStream`.
+             * @since v17.0.0
+             * @experimental
+             */
+            static fromWeb(writableStream: streamWeb.WritableStream, options?: Pick<WritableOptions, 'decodeStrings' | 'highWaterMark' | 'objectMode' | 'signal'>): Writable;
+            /**
+             * A utility method for creating a web `WritableStream` from a `Writable`.
+             * @since v17.0.0
+             * @experimental
+             */
+            static toWeb(streamWritable: Writable): streamWeb.WritableStream;
             /**
              * Is `true` if it is safe to call `writable.write()`, which means
              * the stream has not been destroyed, errored or ended.
@@ -545,6 +580,21 @@ declare module 'stream' {
              * @since v8.0.0
              */
             destroyed: boolean;
+            /**
+             * Is true after 'close' has been emitted.
+             * @since v18.0.0
+             */
+            readonly closed: boolean;
+            /**
+             * Returns error if the stream has been destroyed with an error.
+             * @since v18.0.0
+             */
+            readonly errored: Error | null;
+            /**
+             * Is `true` if the stream's buffer has been full and stream will emit 'drain'.
+             * @since v15.2.0, v14.17.0
+             */
+            readonly writableNeedDrain: boolean;
             constructor(opts?: WritableOptions);
             _write(chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
             _writev?(
@@ -571,7 +621,7 @@ declare module 'stream' {
              * 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.
-             * It is recommended that once `write()` returns false, no more chunks be written
+             * 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.
@@ -665,8 +715,8 @@ declare module 'stream' {
              * The `writable.uncork()` method flushes all data buffered since {@link cork} was called.
              *
              * When using `writable.cork()` and `writable.uncork()` to manage the buffering
-             * of writes to a stream, it is recommended that calls to `writable.uncork()` be
-             * deferred using `process.nextTick()`. Doing so allows batching of all`writable.write()` calls that occur within a given Node.js event loop phase.
+             * 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.
              *
              * ```js
              * stream.cork();
@@ -811,6 +861,9 @@ declare module 'stream' {
             readonly writableLength: number;
             readonly writableObjectMode: boolean;
             readonly writableCorked: number;
+            readonly writableNeedDrain: boolean;
+            readonly closed: boolean;
+            readonly errored: Error | null;
             /**
              * If `false` then the stream will automatically end the writable side when the
              * readable side ends. Set initially by the `allowHalfOpen` constructor option,
@@ -862,105 +915,6 @@ declare module 'stream' {
             end(chunk: any, encoding?: BufferEncoding, cb?: () => void): this;
             cork(): void;
             uncork(): void;
-            /**
-             * Event emitter
-             * The defined events on documents including:
-             * 1.  close
-             * 2.  data
-             * 3.  drain
-             * 4.  end
-             * 5.  error
-             * 6.  finish
-             * 7.  pause
-             * 8.  pipe
-             * 9.  readable
-             * 10. resume
-             * 11. unpipe
-             */
-            addListener(event: 'close', listener: () => void): this;
-            addListener(event: 'data', listener: (chunk: any) => void): this;
-            addListener(event: 'drain', listener: () => void): this;
-            addListener(event: 'end', listener: () => void): this;
-            addListener(event: 'error', listener: (err: Error) => void): this;
-            addListener(event: 'finish', listener: () => void): this;
-            addListener(event: 'pause', listener: () => void): this;
-            addListener(event: 'pipe', listener: (src: Readable) => void): this;
-            addListener(event: 'readable', listener: () => void): this;
-            addListener(event: 'resume', listener: () => void): this;
-            addListener(event: 'unpipe', listener: (src: Readable) => void): this;
-            addListener(event: string | symbol, listener: (...args: any[]) => void): this;
-            emit(event: 'close'): boolean;
-            emit(event: 'data', chunk: any): boolean;
-            emit(event: 'drain'): boolean;
-            emit(event: 'end'): boolean;
-            emit(event: 'error', err: Error): boolean;
-            emit(event: 'finish'): boolean;
-            emit(event: 'pause'): boolean;
-            emit(event: 'pipe', src: Readable): boolean;
-            emit(event: 'readable'): boolean;
-            emit(event: 'resume'): boolean;
-            emit(event: 'unpipe', src: Readable): boolean;
-            emit(event: string | symbol, ...args: any[]): boolean;
-            on(event: 'close', listener: () => void): this;
-            on(event: 'data', listener: (chunk: any) => void): this;
-            on(event: 'drain', listener: () => void): this;
-            on(event: 'end', listener: () => void): this;
-            on(event: 'error', listener: (err: Error) => void): this;
-            on(event: 'finish', listener: () => void): this;
-            on(event: 'pause', listener: () => void): this;
-            on(event: 'pipe', listener: (src: Readable) => void): this;
-            on(event: 'readable', listener: () => void): this;
-            on(event: 'resume', listener: () => void): this;
-            on(event: 'unpipe', listener: (src: Readable) => void): this;
-            on(event: string | symbol, listener: (...args: any[]) => void): this;
-            once(event: 'close', listener: () => void): this;
-            once(event: 'data', listener: (chunk: any) => void): this;
-            once(event: 'drain', listener: () => void): this;
-            once(event: 'end', listener: () => void): this;
-            once(event: 'error', listener: (err: Error) => void): this;
-            once(event: 'finish', listener: () => void): this;
-            once(event: 'pause', listener: () => void): this;
-            once(event: 'pipe', listener: (src: Readable) => void): this;
-            once(event: 'readable', listener: () => void): this;
-            once(event: 'resume', listener: () => void): this;
-            once(event: 'unpipe', listener: (src: Readable) => void): this;
-            once(event: string | symbol, listener: (...args: any[]) => void): this;
-            prependListener(event: 'close', listener: () => void): this;
-            prependListener(event: 'data', listener: (chunk: any) => void): this;
-            prependListener(event: 'drain', listener: () => void): this;
-            prependListener(event: 'end', listener: () => void): this;
-            prependListener(event: 'error', listener: (err: Error) => void): this;
-            prependListener(event: 'finish', listener: () => void): this;
-            prependListener(event: 'pause', listener: () => void): this;
-            prependListener(event: 'pipe', listener: (src: Readable) => void): this;
-            prependListener(event: 'readable', listener: () => void): this;
-            prependListener(event: 'resume', listener: () => void): this;
-            prependListener(event: 'unpipe', listener: (src: Readable) => void): this;
-            prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
-            prependOnceListener(event: 'close', listener: () => void): this;
-            prependOnceListener(event: 'data', listener: (chunk: any) => void): this;
-            prependOnceListener(event: 'drain', listener: () => void): this;
-            prependOnceListener(event: 'end', listener: () => void): this;
-            prependOnceListener(event: 'error', listener: (err: Error) => void): this;
-            prependOnceListener(event: 'finish', listener: () => void): this;
-            prependOnceListener(event: 'pause', listener: () => void): this;
-            prependOnceListener(event: 'pipe', listener: (src: Readable) => void): this;
-            prependOnceListener(event: 'readable', listener: () => void): this;
-            prependOnceListener(event: 'resume', listener: () => void): this;
-            prependOnceListener(event: 'unpipe', listener: (src: Readable) => void): this;
-            prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
-            removeListener(event: 'close', listener: () => void): this;
-            removeListener(event: 'data', listener: (chunk: any) => void): this;
-            removeListener(event: 'drain', listener: () => void): this;
-            removeListener(event: 'end', listener: () => void): this;
-            removeListener(event: 'error', listener: (err: Error) => void): this;
-            removeListener(event: 'finish', listener: () => void): this;
-            removeListener(event: 'pause', listener: () => void): this;
-            removeListener(event: 'pipe', listener: (src: Readable) => void): this;
-            removeListener(event: 'readable', listener: () => void): this;
-            removeListener(event: 'resume', listener: () => void): this;
-            removeListener(event: 'unpipe', listener: (src: Readable) => void): this;
-            removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
         }
         type TransformCallback = (error?: Error | null, data?: any) => void;
         interface TransformOptions extends DuplexOptions {
@@ -1209,7 +1163,7 @@ declare module 'stream' {
          * async function run() {
          *   await pipeline(
          *     fs.createReadStream('lowercase.txt'),
-         *     async function* (source, signal) {
+         *     async function* (source, { signal }) {
          *       source.setEncoding('utf8');  // Work with strings rather than `Buffer`s.
          *       for await (const chunk of source) {
          *         yield await processChunk(chunk, { signal });
@@ -1233,7 +1187,7 @@ declare module 'stream' {
          *
          * async function run() {
          *   await pipeline(
-         *     async function * (signal) {
+         *     async function* ({ signal }) {
          *       await someLongRunningfn({ signal });
          *       yield 'asd';
          *     },
@@ -1252,7 +1206,31 @@ declare module 'stream' {
          *
          * `stream.pipeline()` leaves dangling event listeners on the streams
          * after the `callback` has been invoked. In the case of reuse of streams after
-         * failure, this can cause event listener leaks and swallowed errors.
+         * failure, this can cause event listener leaks and swallowed errors. If the last
+         * stream is readable, dangling event listeners will be removed so that the last
+         * stream can be consumed later.
+         *
+         * `stream.pipeline()` closes all the streams when an error is raised.
+         * The `IncomingRequest` usage with `pipeline` could lead to an unexpected behavior
+         * once it would destroy the socket without sending the expected response.
+         * See the example below:
+         *
+         * ```js
+         * const fs = require('fs');
+         * const http = require('http');
+         * const { pipeline } = require('stream');
+         *
+         * const server = http.createServer((req, res) => {
+         *   const fileStream = fs.createReadStream('./fileNotExist.txt');
+         *   pipeline(fileStream, res, (err) => {
+         *     if (err) {
+         *       console.log(err); // No such file
+         *       // this message can't be sent once `pipeline` already destroyed the socket
+         *       return res.end('error!!!');
+         *     }
+         *   });
+         * });
+         * ```
          * @since v10.0.0
          * @param callback Called when the pipeline is fully done.
          */
@@ -1344,13 +1322,13 @@ declare module 'stream' {
 
         /**
          * Returns whether the stream has encountered an error.
-         * @since v16.14.0
+         * @since v17.3.0
          */
         function isErrored(stream: Readable | Writable | NodeJS.ReadableStream | NodeJS.WritableStream): boolean;
 
         /**
          * Returns whether the stream is readable.
-         * @since v16.14.0
+         * @since v17.4.0
          */
         function isReadable(stream: Readable | NodeJS.ReadableStream): boolean;
 

package/public/types/node/string_decoder.d.ts

@@ -1,5 +1,5 @@
 
-/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
+/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/node-red/nr-monaco-build */
 
 /**
  * The `string_decoder` module provides an API for decoding `Buffer` objects into
@@ -39,7 +39,7 @@
  * decoder.write(Buffer.from([0x82]));
  * console.log(decoder.end(Buffer.from([0xAC])));
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/string_decoder.js)
+ * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/string_decoder.js)
  */
 declare module 'string_decoder' {
     class StringDecoder {