@gjsify/stream 0.0.4 → 0.1.0

package/lib/esm/index.js

@@ -1,6 +1,1098 @@
-export * from "@gjsify/deno_std/node/stream";
-import stream from "@gjsify/deno_std/node/stream";
-var src_default = stream;
+import { EventEmitter } from "@gjsify/events";
+import { nextTick } from "@gjsify/utils";
+let defaultHighWaterMark = 16384;
+let defaultObjectHighWaterMark = 16;
+function getDefaultHighWaterMark(objectMode) {
+  return objectMode ? defaultObjectHighWaterMark : defaultHighWaterMark;
+}
+function setDefaultHighWaterMark(objectMode, value) {
+  if (typeof value !== "number" || value < 0 || Number.isNaN(value)) {
+    throw new TypeError(`Invalid highWaterMark: ${value}`);
+  }
+  if (objectMode) {
+    defaultObjectHighWaterMark = value;
+  } else {
+    defaultHighWaterMark = value;
+  }
+}
+class Stream extends EventEmitter {
+  constructor(opts) {
+    super(opts);
+  }
+  pipe(destination, options) {
+    const source = this;
+    const doEnd = options?.end !== false;
+    const ondata = (chunk) => {
+      if (destination.writable) {
+        if (destination.write(chunk) === false && typeof source.pause === "function") {
+          source.pause();
+        }
+      }
+    };
+    source.on("data", ondata);
+    const ondrain = () => {
+      if (typeof source.resume === "function") {
+        source.resume();
+      }
+    };
+    destination.on("drain", ondrain);
+    const onend = () => {
+      if (doEnd) {
+        destination.end();
+      }
+    };
+    if (doEnd) {
+      source.on("end", onend);
+    }
+    const cleanup = () => {
+      source.removeListener("data", ondata);
+      destination.removeListener("drain", ondrain);
+      source.removeListener("end", onend);
+    };
+    source.on("close", cleanup);
+    destination.on("close", cleanup);
+    if (source instanceof Readable) {
+      source._pipeDests.push({ dest: destination, ondata, ondrain, onend, cleanup, doEnd });
+    }
+    destination.emit("pipe", source);
+    return destination;
+  }
+}
+class Readable extends Stream {
+  readable = true;
+  readableFlowing = null;
+  readableLength = 0;
+  readableHighWaterMark;
+  readableEncoding;
+  readableObjectMode;
+  readableEnded = false;
+  readableAborted = false;
+  destroyed = false;
+  /** @internal Tracked pipe destinations for unpipe. */
+  _pipeDests = [];
+  _buffer = [];
+  _readableState = { ended: false, endEmitted: false, reading: false, constructed: true };
+  _readablePending = false;
+  _readImpl;
+  _destroyImpl;
+  _constructImpl;
+  constructor(opts) {
+    super(opts);
+    this.readableHighWaterMark = opts?.highWaterMark ?? getDefaultHighWaterMark(opts?.objectMode ?? false);
+    this.readableEncoding = opts?.encoding ?? null;
+    this.readableObjectMode = opts?.objectMode ?? false;
+    if (opts?.read) this._readImpl = opts.read;
+    if (opts?.destroy) this._destroyImpl = opts.destroy;
+    if (opts?.construct) this._constructImpl = opts.construct;
+    const hasConstruct = this._constructImpl || this._construct !== Readable.prototype._construct;
+    if (hasConstruct) {
+      this._readableState.constructed = false;
+      nextTick(() => {
+        this._construct((err) => {
+          this._readableState.constructed = true;
+          if (err) {
+            this.destroy(err);
+          } else {
+            if (this.readableFlowing === true) {
+              this._flow();
+            }
+          }
+        });
+      });
+    }
+  }
+  _construct(callback) {
+    if (this._constructImpl) {
+      this._constructImpl.call(this, callback);
+    } else {
+      callback();
+    }
+  }
+  _read(_size) {
+    if (this._readImpl) {
+      this._readImpl.call(this, _size);
+    }
+  }
+  read(size) {
+    if (!this._readableState.constructed) return null;
+    if (this._buffer.length === 0) {
+      if (this._readableState.ended) return null;
+      this._readableState.reading = true;
+      this._read(size ?? this.readableHighWaterMark);
+      this._readableState.reading = false;
+    }
+    if (this._buffer.length === 0) return null;
+    if (size === 0) return null;
+    if (this.readableObjectMode) {
+      if (size === void 0) {
+        const chunk2 = this._buffer.shift();
+        this.readableLength -= 1;
+        if (this._readableState.ended && this._buffer.length === 0 && !this._readableState.endEmitted) {
+          this._emitEnd();
+        }
+        return chunk2;
+      }
+      if (size > this.readableLength) return null;
+      const chunk = this._buffer.shift();
+      this.readableLength -= 1;
+      return chunk;
+    }
+    if (size !== void 0 && size !== null) {
+      if (size > this.readableLength) return null;
+      return this._readBytes(size);
+    }
+    const result = this._buffer.splice(0);
+    this.readableLength = 0;
+    if (this._readableState.ended && this._buffer.length === 0 && !this._readableState.endEmitted) {
+      this._emitEnd();
+    }
+    if (result.length === 1) return result[0];
+    if (result.length === 0) return null;
+    if (typeof result[0] === "string") return result.join("");
+    const BufCtor = globalThis.Buffer;
+    return BufCtor?.concat ? BufCtor.concat(result) : result;
+  }
+  /** @internal Extract exactly `size` bytes from the internal buffer. */
+  _readBytes(size) {
+    let collected = 0;
+    const parts = [];
+    while (collected < size && this._buffer.length > 0) {
+      const chunk = this._buffer[0];
+      const chunkLen = chunk.length ?? 1;
+      if (collected + chunkLen <= size) {
+        parts.push(this._buffer.shift());
+        collected += chunkLen;
+        this.readableLength -= chunkLen;
+      } else {
+        const needed = size - collected;
+        const BufCtor2 = globalThis.Buffer;
+        if (BufCtor2 && BufCtor2.isBuffer(chunk)) {
+          parts.push(chunk.slice(0, needed));
+          this._buffer[0] = chunk.slice(needed);
+        } else if (typeof chunk === "string") {
+          parts.push(chunk.slice(0, needed));
+          this._buffer[0] = chunk.slice(needed);
+        } else {
+          parts.push(chunk.slice(0, needed));
+          this._buffer[0] = chunk.slice(needed);
+        }
+        this.readableLength -= needed;
+        collected += needed;
+      }
+    }
+    if (parts.length === 1) return parts[0];
+    const BufCtor = globalThis.Buffer;
+    return BufCtor?.concat ? BufCtor.concat(parts) : parts;
+  }
+  push(chunk, encoding) {
+    if (chunk === null) {
+      this._readableState.ended = true;
+      this.readableEnded = true;
+      if (this._buffer.length === 0 && !this._readableState.endEmitted) {
+        nextTick(() => this._emitEnd());
+      }
+      this._scheduleReadable();
+      return false;
+    }
+    this._buffer.push(chunk);
+    this.readableLength += this.readableObjectMode ? 1 : chunk.length ?? 1;
+    if (this.readableFlowing && !this._flowing) {
+      nextTick(() => this._flow());
+    }
+    if (this.readableFlowing !== true) {
+      this._scheduleReadable();
+    }
+    return this.readableLength < this.readableHighWaterMark;
+  }
+  /** Emit 'end' followed by 'close' (matches Node.js autoDestroy behavior). */
+  _emitEnd() {
+    if (this._readableState.endEmitted) return;
+    this._readableState.endEmitted = true;
+    this.emit("end");
+    nextTick(() => this.emit("close"));
+  }
+  /** Schedule a single 'readable' event per microtask cycle (deduplicates multiple pushes). */
+  _scheduleReadable() {
+    if (this._readablePending || this.listenerCount("readable") === 0) return;
+    this._readablePending = true;
+    nextTick(() => {
+      this._readablePending = false;
+      if (!this.destroyed) this.emit("readable");
+    });
+  }
+  on(event, listener) {
+    super.on(event, listener);
+    if (event === "data" && this.readableFlowing !== false) {
+      this.resume();
+    }
+    if (event === "readable" && (this._buffer.length > 0 || this._readableState.ended)) {
+      this._scheduleReadable();
+    }
+    return this;
+  }
+  unshift(chunk) {
+    this._buffer.unshift(chunk);
+    this.readableLength += this.readableObjectMode ? 1 : chunk.length ?? 1;
+  }
+  setEncoding(encoding) {
+    this.readableEncoding = encoding;
+    return this;
+  }
+  pause() {
+    this.readableFlowing = false;
+    this.emit("pause");
+    return this;
+  }
+  resume() {
+    if (this.readableFlowing !== true) {
+      this.readableFlowing = true;
+      this.emit("resume");
+      if (this._readableState.constructed) {
+        this._flow();
+      }
+    }
+    return this;
+  }
+  _flowing = false;
+  _flow() {
+    if (this.readableFlowing !== true || this._flowing || this.destroyed) return;
+    if (!this._readableState.constructed) return;
+    this._flowing = true;
+    try {
+      while (this._buffer.length > 0 && this.readableFlowing && !this.destroyed) {
+        let chunk = this._buffer.shift();
+        this.readableLength -= this.readableObjectMode ? 1 : chunk.length ?? 1;
+        if (this.readableEncoding && typeof chunk !== "string") {
+          const BufCtor = globalThis.Buffer;
+          if (BufCtor && BufCtor.isBuffer(chunk)) {
+            chunk = chunk.toString(this.readableEncoding);
+          } else if (chunk instanceof Uint8Array) {
+            chunk = new TextDecoder(this.readableEncoding).decode(chunk);
+          }
+        }
+        this.emit("data", chunk);
+      }
+      if (this.destroyed) return;
+      if (this._readableState.ended && this._buffer.length === 0 && !this._readableState.endEmitted) {
+        nextTick(() => this._emitEnd());
+        return;
+      }
+      if (!this._readableState.ended && !this._readableState.reading && !this.destroyed) {
+        this._readableState.reading = true;
+        this._read(this.readableHighWaterMark);
+        this._readableState.reading = false;
+      }
+    } finally {
+      this._flowing = false;
+    }
+    if (this._buffer.length > 0 && this.readableFlowing && !this.destroyed) {
+      nextTick(() => this._flow());
+    }
+  }
+  isPaused() {
+    return this.readableFlowing === false;
+  }
+  unpipe(destination) {
+    if (!destination) {
+      for (const state of this._pipeDests) {
+        state.cleanup();
+        state.dest.emit("unpipe", this);
+      }
+      this._pipeDests = [];
+      this.readableFlowing = false;
+    } else {
+      const idx = this._pipeDests.findIndex((s) => s.dest === destination);
+      if (idx !== -1) {
+        const state = this._pipeDests[idx];
+        state.cleanup();
+        this._pipeDests.splice(idx, 1);
+        destination.emit("unpipe", this);
+        if (this._pipeDests.length === 0) {
+          this.readableFlowing = false;
+        }
+      }
+    }
+    return this;
+  }
+  destroy(error) {
+    if (this.destroyed) return this;
+    this.destroyed = true;
+    this.readable = false;
+    this.readableAborted = !this.readableEnded;
+    const cb = (err) => {
+      if (err) nextTick(() => this.emit("error", err));
+      nextTick(() => this.emit("close"));
+    };
+    if (this._destroyImpl) {
+      this._destroyImpl.call(this, error ?? null, cb);
+    } else {
+      cb(error);
+    }
+    return this;
+  }
+  [Symbol.asyncIterator]() {
+    const readable = this;
+    const buffer = [];
+    let done = false;
+    let error = null;
+    let waitingResolve = null;
+    let waitingReject = null;
+    readable.on("data", (chunk) => {
+      if (waitingResolve) {
+        const resolve = waitingResolve;
+        waitingResolve = null;
+        waitingReject = null;
+        resolve({ value: chunk, done: false });
+      } else {
+        buffer.push(chunk);
+      }
+    });
+    readable.on("end", () => {
+      done = true;
+      if (waitingResolve) {
+        const resolve = waitingResolve;
+        waitingResolve = null;
+        waitingReject = null;
+        resolve({ value: void 0, done: true });
+      }
+    });
+    readable.on("error", (err) => {
+      error = err;
+      done = true;
+      if (waitingReject) {
+        const reject = waitingReject;
+        waitingResolve = null;
+        waitingReject = null;
+        reject(err);
+      }
+    });
+    return {
+      next() {
+        if (error) return Promise.reject(error);
+        if (buffer.length > 0) return Promise.resolve({ value: buffer.shift(), done: false });
+        if (done) return Promise.resolve({ value: void 0, done: true });
+        return new Promise((resolve, reject) => {
+          waitingResolve = resolve;
+          waitingReject = reject;
+        });
+      },
+      return() {
+        readable.destroy();
+        return Promise.resolve({ value: void 0, done: true });
+      },
+      [Symbol.asyncIterator]() {
+        return this;
+      }
+    };
+  }
+  static from(iterable, opts) {
+    const readable = new Readable({
+      objectMode: true,
+      ...opts,
+      read() {
+      }
+    });
+    if (typeof iterable === "string" || ArrayBuffer.isView(iterable)) {
+      readable.push(iterable);
+      readable.push(null);
+      return readable;
+    }
+    (async () => {
+      try {
+        for await (const chunk of iterable) {
+          if (!readable.push(chunk)) {
+            await new Promise((resolve) => readable.once("drain", resolve));
+          }
+        }
+        readable.push(null);
+      } catch (err) {
+        readable.destroy(err);
+      }
+    })();
+    return readable;
+  }
+}
+class Writable extends Stream {
+  writable = true;
+  writableHighWaterMark;
+  writableLength = 0;
+  writableObjectMode;
+  writableEnded = false;
+  writableFinished = false;
+  writableCorked = 0;
+  writableNeedDrain = false;
+  destroyed = false;
+  _writableState = { ended: false, finished: false, constructed: true, writing: false };
+  _corkedBuffer = [];
+  _writeBuffer = [];
+  _pendingConstruct = [];
+  _ending = false;
+  _endCallback;
+  _pendingEnd = null;
+  _writeImpl;
+  _writev;
+  _finalImpl;
+  _destroyImpl;
+  _constructImpl;
+  _decodeStrings;
+  _defaultEncoding = "utf8";
+  constructor(opts) {
+    super(opts);
+    this.writableHighWaterMark = opts?.highWaterMark ?? getDefaultHighWaterMark(opts?.objectMode ?? false);
+    this.writableObjectMode = opts?.objectMode ?? false;
+    this._decodeStrings = opts?.decodeStrings !== false;
+    if (opts?.write) this._writeImpl = opts.write;
+    if (opts?.writev) this._writev = opts.writev;
+    if (opts?.final) this._finalImpl = opts.final;
+    if (opts?.destroy) this._destroyImpl = opts.destroy;
+    if (opts?.construct) this._constructImpl = opts.construct;
+    const hasConstruct = this._constructImpl || this._construct !== Writable.prototype._construct;
+    if (hasConstruct) {
+      this._writableState.constructed = false;
+      nextTick(() => {
+        this._construct((err) => {
+          this._writableState.constructed = true;
+          if (err) {
+            this.destroy(err);
+          } else {
+            this._maybeFlush();
+          }
+        });
+      });
+    }
+  }
+  _construct(callback) {
+    if (this._constructImpl) {
+      this._constructImpl.call(this, callback);
+    } else {
+      callback();
+    }
+  }
+  _write(chunk, encoding, callback) {
+    if (this._writeImpl) {
+      this._writeImpl.call(this, chunk, encoding, callback);
+    } else {
+      callback();
+    }
+  }
+  _final(callback) {
+    if (this._finalImpl) {
+      this._finalImpl.call(this, callback);
+    } else {
+      callback();
+    }
+  }
+  _maybeFlush() {
+    const pending = this._pendingConstruct.splice(0);
+    if (pending.length > 0) {
+      const [first, ...rest] = pending;
+      this._writeBuffer.push(...rest);
+      this._doWrite(first.chunk, first.encoding, first.callback);
+    }
+    if (this._pendingEnd) {
+      const { chunk, encoding, callback } = this._pendingEnd;
+      this._pendingEnd = null;
+      this._doEnd(chunk, encoding, callback);
+    }
+  }
+  _doWrite(chunk, encoding, callback) {
+    this._writableState.writing = true;
+    this._write(chunk, encoding, (err) => {
+      this._writableState.writing = false;
+      this.writableLength -= this.writableObjectMode ? 1 : chunk?.length ?? 1;
+      if (err) {
+        nextTick(() => {
+          callback(err);
+          this.emit("error", err);
+          this._drainWriteBuffer();
+        });
+      } else {
+        nextTick(() => {
+          callback();
+          if (this.writableNeedDrain && this.writableLength < this.writableHighWaterMark) {
+            this.writableNeedDrain = false;
+            this.emit("drain");
+          }
+          this._drainWriteBuffer();
+        });
+      }
+    });
+  }
+  _drainWriteBuffer() {
+    if (this._writeBuffer.length > 0) {
+      const next = this._writeBuffer.shift();
+      this._doWrite(next.chunk, next.encoding, next.callback);
+    } else {
+      this._maybeFinish();
+    }
+  }
+  _maybeFinish() {
+    if (!this._ending || this._writableState.finished || this._writableState.writing || this._writeBuffer.length > 0) return;
+    this._ending = false;
+    this._final((err) => {
+      this.writableFinished = true;
+      this._writableState.finished = true;
+      nextTick(() => {
+        if (err) {
+          this.emit("error", err);
+        }
+        this.emit("finish");
+        nextTick(() => this.emit("close"));
+        if (this._endCallback) this._endCallback();
+      });
+    });
+  }
+  write(chunk, encoding, callback) {
+    if (typeof encoding === "function") {
+      callback = encoding;
+      encoding = void 0;
+    }
+    if (encoding === void 0) encoding = this._defaultEncoding;
+    callback = callback || (() => {
+    });
+    if (this._decodeStrings && !this.writableObjectMode && typeof chunk === "string") {
+      const BufCtor = globalThis.Buffer;
+      if (BufCtor) {
+        chunk = BufCtor.from(chunk, encoding);
+        encoding = "buffer";
+      }
+    }
+    if (typeof chunk !== "string" && !this.writableObjectMode) {
+      const BufCtor = globalThis.Buffer;
+      if (BufCtor && BufCtor.isBuffer(chunk) || chunk instanceof Uint8Array) {
+        encoding = "buffer";
+      }
+    }
+    if (this.writableEnded) {
+      const err = new Error("write after end");
+      nextTick(() => {
+        if (callback) callback(err);
+        this.emit("error", err);
+      });
+      return false;
+    }
+    this.writableLength += this.writableObjectMode ? 1 : chunk?.length ?? 1;
+    if (this.writableCorked > 0) {
+      this._corkedBuffer.push({ chunk, encoding, callback });
+      return this.writableLength < this.writableHighWaterMark;
+    }
+    if (!this._writableState.constructed) {
+      this._pendingConstruct.push({ chunk, encoding, callback });
+      return this.writableLength < this.writableHighWaterMark;
+    }
+    const belowHWM = this.writableLength < this.writableHighWaterMark;
+    if (!belowHWM) {
+      this.writableNeedDrain = true;
+    }
+    if (this._writableState.writing) {
+      this._writeBuffer.push({ chunk, encoding, callback });
+    } else {
+      this._doWrite(chunk, encoding, callback);
+    }
+    return belowHWM;
+  }
+  _doEnd(chunk, encoding, callback) {
+    if (chunk !== void 0 && chunk !== null) {
+      this.write(chunk, encoding);
+    }
+    this.writableEnded = true;
+    this._writableState.ended = true;
+    this._ending = true;
+    this._endCallback = callback;
+    this._maybeFinish();
+  }
+  end(chunk, encoding, callback) {
+    if (typeof chunk === "function") {
+      callback = chunk;
+      chunk = void 0;
+    }
+    if (typeof encoding === "function") {
+      callback = encoding;
+      encoding = void 0;
+    }
+    if (this.writableEnded) {
+      if (callback) nextTick(callback);
+      return this;
+    }
+    if (!this._writableState.constructed) {
+      this._pendingEnd = { chunk, encoding, callback };
+      return this;
+    }
+    this._doEnd(chunk, encoding, callback);
+    return this;
+  }
+  cork() {
+    this.writableCorked++;
+  }
+  uncork() {
+    if (this.writableCorked > 0) {
+      this.writableCorked--;
+      if (this.writableCorked === 0 && this._corkedBuffer.length > 0) {
+        this._flushCorkedBuffer();
+      }
+    }
+  }
+  _flushCorkedBuffer() {
+    if (this._writev && this._corkedBuffer.length > 1) {
+      const buffered = this._corkedBuffer.splice(0);
+      const chunks = buffered.map((b) => ({ chunk: b.chunk, encoding: b.encoding }));
+      this._writev.call(this, chunks, (err) => {
+        for (const b of buffered) {
+          this.writableLength -= this.writableObjectMode ? 1 : b.chunk?.length ?? 1;
+        }
+        if (err) {
+          for (const b of buffered) b.callback(err);
+          this.emit("error", err);
+        } else {
+          for (const b of buffered) b.callback();
+          if (this.writableNeedDrain && this.writableLength < this.writableHighWaterMark) {
+            this.writableNeedDrain = false;
+            this.emit("drain");
+          }
+        }
+      });
+    } else {
+      const buffered = this._corkedBuffer.splice(0);
+      if (buffered.length > 0) {
+        const [first, ...rest] = buffered;
+        this._writeBuffer.push(...rest);
+        this._doWrite(first.chunk, first.encoding, first.callback);
+      }
+    }
+  }
+  setDefaultEncoding(encoding) {
+    this._defaultEncoding = encoding;
+    return this;
+  }
+  destroy(error) {
+    if (this.destroyed) return this;
+    this.destroyed = true;
+    this.writable = false;
+    const cb = (err) => {
+      if (err) nextTick(() => this.emit("error", err));
+      nextTick(() => this.emit("close"));
+    };
+    if (this._destroyImpl) {
+      this._destroyImpl.call(this, error ?? null, cb);
+    } else {
+      cb(error);
+    }
+    return this;
+  }
+}
+class Duplex extends Readable {
+  writable = true;
+  writableHighWaterMark;
+  writableLength = 0;
+  writableObjectMode;
+  writableEnded = false;
+  writableFinished = false;
+  writableCorked = 0;
+  writableNeedDrain = false;
+  allowHalfOpen;
+  _decodeStrings;
+  _duplexCorkedBuffer = [];
+  _writeImpl;
+  _finalImpl;
+  _defaultEncoding = "utf8";
+  _pendingWrites = 0;
+  _pendingEndCb = null;
+  constructor(opts) {
+    super(opts);
+    this.writableHighWaterMark = opts?.writableHighWaterMark ?? opts?.highWaterMark ?? getDefaultHighWaterMark(opts?.writableObjectMode ?? opts?.objectMode ?? false);
+    this.writableObjectMode = opts?.writableObjectMode ?? opts?.objectMode ?? false;
+    this.allowHalfOpen = opts?.allowHalfOpen !== false;
+    this._decodeStrings = opts?.decodeStrings !== false;
+    if (opts?.write) this._writeImpl = opts.write;
+    if (opts?.final) this._finalImpl = opts.final;
+    if (!this.allowHalfOpen) {
+      this.once("end", () => {
+        if (!this.writableEnded) {
+          nextTick(() => this.end());
+        }
+      });
+    }
+  }
+  _write(chunk, encoding, callback) {
+    if (this._writeImpl) {
+      this._writeImpl.call(this, chunk, encoding, callback);
+    } else {
+      callback();
+    }
+  }
+  _final(callback) {
+    if (this._finalImpl) {
+      this._finalImpl.call(this, callback);
+    } else {
+      callback();
+    }
+  }
+  destroy(error) {
+    if (this.destroyed) return this;
+    this.writable = false;
+    return super.destroy(error);
+  }
+  write(chunk, encoding, callback) {
+    if (typeof encoding === "function") {
+      callback = encoding;
+      encoding = void 0;
+    }
+    if (encoding === void 0) encoding = this._defaultEncoding;
+    if (this._decodeStrings && !this.writableObjectMode && typeof chunk === "string") {
+      const BufCtor = globalThis.Buffer;
+      if (BufCtor) {
+        chunk = BufCtor.from(chunk, encoding);
+        encoding = "buffer";
+      }
+    }
+    if (typeof chunk !== "string" && !this.writableObjectMode) {
+      const BufCtor = globalThis.Buffer;
+      if (BufCtor && BufCtor.isBuffer(chunk) || chunk instanceof Uint8Array) {
+        encoding = "buffer";
+      }
+    }
+    if (this.writableEnded) {
+      const err = new Error("write after end");
+      const cb2 = callback || (() => {
+      });
+      nextTick(() => {
+        cb2(err);
+        this.emit("error", err);
+      });
+      return false;
+    }
+    this.writableLength += this.writableObjectMode ? 1 : chunk?.length ?? 1;
+    if (this.writableCorked > 0) {
+      this._duplexCorkedBuffer.push({ chunk, encoding, callback: callback || (() => {
+      }) });
+      return this.writableLength < this.writableHighWaterMark;
+    }
+    const belowHWM = this.writableLength < this.writableHighWaterMark;
+    if (!belowHWM) {
+      this.writableNeedDrain = true;
+    }
+    const cb = callback || (() => {
+    });
+    this._pendingWrites++;
+    this._write(chunk, encoding, (err) => {
+      this._pendingWrites--;
+      this.writableLength -= this.writableObjectMode ? 1 : chunk?.length ?? 1;
+      if (err) {
+        nextTick(() => {
+          cb(err);
+          this.emit("error", err);
+        });
+      } else {
+        nextTick(() => {
+          cb();
+          if (this.writableNeedDrain && this.writableLength < this.writableHighWaterMark) {
+            this.writableNeedDrain = false;
+            this.emit("drain");
+          }
+          if (this._pendingWrites === 0 && this._pendingEndCb) {
+            const endCb = this._pendingEndCb;
+            this._pendingEndCb = null;
+            endCb();
+          }
+        });
+      }
+    });
+    return belowHWM;
+  }
+  end(chunk, encoding, callback) {
+    if (typeof chunk === "function") {
+      callback = chunk;
+      chunk = void 0;
+    }
+    if (typeof encoding === "function") {
+      callback = encoding;
+      encoding = void 0;
+    }
+    if (chunk !== void 0 && chunk !== null) {
+      this.write(chunk, encoding);
+    }
+    this.writableEnded = true;
+    const doFinal = () => {
+      this._final((err) => {
+        this.writableFinished = true;
+        nextTick(() => {
+          if (err) this.emit("error", err);
+          this.emit("finish");
+          nextTick(() => this.emit("close"));
+          if (callback) callback();
+        });
+      });
+    };
+    if (this._pendingWrites > 0) {
+      this._pendingEndCb = doFinal;
+    } else {
+      doFinal();
+    }
+    return this;
+  }
+  cork() {
+    this.writableCorked++;
+  }
+  uncork() {
+    if (this.writableCorked > 0) {
+      this.writableCorked--;
+      if (this.writableCorked === 0 && this._duplexCorkedBuffer.length > 0) {
+        const buffered = this._duplexCorkedBuffer.splice(0);
+        for (const { chunk, encoding, callback } of buffered) {
+          this._write(chunk, encoding, (err) => {
+            this.writableLength -= this.writableObjectMode ? 1 : chunk?.length ?? 1;
+            if (err) {
+              callback(err);
+              this.emit("error", err);
+            } else {
+              callback();
+            }
+          });
+        }
+        if (this.writableNeedDrain && this.writableLength < this.writableHighWaterMark) {
+          this.writableNeedDrain = false;
+          nextTick(() => this.emit("drain"));
+        }
+      }
+    }
+  }
+  setDefaultEncoding(encoding) {
+    this._defaultEncoding = encoding;
+    return this;
+  }
+}
+class Transform extends Duplex {
+  _transformImpl;
+  _flushImpl;
+  constructor(opts) {
+    super({
+      ...opts,
+      write: void 0
+      // Override write to use transform
+    });
+    if (opts?.transform) this._transformImpl = opts.transform;
+    if (opts?.flush) this._flushImpl = opts.flush;
+  }
+  _transform(chunk, encoding, callback) {
+    if (this._transformImpl) {
+      this._transformImpl.call(this, chunk, encoding, callback);
+    } else {
+      callback(null, chunk);
+    }
+  }
+  _flush(callback) {
+    if (this._flushImpl) {
+      this._flushImpl.call(this, callback);
+    } else {
+      callback();
+    }
+  }
+  _write(chunk, encoding, callback) {
+    this._transform(chunk, encoding, (err, data) => {
+      if (err) {
+        callback(err);
+        return;
+      }
+      if (data !== void 0 && data !== null) {
+        this.push(data);
+      }
+      callback();
+    });
+  }
+  _final(callback) {
+    this._flush((err, data) => {
+      if (err) {
+        callback(err);
+        return;
+      }
+      if (data !== void 0 && data !== null) {
+        this.push(data);
+      }
+      this.push(null);
+      callback();
+    });
+  }
+}
+class PassThrough extends Transform {
+  constructor(opts) {
+    super({
+      ...opts,
+      transform(chunk, _encoding, callback) {
+        callback(null, chunk);
+      }
+    });
+  }
+}
+function pipeline(...args) {
+  const callback = typeof args[args.length - 1] === "function" ? args.pop() : void 0;
+  const streams = args;
+  if (streams.length < 2) {
+    throw new Error("pipeline requires at least 2 streams");
+  }
+  let error = null;
+  function onError(err) {
+    if (!error) {
+      error = err;
+      for (const stream of streams) {
+        if (typeof stream.destroy === "function") {
+          stream.destroy();
+        }
+      }
+      if (callback) callback(err);
+    }
+  }
+  let current = streams[0];
+  for (let i = 1; i < streams.length; i++) {
+    const next = streams[i];
+    current.pipe(next);
+    current.on("error", onError);
+    current = next;
+  }
+  const last = streams[streams.length - 1];
+  last.on("error", onError);
+  last.on("finish", () => {
+    if (callback && !error) callback(null);
+  });
+  return last;
+}
+function finished(stream, optsOrCb, callback) {
+  let cb;
+  let _opts = {};
+  if (typeof optsOrCb === "function") {
+    cb = optsOrCb;
+  } else {
+    _opts = optsOrCb || {};
+    cb = callback;
+  }
+  let called = false;
+  function done(err) {
+    if (!called) {
+      called = true;
+      cb(err);
+    }
+  }
+  const onFinish = () => done();
+  const onEnd = () => done();
+  const onError = (err) => done(err);
+  const onClose = () => {
+    if (!stream.writableFinished && !stream.readableEnded) {
+      done(new Error("premature close"));
+    }
+  };
+  stream.on("finish", onFinish);
+  stream.on("end", onEnd);
+  stream.on("error", onError);
+  stream.on("close", onClose);
+  const isWritableStream = typeof stream.write === "function";
+  const isReadableStream = typeof stream.read === "function";
+  const writableFinished = stream.writableFinished === true;
+  const readableEnded = stream.readableEnded === true;
+  const destroyed = stream.destroyed === true;
+  if (destroyed) {
+    queueMicrotask(() => done(stream._err || null));
+  } else if (isWritableStream && !isReadableStream && writableFinished) {
+    queueMicrotask(() => done());
+  } else if (!isWritableStream && isReadableStream && readableEnded) {
+    queueMicrotask(() => done());
+  } else if (isWritableStream && isReadableStream && writableFinished && readableEnded) {
+    queueMicrotask(() => done());
+  }
+  return function cleanup() {
+    stream.removeListener("finish", onFinish);
+    stream.removeListener("end", onEnd);
+    stream.removeListener("error", onError);
+    stream.removeListener("close", onClose);
+  };
+}
+function addAbortSignal(signal, stream) {
+  if (!(signal instanceof AbortSignal)) {
+    throw new TypeError("The first argument must be an AbortSignal");
+  }
+  if (!(stream instanceof Stream)) {
+    throw new TypeError("The second argument must be a Stream");
+  }
+  if (signal.aborted) {
+    stream.destroy(new Error("The operation was aborted"));
+  } else {
+    const onAbort = () => {
+      stream.destroy(new Error("The operation was aborted"));
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    stream.once("close", () => {
+      signal.removeEventListener("abort", onAbort);
+    });
+  }
+  return stream;
+}
+function isReadable(stream) {
+  if (stream == null) return false;
+  const s = stream;
+  if (typeof s.readable !== "boolean") return false;
+  if (typeof s.read !== "function") return false;
+  if (s.destroyed === true) return false;
+  if (s.readableEnded === true) return false;
+  return s.readable === true;
+}
+function isWritable(stream) {
+  if (stream == null) return false;
+  const s = stream;
+  if (typeof s.writable !== "boolean") return false;
+  if (typeof s.write !== "function") return false;
+  if (s.destroyed === true) return false;
+  if (s.writableEnded === true) return false;
+  return s.writable === true;
+}
+function isDestroyed(stream) {
+  if (stream == null) return false;
+  return stream.destroyed === true;
+}
+function isDisturbed(stream) {
+  if (stream == null) return false;
+  const s = stream;
+  return s.readableDidRead === true || s.readableFlowing !== null && s.readableFlowing !== void 0;
+}
+function isErrored(stream) {
+  if (stream == null) return false;
+  const s = stream;
+  if (s.destroyed === true && typeof s.readable === "boolean" && s.readable === false) return true;
+  if (s.destroyed === true && typeof s.writable === "boolean" && s.writable === false) return true;
+  return false;
+}
+const _default = Object.assign(Stream, {
+  Stream,
+  Readable,
+  Writable,
+  Duplex,
+  Transform,
+  PassThrough,
+  pipeline,
+  finished,
+  addAbortSignal,
+  isReadable,
+  isWritable,
+  isDestroyed,
+  isDisturbed,
+  isErrored,
+  getDefaultHighWaterMark,
+  setDefaultHighWaterMark
+});
+var index_default = _default;
 export {
-  src_default as default
+  Duplex,
+  PassThrough,
+  Readable,
+  Stream,
+  Transform,
+  Writable,
+  addAbortSignal,
+  index_default as default,
+  finished,
+  getDefaultHighWaterMark,
+  isDestroyed,
+  isDisturbed,
+  isErrored,
+  isReadable,
+  isWritable,
+  pipeline,
+  setDefaultHighWaterMark
 };