@gjsify/stream 0.3.13 → 0.3.15

package/lib/esm/index.js

@@ -1,1298 +1,1329 @@
-import { EventEmitter } from "@gjsify/events";
+import { makeCallable } from "./callable.js";
 import { nextTick, queueMicrotask } from "@gjsify/utils";
+import { EventEmitter } from "@gjsify/events";
+
+//#region src/index.ts
 let defaultHighWaterMark = 16384;
 let defaultObjectHighWaterMark = 16;
 function getDefaultHighWaterMark(objectMode) {
-  return objectMode ? defaultObjectHighWaterMark : defaultHighWaterMark;
+	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;
-  }
+	if (typeof value !== "number" || value < 0 || Number.isNaN(value)) {
+		throw new TypeError(`Invalid highWaterMark: ${value}`);
+	}
+	if (objectMode) {
+		defaultObjectHighWaterMark = value;
+	} else {
+		defaultHighWaterMark = value;
+	}
 }
+/** Validate a named high-water-mark option and throw ERR_INVALID_ARG_VALUE on NaN/non-number. */
 function validateHighWaterMark(name, value) {
-  if (value === void 0) return;
-  if (typeof value !== "number" || Number.isNaN(value)) {
-    const err = new TypeError(`The value of "${name}" is invalid. Received ${value}`);
-    err.code = "ERR_INVALID_ARG_VALUE";
-    throw err;
-  }
-}
-class Stream_ extends EventEmitter {
-  constructor(opts) {
-    super(opts);
-  }
-  pipe(destination, options) {
-    const source = this;
-    const doEnd = options?.end !== false;
-    let drainListenerAdded = false;
-    const ondrain = () => {
-      drainListenerAdded = false;
-      destination.removeListener("drain", ondrain);
-      if (typeof source.resume === "function") {
-        source.resume();
-      }
-    };
-    const ondata = (chunk) => {
-      if (destination.writable) {
-        if (destination.write(chunk) === false && typeof source.pause === "function") {
-          source.pause();
-          if (!drainListenerAdded) {
-            drainListenerAdded = true;
-            destination.on("drain", ondrain);
-          }
-        }
-      }
-    };
-    source.on("data", ondata);
-    let didEnd = false;
-    const onend = () => {
-      if (didEnd) return;
-      didEnd = true;
-      if (doEnd) destination.end();
-    };
-    const onclose = () => {
-      if (didEnd) return;
-      didEnd = true;
-      if (doEnd) {
-        if (!(source instanceof Readable) && typeof destination.destroy === "function") {
-          destination.destroy();
-        }
-      }
-    };
-    if (doEnd) {
-      source.on("end", onend);
-      source.on("close", onclose);
-    }
-    const cleanup = () => {
-      source.removeListener("data", ondata);
-      if (drainListenerAdded) destination.removeListener("drain", ondrain);
-      source.removeListener("end", onend);
-      source.removeListener("close", onclose);
-      source.removeListener("end", cleanup);
-      source.removeListener("close", cleanup);
-      destination.removeListener("close", cleanup);
-    };
-    source.on("end", cleanup);
-    source.on("close", cleanup);
-    destination.on("close", cleanup);
-    if (source instanceof Readable) {
-      source._pipeDests.push({ dest: destination, cleanup });
-      source._readableState.pipes.push(destination);
-    }
-    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, highWaterMark: 0, objectMode: false, pipes: [] };
-  _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;
-    this._readableState.highWaterMark = this.readableHighWaterMark;
-    this._readableState.objectMode = this.readableObjectMode;
-    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;
-    }
-    if (!this.readableObjectMode) {
-      const isValid = typeof chunk === "string" || ArrayBuffer.isView(chunk);
-      if (!isValid) {
-        const err = Object.assign(
-          new TypeError(`Invalid non-string/buffer chunk type: ${typeof chunk}`),
-          { code: "ERR_INVALID_ARG_TYPE" }
-        );
-        nextTick(() => this.emit("error", err));
-        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._autoClose());
-  }
-  /** Override in subclasses to suppress automatic 'close' after 'end'. */
-  _autoClose() {
-    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._readableState.pipes = [];
-      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);
-        const pipeIdx = this._readableState.pipes.indexOf(destination);
-        if (pipeIdx !== -1) this._readableState.pipes.splice(pipeIdx, 1);
-        destination.emit("unpipe", this);
-        if (this._pipeDests.length === 0) {
-          this.readableFlowing = false;
-        }
-      }
-    }
-    return this;
-  }
-  _destroy(error, callback) {
-    if (this._destroyImpl) {
-      this._destroyImpl.call(this, error, callback);
-    } else {
-      callback(error ?? void 0);
-    }
-  }
-  destroy(error) {
-    if (this.destroyed) return this;
-    this.destroyed = true;
-    this.readable = false;
-    this.readableAborted = !this.readableEnded;
-    if (error) this._err = error;
-    const cb = (err) => {
-      if (err) nextTick(() => this.emit("error", err));
-      nextTick(() => this.emit("close"));
-    };
-    if (Object.prototype.hasOwnProperty.call(this, "_destroy")) {
-      this._destroy(error ?? null, cb);
-    } else if (this._destroyImpl) {
-      this._destroyImpl.call(this, error ?? null, cb);
-    } else {
-      cb(error);
-    }
-    return this;
-  }
-  /**
-   * Converts this Node.js Readable to a Web ReadableStream.
-   * Used by @hono/node-server to bridge Node.js HTTP → Web Standard Request.
-   */
-  static toWeb(nodeReadable) {
-    return new ReadableStream({
-      start(controller) {
-        nodeReadable.on("data", (chunk) => {
-          if (typeof chunk === "string") {
-            controller.enqueue(new TextEncoder().encode(chunk));
-          } else if (chunk instanceof Uint8Array) {
-            controller.enqueue(chunk);
-          } else if (chunk && typeof chunk.length === "number") {
-            controller.enqueue(new Uint8Array(chunk));
-          }
-        });
-        nodeReadable.on("end", () => {
-          controller.close();
-        });
-        nodeReadable.on("error", (err) => {
-          controller.error(err);
-        });
-      },
-      cancel() {
-        nodeReadable.destroy();
-      }
-    });
-  }
-  /**
-   * Creates a Node.js Readable from a Web ReadableStream.
-   */
-  static fromWeb(webStream, options) {
-    const reader = webStream.getReader();
-    return new Readable_({
-      ...options,
-      read() {
-        reader.read().then(
-          ({ done, value }) => {
-            if (done) {
-              this.push(null);
-            } else {
-              this.push(value);
-            }
-          },
-          (err) => {
-            this.destroy(err);
-          }
-        );
-      },
-      destroy(error, callback) {
-        reader.cancel(error?.message).then(() => callback(null), callback);
-      }
-    });
-  }
-  [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_ {
-  // Allow `duplex instanceof Writable` to return true even though Duplex inherits
-  // from Readable_ only. Mirrors Node.js: standard prototype-chain check first,
-  // then duck-type fallback — but only when checking against Writable itself, not
-  // against a user subclass. Because `Writable` is exported as a makeCallable Proxy,
-  // `this === Writable_` fails for `obj instanceof Writable`; however the Proxy's
-  // default `get` trap forwards `.prototype` straight to the target, so the
-  // prototype reference check below correctly recognises both.
-  static [Symbol.hasInstance](obj) {
-    if (typeof this.prototype !== "undefined" && Object.prototype.isPrototypeOf.call(this.prototype, obj)) return true;
-    if (this.prototype !== Writable_.prototype) return false;
-    return obj !== null && obj !== void 0 && typeof obj.writableHighWaterMark === "number";
-  }
-  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;
-    let sync = true;
-    this._write(chunk, encoding, (err) => {
-      this.writableLength -= this.writableObjectMode ? 1 : chunk?.length ?? 1;
-      if (sync) {
-        nextTick(() => {
-          if (err) {
-            callback(err);
-            this.emit("error", err);
-            return;
-          }
-          callback();
-          if (this.writableNeedDrain && this.writableLength <= this.writableHighWaterMark) {
-            this.writableNeedDrain = false;
-            this.emit("drain");
-          }
-        });
-        if (!err) this._drainWriteBuffer();
-        return;
-      }
-      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();
-        });
-      }
-    });
-    sync = false;
-  }
-  _drainWriteBuffer() {
-    if (this._writeBuffer.length > 0) {
-      const next = this._writeBuffer.shift();
-      this._doWrite(next.chunk, next.encoding, next.callback);
-    } else {
-      this._writableState.writing = false;
-      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;
-    if (error) this._err = error;
-    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;
-  // Exposed writable-side state (mirrors Node.js _writableState for split HWM tests)
-  _writableState = { highWaterMark: 0, objectMode: false };
-  _duplexCorkedBuffer = [];
-  // Write serialization — prevents concurrent write_bytes_async calls (GIO_ERROR_PENDING).
-  // Duplex inherits from Readable, not Writable, so it needs its own queue separate from
-  // Writable_._doWrite/_drainWriteBuffer.
-  _duplexWriting = false;
-  _duplexWriteQueue = [];
-  _writeImpl;
-  _finalImpl;
-  _defaultEncoding = "utf8";
-  _pendingWrites = 0;
-  _pendingEndCb = null;
-  constructor(opts) {
-    super(opts);
-    validateHighWaterMark("writableHighWaterMark", opts?.writableHighWaterMark);
-    validateHighWaterMark("readableHighWaterMark", opts?.readableHighWaterMark);
-    this.writableObjectMode = opts?.writableObjectMode ?? opts?.objectMode ?? false;
-    this.writableHighWaterMark = opts?.highWaterMark ?? opts?.writableHighWaterMark ?? getDefaultHighWaterMark(this.writableObjectMode);
-    this._writableState.highWaterMark = this.writableHighWaterMark;
-    this._writableState.objectMode = this.writableObjectMode;
-    if (opts?.highWaterMark === void 0 && opts?.readableHighWaterMark !== void 0) {
-      this.readableHighWaterMark = opts.readableHighWaterMark;
-      this._readableState.highWaterMark = opts.readableHighWaterMark;
-    }
-    if (opts?.readableObjectMode !== void 0) {
-      this.readableObjectMode = opts.readableObjectMode;
-      this._readableState.objectMode = opts.readableObjectMode;
-      if (opts?.readableHighWaterMark === void 0 && opts?.highWaterMark === void 0) {
-        this.readableHighWaterMark = getDefaultHighWaterMark(opts.readableObjectMode);
-        this._readableState.highWaterMark = this.readableHighWaterMark;
-      }
-    }
-    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._duplexDoWrite(chunk, encoding, cb);
-    return belowHWM;
-  }
-  _duplexDoWrite(chunk, encoding, cb) {
-    if (this._duplexWriting) {
-      this._duplexWriteQueue.push({ chunk, encoding, callback: cb });
-      return;
-    }
-    this._duplexWriting = true;
-    this._duplexStartWrite(chunk, encoding, cb);
-  }
-  // Starts a write assuming _duplexWriting is already true. After the write
-  // completes, either start the next queued write (keeping _duplexWriting=true
-  // to preserve FIFO order) or clear the flag and emit 'drain'. The 'drain'
-  // listener on streamx may synchronously call conn.write() — emitting drain
-  // BEFORE the queue is fully processed would let that new write bypass the
-  // queue, causing out-of-order bytes on the wire (and, for bittorrent-protocol,
-  // desync of piece header vs. piece payload).
-  _duplexStartWrite(chunk, encoding, cb) {
-    this._pendingWrites++;
-    this._write(chunk, encoding, (err) => {
-      this._pendingWrites--;
-      this.writableLength -= this.writableObjectMode ? 1 : chunk?.length ?? 1;
-      if (err) {
-        nextTick(() => {
-          cb(err);
-          this._duplexWriting = false;
-          this.emit("error", err);
-          if (this._duplexWriteQueue.length > 0) {
-            const next = this._duplexWriteQueue.shift();
-            this._duplexWriting = true;
-            this._duplexStartWrite(next.chunk, next.encoding, next.callback);
-          }
-        });
-      } else {
-        nextTick(() => {
-          cb();
-          if (this._duplexWriteQueue.length > 0) {
-            const next = this._duplexWriteQueue.shift();
-            this._duplexStartWrite(next.chunk, next.encoding, next.callback);
-            return;
-          }
-          this._duplexWriting = false;
-          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();
-          }
-        });
-      }
-    });
-  }
-  _duplexDrainQueue() {
-    if (this._duplexWriteQueue.length > 0) {
-      const next = this._duplexWriteQueue.shift();
-      this._duplexDoWrite(next.chunk, next.encoding, next.callback);
-    }
-  }
-  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;
-        this._doPrefinishHooks(() => {
-          nextTick(() => {
-            if (err) this.emit("error", err);
-            this.emit("finish");
-            nextTick(() => this.emit("close"));
-            if (callback) callback();
-          });
-        });
-      });
-    };
-    if (this._pendingWrites > 0 || this._duplexWriting || this._duplexWriteQueue.length > 0) {
-      this._pendingEndCb = doFinal;
-    } else {
-      doFinal();
-    }
-    return this;
-  }
-  /** Hook for subclasses to run logic between _final and 'finish'. Default: no-op. */
-  _doPrefinishHooks(cb) {
-    cb();
-  }
-  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_ {
-  constructor(opts) {
-    super({ ...opts, write: void 0, final: void 0 });
-    if (opts?.transform) this._transform = opts.transform;
-    if (opts?.flush) this._flush = opts.flush;
-    if (opts?.final) this._final = opts.final;
-  }
-  _transform(_chunk, _encoding, _callback) {
-    const err = Object.assign(
-      new Error("The _transform() method is not implemented"),
-      { code: "ERR_METHOD_NOT_IMPLEMENTED" }
-    );
-    throw err;
-  }
-  _flush(callback) {
-    callback();
-  }
-  _write(chunk, encoding, callback) {
-    let called = false;
-    try {
-      this._transform(chunk, encoding, (err, data) => {
-        if (called) {
-          const e = Object.assign(new Error("Callback called multiple times"), { code: "ERR_MULTIPLE_CALLBACK" });
-          nextTick(() => this.emit("error", e));
-          return;
-        }
-        called = true;
-        if (err) {
-          callback(err);
-          return;
-        }
-        if (data !== void 0 && data !== null) {
-          this.push(data);
-        }
-        callback();
-      });
-    } catch (err) {
-      if (err?.code === "ERR_METHOD_NOT_IMPLEMENTED") throw err;
-      callback(err);
-    }
-  }
-  // Transform's built-in _final: calls _flush then pushes null.
-  // This is the default; when the user provides opts.final it is overridden on
-  // the instance and _doPrefinishHooks ensures _flush is still called after it.
-  _final(callback) {
-    this._flush((err, data) => {
-      if (err) {
-        callback(err);
-        return;
-      }
-      if (data !== void 0 && data !== null) {
-        this.push(data);
-      }
-      this.push(null);
-      callback();
-    });
-  }
-  // When a user-provided _final overrides the prototype method, we still need
-  // to call the built-in flush+push-null logic (mirroring Node.js's prefinish).
-  _doPrefinishHooks(cb) {
-    const protoFinal = Transform_.prototype._final;
-    if (this._final !== protoFinal) {
-      protoFinal.call(this, cb);
-    } else {
-      cb();
-    }
-  }
-}
-class PassThrough_ extends Transform_ {
-  constructor(opts) {
-    super({
-      ...opts,
-      transform(chunk, _encoding, callback) {
-        callback(null, chunk);
-      }
-    });
-  }
+	if (value === undefined) return;
+	if (typeof value !== "number" || Number.isNaN(value)) {
+		const err = new TypeError(`The value of "${name}" is invalid. Received ${value}`);
+		err.code = "ERR_INVALID_ARG_VALUE";
+		throw err;
+	}
 }
+var Stream_ = class extends EventEmitter {
+	constructor(opts) {
+		super(opts);
+	}
+	pipe(destination, options) {
+		const source = this;
+		const doEnd = options?.end !== false;
+		let drainListenerAdded = false;
+		const ondrain = () => {
+			drainListenerAdded = false;
+			destination.removeListener("drain", ondrain);
+			if (typeof source.resume === "function") {
+				source.resume();
+			}
+		};
+		const ondata = (chunk) => {
+			if (destination.writable) {
+				if (destination.write(chunk) === false && typeof source.pause === "function") {
+					source.pause();
+					if (!drainListenerAdded) {
+						drainListenerAdded = true;
+						destination.on("drain", ondrain);
+					}
+				}
+			}
+		};
+		source.on("data", ondata);
+		let didEnd = false;
+		const onend = () => {
+			if (didEnd) return;
+			didEnd = true;
+			if (doEnd) destination.end();
+		};
+		const onclose = () => {
+			if (didEnd) return;
+			didEnd = true;
+			if (doEnd) {
+				if (!(source instanceof Readable) && typeof destination.destroy === "function") {
+					destination.destroy();
+				}
+			}
+		};
+		if (doEnd) {
+			source.on("end", onend);
+			source.on("close", onclose);
+		}
+		const cleanup = () => {
+			source.removeListener("data", ondata);
+			if (drainListenerAdded) destination.removeListener("drain", ondrain);
+			source.removeListener("end", onend);
+			source.removeListener("close", onclose);
+			source.removeListener("end", cleanup);
+			source.removeListener("close", cleanup);
+			destination.removeListener("close", cleanup);
+		};
+		source.on("end", cleanup);
+		source.on("close", cleanup);
+		destination.on("close", cleanup);
+		if (source instanceof Readable) {
+			source._pipeDests.push({
+				dest: destination,
+				cleanup
+			});
+			source._readableState.pipes.push(destination);
+		}
+		destination.emit("pipe", source);
+		return destination;
+	}
+};
+var Readable_ = 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,
+		highWaterMark: 0,
+		objectMode: false,
+		pipes: []
+	};
+	_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;
+		this._readableState.highWaterMark = this.readableHighWaterMark;
+		this._readableState.objectMode = this.readableObjectMode;
+		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 === undefined) {
+				const chunk = this._buffer.shift();
+				this.readableLength -= 1;
+				if (this._readableState.ended && this._buffer.length === 0 && !this._readableState.endEmitted) {
+					this._emitEnd();
+				}
+				return chunk;
+			}
+			if (size > this.readableLength) return null;
+			const chunk = this._buffer.shift();
+			this.readableLength -= 1;
+			return chunk;
+		}
+		if (size !== undefined && 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 BufCtor = globalThis.Buffer;
+				if (BufCtor && BufCtor.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;
+		}
+		if (!this.readableObjectMode) {
+			const isValid = typeof chunk === "string" || ArrayBuffer.isView(chunk);
+			if (!isValid) {
+				const err = Object.assign(new TypeError(`Invalid non-string/buffer chunk type: ${typeof chunk}`), { code: "ERR_INVALID_ARG_TYPE" });
+				nextTick(() => this.emit("error", err));
+				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._autoClose());
+	}
+	/** Override in subclasses to suppress automatic 'close' after 'end'. */
+	_autoClose() {
+		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._readableState.pipes = [];
+			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);
+				const pipeIdx = this._readableState.pipes.indexOf(destination);
+				if (pipeIdx !== -1) this._readableState.pipes.splice(pipeIdx, 1);
+				destination.emit("unpipe", this);
+				if (this._pipeDests.length === 0) {
+					this.readableFlowing = false;
+				}
+			}
+		}
+		return this;
+	}
+	_destroy(error, callback) {
+		if (this._destroyImpl) {
+			this._destroyImpl.call(this, error, callback);
+		} else {
+			callback(error ?? undefined);
+		}
+	}
+	destroy(error) {
+		if (this.destroyed) return this;
+		this.destroyed = true;
+		this.readable = false;
+		this.readableAborted = !this.readableEnded;
+		if (error) this._err = error;
+		const cb = (err) => {
+			if (err) nextTick(() => this.emit("error", err));
+			nextTick(() => this.emit("close"));
+		};
+		if (Object.prototype.hasOwnProperty.call(this, "_destroy")) {
+			this._destroy(error ?? null, cb);
+		} else if (this._destroyImpl) {
+			this._destroyImpl.call(this, error ?? null, cb);
+		} else {
+			cb(error);
+		}
+		return this;
+	}
+	/**
+	* Converts this Node.js Readable to a Web ReadableStream.
+	* Used by @hono/node-server to bridge Node.js HTTP → Web Standard Request.
+	*/
+	static toWeb(nodeReadable) {
+		return new ReadableStream({
+			start(controller) {
+				nodeReadable.on("data", (chunk) => {
+					if (typeof chunk === "string") {
+						controller.enqueue(new TextEncoder().encode(chunk));
+					} else if (chunk instanceof Uint8Array) {
+						controller.enqueue(chunk);
+					} else if (chunk && typeof chunk.length === "number") {
+						controller.enqueue(new Uint8Array(chunk));
+					}
+				});
+				nodeReadable.on("end", () => {
+					controller.close();
+				});
+				nodeReadable.on("error", (err) => {
+					controller.error(err);
+				});
+			},
+			cancel() {
+				nodeReadable.destroy();
+			}
+		});
+	}
+	/**
+	* Creates a Node.js Readable from a Web ReadableStream.
+	*/
+	static fromWeb(webStream, options) {
+		const reader = webStream.getReader();
+		return new Readable_({
+			...options,
+			read() {
+				reader.read().then(({ done, value }) => {
+					if (done) {
+						this.push(null);
+					} else {
+						this.push(value);
+					}
+				}, (err) => {
+					this.destroy(err);
+				});
+			},
+			destroy(error, callback) {
+				reader.cancel(error?.message).then(() => callback(null), callback);
+			}
+		});
+	}
+	[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: undefined,
+					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: undefined,
+					done: true
+				});
+				return new Promise((resolve, reject) => {
+					waitingResolve = resolve;
+					waitingReject = reject;
+				});
+			},
+			return() {
+				readable.destroy();
+				return Promise.resolve({
+					value: undefined,
+					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;
+	}
+};
+var Writable_ = class Writable_ extends Stream_ {
+	static [Symbol.hasInstance](obj) {
+		if (typeof this.prototype !== "undefined" && Object.prototype.isPrototypeOf.call(this.prototype, obj)) return true;
+		if (this.prototype !== Writable_.prototype) return false;
+		return obj !== null && obj !== undefined && typeof obj.writableHighWaterMark === "number";
+	}
+	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;
+		let sync = true;
+		this._write(chunk, encoding, (err) => {
+			this.writableLength -= this.writableObjectMode ? 1 : chunk?.length ?? 1;
+			if (sync) {
+				nextTick(() => {
+					if (err) {
+						callback(err);
+						this.emit("error", err);
+						return;
+					}
+					callback();
+					if (this.writableNeedDrain && this.writableLength <= this.writableHighWaterMark) {
+						this.writableNeedDrain = false;
+						this.emit("drain");
+					}
+				});
+				if (!err) this._drainWriteBuffer();
+				return;
+			}
+			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();
+				});
+			}
+		});
+		sync = false;
+	}
+	_drainWriteBuffer() {
+		if (this._writeBuffer.length > 0) {
+			const next = this._writeBuffer.shift();
+			this._doWrite(next.chunk, next.encoding, next.callback);
+		} else {
+			this._writableState.writing = false;
+			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 = undefined;
+		}
+		if (encoding === undefined) 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 !== undefined && 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 = undefined;
+		}
+		if (typeof encoding === "function") {
+			callback = encoding;
+			encoding = undefined;
+		}
+		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;
+		if (error) this._err = error;
+		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;
+	}
+};
+var Duplex_ = class extends Readable_ {
+	writable = true;
+	writableHighWaterMark;
+	writableLength = 0;
+	writableObjectMode;
+	writableEnded = false;
+	writableFinished = false;
+	writableCorked = 0;
+	writableNeedDrain = false;
+	allowHalfOpen;
+	_decodeStrings;
+	_writableState = {
+		highWaterMark: 0,
+		objectMode: false
+	};
+	_duplexCorkedBuffer = [];
+	_duplexWriting = false;
+	_duplexWriteQueue = [];
+	_writeImpl;
+	_finalImpl;
+	_defaultEncoding = "utf8";
+	_pendingWrites = 0;
+	_pendingEndCb = null;
+	constructor(opts) {
+		super(opts);
+		validateHighWaterMark("writableHighWaterMark", opts?.writableHighWaterMark);
+		validateHighWaterMark("readableHighWaterMark", opts?.readableHighWaterMark);
+		this.writableObjectMode = opts?.writableObjectMode ?? opts?.objectMode ?? false;
+		this.writableHighWaterMark = opts?.highWaterMark ?? opts?.writableHighWaterMark ?? getDefaultHighWaterMark(this.writableObjectMode);
+		this._writableState.highWaterMark = this.writableHighWaterMark;
+		this._writableState.objectMode = this.writableObjectMode;
+		if (opts?.highWaterMark === undefined && opts?.readableHighWaterMark !== undefined) {
+			this.readableHighWaterMark = opts.readableHighWaterMark;
+			this._readableState.highWaterMark = opts.readableHighWaterMark;
+		}
+		if (opts?.readableObjectMode !== undefined) {
+			this.readableObjectMode = opts.readableObjectMode;
+			this._readableState.objectMode = opts.readableObjectMode;
+			if (opts?.readableHighWaterMark === undefined && opts?.highWaterMark === undefined) {
+				this.readableHighWaterMark = getDefaultHighWaterMark(opts.readableObjectMode);
+				this._readableState.highWaterMark = this.readableHighWaterMark;
+			}
+		}
+		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 = undefined;
+		}
+		if (encoding === undefined) 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 cb = callback || (() => {});
+			nextTick(() => {
+				cb(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._duplexDoWrite(chunk, encoding, cb);
+		return belowHWM;
+	}
+	_duplexDoWrite(chunk, encoding, cb) {
+		if (this._duplexWriting) {
+			this._duplexWriteQueue.push({
+				chunk,
+				encoding,
+				callback: cb
+			});
+			return;
+		}
+		this._duplexWriting = true;
+		this._duplexStartWrite(chunk, encoding, cb);
+	}
+	_duplexStartWrite(chunk, encoding, cb) {
+		this._pendingWrites++;
+		this._write(chunk, encoding, (err) => {
+			this._pendingWrites--;
+			this.writableLength -= this.writableObjectMode ? 1 : chunk?.length ?? 1;
+			if (err) {
+				nextTick(() => {
+					cb(err);
+					this._duplexWriting = false;
+					this.emit("error", err);
+					if (this._duplexWriteQueue.length > 0) {
+						const next = this._duplexWriteQueue.shift();
+						this._duplexWriting = true;
+						this._duplexStartWrite(next.chunk, next.encoding, next.callback);
+					}
+				});
+			} else {
+				nextTick(() => {
+					cb();
+					if (this._duplexWriteQueue.length > 0) {
+						const next = this._duplexWriteQueue.shift();
+						this._duplexStartWrite(next.chunk, next.encoding, next.callback);
+						return;
+					}
+					this._duplexWriting = false;
+					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();
+					}
+				});
+			}
+		});
+	}
+	_duplexDrainQueue() {
+		if (this._duplexWriteQueue.length > 0) {
+			const next = this._duplexWriteQueue.shift();
+			this._duplexDoWrite(next.chunk, next.encoding, next.callback);
+		}
+	}
+	end(chunk, encoding, callback) {
+		if (typeof chunk === "function") {
+			callback = chunk;
+			chunk = undefined;
+		}
+		if (typeof encoding === "function") {
+			callback = encoding;
+			encoding = undefined;
+		}
+		if (chunk !== undefined && chunk !== null) {
+			this.write(chunk, encoding);
+		}
+		this.writableEnded = true;
+		const doFinal = () => {
+			this._final((err) => {
+				this.writableFinished = true;
+				this._doPrefinishHooks(() => {
+					nextTick(() => {
+						if (err) this.emit("error", err);
+						this.emit("finish");
+						nextTick(() => this.emit("close"));
+						if (callback) callback();
+					});
+				});
+			});
+		};
+		if (this._pendingWrites > 0 || this._duplexWriting || this._duplexWriteQueue.length > 0) {
+			this._pendingEndCb = doFinal;
+		} else {
+			doFinal();
+		}
+		return this;
+	}
+	/** Hook for subclasses to run logic between _final and 'finish'. Default: no-op. */
+	_doPrefinishHooks(cb) {
+		cb();
+	}
+	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;
+	}
+};
+var Transform_ = class Transform_ extends Duplex_ {
+	constructor(opts) {
+		super({
+			...opts,
+			write: undefined,
+			final: undefined
+		});
+		if (opts?.transform) this._transform = opts.transform;
+		if (opts?.flush) this._flush = opts.flush;
+		if (opts?.final) this._final = opts.final;
+	}
+	_transform(_chunk, _encoding, _callback) {
+		const err = Object.assign(new Error("The _transform() method is not implemented"), { code: "ERR_METHOD_NOT_IMPLEMENTED" });
+		throw err;
+	}
+	_flush(callback) {
+		callback();
+	}
+	_write(chunk, encoding, callback) {
+		let called = false;
+		try {
+			this._transform(chunk, encoding, (err, data) => {
+				if (called) {
+					const e = Object.assign(new Error("Callback called multiple times"), { code: "ERR_MULTIPLE_CALLBACK" });
+					nextTick(() => this.emit("error", e));
+					return;
+				}
+				called = true;
+				if (err) {
+					callback(err);
+					return;
+				}
+				if (data !== undefined && data !== null) {
+					this.push(data);
+				}
+				callback();
+			});
+		} catch (err) {
+			if (err?.code === "ERR_METHOD_NOT_IMPLEMENTED") throw err;
+			callback(err);
+		}
+	}
+	_final(callback) {
+		this._flush((err, data) => {
+			if (err) {
+				callback(err);
+				return;
+			}
+			if (data !== undefined && data !== null) {
+				this.push(data);
+			}
+			this.push(null);
+			callback();
+		});
+	}
+	_doPrefinishHooks(cb) {
+		const protoFinal = Transform_.prototype._final;
+		if (this._final !== protoFinal) {
+			protoFinal.call(this, cb);
+		} else {
+			cb();
+		}
+	}
+};
+var PassThrough_ = class 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;
+	const callback = typeof args[args.length - 1] === "function" ? args.pop() : undefined;
+	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) {
-    const storedErr = stream._err;
-    if (storedErr) {
-      queueMicrotask(() => done(storedErr));
-    } else if (isWritableStream && writableFinished || isReadableStream && readableEnded) {
-      queueMicrotask(() => done());
-    } else {
-      queueMicrotask(() => done(new Error("premature close")));
-    }
-  } 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);
-  };
+	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) {
+		const storedErr = stream._err;
+		if (storedErr) {
+			queueMicrotask(() => done(storedErr));
+		} else if (isWritableStream && writableFinished || isReadableStream && readableEnded) {
+			queueMicrotask(() => done());
+		} else {
+			queueMicrotask(() => done(new Error("premature close")));
+		}
+	} 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;
+	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;
+	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;
+	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;
+	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;
+	if (stream == null) return false;
+	const s = stream;
+	return s.readableDidRead === true || s.readableFlowing !== null && s.readableFlowing !== undefined;
 }
 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;
+	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;
 }
-import { makeCallable } from "./callable.js";
 const Stream = makeCallable(Stream_);
 const Readable = makeCallable(Readable_);
 const Writable = makeCallable(Writable_);
@@ -1300,40 +1331,23 @@ const Duplex = makeCallable(Duplex_);
 const Transform = makeCallable(Transform_);
 const PassThrough = makeCallable(PassThrough_);
 const _default = Object.assign(Stream, {
-  Stream,
-  Readable,
-  Writable,
-  Duplex,
-  Transform,
-  PassThrough,
-  pipeline,
-  finished,
-  addAbortSignal,
-  isReadable,
-  isWritable,
-  isDestroyed,
-  isDisturbed,
-  isErrored,
-  getDefaultHighWaterMark,
-  setDefaultHighWaterMark
+	Stream,
+	Readable,
+	Writable,
+	Duplex,
+	Transform,
+	PassThrough,
+	pipeline,
+	finished,
+	addAbortSignal,
+	isReadable,
+	isWritable,
+	isDestroyed,
+	isDisturbed,
+	isErrored,
+	getDefaultHighWaterMark,
+	setDefaultHighWaterMark
 });
-var index_default = _default;
-export {
-  Duplex,
-  PassThrough,
-  Readable,
-  Stream,
-  Transform,
-  Writable,
-  addAbortSignal,
-  index_default as default,
-  finished,
-  getDefaultHighWaterMark,
-  isDestroyed,
-  isDisturbed,
-  isErrored,
-  isReadable,
-  isWritable,
-  pipeline,
-  setDefaultHighWaterMark
-};
+
+//#endregion
+export { Duplex, PassThrough, Readable, Stream, Transform, Writable, addAbortSignal, _default as default, finished, getDefaultHighWaterMark, isDestroyed, isDisturbed, isErrored, isReadable, isWritable, pipeline, setDefaultHighWaterMark };