@takeshape/streams 10.38.0 → 10.39.4

package/dist/index.d.ts

@@ -1,2 +1,3 @@
 export * from './streams';
+export * from './merge';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC"}

package/dist/index.js

@@ -13,4 +13,15 @@ Object.keys(_streams).forEach(function (key) {
       return _streams[key];
     }
   });
+});
+var _merge = require("./merge");
+Object.keys(_merge).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _merge[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _merge[key];
+    }
+  });
 });

package/dist/merge.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import { type Readable, PassThrough as PassThroughStream } from 'node:stream';
+export declare function mergeStreams(streams: Readable[]): MergedStream;
+declare class MergedStream extends PassThroughStream {
+    #private;
+    add(stream: Readable): void;
+    remove(stream: Readable): Promise<boolean>;
+}
+export {};
+//# sourceMappingURL=merge.d.ts.map

package/dist/merge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge.d.ts","sourceRoot":"","sources":["../../src/merge.ts"],"names":[],"mappings":";AAOA,OAAO,EACL,KAAK,QAAQ,EACb,WAAW,IAAI,iBAAiB,EAGjC,MAAM,aAAa,CAAC;AAGrB,wBAAgB,YAAY,CAAC,OAAO,EAAE,QAAQ,EAAE,GAAG,YAAY,CAsB9D;AAaD,cAAM,YAAa,SAAQ,iBAAiB;;IAQ1C,GAAG,CAAC,MAAM,EAAE,QAAQ;IAwBd,MAAM,CAAC,MAAM,EAAE,QAAQ;CAkB9B"}

package/dist/merge.js

@@ -0,0 +1,283 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.mergeStreams = mergeStreams;
+var _nodeEvents = require("node:events");
+var _nodeStream = require("node:stream");
+var _promises = require("node:stream/promises");
+/* istanbul ignore file */
+/**
+ * Borrowed code, due to ESM-only issues
+ *
+ * @link https://github.com/sindresorhus/merge-streams/blob/main/index.js
+ */
+
+function mergeStreams(streams) {
+  if (!Array.isArray(streams)) {
+    throw new TypeError(`Expected an array, got \`${typeof streams}\`.`);
+  }
+  for (const stream of streams) {
+    validateStream(stream);
+  }
+  const objectMode = streams.some(({
+    readableObjectMode
+  }) => readableObjectMode);
+  const highWaterMark = getHighWaterMark(streams, objectMode);
+  const passThroughStream = new MergedStream({
+    objectMode,
+    writableHighWaterMark: highWaterMark,
+    readableHighWaterMark: highWaterMark
+  });
+  for (const stream of streams) {
+    passThroughStream.add(stream);
+  }
+  return passThroughStream;
+}
+const getHighWaterMark = (streams, objectMode) => {
+  if (streams.length === 0) {
+    return (0, _nodeStream.getDefaultHighWaterMark)(objectMode);
+  }
+  const highWaterMarks = streams.filter(({
+    readableObjectMode
+  }) => readableObjectMode === objectMode).map(({
+    readableHighWaterMark
+  }) => readableHighWaterMark);
+  return Math.max(...highWaterMarks);
+};
+class MergedStream extends _nodeStream.PassThrough {
+  #streams = new Set([]);
+  #ended = new Set([]);
+  #aborted = new Set([]);
+  #onFinished;
+  #unpipeEvent = Symbol('unpipe');
+  #streamPromises = new WeakMap();
+  add(stream) {
+    validateStream(stream);
+    if (this.#streams.has(stream)) {
+      return;
+    }
+    this.#streams.add(stream);
+    this.#onFinished ??= onMergedStreamFinished(this, this.#streams, this.#unpipeEvent);
+    const streamPromise = endWhenStreamsDone({
+      passThroughStream: this,
+      stream,
+      streams: this.#streams,
+      ended: this.#ended,
+      aborted: this.#aborted,
+      onFinished: this.#onFinished,
+      unpipeEvent: this.#unpipeEvent
+    });
+    this.#streamPromises.set(stream, streamPromise);
+    stream.pipe(this, {
+      end: false
+    });
+  }
+  async remove(stream) {
+    validateStream(stream);
+    if (!this.#streams.has(stream)) {
+      return false;
+    }
+    const streamPromise = this.#streamPromises.get(stream);
+    if (streamPromise === undefined) {
+      return false;
+    }
+    this.#streamPromises.delete(stream);
+    stream.unpipe(this);
+    await streamPromise;
+    return true;
+  }
+}
+const onMergedStreamFinished = async (passThroughStream, streams, unpipeEvent) => {
+  updateMaxListeners(passThroughStream, PASSTHROUGH_LISTENERS_COUNT);
+  const controller = new AbortController();
+  try {
+    await Promise.race([onMergedStreamEnd(passThroughStream, controller), onInputStreamsUnpipe(passThroughStream, streams, unpipeEvent, controller)]);
+  } finally {
+    controller.abort();
+    updateMaxListeners(passThroughStream, -PASSTHROUGH_LISTENERS_COUNT);
+  }
+};
+const onMergedStreamEnd = async (passThroughStream, {
+  signal
+}) => {
+  try {
+    await (0, _promises.finished)(passThroughStream, {
+      signal,
+      cleanup: true
+    });
+  } catch (error) {
+    errorOrAbortStream(passThroughStream, error);
+    throw error;
+  }
+};
+const onInputStreamsUnpipe = async (passThroughStream, streams, unpipeEvent, {
+  signal
+}) => {
+  for await (const [unpipedStream] of (0, _nodeEvents.on)(passThroughStream, 'unpipe', {
+    signal
+  })) {
+    if (streams.has(unpipedStream)) {
+      unpipedStream.emit(unpipeEvent);
+    }
+  }
+};
+const validateStream = stream => {
+  if (typeof stream?.pipe !== 'function') {
+    throw new TypeError(`Expected a readable stream, got: \`${typeof stream}\`.`);
+  }
+};
+const endWhenStreamsDone = async ({
+  passThroughStream,
+  stream,
+  streams,
+  ended,
+  aborted,
+  onFinished,
+  unpipeEvent
+}) => {
+  updateMaxListeners(passThroughStream, PASSTHROUGH_LISTENERS_PER_STREAM);
+  const controller = new AbortController();
+  try {
+    await Promise.race([afterMergedStreamFinished(onFinished, stream, controller), onInputStreamEnd({
+      passThroughStream,
+      stream,
+      streams,
+      ended,
+      aborted,
+      controller
+    }), onInputStreamUnpipe({
+      stream,
+      streams,
+      ended,
+      aborted,
+      unpipeEvent,
+      controller
+    })]);
+  } finally {
+    controller.abort();
+    updateMaxListeners(passThroughStream, -PASSTHROUGH_LISTENERS_PER_STREAM);
+  }
+  if (streams.size > 0 && streams.size === ended.size + aborted.size) {
+    if (ended.size === 0 && aborted.size > 0) {
+      abortStream(passThroughStream);
+    } else {
+      endStream(passThroughStream);
+    }
+  }
+};
+const afterMergedStreamFinished = async (onFinished, stream, {
+  signal
+}) => {
+  try {
+    await onFinished;
+    if (!signal.aborted) {
+      abortStream(stream);
+    }
+  } catch (error) {
+    if (!signal.aborted) {
+      errorOrAbortStream(stream, error);
+    }
+  }
+};
+const onInputStreamEnd = async ({
+  passThroughStream,
+  stream,
+  streams,
+  ended,
+  aborted,
+  controller: {
+    signal
+  }
+}) => {
+  try {
+    await (0, _promises.finished)(stream, {
+      signal,
+      cleanup: true,
+      readable: true,
+      writable: false
+    });
+    if (streams.has(stream)) {
+      ended.add(stream);
+    }
+  } catch (error) {
+    if (signal.aborted || !streams.has(stream)) {
+      return;
+    }
+    if (isAbortError(error)) {
+      aborted.add(stream);
+    } else {
+      errorStream(passThroughStream, error);
+    }
+  }
+};
+const onInputStreamUnpipe = async ({
+  stream,
+  streams,
+  ended,
+  aborted,
+  unpipeEvent,
+  controller: {
+    signal
+  }
+}) => {
+  await (0, _nodeEvents.once)(stream, unpipeEvent, {
+    signal
+  });
+  if (!stream.readable) {
+    return (0, _nodeEvents.once)(signal, 'abort', {
+      signal
+    });
+  }
+  streams.delete(stream);
+  ended.delete(stream);
+  aborted.delete(stream);
+};
+const endStream = stream => {
+  if (stream.writable) {
+    stream.end();
+  }
+};
+const errorOrAbortStream = (stream, error) => {
+  if (isAbortError(error)) {
+    abortStream(stream);
+  } else {
+    errorStream(stream, error);
+  }
+};
+
+// This is the error thrown by `finished()` on `stream.destroy()`
+const isAbortError = error => error?.code === 'ERR_STREAM_PREMATURE_CLOSE';
+const abortStream = stream => {
+  if (stream.readable || stream.writable) {
+    stream.destroy();
+  }
+};
+
+// `stream.destroy(error)` crashes the process with `uncaughtException` if no `error` event listener exists on `stream`.
+// We take care of error handling on user behalf, so we do not want this to happen.
+const errorStream = (stream, error) => {
+  if (!stream.destroyed) {
+    stream.once('error', noop);
+    stream.destroy(error);
+  }
+};
+const noop = () => {
+  // empty
+};
+const updateMaxListeners = (passThroughStream, increment) => {
+  const maxListeners = passThroughStream.getMaxListeners();
+  if (maxListeners !== 0 && maxListeners !== Number.POSITIVE_INFINITY) {
+    passThroughStream.setMaxListeners(maxListeners + increment);
+  }
+};
+
+// Number of times `passThroughStream.on()` is called regardless of streams:
+//  - once due to `finished(passThroughStream)`
+//  - once due to `on(passThroughStream)`
+const PASSTHROUGH_LISTENERS_COUNT = 2;
+
+// Number of times `passThroughStream.on()` is called per stream:
+//  - once due to `stream.pipe(passThroughStream)`
+const PASSTHROUGH_LISTENERS_PER_STREAM = 1;

package/dist/streams.d.ts

@@ -2,7 +2,7 @@
 /// <reference types="node" />
 /// <reference types="node" />
 /// <reference types="node" />
-import { PassThrough, Readable, type ReadableOptions, Writable, type WritableOptions, Transform } from 'node:stream';
+import { Readable, type ReadableOptions, Writable, type WritableOptions, Transform } from 'node:stream';
 import { pipeline } from 'node:stream/promises';
 export { compose } from 'node:stream';
 export declare const pump: typeof pipeline;
@@ -16,5 +16,4 @@ export declare function tee(...args: NodeJS.WritableStream[] | [NodeJS.WritableS
 export declare function readableFromArray(array: any[], options?: Partial<ReadableOptions>): Readable;
 export declare function collectStreamIntoArray(array?: any[], options?: Partial<WritableOptions>): Writable;
 export declare function readStreamToBuffer(stream: NodeJS.ReadableStream): Promise<Buffer>;
-export declare function mergeStreams(...streams: NodeJS.ReadableStream[]): PassThrough;
 //# sourceMappingURL=streams.d.ts.map

package/dist/streams.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"streams.d.ts","sourceRoot":"","sources":["../../src/streams.ts"],"names":[],"mappings":";;;;AAAA,OAAO,EAAC,WAAW,EAAE,QAAQ,EAAE,KAAK,eAAe,EAAE,QAAQ,EAAE,KAAK,eAAe,EAAE,SAAS,EAAC,MAAM,aAAa,CAAC;AACnH,OAAO,EAAC,QAAQ,EAAC,MAAM,sBAAsB,CAAC;AAK9C,OAAO,EAAC,OAAO,EAAC,MAAM,aAAa,CAAC;AAEpC,eAAO,MAAM,IAAI,iBAAW,CAAC;AAE7B,wBAAsB,eAAe,CAAC,MAAM,EAAE,MAAM,CAAC,cAAc,GAAG,MAAM,CAAC,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAK1G;AAED,wBAAgB,eAAe,CAAC,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,GAAG,aAY5D;AAED,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,aAc1E;AAED,wBAAgB,YAAY,CAAC,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,OAAO,aAe7D;AAED,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI,aAQjE;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC,EAAE,WAAW,SAAK,YAcxF;AAED,wBAAgB,GAAG,CAAC,GAAG,IAAI,EAAE,MAAM,CAAC,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC,YA0B/E;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,YAEjF;AAED,wBAAgB,sBAAsB,CAAC,KAAK,GAAE,GAAG,EAAO,EAAE,OAAO,GAAE,OAAO,CAAC,eAAe,CAAM,YAS/F;AAED,wBAAsB,kBAAkB,CAAC,MAAM,EAAE,MAAM,CAAC,cAAc,mBAMrE;AAED,wBAAgB,YAAY,CAAC,GAAG,OAAO,EAAE,MAAM,CAAC,cAAc,EAAE,eAS/D"}
+{"version":3,"file":"streams.d.ts","sourceRoot":"","sources":["../../src/streams.ts"],"names":[],"mappings":";;;;AAAA,OAAO,EAAc,QAAQ,EAAE,KAAK,eAAe,EAAE,QAAQ,EAAE,KAAK,eAAe,EAAE,SAAS,EAAC,MAAM,aAAa,CAAC;AACnH,OAAO,EAAC,QAAQ,EAAC,MAAM,sBAAsB,CAAC;AAK9C,OAAO,EAAC,OAAO,EAAC,MAAM,aAAa,CAAC;AAEpC,eAAO,MAAM,IAAI,iBAAW,CAAC;AAE7B,wBAAsB,eAAe,CAAC,MAAM,EAAE,MAAM,CAAC,cAAc,GAAG,MAAM,CAAC,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAK1G;AAED,wBAAgB,eAAe,CAAC,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,GAAG,aAY5D;AAED,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,aAc1E;AAED,wBAAgB,YAAY,CAAC,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,OAAO,aAe7D;AAED,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI,aAQjE;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC,EAAE,WAAW,SAAK,YAcxF;AAED,wBAAgB,GAAG,CAAC,GAAG,IAAI,EAAE,MAAM,CAAC,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC,YA0B/E;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,YAEjF;AAED,wBAAgB,sBAAsB,CAAC,KAAK,GAAE,GAAG,EAAO,EAAE,OAAO,GAAE,OAAO,CAAC,eAAe,CAAM,YAS/F;AAED,wBAAsB,kBAAkB,CAAC,MAAM,EAAE,MAAM,CAAC,cAAc,mBAMrE"}

package/dist/streams.js

@@ -15,7 +15,6 @@ exports.createAsyncTransform = createAsyncTransform;
 exports.createAsyncWritable = createAsyncWritable;
 exports.createFilter = createFilter;
 exports.createTransform = createTransform;
-exports.mergeStreams = mergeStreams;
 exports.pump = void 0;
 exports.readStreamToBuffer = readStreamToBuffer;
 exports.readableFromArray = readableFromArray;
@@ -146,14 +145,4 @@ async function readStreamToBuffer(stream) {
   writeStream.on('data', chunk => chunks.push(chunk));
   await pump(stream, writeStream);
   return Buffer.concat(chunks);
-}
-function mergeStreams(...streams) {
-  let passThrough = new _nodeStream.PassThrough();
-  for (const stream of streams) {
-    const end = stream === streams.at(-1);
-    passThrough = stream.pipe(passThrough, {
-      end
-    });
-  }
-  return passThrough;
 }

package/es/index.js

@@ -1 +1,2 @@
-export * from './streams';
+export * from './streams';
+export * from './merge';

package/es/merge.js

@@ -0,0 +1,276 @@
+/* istanbul ignore file */
+/**
+ * Borrowed code, due to ESM-only issues
+ *
+ * @link https://github.com/sindresorhus/merge-streams/blob/main/index.js
+ */
+import { on, once } from 'node:events';
+import { PassThrough as PassThroughStream, getDefaultHighWaterMark } from 'node:stream';
+import { finished } from 'node:stream/promises';
+export function mergeStreams(streams) {
+  if (!Array.isArray(streams)) {
+    throw new TypeError(`Expected an array, got \`${typeof streams}\`.`);
+  }
+  for (const stream of streams) {
+    validateStream(stream);
+  }
+  const objectMode = streams.some(({
+    readableObjectMode
+  }) => readableObjectMode);
+  const highWaterMark = getHighWaterMark(streams, objectMode);
+  const passThroughStream = new MergedStream({
+    objectMode,
+    writableHighWaterMark: highWaterMark,
+    readableHighWaterMark: highWaterMark
+  });
+  for (const stream of streams) {
+    passThroughStream.add(stream);
+  }
+  return passThroughStream;
+}
+const getHighWaterMark = (streams, objectMode) => {
+  if (streams.length === 0) {
+    return getDefaultHighWaterMark(objectMode);
+  }
+  const highWaterMarks = streams.filter(({
+    readableObjectMode
+  }) => readableObjectMode === objectMode).map(({
+    readableHighWaterMark
+  }) => readableHighWaterMark);
+  return Math.max(...highWaterMarks);
+};
+class MergedStream extends PassThroughStream {
+  #streams = new Set([]);
+  #ended = new Set([]);
+  #aborted = new Set([]);
+  #onFinished;
+  #unpipeEvent = Symbol('unpipe');
+  #streamPromises = new WeakMap();
+  add(stream) {
+    validateStream(stream);
+    if (this.#streams.has(stream)) {
+      return;
+    }
+    this.#streams.add(stream);
+    this.#onFinished ??= onMergedStreamFinished(this, this.#streams, this.#unpipeEvent);
+    const streamPromise = endWhenStreamsDone({
+      passThroughStream: this,
+      stream,
+      streams: this.#streams,
+      ended: this.#ended,
+      aborted: this.#aborted,
+      onFinished: this.#onFinished,
+      unpipeEvent: this.#unpipeEvent
+    });
+    this.#streamPromises.set(stream, streamPromise);
+    stream.pipe(this, {
+      end: false
+    });
+  }
+  async remove(stream) {
+    validateStream(stream);
+    if (!this.#streams.has(stream)) {
+      return false;
+    }
+    const streamPromise = this.#streamPromises.get(stream);
+    if (streamPromise === undefined) {
+      return false;
+    }
+    this.#streamPromises.delete(stream);
+    stream.unpipe(this);
+    await streamPromise;
+    return true;
+  }
+}
+const onMergedStreamFinished = async (passThroughStream, streams, unpipeEvent) => {
+  updateMaxListeners(passThroughStream, PASSTHROUGH_LISTENERS_COUNT);
+  const controller = new AbortController();
+  try {
+    await Promise.race([onMergedStreamEnd(passThroughStream, controller), onInputStreamsUnpipe(passThroughStream, streams, unpipeEvent, controller)]);
+  } finally {
+    controller.abort();
+    updateMaxListeners(passThroughStream, -PASSTHROUGH_LISTENERS_COUNT);
+  }
+};
+const onMergedStreamEnd = async (passThroughStream, {
+  signal
+}) => {
+  try {
+    await finished(passThroughStream, {
+      signal,
+      cleanup: true
+    });
+  } catch (error) {
+    errorOrAbortStream(passThroughStream, error);
+    throw error;
+  }
+};
+const onInputStreamsUnpipe = async (passThroughStream, streams, unpipeEvent, {
+  signal
+}) => {
+  for await (const [unpipedStream] of on(passThroughStream, 'unpipe', {
+    signal
+  })) {
+    if (streams.has(unpipedStream)) {
+      unpipedStream.emit(unpipeEvent);
+    }
+  }
+};
+const validateStream = stream => {
+  if (typeof stream?.pipe !== 'function') {
+    throw new TypeError(`Expected a readable stream, got: \`${typeof stream}\`.`);
+  }
+};
+const endWhenStreamsDone = async ({
+  passThroughStream,
+  stream,
+  streams,
+  ended,
+  aborted,
+  onFinished,
+  unpipeEvent
+}) => {
+  updateMaxListeners(passThroughStream, PASSTHROUGH_LISTENERS_PER_STREAM);
+  const controller = new AbortController();
+  try {
+    await Promise.race([afterMergedStreamFinished(onFinished, stream, controller), onInputStreamEnd({
+      passThroughStream,
+      stream,
+      streams,
+      ended,
+      aborted,
+      controller
+    }), onInputStreamUnpipe({
+      stream,
+      streams,
+      ended,
+      aborted,
+      unpipeEvent,
+      controller
+    })]);
+  } finally {
+    controller.abort();
+    updateMaxListeners(passThroughStream, -PASSTHROUGH_LISTENERS_PER_STREAM);
+  }
+  if (streams.size > 0 && streams.size === ended.size + aborted.size) {
+    if (ended.size === 0 && aborted.size > 0) {
+      abortStream(passThroughStream);
+    } else {
+      endStream(passThroughStream);
+    }
+  }
+};
+const afterMergedStreamFinished = async (onFinished, stream, {
+  signal
+}) => {
+  try {
+    await onFinished;
+    if (!signal.aborted) {
+      abortStream(stream);
+    }
+  } catch (error) {
+    if (!signal.aborted) {
+      errorOrAbortStream(stream, error);
+    }
+  }
+};
+const onInputStreamEnd = async ({
+  passThroughStream,
+  stream,
+  streams,
+  ended,
+  aborted,
+  controller: {
+    signal
+  }
+}) => {
+  try {
+    await finished(stream, {
+      signal,
+      cleanup: true,
+      readable: true,
+      writable: false
+    });
+    if (streams.has(stream)) {
+      ended.add(stream);
+    }
+  } catch (error) {
+    if (signal.aborted || !streams.has(stream)) {
+      return;
+    }
+    if (isAbortError(error)) {
+      aborted.add(stream);
+    } else {
+      errorStream(passThroughStream, error);
+    }
+  }
+};
+const onInputStreamUnpipe = async ({
+  stream,
+  streams,
+  ended,
+  aborted,
+  unpipeEvent,
+  controller: {
+    signal
+  }
+}) => {
+  await once(stream, unpipeEvent, {
+    signal
+  });
+  if (!stream.readable) {
+    return once(signal, 'abort', {
+      signal
+    });
+  }
+  streams.delete(stream);
+  ended.delete(stream);
+  aborted.delete(stream);
+};
+const endStream = stream => {
+  if (stream.writable) {
+    stream.end();
+  }
+};
+const errorOrAbortStream = (stream, error) => {
+  if (isAbortError(error)) {
+    abortStream(stream);
+  } else {
+    errorStream(stream, error);
+  }
+};
+
+// This is the error thrown by `finished()` on `stream.destroy()`
+const isAbortError = error => error?.code === 'ERR_STREAM_PREMATURE_CLOSE';
+const abortStream = stream => {
+  if (stream.readable || stream.writable) {
+    stream.destroy();
+  }
+};
+
+// `stream.destroy(error)` crashes the process with `uncaughtException` if no `error` event listener exists on `stream`.
+// We take care of error handling on user behalf, so we do not want this to happen.
+const errorStream = (stream, error) => {
+  if (!stream.destroyed) {
+    stream.once('error', noop);
+    stream.destroy(error);
+  }
+};
+const noop = () => {
+  // empty
+};
+const updateMaxListeners = (passThroughStream, increment) => {
+  const maxListeners = passThroughStream.getMaxListeners();
+  if (maxListeners !== 0 && maxListeners !== Number.POSITIVE_INFINITY) {
+    passThroughStream.setMaxListeners(maxListeners + increment);
+  }
+};
+
+// Number of times `passThroughStream.on()` is called regardless of streams:
+//  - once due to `finished(passThroughStream)`
+//  - once due to `on(passThroughStream)`
+const PASSTHROUGH_LISTENERS_COUNT = 2;
+
+// Number of times `passThroughStream.on()` is called per stream:
+//  - once due to `stream.pipe(passThroughStream)`
+const PASSTHROUGH_LISTENERS_PER_STREAM = 1;

package/es/streams.js

@@ -123,14 +123,4 @@ export async function readStreamToBuffer(stream) {
   writeStream.on('data', chunk => chunks.push(chunk));
   await pump(stream, writeStream);
   return Buffer.concat(chunks);
-}
-export function mergeStreams(...streams) {
-  let passThrough = new PassThrough();
-  for (const stream of streams) {
-    const end = stream === streams.at(-1);
-    passThrough = stream.pipe(passThrough, {
-      end
-    });
-  }
-  return passThrough;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@takeshape/streams",
-  "version": "10.38.0",
+  "version": "10.39.4",
   "description": "Stream helpers",
   "homepage": "https://www.takeshape.io",
   "repository": {