@dxos/vendor-hypercore 0.8.4-main.a4bbb77 → 0.8.4-main.bbf232bc24

package/dist/lib/node-esm/hypercore.mjs

@@ -5,8 +5,17 @@ import {
   __reExport,
   __require,
   __toESM,
-  require_hypercore_crypto
-} from "./chunk-IEADO42Y.mjs";
+  require_b4a,
+  require_crypto_aead,
+  require_crypto_generichash,
+  require_crypto_kx,
+  require_crypto_scalarmult,
+  require_helpers,
+  require_hypercore_crypto,
+  require_memory,
+  require_nanoassert,
+  require_sodium_javascript
+} from "./chunk-H7LBQLKP.mjs";
 
 // ../../node_modules/.pnpm/last-one-wins@1.0.4/node_modules/last-one-wins/index.js
 var require_last_one_wins = __commonJS({
@@ -2017,7 +2026,7 @@ var require_inspect_custom_symbol = __commonJS({
   "../../node_modules/.pnpm/inspect-custom-symbol@1.1.1/node_modules/inspect-custom-symbol/index.js"(exports, module) {
     var util = __require("node:util");
     var custom = util.inspect.custom;
-    module.exports = custom || Symbol.for("nodejs.util.inspect.custom");
+    module.exports = custom || /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
   }
 });
 
@@ -2105,23 +2114,6 @@ var require_safe_buffer_equals = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/nanoassert@2.0.0/node_modules/nanoassert/index.js
-var require_nanoassert = __commonJS({
-  "../../node_modules/.pnpm/nanoassert@2.0.0/node_modules/nanoassert/index.js"(exports, module) {
-    module.exports = assert;
-    var AssertionError = class extends Error {
-    };
-    AssertionError.prototype.name = "AssertionError";
-    function assert(t, m) {
-      if (!t) {
-        var err = new AssertionError(m);
-        if (Error.captureStackTrace) Error.captureStackTrace(err, assert);
-        throw err;
-      }
-    }
-  }
-});
-
 // ../../node_modules/.pnpm/clone@2.1.2/node_modules/clone/clone.js
 var require_clone = __commonJS({
   "../../node_modules/.pnpm/clone@2.1.2/node_modules/clone/clone.js"(exports, module) {
@@ -2321,14 +2313,14 @@ var require_clone = __commonJS({
 // ../../node_modules/.pnpm/noise-protocol@3.0.1/node_modules/noise-protocol/cipher.js
 var require_cipher = __commonJS({
   "../../node_modules/.pnpm/noise-protocol@3.0.1/node_modules/noise-protocol/cipher.js"(exports, module) {
-    var { sodium_malloc, sodium_memzero } = __require("sodium-universal/memory");
+    var { sodium_malloc, sodium_memzero } = require_memory();
     var {
       crypto_aead_chacha20poly1305_ietf_KEYBYTES,
       crypto_aead_chacha20poly1305_ietf_NPUBBYTES,
       crypto_aead_chacha20poly1305_ietf_ABYTES,
       crypto_aead_chacha20poly1305_ietf_encrypt,
       crypto_aead_chacha20poly1305_ietf_decrypt
-    } = __require("sodium-universal/crypto_aead");
+    } = require_crypto_aead();
     var assert = require_nanoassert();
     var KEYLEN = 32;
     var NONCELEN = 8;
@@ -2395,8 +2387,8 @@ var require_cipher = __commonJS({
 // ../../node_modules/.pnpm/noise-protocol@3.0.1/node_modules/noise-protocol/cipher-state.js
 var require_cipher_state = __commonJS({
   "../../node_modules/.pnpm/noise-protocol@3.0.1/node_modules/noise-protocol/cipher-state.js"(exports, module) {
-    var { sodium_memzero } = __require("sodium-universal/memory");
-    var { sodium_increment, sodium_memcmp, sodium_is_zero } = __require("sodium-universal/helpers");
+    var { sodium_memzero } = require_memory();
+    var { sodium_increment, sodium_memcmp, sodium_is_zero } = require_helpers();
     var assert = require_nanoassert();
     var cipher = require_cipher();
     var STATELEN = cipher.KEYLEN + cipher.NONCELEN;
@@ -2528,8 +2520,8 @@ var require_nanoassert2 = __commonJS({
 // ../../node_modules/.pnpm/hmac-blake2b@2.0.0/node_modules/hmac-blake2b/index.js
 var require_hmac_blake2b = __commonJS({
   "../../node_modules/.pnpm/hmac-blake2b@2.0.0/node_modules/hmac-blake2b/index.js"(exports, module) {
-    var { sodium_malloc, sodium_memzero } = __require("sodium-universal/memory");
-    var { crypto_generichash, crypto_generichash_batch } = __require("sodium-universal/crypto_generichash");
+    var { sodium_malloc, sodium_memzero } = require_memory();
+    var { crypto_generichash, crypto_generichash_batch } = require_crypto_generichash();
     var assert = require_nanoassert2();
     var HASHLEN = 64;
     var BLOCKLEN = 128;
@@ -2566,8 +2558,8 @@ var require_hmac_blake2b = __commonJS({
 // ../../node_modules/.pnpm/noise-protocol@3.0.1/node_modules/noise-protocol/dh.js
 var require_dh = __commonJS({
   "../../node_modules/.pnpm/noise-protocol@3.0.1/node_modules/noise-protocol/dh.js"(exports, module) {
-    var { crypto_kx_SEEDBYTES, crypto_kx_keypair, crypto_kx_seed_keypair } = __require("sodium-universal/crypto_kx");
-    var { crypto_scalarmult_BYTES, crypto_scalarmult_SCALARBYTES, crypto_scalarmult } = __require("sodium-universal/crypto_scalarmult");
+    var { crypto_kx_SEEDBYTES, crypto_kx_keypair, crypto_kx_seed_keypair } = require_crypto_kx();
+    var { crypto_scalarmult_BYTES, crypto_scalarmult_SCALARBYTES, crypto_scalarmult } = require_crypto_scalarmult();
     var assert = require_nanoassert();
     var DHLEN = crypto_scalarmult_BYTES;
     var PKLEN = crypto_scalarmult_BYTES;
@@ -2609,8 +2601,8 @@ var require_dh = __commonJS({
 // ../../node_modules/.pnpm/noise-protocol@3.0.1/node_modules/noise-protocol/hash.js
 var require_hash = __commonJS({
   "../../node_modules/.pnpm/noise-protocol@3.0.1/node_modules/noise-protocol/hash.js"(exports, module) {
-    var { sodium_malloc, sodium_memzero } = __require("sodium-universal/memory");
-    var { crypto_generichash_batch } = __require("sodium-universal/crypto_generichash");
+    var { sodium_malloc, sodium_memzero } = require_memory();
+    var { crypto_generichash_batch } = require_crypto_generichash();
     var assert = require_nanoassert();
     var hmacBlake2b = require_hmac_blake2b();
     var dh = require_dh();
@@ -2657,7 +2649,7 @@ var require_hash = __commonJS({
 // ../../node_modules/.pnpm/noise-protocol@3.0.1/node_modules/noise-protocol/symmetric-state.js
 var require_symmetric_state = __commonJS({
   "../../node_modules/.pnpm/noise-protocol@3.0.1/node_modules/noise-protocol/symmetric-state.js"(exports, module) {
-    var { sodium_malloc, sodium_memzero } = __require("sodium-universal/memory");
+    var { sodium_malloc, sodium_memzero } = require_memory();
     var assert = require_nanoassert();
     var cipherState = require_cipher_state();
     var hash = require_hash();
@@ -2784,7 +2776,7 @@ var require_symmetric_state = __commonJS({
 // ../../node_modules/.pnpm/noise-protocol@3.0.1/node_modules/noise-protocol/handshake-state.js
 var require_handshake_state = __commonJS({
   "../../node_modules/.pnpm/noise-protocol@3.0.1/node_modules/noise-protocol/handshake-state.js"(exports, module) {
-    var { sodium_malloc, sodium_memzero, sodium_free } = __require("sodium-universal/memory");
+    var { sodium_malloc, sodium_memzero, sodium_free } = require_memory();
     var assert = require_nanoassert();
     var clone = require_clone();
     var symmetricState = require_symmetric_state();
@@ -2813,14 +2805,14 @@ var require_handshake_state = __commonJS({
       this.re = null;
       this.messagePatterns = null;
     }
-    var INITIATOR = Symbol("initiator");
-    var RESPONDER = Symbol("responder");
-    var TOK_S = Symbol("s");
-    var TOK_E = Symbol("e");
-    var TOK_ES = Symbol("es");
-    var TOK_SE = Symbol("se");
-    var TOK_EE = Symbol("ee");
-    var TOK_SS = Symbol("es");
+    var INITIATOR = /* @__PURE__ */ Symbol("initiator");
+    var RESPONDER = /* @__PURE__ */ Symbol("responder");
+    var TOK_S = /* @__PURE__ */ Symbol("s");
+    var TOK_E = /* @__PURE__ */ Symbol("e");
+    var TOK_ES = /* @__PURE__ */ Symbol("es");
+    var TOK_SE = /* @__PURE__ */ Symbol("se");
+    var TOK_EE = /* @__PURE__ */ Symbol("ee");
+    var TOK_SS = /* @__PURE__ */ Symbol("es");
     var PATTERNS = Object.freeze({
       N: {
         premessages: [
@@ -3607,131 +3599,6 @@ var require_signed_varint = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/b4a@1.6.4/node_modules/b4a/index.js
-var require_b4a = __commonJS({
-  "../../node_modules/.pnpm/b4a@1.6.4/node_modules/b4a/index.js"(exports, module) {
-    function isBuffer(value) {
-      return Buffer.isBuffer(value) || value instanceof Uint8Array;
-    }
-    function isEncoding(encoding) {
-      return Buffer.isEncoding(encoding);
-    }
-    function alloc(size, fill2, encoding) {
-      return Buffer.alloc(size, fill2, encoding);
-    }
-    function allocUnsafe(size) {
-      return Buffer.allocUnsafe(size);
-    }
-    function allocUnsafeSlow(size) {
-      return Buffer.allocUnsafeSlow(size);
-    }
-    function byteLength(string, encoding) {
-      return Buffer.byteLength(string, encoding);
-    }
-    function compare(a, b) {
-      return Buffer.compare(a, b);
-    }
-    function concat(buffers, totalLength) {
-      return Buffer.concat(buffers, totalLength);
-    }
-    function copy(source, target, targetStart, start, end) {
-      return toBuffer(source).copy(target, targetStart, start, end);
-    }
-    function equals(a, b) {
-      return toBuffer(a).equals(b);
-    }
-    function fill(buffer, value, offset, end, encoding) {
-      return toBuffer(buffer).fill(value, offset, end, encoding);
-    }
-    function from(value, encodingOrOffset, length) {
-      return Buffer.from(value, encodingOrOffset, length);
-    }
-    function includes(buffer, value, byteOffset, encoding) {
-      return toBuffer(buffer).includes(value, byteOffset, encoding);
-    }
-    function indexOf(buffer, value, byfeOffset, encoding) {
-      return toBuffer(buffer).indexOf(value, byfeOffset, encoding);
-    }
-    function lastIndexOf(buffer, value, byteOffset, encoding) {
-      return toBuffer(buffer).lastIndexOf(value, byteOffset, encoding);
-    }
-    function swap16(buffer) {
-      return toBuffer(buffer).swap16();
-    }
-    function swap32(buffer) {
-      return toBuffer(buffer).swap32();
-    }
-    function swap64(buffer) {
-      return toBuffer(buffer).swap64();
-    }
-    function toBuffer(buffer) {
-      if (Buffer.isBuffer(buffer)) return buffer;
-      return Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-    }
-    function toString(buffer, encoding, start, end) {
-      return toBuffer(buffer).toString(encoding, start, end);
-    }
-    function write(buffer, string, offset, length, encoding) {
-      return toBuffer(buffer).write(string, offset, length, encoding);
-    }
-    function writeDoubleLE(buffer, value, offset) {
-      return toBuffer(buffer).writeDoubleLE(value, offset);
-    }
-    function writeFloatLE(buffer, value, offset) {
-      return toBuffer(buffer).writeFloatLE(value, offset);
-    }
-    function writeUInt32LE(buffer, value, offset) {
-      return toBuffer(buffer).writeUInt32LE(value, offset);
-    }
-    function writeInt32LE(buffer, value, offset) {
-      return toBuffer(buffer).writeInt32LE(value, offset);
-    }
-    function readDoubleLE(buffer, offset) {
-      return toBuffer(buffer).readDoubleLE(offset);
-    }
-    function readFloatLE(buffer, offset) {
-      return toBuffer(buffer).readFloatLE(offset);
-    }
-    function readUInt32LE(buffer, offset) {
-      return toBuffer(buffer).readUInt32LE(offset);
-    }
-    function readInt32LE(buffer, offset) {
-      return toBuffer(buffer).readInt32LE(offset);
-    }
-    module.exports = {
-      isBuffer,
-      isEncoding,
-      alloc,
-      allocUnsafe,
-      allocUnsafeSlow,
-      byteLength,
-      compare,
-      concat,
-      copy,
-      equals,
-      fill,
-      from,
-      includes,
-      indexOf,
-      lastIndexOf,
-      swap16,
-      swap32,
-      swap64,
-      toBuffer,
-      toString,
-      write,
-      writeDoubleLE,
-      writeFloatLE,
-      writeUInt32LE,
-      writeInt32LE,
-      readDoubleLE,
-      readFloatLE,
-      readUInt32LE,
-      readInt32LE
-    };
-  }
-});
-
 // ../../node_modules/.pnpm/protocol-buffers-encodings@1.2.0/node_modules/protocol-buffers-encodings/index.js
 var require_protocol_buffers_encodings = __commonJS({
   "../../node_modules/.pnpm/protocol-buffers-encodings@1.2.0/node_modules/protocol-buffers-encodings/index.js"(exports) {
@@ -5105,7 +4972,7 @@ var require_messages = __commonJS({
 // ../../node_modules/.pnpm/xsalsa20-universal@1.0.0/node_modules/xsalsa20-universal/index.js
 var require_xsalsa20_universal = __commonJS({
   "../../node_modules/.pnpm/xsalsa20-universal@1.0.0/node_modules/xsalsa20-universal/index.js"(exports, module) {
-    var sodium = __require("sodium-native");
+    var sodium = require_sodium_javascript();
     module.exports = class XORNative {
       constructor(nonce, key) {
         this.handle = Buffer.alloc(sodium.crypto_stream_xor_STATEBYTES);
@@ -5788,6 +5655,998 @@ var require_abstract_extension = __commonJS({
   }
 });
 
+// ../../node_modules/.pnpm/queue-tick@1.0.1/node_modules/queue-tick/queue-microtask.js
+var require_queue_microtask = __commonJS({
+  "../../node_modules/.pnpm/queue-tick@1.0.1/node_modules/queue-tick/queue-microtask.js"(exports, module) {
+    module.exports = typeof queueMicrotask === "function" ? queueMicrotask : (fn) => Promise.resolve().then(fn);
+  }
+});
+
+// ../../node_modules/.pnpm/queue-tick@1.0.1/node_modules/queue-tick/process-next-tick.js
+var require_process_next_tick = __commonJS({
+  "../../node_modules/.pnpm/queue-tick@1.0.1/node_modules/queue-tick/process-next-tick.js"(exports, module) {
+    module.exports = typeof process !== "undefined" && typeof process.nextTick === "function" ? process.nextTick.bind(process) : require_queue_microtask();
+  }
+});
+
+// ../../node_modules/.pnpm/fast-fifo@1.3.2/node_modules/fast-fifo/fixed-size.js
+var require_fixed_size = __commonJS({
+  "../../node_modules/.pnpm/fast-fifo@1.3.2/node_modules/fast-fifo/fixed-size.js"(exports, module) {
+    module.exports = class FixedFIFO {
+      constructor(hwm) {
+        if (!(hwm > 0) || (hwm - 1 & hwm) !== 0) throw new Error("Max size for a FixedFIFO should be a power of two");
+        this.buffer = new Array(hwm);
+        this.mask = hwm - 1;
+        this.top = 0;
+        this.btm = 0;
+        this.next = null;
+      }
+      clear() {
+        this.top = this.btm = 0;
+        this.next = null;
+        this.buffer.fill(void 0);
+      }
+      push(data) {
+        if (this.buffer[this.top] !== void 0) return false;
+        this.buffer[this.top] = data;
+        this.top = this.top + 1 & this.mask;
+        return true;
+      }
+      shift() {
+        const last = this.buffer[this.btm];
+        if (last === void 0) return void 0;
+        this.buffer[this.btm] = void 0;
+        this.btm = this.btm + 1 & this.mask;
+        return last;
+      }
+      peek() {
+        return this.buffer[this.btm];
+      }
+      isEmpty() {
+        return this.buffer[this.btm] === void 0;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/fast-fifo@1.3.2/node_modules/fast-fifo/index.js
+var require_fast_fifo = __commonJS({
+  "../../node_modules/.pnpm/fast-fifo@1.3.2/node_modules/fast-fifo/index.js"(exports, module) {
+    var FixedFIFO = require_fixed_size();
+    module.exports = class FastFIFO {
+      constructor(hwm) {
+        this.hwm = hwm || 16;
+        this.head = new FixedFIFO(this.hwm);
+        this.tail = this.head;
+        this.length = 0;
+      }
+      clear() {
+        this.head = this.tail;
+        this.head.clear();
+        this.length = 0;
+      }
+      push(val) {
+        this.length++;
+        if (!this.head.push(val)) {
+          const prev = this.head;
+          this.head = prev.next = new FixedFIFO(2 * this.head.buffer.length);
+          this.head.push(val);
+        }
+      }
+      shift() {
+        if (this.length !== 0) this.length--;
+        const val = this.tail.shift();
+        if (val === void 0 && this.tail.next) {
+          const next = this.tail.next;
+          this.tail.next = null;
+          this.tail = next;
+          return this.tail.shift();
+        }
+        return val;
+      }
+      peek() {
+        const val = this.tail.peek();
+        if (val === void 0 && this.tail.next) return this.tail.next.peek();
+        return val;
+      }
+      isEmpty() {
+        return this.length === 0;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/streamx@2.15.6/node_modules/streamx/index.js
+var require_streamx = __commonJS({
+  "../../node_modules/.pnpm/streamx@2.15.6/node_modules/streamx/index.js"(exports, module) {
+    var { EventEmitter } = __require("node:events");
+    var STREAM_DESTROYED = new Error("Stream was destroyed");
+    var PREMATURE_CLOSE = new Error("Premature close");
+    var queueTick = require_process_next_tick();
+    var FIFO = require_fast_fifo();
+    var MAX = (1 << 27) - 1;
+    var OPENING = 1;
+    var PREDESTROYING = 2;
+    var DESTROYING = 4;
+    var DESTROYED = 8;
+    var NOT_OPENING = MAX ^ OPENING;
+    var NOT_PREDESTROYING = MAX ^ PREDESTROYING;
+    var READ_ACTIVE = 1 << 4;
+    var READ_UPDATING = 2 << 4;
+    var READ_PRIMARY = 4 << 4;
+    var READ_QUEUED = 8 << 4;
+    var READ_RESUMED = 16 << 4;
+    var READ_PIPE_DRAINED = 32 << 4;
+    var READ_ENDING = 64 << 4;
+    var READ_EMIT_DATA = 128 << 4;
+    var READ_EMIT_READABLE = 256 << 4;
+    var READ_EMITTED_READABLE = 512 << 4;
+    var READ_DONE = 1024 << 4;
+    var READ_NEXT_TICK = 2048 << 4;
+    var READ_NEEDS_PUSH = 4096 << 4;
+    var READ_FLOWING = READ_RESUMED | READ_PIPE_DRAINED;
+    var READ_ACTIVE_AND_NEEDS_PUSH = READ_ACTIVE | READ_NEEDS_PUSH;
+    var READ_PRIMARY_AND_ACTIVE = READ_PRIMARY | READ_ACTIVE;
+    var READ_EMIT_READABLE_AND_QUEUED = READ_EMIT_READABLE | READ_QUEUED;
+    var READ_NOT_ACTIVE = MAX ^ READ_ACTIVE;
+    var READ_NON_PRIMARY = MAX ^ READ_PRIMARY;
+    var READ_NON_PRIMARY_AND_PUSHED = MAX ^ (READ_PRIMARY | READ_NEEDS_PUSH);
+    var READ_PUSHED = MAX ^ READ_NEEDS_PUSH;
+    var READ_PAUSED = MAX ^ READ_RESUMED;
+    var READ_NOT_QUEUED = MAX ^ (READ_QUEUED | READ_EMITTED_READABLE);
+    var READ_NOT_ENDING = MAX ^ READ_ENDING;
+    var READ_PIPE_NOT_DRAINED = MAX ^ READ_FLOWING;
+    var READ_NOT_NEXT_TICK = MAX ^ READ_NEXT_TICK;
+    var READ_NOT_UPDATING = MAX ^ READ_UPDATING;
+    var WRITE_ACTIVE = 1 << 17;
+    var WRITE_UPDATING = 2 << 17;
+    var WRITE_PRIMARY = 4 << 17;
+    var WRITE_QUEUED = 8 << 17;
+    var WRITE_UNDRAINED = 16 << 17;
+    var WRITE_DONE = 32 << 17;
+    var WRITE_EMIT_DRAIN = 64 << 17;
+    var WRITE_NEXT_TICK = 128 << 17;
+    var WRITE_WRITING = 256 << 17;
+    var WRITE_FINISHING = 512 << 17;
+    var WRITE_NOT_ACTIVE = MAX ^ (WRITE_ACTIVE | WRITE_WRITING);
+    var WRITE_NON_PRIMARY = MAX ^ WRITE_PRIMARY;
+    var WRITE_NOT_FINISHING = MAX ^ WRITE_FINISHING;
+    var WRITE_DRAINED = MAX ^ WRITE_UNDRAINED;
+    var WRITE_NOT_QUEUED = MAX ^ WRITE_QUEUED;
+    var WRITE_NOT_NEXT_TICK = MAX ^ WRITE_NEXT_TICK;
+    var WRITE_NOT_UPDATING = MAX ^ WRITE_UPDATING;
+    var ACTIVE = READ_ACTIVE | WRITE_ACTIVE;
+    var NOT_ACTIVE = MAX ^ ACTIVE;
+    var DONE = READ_DONE | WRITE_DONE;
+    var DESTROY_STATUS = DESTROYING | DESTROYED | PREDESTROYING;
+    var OPEN_STATUS = DESTROY_STATUS | OPENING;
+    var AUTO_DESTROY = DESTROY_STATUS | DONE;
+    var NON_PRIMARY = WRITE_NON_PRIMARY & READ_NON_PRIMARY;
+    var ACTIVE_OR_TICKING = WRITE_NEXT_TICK | READ_NEXT_TICK;
+    var TICKING = ACTIVE_OR_TICKING & NOT_ACTIVE;
+    var IS_OPENING = OPEN_STATUS | TICKING;
+    var READ_PRIMARY_STATUS = OPEN_STATUS | READ_ENDING | READ_DONE;
+    var READ_STATUS = OPEN_STATUS | READ_DONE | READ_QUEUED;
+    var READ_ENDING_STATUS = OPEN_STATUS | READ_ENDING | READ_QUEUED;
+    var READ_READABLE_STATUS = OPEN_STATUS | READ_EMIT_READABLE | READ_QUEUED | READ_EMITTED_READABLE;
+    var SHOULD_NOT_READ = OPEN_STATUS | READ_ACTIVE | READ_ENDING | READ_DONE | READ_NEEDS_PUSH;
+    var READ_BACKPRESSURE_STATUS = DESTROY_STATUS | READ_ENDING | READ_DONE;
+    var READ_UPDATE_SYNC_STATUS = READ_UPDATING | OPEN_STATUS | READ_NEXT_TICK | READ_PRIMARY;
+    var WRITE_PRIMARY_STATUS = OPEN_STATUS | WRITE_FINISHING | WRITE_DONE;
+    var WRITE_QUEUED_AND_UNDRAINED = WRITE_QUEUED | WRITE_UNDRAINED;
+    var WRITE_QUEUED_AND_ACTIVE = WRITE_QUEUED | WRITE_ACTIVE;
+    var WRITE_DRAIN_STATUS = WRITE_QUEUED | WRITE_UNDRAINED | OPEN_STATUS | WRITE_ACTIVE;
+    var WRITE_STATUS = OPEN_STATUS | WRITE_ACTIVE | WRITE_QUEUED;
+    var WRITE_PRIMARY_AND_ACTIVE = WRITE_PRIMARY | WRITE_ACTIVE;
+    var WRITE_ACTIVE_AND_WRITING = WRITE_ACTIVE | WRITE_WRITING;
+    var WRITE_FINISHING_STATUS = OPEN_STATUS | WRITE_FINISHING | WRITE_QUEUED_AND_ACTIVE | WRITE_DONE;
+    var WRITE_BACKPRESSURE_STATUS = WRITE_UNDRAINED | DESTROY_STATUS | WRITE_FINISHING | WRITE_DONE;
+    var WRITE_UPDATE_SYNC_STATUS = WRITE_UPDATING | OPEN_STATUS | WRITE_NEXT_TICK | WRITE_PRIMARY;
+    var asyncIterator = Symbol.asyncIterator || /* @__PURE__ */ Symbol("asyncIterator");
+    var WritableState = class {
+      constructor(stream, { highWaterMark = 16384, map = null, mapWritable, byteLength, byteLengthWritable } = {}) {
+        this.stream = stream;
+        this.queue = new FIFO();
+        this.highWaterMark = highWaterMark;
+        this.buffered = 0;
+        this.error = null;
+        this.pipeline = null;
+        this.drains = null;
+        this.byteLength = byteLengthWritable || byteLength || defaultByteLength;
+        this.map = mapWritable || map;
+        this.afterWrite = afterWrite.bind(this);
+        this.afterUpdateNextTick = updateWriteNT.bind(this);
+      }
+      get ended() {
+        return (this.stream._duplexState & WRITE_DONE) !== 0;
+      }
+      push(data) {
+        if (this.map !== null) data = this.map(data);
+        this.buffered += this.byteLength(data);
+        this.queue.push(data);
+        if (this.buffered < this.highWaterMark) {
+          this.stream._duplexState |= WRITE_QUEUED;
+          return true;
+        }
+        this.stream._duplexState |= WRITE_QUEUED_AND_UNDRAINED;
+        return false;
+      }
+      shift() {
+        const data = this.queue.shift();
+        this.buffered -= this.byteLength(data);
+        if (this.buffered === 0) this.stream._duplexState &= WRITE_NOT_QUEUED;
+        return data;
+      }
+      end(data) {
+        if (typeof data === "function") this.stream.once("finish", data);
+        else if (data !== void 0 && data !== null) this.push(data);
+        this.stream._duplexState = (this.stream._duplexState | WRITE_FINISHING) & WRITE_NON_PRIMARY;
+      }
+      autoBatch(data, cb) {
+        const buffer = [];
+        const stream = this.stream;
+        buffer.push(data);
+        while ((stream._duplexState & WRITE_STATUS) === WRITE_QUEUED_AND_ACTIVE) {
+          buffer.push(stream._writableState.shift());
+        }
+        if ((stream._duplexState & OPEN_STATUS) !== 0) return cb(null);
+        stream._writev(buffer, cb);
+      }
+      update() {
+        const stream = this.stream;
+        stream._duplexState |= WRITE_UPDATING;
+        do {
+          while ((stream._duplexState & WRITE_STATUS) === WRITE_QUEUED) {
+            const data = this.shift();
+            stream._duplexState |= WRITE_ACTIVE_AND_WRITING;
+            stream._write(data, this.afterWrite);
+          }
+          if ((stream._duplexState & WRITE_PRIMARY_AND_ACTIVE) === 0) this.updateNonPrimary();
+        } while (this.continueUpdate() === true);
+        stream._duplexState &= WRITE_NOT_UPDATING;
+      }
+      updateNonPrimary() {
+        const stream = this.stream;
+        if ((stream._duplexState & WRITE_FINISHING_STATUS) === WRITE_FINISHING) {
+          stream._duplexState = (stream._duplexState | WRITE_ACTIVE) & WRITE_NOT_FINISHING;
+          stream._final(afterFinal.bind(this));
+          return;
+        }
+        if ((stream._duplexState & DESTROY_STATUS) === DESTROYING) {
+          if ((stream._duplexState & ACTIVE_OR_TICKING) === 0) {
+            stream._duplexState |= ACTIVE;
+            stream._destroy(afterDestroy.bind(this));
+          }
+          return;
+        }
+        if ((stream._duplexState & IS_OPENING) === OPENING) {
+          stream._duplexState = (stream._duplexState | ACTIVE) & NOT_OPENING;
+          stream._open(afterOpen.bind(this));
+        }
+      }
+      continueUpdate() {
+        if ((this.stream._duplexState & WRITE_NEXT_TICK) === 0) return false;
+        this.stream._duplexState &= WRITE_NOT_NEXT_TICK;
+        return true;
+      }
+      updateCallback() {
+        if ((this.stream._duplexState & WRITE_UPDATE_SYNC_STATUS) === WRITE_PRIMARY) this.update();
+        else this.updateNextTick();
+      }
+      updateNextTick() {
+        if ((this.stream._duplexState & WRITE_NEXT_TICK) !== 0) return;
+        this.stream._duplexState |= WRITE_NEXT_TICK;
+        if ((this.stream._duplexState & WRITE_UPDATING) === 0) queueTick(this.afterUpdateNextTick);
+      }
+    };
+    var ReadableState = class {
+      constructor(stream, { highWaterMark = 16384, map = null, mapReadable, byteLength, byteLengthReadable } = {}) {
+        this.stream = stream;
+        this.queue = new FIFO();
+        this.highWaterMark = highWaterMark;
+        this.buffered = 0;
+        this.error = null;
+        this.pipeline = null;
+        this.byteLength = byteLengthReadable || byteLength || defaultByteLength;
+        this.map = mapReadable || map;
+        this.pipeTo = null;
+        this.afterRead = afterRead.bind(this);
+        this.afterUpdateNextTick = updateReadNT.bind(this);
+      }
+      get ended() {
+        return (this.stream._duplexState & READ_DONE) !== 0;
+      }
+      pipe(pipeTo, cb) {
+        if (this.pipeTo !== null) throw new Error("Can only pipe to one destination");
+        if (typeof cb !== "function") cb = null;
+        this.stream._duplexState |= READ_PIPE_DRAINED;
+        this.pipeTo = pipeTo;
+        this.pipeline = new Pipeline(this.stream, pipeTo, cb);
+        if (cb) this.stream.on("error", noop);
+        if (isStreamx(pipeTo)) {
+          pipeTo._writableState.pipeline = this.pipeline;
+          if (cb) pipeTo.on("error", noop);
+          pipeTo.on("finish", this.pipeline.finished.bind(this.pipeline));
+        } else {
+          const onerror = this.pipeline.done.bind(this.pipeline, pipeTo);
+          const onclose = this.pipeline.done.bind(this.pipeline, pipeTo, null);
+          pipeTo.on("error", onerror);
+          pipeTo.on("close", onclose);
+          pipeTo.on("finish", this.pipeline.finished.bind(this.pipeline));
+        }
+        pipeTo.on("drain", afterDrain.bind(this));
+        this.stream.emit("piping", pipeTo);
+        pipeTo.emit("pipe", this.stream);
+      }
+      push(data) {
+        const stream = this.stream;
+        if (data === null) {
+          this.highWaterMark = 0;
+          stream._duplexState = (stream._duplexState | READ_ENDING) & READ_NON_PRIMARY_AND_PUSHED;
+          return false;
+        }
+        if (this.map !== null) data = this.map(data);
+        this.buffered += this.byteLength(data);
+        this.queue.push(data);
+        stream._duplexState = (stream._duplexState | READ_QUEUED) & READ_PUSHED;
+        return this.buffered < this.highWaterMark;
+      }
+      shift() {
+        const data = this.queue.shift();
+        this.buffered -= this.byteLength(data);
+        if (this.buffered === 0) this.stream._duplexState &= READ_NOT_QUEUED;
+        return data;
+      }
+      unshift(data) {
+        const pending = [this.map !== null ? this.map(data) : data];
+        while (this.buffered > 0) pending.push(this.shift());
+        for (let i = 0; i < pending.length - 1; i++) {
+          const data2 = pending[i];
+          this.buffered += this.byteLength(data2);
+          this.queue.push(data2);
+        }
+        this.push(pending[pending.length - 1]);
+      }
+      read() {
+        const stream = this.stream;
+        if ((stream._duplexState & READ_STATUS) === READ_QUEUED) {
+          const data = this.shift();
+          if (this.pipeTo !== null && this.pipeTo.write(data) === false) stream._duplexState &= READ_PIPE_NOT_DRAINED;
+          if ((stream._duplexState & READ_EMIT_DATA) !== 0) stream.emit("data", data);
+          return data;
+        }
+        return null;
+      }
+      drain() {
+        const stream = this.stream;
+        while ((stream._duplexState & READ_STATUS) === READ_QUEUED && (stream._duplexState & READ_FLOWING) !== 0) {
+          const data = this.shift();
+          if (this.pipeTo !== null && this.pipeTo.write(data) === false) stream._duplexState &= READ_PIPE_NOT_DRAINED;
+          if ((stream._duplexState & READ_EMIT_DATA) !== 0) stream.emit("data", data);
+        }
+      }
+      update() {
+        const stream = this.stream;
+        stream._duplexState |= READ_UPDATING;
+        do {
+          this.drain();
+          while (this.buffered < this.highWaterMark && (stream._duplexState & SHOULD_NOT_READ) === 0) {
+            stream._duplexState |= READ_ACTIVE_AND_NEEDS_PUSH;
+            stream._read(this.afterRead);
+            this.drain();
+          }
+          if ((stream._duplexState & READ_READABLE_STATUS) === READ_EMIT_READABLE_AND_QUEUED) {
+            stream._duplexState |= READ_EMITTED_READABLE;
+            stream.emit("readable");
+          }
+          if ((stream._duplexState & READ_PRIMARY_AND_ACTIVE) === 0) this.updateNonPrimary();
+        } while (this.continueUpdate() === true);
+        stream._duplexState &= READ_NOT_UPDATING;
+      }
+      updateNonPrimary() {
+        const stream = this.stream;
+        if ((stream._duplexState & READ_ENDING_STATUS) === READ_ENDING) {
+          stream._duplexState = (stream._duplexState | READ_DONE) & READ_NOT_ENDING;
+          stream.emit("end");
+          if ((stream._duplexState & AUTO_DESTROY) === DONE) stream._duplexState |= DESTROYING;
+          if (this.pipeTo !== null) this.pipeTo.end();
+        }
+        if ((stream._duplexState & DESTROY_STATUS) === DESTROYING) {
+          if ((stream._duplexState & ACTIVE_OR_TICKING) === 0) {
+            stream._duplexState |= ACTIVE;
+            stream._destroy(afterDestroy.bind(this));
+          }
+          return;
+        }
+        if ((stream._duplexState & IS_OPENING) === OPENING) {
+          stream._duplexState = (stream._duplexState | ACTIVE) & NOT_OPENING;
+          stream._open(afterOpen.bind(this));
+        }
+      }
+      continueUpdate() {
+        if ((this.stream._duplexState & READ_NEXT_TICK) === 0) return false;
+        this.stream._duplexState &= READ_NOT_NEXT_TICK;
+        return true;
+      }
+      updateCallback() {
+        if ((this.stream._duplexState & READ_UPDATE_SYNC_STATUS) === READ_PRIMARY) this.update();
+        else this.updateNextTick();
+      }
+      updateNextTick() {
+        if ((this.stream._duplexState & READ_NEXT_TICK) !== 0) return;
+        this.stream._duplexState |= READ_NEXT_TICK;
+        if ((this.stream._duplexState & READ_UPDATING) === 0) queueTick(this.afterUpdateNextTick);
+      }
+    };
+    var TransformState = class {
+      constructor(stream) {
+        this.data = null;
+        this.afterTransform = afterTransform.bind(stream);
+        this.afterFinal = null;
+      }
+    };
+    var Pipeline = class {
+      constructor(src, dst, cb) {
+        this.from = src;
+        this.to = dst;
+        this.afterPipe = cb;
+        this.error = null;
+        this.pipeToFinished = false;
+      }
+      finished() {
+        this.pipeToFinished = true;
+      }
+      done(stream, err) {
+        if (err) this.error = err;
+        if (stream === this.to) {
+          this.to = null;
+          if (this.from !== null) {
+            if ((this.from._duplexState & READ_DONE) === 0 || !this.pipeToFinished) {
+              this.from.destroy(this.error || new Error("Writable stream closed prematurely"));
+            }
+            return;
+          }
+        }
+        if (stream === this.from) {
+          this.from = null;
+          if (this.to !== null) {
+            if ((stream._duplexState & READ_DONE) === 0) {
+              this.to.destroy(this.error || new Error("Readable stream closed before ending"));
+            }
+            return;
+          }
+        }
+        if (this.afterPipe !== null) this.afterPipe(this.error);
+        this.to = this.from = this.afterPipe = null;
+      }
+    };
+    function afterDrain() {
+      this.stream._duplexState |= READ_PIPE_DRAINED;
+      this.updateCallback();
+    }
+    function afterFinal(err) {
+      const stream = this.stream;
+      if (err) stream.destroy(err);
+      if ((stream._duplexState & DESTROY_STATUS) === 0) {
+        stream._duplexState |= WRITE_DONE;
+        stream.emit("finish");
+      }
+      if ((stream._duplexState & AUTO_DESTROY) === DONE) {
+        stream._duplexState |= DESTROYING;
+      }
+      stream._duplexState &= WRITE_NOT_ACTIVE;
+      if ((stream._duplexState & WRITE_UPDATING) === 0) this.update();
+      else this.updateNextTick();
+    }
+    function afterDestroy(err) {
+      const stream = this.stream;
+      if (!err && this.error !== STREAM_DESTROYED) err = this.error;
+      if (err) stream.emit("error", err);
+      stream._duplexState |= DESTROYED;
+      stream.emit("close");
+      const rs = stream._readableState;
+      const ws = stream._writableState;
+      if (rs !== null && rs.pipeline !== null) rs.pipeline.done(stream, err);
+      if (ws !== null) {
+        while (ws.drains !== null && ws.drains.length > 0) ws.drains.shift().resolve(false);
+        if (ws.pipeline !== null) ws.pipeline.done(stream, err);
+      }
+    }
+    function afterWrite(err) {
+      const stream = this.stream;
+      if (err) stream.destroy(err);
+      stream._duplexState &= WRITE_NOT_ACTIVE;
+      if (this.drains !== null) tickDrains(this.drains);
+      if ((stream._duplexState & WRITE_DRAIN_STATUS) === WRITE_UNDRAINED) {
+        stream._duplexState &= WRITE_DRAINED;
+        if ((stream._duplexState & WRITE_EMIT_DRAIN) === WRITE_EMIT_DRAIN) {
+          stream.emit("drain");
+        }
+      }
+      this.updateCallback();
+    }
+    function afterRead(err) {
+      if (err) this.stream.destroy(err);
+      this.stream._duplexState &= READ_NOT_ACTIVE;
+      this.updateCallback();
+    }
+    function updateReadNT() {
+      if ((this.stream._duplexState & READ_UPDATING) === 0) {
+        this.stream._duplexState &= READ_NOT_NEXT_TICK;
+        this.update();
+      }
+    }
+    function updateWriteNT() {
+      if ((this.stream._duplexState & WRITE_UPDATING) === 0) {
+        this.stream._duplexState &= WRITE_NOT_NEXT_TICK;
+        this.update();
+      }
+    }
+    function tickDrains(drains) {
+      for (let i = 0; i < drains.length; i++) {
+        if (--drains[i].writes === 0) {
+          drains.shift().resolve(true);
+          i--;
+        }
+      }
+    }
+    function afterOpen(err) {
+      const stream = this.stream;
+      if (err) stream.destroy(err);
+      if ((stream._duplexState & DESTROYING) === 0) {
+        if ((stream._duplexState & READ_PRIMARY_STATUS) === 0) stream._duplexState |= READ_PRIMARY;
+        if ((stream._duplexState & WRITE_PRIMARY_STATUS) === 0) stream._duplexState |= WRITE_PRIMARY;
+        stream.emit("open");
+      }
+      stream._duplexState &= NOT_ACTIVE;
+      if (stream._writableState !== null) {
+        stream._writableState.updateCallback();
+      }
+      if (stream._readableState !== null) {
+        stream._readableState.updateCallback();
+      }
+    }
+    function afterTransform(err, data) {
+      if (data !== void 0 && data !== null) this.push(data);
+      this._writableState.afterWrite(err);
+    }
+    function newListener(name) {
+      if (this._readableState !== null) {
+        if (name === "data") {
+          this._duplexState |= READ_EMIT_DATA | READ_RESUMED;
+          this._readableState.updateNextTick();
+        }
+        if (name === "readable") {
+          this._duplexState |= READ_EMIT_READABLE;
+          this._readableState.updateNextTick();
+        }
+      }
+      if (this._writableState !== null) {
+        if (name === "drain") {
+          this._duplexState |= WRITE_EMIT_DRAIN;
+          this._writableState.updateNextTick();
+        }
+      }
+    }
+    var Stream = class extends EventEmitter {
+      constructor(opts) {
+        super();
+        this._duplexState = 0;
+        this._readableState = null;
+        this._writableState = null;
+        if (opts) {
+          if (opts.open) this._open = opts.open;
+          if (opts.destroy) this._destroy = opts.destroy;
+          if (opts.predestroy) this._predestroy = opts.predestroy;
+          if (opts.signal) {
+            opts.signal.addEventListener("abort", abort.bind(this));
+          }
+        }
+        this.on("newListener", newListener);
+      }
+      _open(cb) {
+        cb(null);
+      }
+      _destroy(cb) {
+        cb(null);
+      }
+      _predestroy() {
+      }
+      get readable() {
+        return this._readableState !== null ? true : void 0;
+      }
+      get writable() {
+        return this._writableState !== null ? true : void 0;
+      }
+      get destroyed() {
+        return (this._duplexState & DESTROYED) !== 0;
+      }
+      get destroying() {
+        return (this._duplexState & DESTROY_STATUS) !== 0;
+      }
+      destroy(err) {
+        if ((this._duplexState & DESTROY_STATUS) === 0) {
+          if (!err) err = STREAM_DESTROYED;
+          this._duplexState = (this._duplexState | DESTROYING) & NON_PRIMARY;
+          if (this._readableState !== null) {
+            this._readableState.highWaterMark = 0;
+            this._readableState.error = err;
+          }
+          if (this._writableState !== null) {
+            this._writableState.highWaterMark = 0;
+            this._writableState.error = err;
+          }
+          this._duplexState |= PREDESTROYING;
+          this._predestroy();
+          this._duplexState &= NOT_PREDESTROYING;
+          if (this._readableState !== null) this._readableState.updateNextTick();
+          if (this._writableState !== null) this._writableState.updateNextTick();
+        }
+      }
+    };
+    var Readable = class _Readable extends Stream {
+      constructor(opts) {
+        super(opts);
+        this._duplexState |= OPENING | WRITE_DONE;
+        this._readableState = new ReadableState(this, opts);
+        if (opts) {
+          if (opts.read) this._read = opts.read;
+          if (opts.eagerOpen) this._readableState.updateNextTick();
+        }
+      }
+      _read(cb) {
+        cb(null);
+      }
+      pipe(dest, cb) {
+        this._readableState.updateNextTick();
+        this._readableState.pipe(dest, cb);
+        return dest;
+      }
+      read() {
+        this._readableState.updateNextTick();
+        return this._readableState.read();
+      }
+      push(data) {
+        this._readableState.updateNextTick();
+        return this._readableState.push(data);
+      }
+      unshift(data) {
+        this._readableState.updateNextTick();
+        return this._readableState.unshift(data);
+      }
+      resume() {
+        this._duplexState |= READ_RESUMED;
+        this._readableState.updateNextTick();
+        return this;
+      }
+      pause() {
+        this._duplexState &= READ_PAUSED;
+        return this;
+      }
+      static _fromAsyncIterator(ite, opts) {
+        let destroy;
+        const rs = new _Readable({
+          ...opts,
+          read(cb) {
+            ite.next().then(push).then(cb.bind(null, null)).catch(cb);
+          },
+          predestroy() {
+            destroy = ite.return();
+          },
+          destroy(cb) {
+            if (!destroy) return cb(null);
+            destroy.then(cb.bind(null, null)).catch(cb);
+          }
+        });
+        return rs;
+        function push(data) {
+          if (data.done) rs.push(null);
+          else rs.push(data.value);
+        }
+      }
+      static from(data, opts) {
+        if (isReadStreamx(data)) return data;
+        if (data[asyncIterator]) return this._fromAsyncIterator(data[asyncIterator](), opts);
+        if (!Array.isArray(data)) data = data === void 0 ? [] : [data];
+        let i = 0;
+        return new _Readable({
+          ...opts,
+          read(cb) {
+            this.push(i === data.length ? null : data[i++]);
+            cb(null);
+          }
+        });
+      }
+      static isBackpressured(rs) {
+        return (rs._duplexState & READ_BACKPRESSURE_STATUS) !== 0 || rs._readableState.buffered >= rs._readableState.highWaterMark;
+      }
+      static isPaused(rs) {
+        return (rs._duplexState & READ_RESUMED) === 0;
+      }
+      [asyncIterator]() {
+        const stream = this;
+        let error = null;
+        let promiseResolve = null;
+        let promiseReject = null;
+        this.on("error", (err) => {
+          error = err;
+        });
+        this.on("readable", onreadable);
+        this.on("close", onclose);
+        return {
+          [asyncIterator]() {
+            return this;
+          },
+          next() {
+            return new Promise(function(resolve, reject) {
+              promiseResolve = resolve;
+              promiseReject = reject;
+              const data = stream.read();
+              if (data !== null) ondata(data);
+              else if ((stream._duplexState & DESTROYED) !== 0) ondata(null);
+            });
+          },
+          return() {
+            return destroy(null);
+          },
+          throw(err) {
+            return destroy(err);
+          }
+        };
+        function onreadable() {
+          if (promiseResolve !== null) ondata(stream.read());
+        }
+        function onclose() {
+          if (promiseResolve !== null) ondata(null);
+        }
+        function ondata(data) {
+          if (promiseReject === null) return;
+          if (error) promiseReject(error);
+          else if (data === null && (stream._duplexState & READ_DONE) === 0) promiseReject(STREAM_DESTROYED);
+          else promiseResolve({ value: data, done: data === null });
+          promiseReject = promiseResolve = null;
+        }
+        function destroy(err) {
+          stream.destroy(err);
+          return new Promise((resolve, reject) => {
+            if (stream._duplexState & DESTROYED) return resolve({ value: void 0, done: true });
+            stream.once("close", function() {
+              if (err) reject(err);
+              else resolve({ value: void 0, done: true });
+            });
+          });
+        }
+      }
+    };
+    var Writable = class extends Stream {
+      constructor(opts) {
+        super(opts);
+        this._duplexState |= OPENING | READ_DONE;
+        this._writableState = new WritableState(this, opts);
+        if (opts) {
+          if (opts.writev) this._writev = opts.writev;
+          if (opts.write) this._write = opts.write;
+          if (opts.final) this._final = opts.final;
+          if (opts.eagerOpen) this._writableState.updateNextTick();
+        }
+      }
+      _writev(batch, cb) {
+        cb(null);
+      }
+      _write(data, cb) {
+        this._writableState.autoBatch(data, cb);
+      }
+      _final(cb) {
+        cb(null);
+      }
+      static isBackpressured(ws) {
+        return (ws._duplexState & WRITE_BACKPRESSURE_STATUS) !== 0;
+      }
+      static drained(ws) {
+        if (ws.destroyed) return Promise.resolve(false);
+        const state = ws._writableState;
+        const pending = isWritev(ws) ? Math.min(1, state.queue.length) : state.queue.length;
+        const writes = pending + (ws._duplexState & WRITE_WRITING ? 1 : 0);
+        if (writes === 0) return Promise.resolve(true);
+        if (state.drains === null) state.drains = [];
+        return new Promise((resolve) => {
+          state.drains.push({ writes, resolve });
+        });
+      }
+      write(data) {
+        this._writableState.updateNextTick();
+        return this._writableState.push(data);
+      }
+      end(data) {
+        this._writableState.updateNextTick();
+        this._writableState.end(data);
+        return this;
+      }
+    };
+    var Duplex = class extends Readable {
+      // and Writable
+      constructor(opts) {
+        super(opts);
+        this._duplexState = OPENING;
+        this._writableState = new WritableState(this, opts);
+        if (opts) {
+          if (opts.writev) this._writev = opts.writev;
+          if (opts.write) this._write = opts.write;
+          if (opts.final) this._final = opts.final;
+        }
+      }
+      _writev(batch, cb) {
+        cb(null);
+      }
+      _write(data, cb) {
+        this._writableState.autoBatch(data, cb);
+      }
+      _final(cb) {
+        cb(null);
+      }
+      write(data) {
+        this._writableState.updateNextTick();
+        return this._writableState.push(data);
+      }
+      end(data) {
+        this._writableState.updateNextTick();
+        this._writableState.end(data);
+        return this;
+      }
+    };
+    var Transform = class extends Duplex {
+      constructor(opts) {
+        super(opts);
+        this._transformState = new TransformState(this);
+        if (opts) {
+          if (opts.transform) this._transform = opts.transform;
+          if (opts.flush) this._flush = opts.flush;
+        }
+      }
+      _write(data, cb) {
+        if (this._readableState.buffered >= this._readableState.highWaterMark) {
+          this._transformState.data = data;
+        } else {
+          this._transform(data, this._transformState.afterTransform);
+        }
+      }
+      _read(cb) {
+        if (this._transformState.data !== null) {
+          const data = this._transformState.data;
+          this._transformState.data = null;
+          cb(null);
+          this._transform(data, this._transformState.afterTransform);
+        } else {
+          cb(null);
+        }
+      }
+      destroy(err) {
+        super.destroy(err);
+        if (this._transformState.data !== null) {
+          this._transformState.data = null;
+          this._transformState.afterTransform();
+        }
+      }
+      _transform(data, cb) {
+        cb(null, data);
+      }
+      _flush(cb) {
+        cb(null);
+      }
+      _final(cb) {
+        this._transformState.afterFinal = cb;
+        this._flush(transformAfterFlush.bind(this));
+      }
+    };
+    var PassThrough = class extends Transform {
+    };
+    function transformAfterFlush(err, data) {
+      const cb = this._transformState.afterFinal;
+      if (err) return cb(err);
+      if (data !== null && data !== void 0) this.push(data);
+      this.push(null);
+      cb(null);
+    }
+    function pipelinePromise(...streams) {
+      return new Promise((resolve, reject) => {
+        return pipeline(...streams, (err) => {
+          if (err) return reject(err);
+          resolve();
+        });
+      });
+    }
+    function pipeline(stream, ...streams) {
+      const all = Array.isArray(stream) ? [...stream, ...streams] : [stream, ...streams];
+      const done = all.length && typeof all[all.length - 1] === "function" ? all.pop() : null;
+      if (all.length < 2) throw new Error("Pipeline requires at least 2 streams");
+      let src = all[0];
+      let dest = null;
+      let error = null;
+      for (let i = 1; i < all.length; i++) {
+        dest = all[i];
+        if (isStreamx(src)) {
+          src.pipe(dest, onerror);
+        } else {
+          errorHandle(src, true, i > 1, onerror);
+          src.pipe(dest);
+        }
+        src = dest;
+      }
+      if (done) {
+        let fin = false;
+        const autoDestroy = isStreamx(dest) || !!(dest._writableState && dest._writableState.autoDestroy);
+        dest.on("error", (err) => {
+          if (error === null) error = err;
+        });
+        dest.on("finish", () => {
+          fin = true;
+          if (!autoDestroy) done(error);
+        });
+        if (autoDestroy) {
+          dest.on("close", () => done(error || (fin ? null : PREMATURE_CLOSE)));
+        }
+      }
+      return dest;
+      function errorHandle(s, rd, wr, onerror2) {
+        s.on("error", onerror2);
+        s.on("close", onclose);
+        function onclose() {
+          if (rd && s._readableState && !s._readableState.ended) return onerror2(PREMATURE_CLOSE);
+          if (wr && s._writableState && !s._writableState.ended) return onerror2(PREMATURE_CLOSE);
+        }
+      }
+      function onerror(err) {
+        if (!err || error) return;
+        error = err;
+        for (const s of all) {
+          s.destroy(err);
+        }
+      }
+    }
+    function isStream(stream) {
+      return !!stream._readableState || !!stream._writableState;
+    }
+    function isStreamx(stream) {
+      return typeof stream._duplexState === "number" && isStream(stream);
+    }
+    function getStreamError(stream) {
+      const err = stream._readableState && stream._readableState.error || stream._writableState && stream._writableState.error;
+      return err === STREAM_DESTROYED ? null : err;
+    }
+    function isReadStreamx(stream) {
+      return isStreamx(stream) && stream.readable;
+    }
+    function isTypedArray(data) {
+      return typeof data === "object" && data !== null && typeof data.byteLength === "number";
+    }
+    function defaultByteLength(data) {
+      return isTypedArray(data) ? data.byteLength : 1024;
+    }
+    function noop() {
+    }
+    function abort() {
+      this.destroy(new Error("Stream aborted."));
+    }
+    function isWritev(s) {
+      return s._writev !== Writable.prototype._writev && s._writev !== Duplex.prototype._writev;
+    }
+    module.exports = {
+      pipeline,
+      pipelinePromise,
+      isStream,
+      isStreamx,
+      getStreamError,
+      Stream,
+      Writable,
+      Readable,
+      Duplex,
+      Transform,
+      // Export PassThrough for compatibility with Node.js core's stream module
+      PassThrough
+    };
+  }
+});
+
 // ../../node_modules/.pnpm/ms@2.1.3/node_modules/ms/index.js
 var require_ms = __commonJS({
   "../../node_modules/.pnpm/ms@2.1.3/node_modules/ms/index.js"(exports, module) {
@@ -5904,9 +6763,9 @@ var require_ms = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/debug@4.4.1/node_modules/debug/src/common.js
+// ../../node_modules/.pnpm/debug@4.4.3_supports-color@5.5.0/node_modules/debug/src/common.js
 var require_common = __commonJS({
-  "../../node_modules/.pnpm/debug@4.4.1/node_modules/debug/src/common.js"(exports, module) {
+  "../../node_modules/.pnpm/debug@4.4.3_supports-color@5.5.0/node_modules/debug/src/common.js"(exports, module) {
     function setup(env) {
       createDebug.debug = createDebug;
       createDebug.default = createDebug;
@@ -6081,9 +6940,9 @@ var require_common = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/debug@4.4.1/node_modules/debug/src/browser.js
+// ../../node_modules/.pnpm/debug@4.4.3_supports-color@5.5.0/node_modules/debug/src/browser.js
 var require_browser2 = __commonJS({
-  "../../node_modules/.pnpm/debug@4.4.1/node_modules/debug/src/browser.js"(exports, module) {
+  "../../node_modules/.pnpm/debug@4.4.3_supports-color@5.5.0/node_modules/debug/src/browser.js"(exports, module) {
     exports.formatArgs = formatArgs;
     exports.save = save;
     exports.load = load;
@@ -6251,43 +7110,35 @@ var require_browser2 = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/has-flag@4.0.0/node_modules/has-flag/index.js
+// ../../node_modules/.pnpm/has-flag@3.0.0/node_modules/has-flag/index.js
 var require_has_flag = __commonJS({
-  "../../node_modules/.pnpm/has-flag@4.0.0/node_modules/has-flag/index.js"(exports, module) {
+  "../../node_modules/.pnpm/has-flag@3.0.0/node_modules/has-flag/index.js"(exports, module) {
     "use strict";
-    module.exports = (flag, argv = process.argv) => {
+    module.exports = (flag, argv) => {
+      argv = argv || process.argv;
       const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
-      const position = argv.indexOf(prefix + flag);
-      const terminatorPosition = argv.indexOf("--");
-      return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+      const pos = argv.indexOf(prefix + flag);
+      const terminatorPos = argv.indexOf("--");
+      return pos !== -1 && (terminatorPos === -1 ? true : pos < terminatorPos);
     };
   }
 });
 
-// ../../node_modules/.pnpm/supports-color@8.1.1/node_modules/supports-color/index.js
+// ../../node_modules/.pnpm/supports-color@5.5.0/node_modules/supports-color/index.js
 var require_supports_color = __commonJS({
-  "../../node_modules/.pnpm/supports-color@8.1.1/node_modules/supports-color/index.js"(exports, module) {
+  "../../node_modules/.pnpm/supports-color@5.5.0/node_modules/supports-color/index.js"(exports, module) {
     "use strict";
     var os = __require("node:os");
-    var tty = __require("node:tty");
     var hasFlag = require_has_flag();
-    var { env } = process;
-    var flagForceColor;
-    if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
-      flagForceColor = 0;
+    var env = process.env;
+    var forceColor;
+    if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false")) {
+      forceColor = false;
     } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
-      flagForceColor = 1;
+      forceColor = true;
     }
-    function envForceColor() {
-      if ("FORCE_COLOR" in env) {
-        if (env.FORCE_COLOR === "true") {
-          return 1;
-        }
-        if (env.FORCE_COLOR === "false") {
-          return 0;
-        }
-        return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
-      }
+    if ("FORCE_COLOR" in env) {
+      forceColor = env.FORCE_COLOR.length === 0 || parseInt(env.FORCE_COLOR, 10) !== 0;
     }
     function translateLevel(level) {
       if (level === 0) {
@@ -6300,39 +7151,29 @@ var require_supports_color = __commonJS({
         has16m: level >= 3
       };
     }
-    function supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
-      const noFlagForceColor = envForceColor();
-      if (noFlagForceColor !== void 0) {
-        flagForceColor = noFlagForceColor;
-      }
-      const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
-      if (forceColor === 0) {
+    function supportsColor(stream) {
+      if (forceColor === false) {
         return 0;
       }
-      if (sniffFlags) {
-        if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
-          return 3;
-        }
-        if (hasFlag("color=256")) {
-          return 2;
-        }
+      if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+        return 3;
       }
-      if (haveStream && !streamIsTTY && forceColor === void 0) {
-        return 0;
+      if (hasFlag("color=256")) {
+        return 2;
       }
-      const min = forceColor || 0;
-      if (env.TERM === "dumb") {
-        return min;
+      if (stream && !stream.isTTY && forceColor !== true) {
+        return 0;
       }
+      const min = forceColor ? 1 : 0;
       if (process.platform === "win32") {
         const osRelease = os.release().split(".");
-        if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+        if (Number(process.versions.node.split(".")[0]) >= 8 && Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
           return Number(osRelease[2]) >= 14931 ? 3 : 2;
         }
         return 1;
       }
       if ("CI" in env) {
-        if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+        if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
           return 1;
         }
         return min;
@@ -6344,7 +7185,7 @@ var require_supports_color = __commonJS({
         return 3;
       }
       if ("TERM_PROGRAM" in env) {
-        const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+        const version = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
         switch (env.TERM_PROGRAM) {
           case "iTerm.app":
             return version >= 3 ? 3 : 2;
@@ -6361,26 +7202,26 @@ var require_supports_color = __commonJS({
       if ("COLORTERM" in env) {
         return 1;
       }
+      if (env.TERM === "dumb") {
+        return min;
+      }
       return min;
     }
-    function getSupportLevel(stream, options = {}) {
-      const level = supportsColor(stream, {
-        streamIsTTY: stream && stream.isTTY,
-        ...options
-      });
+    function getSupportLevel(stream) {
+      const level = supportsColor(stream);
       return translateLevel(level);
     }
     module.exports = {
       supportsColor: getSupportLevel,
-      stdout: getSupportLevel({ isTTY: tty.isatty(1) }),
-      stderr: getSupportLevel({ isTTY: tty.isatty(2) })
+      stdout: getSupportLevel(process.stdout),
+      stderr: getSupportLevel(process.stderr)
     };
   }
 });
 
-// ../../node_modules/.pnpm/debug@4.4.1/node_modules/debug/src/node.js
+// ../../node_modules/.pnpm/debug@4.4.3_supports-color@5.5.0/node_modules/debug/src/node.js
 var require_node = __commonJS({
-  "../../node_modules/.pnpm/debug@4.4.1/node_modules/debug/src/node.js"(exports, module) {
+  "../../node_modules/.pnpm/debug@4.4.3_supports-color@5.5.0/node_modules/debug/src/node.js"(exports, module) {
     var tty = __require("node:tty");
     var util = __require("node:util");
     exports.init = init;
@@ -6552,9 +7393,9 @@ var require_node = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/debug@4.4.1/node_modules/debug/src/index.js
+// ../../node_modules/.pnpm/debug@4.4.3_supports-color@5.5.0/node_modules/debug/src/index.js
 var require_src = __commonJS({
-  "../../node_modules/.pnpm/debug@4.4.1/node_modules/debug/src/index.js"(exports, module) {
+  "../../node_modules/.pnpm/debug@4.4.3_supports-color@5.5.0/node_modules/debug/src/index.js"(exports, module) {
     if (typeof process === "undefined" || process.type === "renderer" || process.browser === true || process.__nwjs) {
       module.exports = require_browser2();
     } else {
@@ -6573,7 +7414,7 @@ var require_hypercore_protocol = __commonJS({
     var Nanoguard = require_nanoguard();
     var pretty = require_pretty_hash();
     var Message = require_abstract_extension();
-    var { Duplex } = __require("streamx");
+    var { Duplex } = require_streamx();
     var debug = require_src()("hypercore-protocol");
     var StreamExtension = class extends Message {
       send(message) {
@@ -8033,11 +8874,11 @@ var require_emitter = __commonJS({
   "../../node_modules/.pnpm/nanoresource@1.3.0/node_modules/nanoresource/emitter.js"(exports, module) {
     var events = __require("node:events");
     var inherits = require_inherits();
-    var opening = Symbol("opening queue");
-    var preclosing = Symbol("closing when inactive");
-    var closing = Symbol("closing queue");
-    var sync = Symbol("sync");
-    var fastClose = Symbol("fast close");
+    var opening = /* @__PURE__ */ Symbol("opening queue");
+    var preclosing = /* @__PURE__ */ Symbol("closing when inactive");
+    var closing = /* @__PURE__ */ Symbol("closing queue");
+    var sync = /* @__PURE__ */ Symbol("sync");
+    var fastClose = /* @__PURE__ */ Symbol("fast close");
     module.exports = Nanoresource;
     function Nanoresource(opts) {
       if (!(this instanceof Nanoresource)) return new Nanoresource(opts);
@@ -8163,7 +9004,7 @@ var require_empty = __commonJS({
 // ../../node_modules/.pnpm/hypercore-streams@1.0.1/node_modules/hypercore-streams/index.js
 var require_hypercore_streams = __commonJS({
   "../../node_modules/.pnpm/hypercore-streams@1.0.1/node_modules/hypercore-streams/index.js"(exports, module) {
-    var { Writable, Readable } = __require("streamx");
+    var { Writable, Readable } = require_streamx();
     var WriteStream = class extends Writable {
       constructor(feed, opts) {
         super();
@@ -9232,7 +10073,7 @@ var require_hypercore = __commonJS({
     Feed.prototype.get = function(index, opts, cb) {
       if (typeof opts === "function") return this.get(index, null, opts);
       opts = { ...opts };
-      if (!opts.cancel) opts.cancel = Symbol("hypercore-get");
+      if (!opts.cancel) opts.cancel = /* @__PURE__ */ Symbol("hypercore-get");
       if (!this.opened) return this._readyAndGet(index, opts, cb);
       if (!this.readable) {
         process.nextTick(cb, new Error("Feed is closed"));