@ai-ecoverse/slicc-jsh 0.3.1 → 0.3.3

package/dist/node.mjs

@@ -1585,7 +1585,7 @@ function assignProcessExitCode(value) {
 // package.json
 var package_default = {
   name: "@ai-ecoverse/slicc-jsh",
-  version: "0.3.1",
+  version: "0.3.3",
   description: "Node.js-compatible runtime for slicc-kernel: the node and jsh commands (abi: js)",
   type: "module",
   license: "Apache-2.0",
@@ -1655,7 +1655,7 @@ var package_default = {
     "trust:dry": "npx fledgling sync --dry-run -y --skip-publish"
   },
   devDependencies: {
-    "@ai-ecoverse/slicc-kernel": "1.59.1",
+    "@ai-ecoverse/slicc-kernel": "1.61.0",
     "@ai-ecoverse/wasi-pnpm": "12.9.1-8",
     "abort-controller": "3.0.0",
     acorn: "8.19.0",
@@ -10818,6 +10818,9 @@ function notSupported(name) {
   err.code = "ERR_NOT_SUPPORTED";
   throw err;
 }
+function isExitError(err) {
+  return err?.name === "NodeExitError";
+}
 function normalizeArgs(file, args, options, callback) {
   if (typeof args === "function") {
     return { args: [], options: {}, callback: args };
@@ -10857,11 +10860,16 @@ function signalName(sig) {
   if (typeof sig === "number") return SIGNAL_NAMES[sig] ?? String(sig);
   return null;
 }
+function decodeOutput(buf, encoding) {
+  if (encoding === "buffer" || encoding === null) return buf;
+  const enc = encoding === void 0 ? "utf8" : encoding;
+  return buf.toString(enc);
+}
 function spawnError(command, args, code, message) {
   const err = new Error(message ?? `spawn ${command} ${code}`);
   err.code = code;
   err.errno = code === "ENOENT" ? -2 : void 0;
-  err.syscall = "spawn";
+  err.syscall = `spawn ${command}`;
   err.path = command;
   err.spawnargs = args;
   return err;
@@ -10883,16 +10891,22 @@ function createChildProcess({ ctx, process: process2, Buffer: Buffer2, handles,
       this.#kernel = null;
       this.#handle = null;
       this.#closing = false;
+      this.#exited = false;
     }
     #kernel;
     #handle;
     #closing;
+    #exited;
     kill(signal = "SIGTERM") {
+      if (this.#exited || this.#closing || !this.#kernel) return false;
       const name = signalName(signal) ?? "SIGTERM";
       this.killed = true;
-      if (!this.#kernel) return false;
       try {
         const ret = this.#kernel.kill(name);
+        if (ret != null && typeof ret.then === "function") {
+          ret.catch(() => {
+          });
+        }
         return ret !== false;
       } catch {
         return false;
@@ -10923,6 +10937,7 @@ function createChildProcess({ ctx, process: process2, Buffer: Buffer2, handles,
     /** @internal */
     _markClosing() {
       this.#closing = true;
+      this.#exited = true;
     }
     get _closing() {
       return this.#closing;
@@ -11009,20 +11024,46 @@ function createChildProcess({ ctx, process: process2, Buffer: Buffer2, handles,
     if (child.stderr?._sliccPump) pumps.push(child.stderr._sliccPump(kernelChild.stderr));
     child._stdioPumps = Promise.all(pumps);
   }
+  function safeEmit(child, event, ...args) {
+    try {
+      child.emit(event, ...args);
+    } catch (err) {
+      if (isExitError(err)) return err;
+      throw err;
+    }
+    return null;
+  }
   function finish(child, code, signal) {
     if (child._closing) return;
     child._markClosing();
     child.exitCode = code;
     child.signalCode = signal;
-    child.emit("exit", code, signal);
+    const exitErr = safeEmit(child, "exit", code, signal);
+    if (exitErr) {
+      child._release();
+      handles.notify?.();
+      return;
+    }
     const after = child._stdioPumps ?? Promise.resolve();
     trackPromise(handles, after);
     after.finally(() => {
-      child.emit("close", code, signal);
+      const closeErr = safeEmit(child, "close", code, signal);
       child._release();
       handles.notify?.();
+      if (closeErr) return;
     });
   }
+  function decodeWait(status) {
+    const sigNum = status?.signal;
+    if (sigNum != null && sigNum !== 0) {
+      return { code: null, signal: SIGNAL_NAMES[sigNum] ?? String(sigNum) };
+    }
+    const code = typeof status?.status === "number" ? status.status : 0;
+    if (code > 128 && code < 128 + 32 && SIGNAL_NAMES[code - 128]) {
+      return { code: null, signal: SIGNAL_NAMES[code - 128] };
+    }
+    return { code, signal: null };
+  }
   function startSpawn(child, file, args, options, stdio) {
     const cwd = options.cwd != null ? String(options.cwd) : process2.cwd();
     const env = options.env ? { ...options.env } : { ...process2.env };
@@ -11042,22 +11083,18 @@ function createChildProcess({ ctx, process: process2, Buffer: Buffer2, handles,
       (kernelChild) => {
         child._bindKernel(kernelChild);
         connectStdio(child, kernelChild);
-        child.emit("spawn");
+        const spawnErr = safeEmit(child, "spawn");
+        if (spawnErr) return;
         const waitP = kernelChild.wait();
         trackPromise(handles, waitP);
         waitP.then(
           (status) => {
-            const sigNum = status?.signal;
-            if (sigNum != null && sigNum !== 0) {
-              const name = SIGNAL_NAMES[sigNum] ?? String(sigNum);
-              finish(child, null, name);
-            } else {
-              const code = typeof status?.status === "number" ? status.status : 0;
-              finish(child, code, null);
-            }
+            const { code, signal } = decodeWait(status);
+            finish(child, code, signal);
           },
           (err) => {
-            child.emit("error", err);
+            if (isExitError(err)) return;
+            safeEmit(child, "error", err);
             finish(child, 1, null);
           }
         );
@@ -11074,15 +11111,23 @@ function createChildProcess({ ctx, process: process2, Buffer: Buffer2, handles,
         } catch {
         }
         process2.nextTick(() => {
-          child.emit("error", error);
+          const emitErr = safeEmit(child, "error", error);
+          if (emitErr) {
+            child._release();
+            handles.notify?.();
+            return;
+          }
           if (code === "ENOENT") {
             child.exitCode = -2;
-            child.emit("close", -2, null);
+            child._markClosing();
+            setTimeout(() => {
+              safeEmit(child, "close", -2, null);
+              child._release();
+              handles.notify?.();
+            }, 20);
           } else {
             finish(child, 1, null);
           }
-          child._release();
-          handles.notify?.();
         });
       }
     );
@@ -11106,7 +11151,23 @@ function createChildProcess({ ctx, process: process2, Buffer: Buffer2, handles,
     }
     const stdio = normalizeStdio(opts.stdio);
     const child = new ChildProcess();
-    prepareStdio(child, stdio);
+    try {
+      prepareStdio(child, stdio);
+    } catch (err) {
+      const code = err?.code === "ENOENT" || /\bENOENT\b/.test(err?.message ?? "") ? "ENOENT" : err?.code ?? "ERR_SPAWN_FAILED";
+      const error = code === "ENOENT" ? spawnError(file, argv, "ENOENT", `spawn ${file} ENOENT`) : spawnError(file, argv, code, err?.message ?? String(err));
+      process2.nextTick(() => {
+        safeEmit(child, "error", error);
+        if (code === "ENOENT") {
+          child.exitCode = -2;
+          child._markClosing();
+          safeEmit(child, "close", -2, null);
+        } else {
+          finish(child, 1, null);
+        }
+      });
+      return child;
+    }
     process2.nextTick(() => startSpawn(child, file, argv, opts, stdio));
     return child;
   }
@@ -11117,53 +11178,95 @@ function createChildProcess({ ctx, process: process2, Buffer: Buffer2, handles,
     const child = spawn(String(file), norm.args, opts);
     if (!norm.callback) return child;
     const maxBuffer = opts.maxBuffer ?? 1024 * 1024;
+    const encoding = opts.encoding;
+    const killSignal = signalName(opts.killSignal) ?? "SIGTERM";
     let stdout = Buffer2.alloc(0);
     let stderr = Buffer2.alloc(0);
     let exited = false;
+    let timedOut = false;
+    let timer;
+    const clearTimer = () => {
+      if (timer) {
+        clearTimeout(timer);
+        timer = void 0;
+      }
+    };
     const done = (err) => {
       if (exited) return;
       exited = true;
-      const enc = opts.encoding;
-      const out = enc ? stdout.toString(enc) : stdout;
-      const errOut = enc ? stderr.toString(enc) : stderr;
+      clearTimer();
+      const out = decodeOutput(stdout, encoding);
+      const errOut = decodeOutput(stderr, encoding);
+      if (err) {
+        err.stdout = out;
+        err.stderr = errOut;
+      }
       norm.callback(err, out, errOut);
     };
-    if (child.stdout) {
-      child.stdout.on("data", (chunk) => {
-        stdout = Buffer2.concat([stdout, Buffer2.isBuffer(chunk) ? chunk : Buffer2.from(chunk)]);
+    if (opts.timeout != null && opts.timeout > 0) {
+      timer = setTimeout(() => {
+        timedOut = true;
+        child.kill(killSignal);
+      }, Number(opts.timeout));
+      timer.unref?.();
+    }
+    const append = (kind, chunk) => {
+      const buf = Buffer2.isBuffer(chunk) ? chunk : Buffer2.from(chunk);
+      if (kind === "stdout") {
+        stdout = Buffer2.concat([stdout, buf]);
         if (stdout.length > maxBuffer) {
+          stdout = stdout.subarray(0, maxBuffer);
           child.kill();
-          const err = new Error("stdout maxBuffer exceeded");
+          const err = new Error("stdout maxBuffer length exceeded");
           err.code = "ERR_CHILD_PROCESS_STDIO_MAXBUFFER";
           done(err);
+          return false;
         }
-      });
-    }
-    if (child.stderr) {
-      child.stderr.on("data", (chunk) => {
-        stderr = Buffer2.concat([stderr, Buffer2.isBuffer(chunk) ? chunk : Buffer2.from(chunk)]);
+      } else {
+        stderr = Buffer2.concat([stderr, buf]);
         if (stderr.length > maxBuffer) {
+          stderr = stderr.subarray(0, maxBuffer);
           child.kill();
-          const err = new Error("stderr maxBuffer exceeded");
+          const err = new Error("stderr maxBuffer length exceeded");
           err.code = "ERR_CHILD_PROCESS_STDIO_MAXBUFFER";
           done(err);
+          return false;
         }
+      }
+      return true;
+    };
+    if (child.stdout) {
+      child.stdout.on("data", (chunk) => {
+        append("stdout", chunk);
+      });
+    }
+    if (child.stderr) {
+      child.stderr.on("data", (chunk) => {
+        append("stderr", chunk);
       });
     }
     child.on("error", (err) => done(err));
     child.on("close", (code, signal) => {
       if (exited) return;
+      const cmd = opts._execCmd != null ? String(opts._execCmd) : `${file} ${norm.args.join(" ")}`.trim();
+      if (timedOut) {
+        const err2 = new Error(`Command failed: ${cmd}`);
+        err2.code = null;
+        err2.killed = true;
+        err2.signal = killSignal;
+        err2.cmd = cmd;
+        done(err2);
+        return;
+      }
       if (code === 0 && !signal) {
         done(null);
         return;
       }
-      const err = new Error(`Command failed: ${file} ${norm.args.join(" ")}`);
+      const err = new Error(`Command failed: ${cmd}`);
       err.code = code;
       err.killed = child.killed;
       err.signal = signal;
-      err.cmd = `${file} ${norm.args.join(" ")}`.trim();
-      err.stdout = opts.encoding ? stdout.toString(opts.encoding) : stdout;
-      err.stderr = opts.encoding ? stderr.toString(opts.encoding) : stderr;
+      err.cmd = cmd;
       done(err);
     });
     return child;
@@ -11177,7 +11280,8 @@ function createChildProcess({ ctx, process: process2, Buffer: Buffer2, handles,
     }
     opts = opts && typeof opts === "object" ? opts : {};
     const shell = typeof opts.shell === "string" ? opts.shell : "sh";
-    return execFile(shell, ["-c", String(command)], { ...opts, shell: false }, cb);
+    const cmd = String(command);
+    return execFile(shell, ["-c", cmd], { ...opts, shell: false, _execCmd: cmd }, cb);
   }
   return {
     spawn,
@@ -13869,6 +13973,12 @@ function createQuerystring() {
   };
 }
 
+// src/runtime/vendor-embedded.mjs
+var VENDOR = {
+  "readable-stream": '"use strict";\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __commonJS = (cb, mod) => function __require() {\n  try {\n    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;\n  } catch (e) {\n    throw mod = 0, e;\n  }\n};\n\n// src/vendor-shims/buffer.cjs\nvar require_buffer = __commonJS({\n  "src/vendor-shims/buffer.cjs"(exports2, module2) {\n    "use strict";\n    var Buffer2 = globalThis.Buffer;\n    module2.exports = Buffer2;\n    module2.exports.Buffer = Buffer2;\n    module2.exports.SlowBuffer = Buffer2;\n    module2.exports.kMaxLength = 2147483647;\n    module2.exports.INSPECT_MAX_BYTES = 50;\n    if (typeof globalThis.Blob !== "undefined") {\n      module2.exports.Blob = globalThis.Blob;\n    }\n  }\n});\n\n// node_modules/readable-stream/lib/ours/primordials.js\nvar require_primordials = __commonJS({\n  "node_modules/readable-stream/lib/ours/primordials.js"(exports2, module2) {\n    "use strict";\n    var AggregateError = class extends Error {\n      constructor(errors) {\n        if (!Array.isArray(errors)) {\n          throw new TypeError(`Expected input to be an Array, got ${typeof errors}`);\n        }\n        let message = "";\n        for (let i = 0; i < errors.length; i++) {\n          message += `    ${errors[i].stack}\n`;\n        }\n        super(message);\n        this.name = "AggregateError";\n        this.errors = errors;\n      }\n    };\n    module2.exports = {\n      AggregateError,\n      ArrayIsArray(self) {\n        return Array.isArray(self);\n      },\n      ArrayPrototypeIncludes(self, el) {\n        return self.includes(el);\n      },\n      ArrayPrototypeIndexOf(self, el) {\n        return self.indexOf(el);\n      },\n      ArrayPrototypeJoin(self, sep) {\n        return self.join(sep);\n      },\n      ArrayPrototypeMap(self, fn) {\n        return self.map(fn);\n      },\n      ArrayPrototypePop(self, el) {\n        return self.pop(el);\n      },\n      ArrayPrototypePush(self, el) {\n        return self.push(el);\n      },\n      ArrayPrototypeSlice(self, start, end) {\n        return self.slice(start, end);\n      },\n      Error,\n      FunctionPrototypeCall(fn, thisArgs, ...args) {\n        return fn.call(thisArgs, ...args);\n      },\n      FunctionPrototypeSymbolHasInstance(self, instance) {\n        return Function.prototype[Symbol.hasInstance].call(self, instance);\n      },\n      MathFloor: Math.floor,\n      Number,\n      NumberIsInteger: Number.isInteger,\n      NumberIsNaN: Number.isNaN,\n      NumberMAX_SAFE_INTEGER: Number.MAX_SAFE_INTEGER,\n      NumberMIN_SAFE_INTEGER: Number.MIN_SAFE_INTEGER,\n      NumberParseInt: Number.parseInt,\n      ObjectDefineProperties(self, props) {\n        return Object.defineProperties(self, props);\n      },\n      ObjectDefineProperty(self, name, prop) {\n        return Object.defineProperty(self, name, prop);\n      },\n      ObjectGetOwnPropertyDescriptor(self, name) {\n        return Object.getOwnPropertyDescriptor(self, name);\n      },\n      ObjectKeys(obj) {\n        return Object.keys(obj);\n      },\n      ObjectSetPrototypeOf(target, proto) {\n        return Object.setPrototypeOf(target, proto);\n      },\n      Promise,\n      PromisePrototypeCatch(self, fn) {\n        return self.catch(fn);\n      },\n      PromisePrototypeThen(self, thenFn, catchFn) {\n        return self.then(thenFn, catchFn);\n      },\n      PromiseReject(err) {\n        return Promise.reject(err);\n      },\n      PromiseResolve(val) {\n        return Promise.resolve(val);\n      },\n      ReflectApply: Reflect.apply,\n      RegExpPrototypeTest(self, value) {\n        return self.test(value);\n      },\n      SafeSet: Set,\n      String,\n      StringPrototypeSlice(self, start, end) {\n        return self.slice(start, end);\n      },\n      StringPrototypeToLowerCase(self) {\n        return self.toLowerCase();\n      },\n      StringPrototypeToUpperCase(self) {\n        return self.toUpperCase();\n      },\n      StringPrototypeTrim(self) {\n        return self.trim();\n      },\n      Symbol,\n      SymbolFor: Symbol.for,\n      SymbolAsyncIterator: Symbol.asyncIterator,\n      SymbolHasInstance: Symbol.hasInstance,\n      SymbolIterator: Symbol.iterator,\n      SymbolDispose: Symbol.dispose || /* @__PURE__ */ Symbol("Symbol.dispose"),\n      SymbolAsyncDispose: Symbol.asyncDispose || /* @__PURE__ */ Symbol("Symbol.asyncDispose"),\n      TypedArrayPrototypeSet(self, buf, len) {\n        return self.set(buf, len);\n      },\n      Boolean,\n      Uint8Array\n    };\n  }\n});\n\n// node_modules/readable-stream/lib/ours/util/inspect.js\nvar require_inspect = __commonJS({\n  "node_modules/readable-stream/lib/ours/util/inspect.js"(exports2, module2) {\n    "use strict";\n    module2.exports = {\n      format(format, ...args) {\n        return format.replace(/%([sdifj])/g, function(...[_unused, type]) {\n          const replacement = args.shift();\n          if (type === "f") {\n            return replacement.toFixed(6);\n          } else if (type === "j") {\n            return JSON.stringify(replacement);\n          } else if (type === "s" && typeof replacement === "object") {\n            const ctor = replacement.constructor !== Object ? replacement.constructor.name : "";\n            return `${ctor} {}`.trim();\n          } else {\n            return replacement.toString();\n          }\n        });\n      },\n      inspect(value) {\n        switch (typeof value) {\n          case "string":\n            if (value.includes("\'")) {\n              if (!value.includes(\'"\')) {\n                return `"${value}"`;\n              } else if (!value.includes("`") && !value.includes("${")) {\n                return `\\`${value}\\``;\n              }\n            }\n            return `\'${value}\'`;\n          case "number":\n            if (isNaN(value)) {\n              return "NaN";\n            } else if (Object.is(value, -0)) {\n              return String(value);\n            }\n            return value;\n          case "bigint":\n            return `${String(value)}n`;\n          case "boolean":\n          case "undefined":\n            return String(value);\n          case "object":\n            return "{}";\n        }\n      }\n    };\n  }\n});\n\n// node_modules/readable-stream/lib/ours/errors.js\nvar require_errors = __commonJS({\n  "node_modules/readable-stream/lib/ours/errors.js"(exports2, module2) {\n    "use strict";\n    var { format, inspect } = require_inspect();\n    var { AggregateError: CustomAggregateError } = require_primordials();\n    var AggregateError = globalThis.AggregateError || CustomAggregateError;\n    var kIsNodeError = /* @__PURE__ */ Symbol("kIsNodeError");\n    var kTypes = [\n      "string",\n      "function",\n      "number",\n      "object",\n      // Accept \'Function\' and \'Object\' as alternative to the lower cased version.\n      "Function",\n      "Object",\n      "boolean",\n      "bigint",\n      "symbol"\n    ];\n    var classRegExp = /^([A-Z][a-z0-9]*)+$/;\n    var nodeInternalPrefix = "__node_internal_";\n    var codes = {};\n    function assert(value, message) {\n      if (!value) {\n        throw new codes.ERR_INTERNAL_ASSERTION(message);\n      }\n    }\n    function addNumericalSeparator(val) {\n      let res = "";\n      let i = val.length;\n      const start = val[0] === "-" ? 1 : 0;\n      for (; i >= start + 4; i -= 3) {\n        res = `_${val.slice(i - 3, i)}${res}`;\n      }\n      return `${val.slice(0, i)}${res}`;\n    }\n    function getMessage(key, msg, args) {\n      if (typeof msg === "function") {\n        assert(\n          msg.length <= args.length,\n          // Default options do not count.\n          `Code: ${key}; The provided arguments length (${args.length}) does not match the required ones (${msg.length}).`\n        );\n        return msg(...args);\n      }\n      const expectedLength = (msg.match(/%[dfijoOs]/g) || []).length;\n      assert(\n        expectedLength === args.length,\n        `Code: ${key}; The provided arguments length (${args.length}) does not match the required ones (${expectedLength}).`\n      );\n      if (args.length === 0) {\n        return msg;\n      }\n      return format(msg, ...args);\n    }\n    function E(code, message, Base) {\n      if (!Base) {\n        Base = Error;\n      }\n      class NodeError extends Base {\n        constructor(...args) {\n          super(getMessage(code, message, args));\n        }\n        toString() {\n          return `${this.name} [${code}]: ${this.message}`;\n        }\n      }\n      Object.defineProperties(NodeError.prototype, {\n        name: {\n          value: Base.name,\n          writable: true,\n          enumerable: false,\n          configurable: true\n        },\n        toString: {\n          value() {\n            return `${this.name} [${code}]: ${this.message}`;\n          },\n          writable: true,\n          enumerable: false,\n          configurable: true\n        }\n      });\n      NodeError.prototype.code = code;\n      NodeError.prototype[kIsNodeError] = true;\n      codes[code] = NodeError;\n    }\n    function hideStackFrames(fn) {\n      const hidden = nodeInternalPrefix + fn.name;\n      Object.defineProperty(fn, "name", {\n        value: hidden\n      });\n      return fn;\n    }\n    function aggregateTwoErrors(innerError, outerError) {\n      if (innerError && outerError && innerError !== outerError) {\n        if (Array.isArray(outerError.errors)) {\n          outerError.errors.push(innerError);\n          return outerError;\n        }\n        const err = new AggregateError([outerError, innerError], outerError.message);\n        err.code = outerError.code;\n        return err;\n      }\n      return innerError || outerError;\n    }\n    var AbortError = class extends Error {\n      constructor(message = "The operation was aborted", options = void 0) {\n        if (options !== void 0 && typeof options !== "object") {\n          throw new codes.ERR_INVALID_ARG_TYPE("options", "Object", options);\n        }\n        super(message, options);\n        this.code = "ABORT_ERR";\n        this.name = "AbortError";\n      }\n    };\n    E("ERR_ASSERTION", "%s", Error);\n    E(\n      "ERR_INVALID_ARG_TYPE",\n      (name, expected, actual) => {\n        assert(typeof name === "string", "\'name\' must be a string");\n        if (!Array.isArray(expected)) {\n          expected = [expected];\n        }\n        let msg = "The ";\n        if (name.endsWith(" argument")) {\n          msg += `${name} `;\n        } else {\n          msg += `"${name}" ${name.includes(".") ? "property" : "argument"} `;\n        }\n        msg += "must be ";\n        const types = [];\n        const instances = [];\n        const other = [];\n        for (const value of expected) {\n          assert(typeof value === "string", "All expected entries have to be of type string");\n          if (kTypes.includes(value)) {\n            types.push(value.toLowerCase());\n          } else if (classRegExp.test(value)) {\n            instances.push(value);\n          } else {\n            assert(value !== "object", \'The value "object" should be written as "Object"\');\n            other.push(value);\n          }\n        }\n        if (instances.length > 0) {\n          const pos = types.indexOf("object");\n          if (pos !== -1) {\n            types.splice(types, pos, 1);\n            instances.push("Object");\n          }\n        }\n        if (types.length > 0) {\n          switch (types.length) {\n            case 1:\n              msg += `of type ${types[0]}`;\n              break;\n            case 2:\n              msg += `one of type ${types[0]} or ${types[1]}`;\n              break;\n            default: {\n              const last = types.pop();\n              msg += `one of type ${types.join(", ")}, or ${last}`;\n            }\n          }\n          if (instances.length > 0 || other.length > 0) {\n            msg += " or ";\n          }\n        }\n        if (instances.length > 0) {\n          switch (instances.length) {\n            case 1:\n              msg += `an instance of ${instances[0]}`;\n              break;\n            case 2:\n              msg += `an instance of ${instances[0]} or ${instances[1]}`;\n              break;\n            default: {\n              const last = instances.pop();\n              msg += `an instance of ${instances.join(", ")}, or ${last}`;\n            }\n          }\n          if (other.length > 0) {\n            msg += " or ";\n          }\n        }\n        switch (other.length) {\n          case 0:\n            break;\n          case 1:\n            if (other[0].toLowerCase() !== other[0]) {\n              msg += "an ";\n            }\n            msg += `${other[0]}`;\n            break;\n          case 2:\n            msg += `one of ${other[0]} or ${other[1]}`;\n            break;\n          default: {\n            const last = other.pop();\n            msg += `one of ${other.join(", ")}, or ${last}`;\n          }\n        }\n        if (actual == null) {\n          msg += `. Received ${actual}`;\n        } else if (typeof actual === "function" && actual.name) {\n          msg += `. Received function ${actual.name}`;\n        } else if (typeof actual === "object") {\n          var _actual$constructor;\n          if ((_actual$constructor = actual.constructor) !== null && _actual$constructor !== void 0 && _actual$constructor.name) {\n            msg += `. Received an instance of ${actual.constructor.name}`;\n          } else {\n            const inspected = inspect(actual, {\n              depth: -1\n            });\n            msg += `. Received ${inspected}`;\n          }\n        } else {\n          let inspected = inspect(actual, {\n            colors: false\n          });\n          if (inspected.length > 25) {\n            inspected = `${inspected.slice(0, 25)}...`;\n          }\n          msg += `. Received type ${typeof actual} (${inspected})`;\n        }\n        return msg;\n      },\n      TypeError\n    );\n    E(\n      "ERR_INVALID_ARG_VALUE",\n      (name, value, reason = "is invalid") => {\n        let inspected = inspect(value);\n        if (inspected.length > 128) {\n          inspected = inspected.slice(0, 128) + "...";\n        }\n        const type = name.includes(".") ? "property" : "argument";\n        return `The ${type} \'${name}\' ${reason}. Received ${inspected}`;\n      },\n      TypeError\n    );\n    E(\n      "ERR_INVALID_RETURN_VALUE",\n      (input, name, value) => {\n        var _value$constructor;\n        const type = value !== null && value !== void 0 && (_value$constructor = value.constructor) !== null && _value$constructor !== void 0 && _value$constructor.name ? `instance of ${value.constructor.name}` : `type ${typeof value}`;\n        return `Expected ${input} to be returned from the "${name}" function but got ${type}.`;\n      },\n      TypeError\n    );\n    E(\n      "ERR_MISSING_ARGS",\n      (...args) => {\n        assert(args.length > 0, "At least one arg needs to be specified");\n        let msg;\n        const len = args.length;\n        args = (Array.isArray(args) ? args : [args]).map((a) => `"${a}"`).join(" or ");\n        switch (len) {\n          case 1:\n            msg += `The ${args[0]} argument`;\n            break;\n          case 2:\n            msg += `The ${args[0]} and ${args[1]} arguments`;\n            break;\n          default:\n            {\n              const last = args.pop();\n              msg += `The ${args.join(", ")}, and ${last} arguments`;\n            }\n            break;\n        }\n        return `${msg} must be specified`;\n      },\n      TypeError\n    );\n    E(\n      "ERR_OUT_OF_RANGE",\n      (str, range, input) => {\n        assert(range, \'Missing "range" argument\');\n        let received;\n        if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) {\n          received = addNumericalSeparator(String(input));\n        } else if (typeof input === "bigint") {\n          received = String(input);\n          const limit = BigInt(2) ** BigInt(32);\n          if (input > limit || input < -limit) {\n            received = addNumericalSeparator(received);\n          }\n          received += "n";\n        } else {\n          received = inspect(input);\n        }\n        return `The value of "${str}" is out of range. It must be ${range}. Received ${received}`;\n      },\n      RangeError\n    );\n    E("ERR_MULTIPLE_CALLBACK", "Callback called multiple times", Error);\n    E("ERR_METHOD_NOT_IMPLEMENTED", "The %s method is not implemented", Error);\n    E("ERR_STREAM_ALREADY_FINISHED", "Cannot call %s after a stream was finished", Error);\n    E("ERR_STREAM_CANNOT_PIPE", "Cannot pipe, not readable", Error);\n    E("ERR_STREAM_DESTROYED", "Cannot call %s after a stream was destroyed", Error);\n    E("ERR_STREAM_NULL_VALUES", "May not write null values to stream", TypeError);\n    E("ERR_STREAM_PREMATURE_CLOSE", "Premature close", Error);\n    E("ERR_STREAM_PUSH_AFTER_EOF", "stream.push() after EOF", Error);\n    E("ERR_STREAM_UNSHIFT_AFTER_END_EVENT", "stream.unshift() after end event", Error);\n    E("ERR_STREAM_WRITE_AFTER_END", "write after end", Error);\n    E("ERR_UNKNOWN_ENCODING", "Unknown encoding: %s", TypeError);\n    module2.exports = {\n      AbortError,\n      aggregateTwoErrors: hideStackFrames(aggregateTwoErrors),\n      hideStackFrames,\n      codes\n    };\n  }\n});\n\n// node_modules/event-target-shim/dist/event-target-shim.js\nvar require_event_target_shim = __commonJS({\n  "node_modules/event-target-shim/dist/event-target-shim.js"(exports2, module2) {\n    "use strict";\n    Object.defineProperty(exports2, "__esModule", { value: true });\n    var privateData = /* @__PURE__ */ new WeakMap();\n    var wrappers = /* @__PURE__ */ new WeakMap();\n    function pd(event) {\n      const retv = privateData.get(event);\n      console.assert(\n        retv != null,\n        "\'this\' is expected an Event object, but got",\n        event\n      );\n      return retv;\n    }\n    function setCancelFlag(data) {\n      if (data.passiveListener != null) {\n        if (typeof console !== "undefined" && typeof console.error === "function") {\n          console.error(\n            "Unable to preventDefault inside passive event listener invocation.",\n            data.passiveListener\n          );\n        }\n        return;\n      }\n      if (!data.event.cancelable) {\n        return;\n      }\n      data.canceled = true;\n      if (typeof data.event.preventDefault === "function") {\n        data.event.preventDefault();\n      }\n    }\n    function Event(eventTarget, event) {\n      privateData.set(this, {\n        eventTarget,\n        event,\n        eventPhase: 2,\n        currentTarget: eventTarget,\n        canceled: false,\n        stopped: false,\n        immediateStopped: false,\n        passiveListener: null,\n        timeStamp: event.timeStamp || Date.now()\n      });\n      Object.defineProperty(this, "isTrusted", { value: false, enumerable: true });\n      const keys = Object.keys(event);\n      for (let i = 0; i < keys.length; ++i) {\n        const key = keys[i];\n        if (!(key in this)) {\n          Object.defineProperty(this, key, defineRedirectDescriptor(key));\n        }\n      }\n    }\n    Event.prototype = {\n      /**\n       * The type of this event.\n       * @type {string}\n       */\n      get type() {\n        return pd(this).event.type;\n      },\n      /**\n       * The target of this event.\n       * @type {EventTarget}\n       */\n      get target() {\n        return pd(this).eventTarget;\n      },\n      /**\n       * The target of this event.\n       * @type {EventTarget}\n       */\n      get currentTarget() {\n        return pd(this).currentTarget;\n      },\n      /**\n       * @returns {EventTarget[]} The composed path of this event.\n       */\n      composedPath() {\n        const currentTarget = pd(this).currentTarget;\n        if (currentTarget == null) {\n          return [];\n        }\n        return [currentTarget];\n      },\n      /**\n       * Constant of NONE.\n       * @type {number}\n       */\n      get NONE() {\n        return 0;\n      },\n      /**\n       * Constant of CAPTURING_PHASE.\n       * @type {number}\n       */\n      get CAPTURING_PHASE() {\n        return 1;\n      },\n      /**\n       * Constant of AT_TARGET.\n       * @type {number}\n       */\n      get AT_TARGET() {\n        return 2;\n      },\n      /**\n       * Constant of BUBBLING_PHASE.\n       * @type {number}\n       */\n      get BUBBLING_PHASE() {\n        return 3;\n      },\n      /**\n       * The target of this event.\n       * @type {number}\n       */\n      get eventPhase() {\n        return pd(this).eventPhase;\n      },\n      /**\n       * Stop event bubbling.\n       * @returns {void}\n       */\n      stopPropagation() {\n        const data = pd(this);\n        data.stopped = true;\n        if (typeof data.event.stopPropagation === "function") {\n          data.event.stopPropagation();\n        }\n      },\n      /**\n       * Stop event bubbling.\n       * @returns {void}\n       */\n      stopImmediatePropagation() {\n        const data = pd(this);\n        data.stopped = true;\n        data.immediateStopped = true;\n        if (typeof data.event.stopImmediatePropagation === "function") {\n          data.event.stopImmediatePropagation();\n        }\n      },\n      /**\n       * The flag to be bubbling.\n       * @type {boolean}\n       */\n      get bubbles() {\n        return Boolean(pd(this).event.bubbles);\n      },\n      /**\n       * The flag to be cancelable.\n       * @type {boolean}\n       */\n      get cancelable() {\n        return Boolean(pd(this).event.cancelable);\n      },\n      /**\n       * Cancel this event.\n       * @returns {void}\n       */\n      preventDefault() {\n        setCancelFlag(pd(this));\n      },\n      /**\n       * The flag to indicate cancellation state.\n       * @type {boolean}\n       */\n      get defaultPrevented() {\n        return pd(this).canceled;\n      },\n      /**\n       * The flag to be composed.\n       * @type {boolean}\n       */\n      get composed() {\n        return Boolean(pd(this).event.composed);\n      },\n      /**\n       * The unix time of this event.\n       * @type {number}\n       */\n      get timeStamp() {\n        return pd(this).timeStamp;\n      },\n      /**\n       * The target of this event.\n       * @type {EventTarget}\n       * @deprecated\n       */\n      get srcElement() {\n        return pd(this).eventTarget;\n      },\n      /**\n       * The flag to stop event bubbling.\n       * @type {boolean}\n       * @deprecated\n       */\n      get cancelBubble() {\n        return pd(this).stopped;\n      },\n      set cancelBubble(value) {\n        if (!value) {\n          return;\n        }\n        const data = pd(this);\n        data.stopped = true;\n        if (typeof data.event.cancelBubble === "boolean") {\n          data.event.cancelBubble = true;\n        }\n      },\n      /**\n       * The flag to indicate cancellation state.\n       * @type {boolean}\n       * @deprecated\n       */\n      get returnValue() {\n        return !pd(this).canceled;\n      },\n      set returnValue(value) {\n        if (!value) {\n          setCancelFlag(pd(this));\n        }\n      },\n      /**\n       * Initialize this event object. But do nothing under event dispatching.\n       * @param {string} type The event type.\n       * @param {boolean} [bubbles=false] The flag to be possible to bubble up.\n       * @param {boolean} [cancelable=false] The flag to be possible to cancel.\n       * @deprecated\n       */\n      initEvent() {\n      }\n    };\n    Object.defineProperty(Event.prototype, "constructor", {\n      value: Event,\n      configurable: true,\n      writable: true\n    });\n    if (typeof window !== "undefined" && typeof window.Event !== "undefined") {\n      Object.setPrototypeOf(Event.prototype, window.Event.prototype);\n      wrappers.set(window.Event.prototype, Event);\n    }\n    function defineRedirectDescriptor(key) {\n      return {\n        get() {\n          return pd(this).event[key];\n        },\n        set(value) {\n          pd(this).event[key] = value;\n        },\n        configurable: true,\n        enumerable: true\n      };\n    }\n    function defineCallDescriptor(key) {\n      return {\n        value() {\n          const event = pd(this).event;\n          return event[key].apply(event, arguments);\n        },\n        configurable: true,\n        enumerable: true\n      };\n    }\n    function defineWrapper(BaseEvent, proto) {\n      const keys = Object.keys(proto);\n      if (keys.length === 0) {\n        return BaseEvent;\n      }\n      function CustomEvent(eventTarget, event) {\n        BaseEvent.call(this, eventTarget, event);\n      }\n      CustomEvent.prototype = Object.create(BaseEvent.prototype, {\n        constructor: { value: CustomEvent, configurable: true, writable: true }\n      });\n      for (let i = 0; i < keys.length; ++i) {\n        const key = keys[i];\n        if (!(key in BaseEvent.prototype)) {\n          const descriptor = Object.getOwnPropertyDescriptor(proto, key);\n          const isFunc = typeof descriptor.value === "function";\n          Object.defineProperty(\n            CustomEvent.prototype,\n            key,\n            isFunc ? defineCallDescriptor(key) : defineRedirectDescriptor(key)\n          );\n        }\n      }\n      return CustomEvent;\n    }\n    function getWrapper(proto) {\n      if (proto == null || proto === Object.prototype) {\n        return Event;\n      }\n      let wrapper = wrappers.get(proto);\n      if (wrapper == null) {\n        wrapper = defineWrapper(getWrapper(Object.getPrototypeOf(proto)), proto);\n        wrappers.set(proto, wrapper);\n      }\n      return wrapper;\n    }\n    function wrapEvent(eventTarget, event) {\n      const Wrapper = getWrapper(Object.getPrototypeOf(event));\n      return new Wrapper(eventTarget, event);\n    }\n    function isStopped(event) {\n      return pd(event).immediateStopped;\n    }\n    function setEventPhase(event, eventPhase) {\n      pd(event).eventPhase = eventPhase;\n    }\n    function setCurrentTarget(event, currentTarget) {\n      pd(event).currentTarget = currentTarget;\n    }\n    function setPassiveListener(event, passiveListener) {\n      pd(event).passiveListener = passiveListener;\n    }\n    var listenersMap = /* @__PURE__ */ new WeakMap();\n    var CAPTURE = 1;\n    var BUBBLE = 2;\n    var ATTRIBUTE = 3;\n    function isObject(x) {\n      return x !== null && typeof x === "object";\n    }\n    function getListeners(eventTarget) {\n      const listeners = listenersMap.get(eventTarget);\n      if (listeners == null) {\n        throw new TypeError(\n          "\'this\' is expected an EventTarget object, but got another value."\n        );\n      }\n      return listeners;\n    }\n    function defineEventAttributeDescriptor(eventName) {\n      return {\n        get() {\n          const listeners = getListeners(this);\n          let node = listeners.get(eventName);\n          while (node != null) {\n            if (node.listenerType === ATTRIBUTE) {\n              return node.listener;\n            }\n            node = node.next;\n          }\n          return null;\n        },\n        set(listener) {\n          if (typeof listener !== "function" && !isObject(listener)) {\n            listener = null;\n          }\n          const listeners = getListeners(this);\n          let prev = null;\n          let node = listeners.get(eventName);\n          while (node != null) {\n            if (node.listenerType === ATTRIBUTE) {\n              if (prev !== null) {\n                prev.next = node.next;\n              } else if (node.next !== null) {\n                listeners.set(eventName, node.next);\n              } else {\n                listeners.delete(eventName);\n              }\n            } else {\n              prev = node;\n            }\n            node = node.next;\n          }\n          if (listener !== null) {\n            const newNode = {\n              listener,\n              listenerType: ATTRIBUTE,\n              passive: false,\n              once: false,\n              next: null\n            };\n            if (prev === null) {\n              listeners.set(eventName, newNode);\n            } else {\n              prev.next = newNode;\n            }\n          }\n        },\n        configurable: true,\n        enumerable: true\n      };\n    }\n    function defineEventAttribute(eventTargetPrototype, eventName) {\n      Object.defineProperty(\n        eventTargetPrototype,\n        `on${eventName}`,\n        defineEventAttributeDescriptor(eventName)\n      );\n    }\n    function defineCustomEventTarget(eventNames) {\n      function CustomEventTarget() {\n        EventTarget.call(this);\n      }\n      CustomEventTarget.prototype = Object.create(EventTarget.prototype, {\n        constructor: {\n          value: CustomEventTarget,\n          configurable: true,\n          writable: true\n        }\n      });\n      for (let i = 0; i < eventNames.length; ++i) {\n        defineEventAttribute(CustomEventTarget.prototype, eventNames[i]);\n      }\n      return CustomEventTarget;\n    }\n    function EventTarget() {\n      if (this instanceof EventTarget) {\n        listenersMap.set(this, /* @__PURE__ */ new Map());\n        return;\n      }\n      if (arguments.length === 1 && Array.isArray(arguments[0])) {\n        return defineCustomEventTarget(arguments[0]);\n      }\n      if (arguments.length > 0) {\n        const types = new Array(arguments.length);\n        for (let i = 0; i < arguments.length; ++i) {\n          types[i] = arguments[i];\n        }\n        return defineCustomEventTarget(types);\n      }\n      throw new TypeError("Cannot call a class as a function");\n    }\n    EventTarget.prototype = {\n      /**\n       * Add a given listener to this event target.\n       * @param {string} eventName The event name to add.\n       * @param {Function} listener The listener to add.\n       * @param {boolean|{capture?:boolean,passive?:boolean,once?:boolean}} [options] The options for this listener.\n       * @returns {void}\n       */\n      addEventListener(eventName, listener, options) {\n        if (listener == null) {\n          return;\n        }\n        if (typeof listener !== "function" && !isObject(listener)) {\n          throw new TypeError("\'listener\' should be a function or an object.");\n        }\n        const listeners = getListeners(this);\n        const optionsIsObj = isObject(options);\n        const capture = optionsIsObj ? Boolean(options.capture) : Boolean(options);\n        const listenerType = capture ? CAPTURE : BUBBLE;\n        const newNode = {\n          listener,\n          listenerType,\n          passive: optionsIsObj && Boolean(options.passive),\n          once: optionsIsObj && Boolean(options.once),\n          next: null\n        };\n        let node = listeners.get(eventName);\n        if (node === void 0) {\n          listeners.set(eventName, newNode);\n          return;\n        }\n        let prev = null;\n        while (node != null) {\n          if (node.listener === listener && node.listenerType === listenerType) {\n            return;\n          }\n          prev = node;\n          node = node.next;\n        }\n        prev.next = newNode;\n      },\n      /**\n       * Remove a given listener from this event target.\n       * @param {string} eventName The event name to remove.\n       * @param {Function} listener The listener to remove.\n       * @param {boolean|{capture?:boolean,passive?:boolean,once?:boolean}} [options] The options for this listener.\n       * @returns {void}\n       */\n      removeEventListener(eventName, listener, options) {\n        if (listener == null) {\n          return;\n        }\n        const listeners = getListeners(this);\n        const capture = isObject(options) ? Boolean(options.capture) : Boolean(options);\n        const listenerType = capture ? CAPTURE : BUBBLE;\n        let prev = null;\n        let node = listeners.get(eventName);\n        while (node != null) {\n          if (node.listener === listener && node.listenerType === listenerType) {\n            if (prev !== null) {\n              prev.next = node.next;\n            } else if (node.next !== null) {\n              listeners.set(eventName, node.next);\n            } else {\n              listeners.delete(eventName);\n            }\n            return;\n          }\n          prev = node;\n          node = node.next;\n        }\n      },\n      /**\n       * Dispatch a given event.\n       * @param {Event|{type:string}} event The event to dispatch.\n       * @returns {boolean} `false` if canceled.\n       */\n      dispatchEvent(event) {\n        if (event == null || typeof event.type !== "string") {\n          throw new TypeError(\'"event.type" should be a string.\');\n        }\n        const listeners = getListeners(this);\n        const eventName = event.type;\n        let node = listeners.get(eventName);\n        if (node == null) {\n          return true;\n        }\n        const wrappedEvent = wrapEvent(this, event);\n        let prev = null;\n        while (node != null) {\n          if (node.once) {\n            if (prev !== null) {\n              prev.next = node.next;\n            } else if (node.next !== null) {\n              listeners.set(eventName, node.next);\n            } else {\n              listeners.delete(eventName);\n            }\n          } else {\n            prev = node;\n          }\n          setPassiveListener(\n            wrappedEvent,\n            node.passive ? node.listener : null\n          );\n          if (typeof node.listener === "function") {\n            try {\n              node.listener.call(this, wrappedEvent);\n            } catch (err) {\n              if (typeof console !== "undefined" && typeof console.error === "function") {\n                console.error(err);\n              }\n            }\n          } else if (node.listenerType !== ATTRIBUTE && typeof node.listener.handleEvent === "function") {\n            node.listener.handleEvent(wrappedEvent);\n          }\n          if (isStopped(wrappedEvent)) {\n            break;\n          }\n          node = node.next;\n        }\n        setPassiveListener(wrappedEvent, null);\n        setEventPhase(wrappedEvent, 0);\n        setCurrentTarget(wrappedEvent, null);\n        return !wrappedEvent.defaultPrevented;\n      }\n    };\n    Object.defineProperty(EventTarget.prototype, "constructor", {\n      value: EventTarget,\n      configurable: true,\n      writable: true\n    });\n    if (typeof window !== "undefined" && typeof window.EventTarget !== "undefined") {\n      Object.setPrototypeOf(EventTarget.prototype, window.EventTarget.prototype);\n    }\n    exports2.defineEventAttribute = defineEventAttribute;\n    exports2.EventTarget = EventTarget;\n    exports2.default = EventTarget;\n    module2.exports = EventTarget;\n    module2.exports.EventTarget = module2.exports["default"] = EventTarget;\n    module2.exports.defineEventAttribute = defineEventAttribute;\n  }\n});\n\n// node_modules/abort-controller/dist/abort-controller.js\nvar require_abort_controller = __commonJS({\n  "node_modules/abort-controller/dist/abort-controller.js"(exports2, module2) {\n    "use strict";\n    Object.defineProperty(exports2, "__esModule", { value: true });\n    var eventTargetShim = require_event_target_shim();\n    var AbortSignal = class extends eventTargetShim.EventTarget {\n      /**\n       * AbortSignal cannot be constructed directly.\n       */\n      constructor() {\n        super();\n        throw new TypeError("AbortSignal cannot be constructed directly");\n      }\n      /**\n       * Returns `true` if this `AbortSignal`\'s `AbortController` has signaled to abort, and `false` otherwise.\n       */\n      get aborted() {\n        const aborted = abortedFlags.get(this);\n        if (typeof aborted !== "boolean") {\n          throw new TypeError(`Expected \'this\' to be an \'AbortSignal\' object, but got ${this === null ? "null" : typeof this}`);\n        }\n        return aborted;\n      }\n    };\n    eventTargetShim.defineEventAttribute(AbortSignal.prototype, "abort");\n    function createAbortSignal() {\n      const signal = Object.create(AbortSignal.prototype);\n      eventTargetShim.EventTarget.call(signal);\n      abortedFlags.set(signal, false);\n      return signal;\n    }\n    function abortSignal(signal) {\n      if (abortedFlags.get(signal) !== false) {\n        return;\n      }\n      abortedFlags.set(signal, true);\n      signal.dispatchEvent({ type: "abort" });\n    }\n    var abortedFlags = /* @__PURE__ */ new WeakMap();\n    Object.defineProperties(AbortSignal.prototype, {\n      aborted: { enumerable: true }\n    });\n    if (typeof Symbol === "function" && typeof Symbol.toStringTag === "symbol") {\n      Object.defineProperty(AbortSignal.prototype, Symbol.toStringTag, {\n        configurable: true,\n        value: "AbortSignal"\n      });\n    }\n    var AbortController = class {\n      /**\n       * Initialize this controller.\n       */\n      constructor() {\n        signals.set(this, createAbortSignal());\n      }\n      /**\n       * Returns the `AbortSignal` object associated with this object.\n       */\n      get signal() {\n        return getSignal(this);\n      }\n      /**\n       * Abort and signal to any observers that the associated activity is to be aborted.\n       */\n      abort() {\n        abortSignal(getSignal(this));\n      }\n    };\n    var signals = /* @__PURE__ */ new WeakMap();\n    function getSignal(controller) {\n      const signal = signals.get(controller);\n      if (signal == null) {\n        throw new TypeError(`Expected \'this\' to be an \'AbortController\' object, but got ${controller === null ? "null" : typeof controller}`);\n      }\n      return signal;\n    }\n    Object.defineProperties(AbortController.prototype, {\n      signal: { enumerable: true },\n      abort: { enumerable: true }\n    });\n    if (typeof Symbol === "function" && typeof Symbol.toStringTag === "symbol") {\n      Object.defineProperty(AbortController.prototype, Symbol.toStringTag, {\n        configurable: true,\n        value: "AbortController"\n      });\n    }\n    exports2.AbortController = AbortController;\n    exports2.AbortSignal = AbortSignal;\n    exports2.default = AbortController;\n    module2.exports = AbortController;\n    module2.exports.AbortController = module2.exports["default"] = AbortController;\n    module2.exports.AbortSignal = AbortSignal;\n  }\n});\n\n// node_modules/events/events.js\nvar require_events = __commonJS({\n  "node_modules/events/events.js"(exports2, module2) {\n    "use strict";\n    var R = typeof Reflect === "object" ? Reflect : null;\n    var ReflectApply = R && typeof R.apply === "function" ? R.apply : function ReflectApply2(target, receiver, args) {\n      return Function.prototype.apply.call(target, receiver, args);\n    };\n    var ReflectOwnKeys;\n    if (R && typeof R.ownKeys === "function") {\n      ReflectOwnKeys = R.ownKeys;\n    } else if (Object.getOwnPropertySymbols) {\n      ReflectOwnKeys = function ReflectOwnKeys2(target) {\n        return Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target));\n      };\n    } else {\n      ReflectOwnKeys = function ReflectOwnKeys2(target) {\n        return Object.getOwnPropertyNames(target);\n      };\n    }\n    function ProcessEmitWarning(warning) {\n      if (console && console.warn) console.warn(warning);\n    }\n    var NumberIsNaN = Number.isNaN || function NumberIsNaN2(value) {\n      return value !== value;\n    };\n    function EventEmitter() {\n      EventEmitter.init.call(this);\n    }\n    module2.exports = EventEmitter;\n    module2.exports.once = once;\n    EventEmitter.EventEmitter = EventEmitter;\n    EventEmitter.prototype._events = void 0;\n    EventEmitter.prototype._eventsCount = 0;\n    EventEmitter.prototype._maxListeners = void 0;\n    var defaultMaxListeners = 10;\n    function checkListener(listener) {\n      if (typeof listener !== "function") {\n        throw new TypeError(\'The "listener" argument must be of type Function. Received type \' + typeof listener);\n      }\n    }\n    Object.defineProperty(EventEmitter, "defaultMaxListeners", {\n      enumerable: true,\n      get: function() {\n        return defaultMaxListeners;\n      },\n      set: function(arg) {\n        if (typeof arg !== "number" || arg < 0 || NumberIsNaN(arg)) {\n          throw new RangeError(\'The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received \' + arg + ".");\n        }\n        defaultMaxListeners = arg;\n      }\n    });\n    EventEmitter.init = function() {\n      if (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) {\n        this._events = /* @__PURE__ */ Object.create(null);\n        this._eventsCount = 0;\n      }\n      this._maxListeners = this._maxListeners || void 0;\n    };\n    EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {\n      if (typeof n !== "number" || n < 0 || NumberIsNaN(n)) {\n        throw new RangeError(\'The value of "n" is out of range. It must be a non-negative number. Received \' + n + ".");\n      }\n      this._maxListeners = n;\n      return this;\n    };\n    function _getMaxListeners(that) {\n      if (that._maxListeners === void 0)\n        return EventEmitter.defaultMaxListeners;\n      return that._maxListeners;\n    }\n    EventEmitter.prototype.getMaxListeners = function getMaxListeners() {\n      return _getMaxListeners(this);\n    };\n    EventEmitter.prototype.emit = function emit(type) {\n      var args = [];\n      for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);\n      var doError = type === "error";\n      var events = this._events;\n      if (events !== void 0)\n        doError = doError && events.error === void 0;\n      else if (!doError)\n        return false;\n      if (doError) {\n        var er;\n        if (args.length > 0)\n          er = args[0];\n        if (er instanceof Error) {\n          throw er;\n        }\n        var err = new Error("Unhandled error." + (er ? " (" + er.message + ")" : ""));\n        err.context = er;\n        throw err;\n      }\n      var handler = events[type];\n      if (handler === void 0)\n        return false;\n      if (typeof handler === "function") {\n        ReflectApply(handler, this, args);\n      } else {\n        var len = handler.length;\n        var listeners = arrayClone(handler, len);\n        for (var i = 0; i < len; ++i)\n          ReflectApply(listeners[i], this, args);\n      }\n      return true;\n    };\n    function _addListener(target, type, listener, prepend) {\n      var m;\n      var events;\n      var existing;\n      checkListener(listener);\n      events = target._events;\n      if (events === void 0) {\n        events = target._events = /* @__PURE__ */ Object.create(null);\n        target._eventsCount = 0;\n      } else {\n        if (events.newListener !== void 0) {\n          target.emit(\n            "newListener",\n            type,\n            listener.listener ? listener.listener : listener\n          );\n          events = target._events;\n        }\n        existing = events[type];\n      }\n      if (existing === void 0) {\n        existing = events[type] = listener;\n        ++target._eventsCount;\n      } else {\n        if (typeof existing === "function") {\n          existing = events[type] = prepend ? [listener, existing] : [existing, listener];\n        } else if (prepend) {\n          existing.unshift(listener);\n        } else {\n          existing.push(listener);\n        }\n        m = _getMaxListeners(target);\n        if (m > 0 && existing.length > m && !existing.warned) {\n          existing.warned = true;\n          var w = new Error("Possible EventEmitter memory leak detected. " + existing.length + " " + String(type) + " listeners added. Use emitter.setMaxListeners() to increase limit");\n          w.name = "MaxListenersExceededWarning";\n          w.emitter = target;\n          w.type = type;\n          w.count = existing.length;\n          ProcessEmitWarning(w);\n        }\n      }\n      return target;\n    }\n    EventEmitter.prototype.addListener = function addListener(type, listener) {\n      return _addListener(this, type, listener, false);\n    };\n    EventEmitter.prototype.on = EventEmitter.prototype.addListener;\n    EventEmitter.prototype.prependListener = function prependListener(type, listener) {\n      return _addListener(this, type, listener, true);\n    };\n    function onceWrapper() {\n      if (!this.fired) {\n        this.target.removeListener(this.type, this.wrapFn);\n        this.fired = true;\n        if (arguments.length === 0)\n          return this.listener.call(this.target);\n        return this.listener.apply(this.target, arguments);\n      }\n    }\n    function _onceWrap(target, type, listener) {\n      var state = { fired: false, wrapFn: void 0, target, type, listener };\n      var wrapped = onceWrapper.bind(state);\n      wrapped.listener = listener;\n      state.wrapFn = wrapped;\n      return wrapped;\n    }\n    EventEmitter.prototype.once = function once2(type, listener) {\n      checkListener(listener);\n      this.on(type, _onceWrap(this, type, listener));\n      return this;\n    };\n    EventEmitter.prototype.prependOnceListener = function prependOnceListener(type, listener) {\n      checkListener(listener);\n      this.prependListener(type, _onceWrap(this, type, listener));\n      return this;\n    };\n    EventEmitter.prototype.removeListener = function removeListener(type, listener) {\n      var list, events, position, i, originalListener;\n      checkListener(listener);\n      events = this._events;\n      if (events === void 0)\n        return this;\n      list = events[type];\n      if (list === void 0)\n        return this;\n      if (list === listener || list.listener === listener) {\n        if (--this._eventsCount === 0)\n          this._events = /* @__PURE__ */ Object.create(null);\n        else {\n          delete events[type];\n          if (events.removeListener)\n            this.emit("removeListener", type, list.listener || listener);\n        }\n      } else if (typeof list !== "function") {\n        position = -1;\n        for (i = list.length - 1; i >= 0; i--) {\n          if (list[i] === listener || list[i].listener === listener) {\n            originalListener = list[i].listener;\n            position = i;\n            break;\n          }\n        }\n        if (position < 0)\n          return this;\n        if (position === 0)\n          list.shift();\n        else {\n          spliceOne(list, position);\n        }\n        if (list.length === 1)\n          events[type] = list[0];\n        if (events.removeListener !== void 0)\n          this.emit("removeListener", type, originalListener || listener);\n      }\n      return this;\n    };\n    EventEmitter.prototype.off = EventEmitter.prototype.removeListener;\n    EventEmitter.prototype.removeAllListeners = function removeAllListeners(type) {\n      var listeners, events, i;\n      events = this._events;\n      if (events === void 0)\n        return this;\n      if (events.removeListener === void 0) {\n        if (arguments.length === 0) {\n          this._events = /* @__PURE__ */ Object.create(null);\n          this._eventsCount = 0;\n        } else if (events[type] !== void 0) {\n          if (--this._eventsCount === 0)\n            this._events = /* @__PURE__ */ Object.create(null);\n          else\n            delete events[type];\n        }\n        return this;\n      }\n      if (arguments.length === 0) {\n        var keys = Object.keys(events);\n        var key;\n        for (i = 0; i < keys.length; ++i) {\n          key = keys[i];\n          if (key === "removeListener") continue;\n          this.removeAllListeners(key);\n        }\n        this.removeAllListeners("removeListener");\n        this._events = /* @__PURE__ */ Object.create(null);\n        this._eventsCount = 0;\n        return this;\n      }\n      listeners = events[type];\n      if (typeof listeners === "function") {\n        this.removeListener(type, listeners);\n      } else if (listeners !== void 0) {\n        for (i = listeners.length - 1; i >= 0; i--) {\n          this.removeListener(type, listeners[i]);\n        }\n      }\n      return this;\n    };\n    function _listeners(target, type, unwrap) {\n      var events = target._events;\n      if (events === void 0)\n        return [];\n      var evlistener = events[type];\n      if (evlistener === void 0)\n        return [];\n      if (typeof evlistener === "function")\n        return unwrap ? [evlistener.listener || evlistener] : [evlistener];\n      return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);\n    }\n    EventEmitter.prototype.listeners = function listeners(type) {\n      return _listeners(this, type, true);\n    };\n    EventEmitter.prototype.rawListeners = function rawListeners(type) {\n      return _listeners(this, type, false);\n    };\n    EventEmitter.listenerCount = function(emitter, type) {\n      if (typeof emitter.listenerCount === "function") {\n        return emitter.listenerCount(type);\n      } else {\n        return listenerCount.call(emitter, type);\n      }\n    };\n    EventEmitter.prototype.listenerCount = listenerCount;\n    function listenerCount(type) {\n      var events = this._events;\n      if (events !== void 0) {\n        var evlistener = events[type];\n        if (typeof evlistener === "function") {\n          return 1;\n        } else if (evlistener !== void 0) {\n          return evlistener.length;\n        }\n      }\n      return 0;\n    }\n    EventEmitter.prototype.eventNames = function eventNames() {\n      return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];\n    };\n    function arrayClone(arr, n) {\n      var copy = new Array(n);\n      for (var i = 0; i < n; ++i)\n        copy[i] = arr[i];\n      return copy;\n    }\n    function spliceOne(list, index) {\n      for (; index + 1 < list.length; index++)\n        list[index] = list[index + 1];\n      list.pop();\n    }\n    function unwrapListeners(arr) {\n      var ret = new Array(arr.length);\n      for (var i = 0; i < ret.length; ++i) {\n        ret[i] = arr[i].listener || arr[i];\n      }\n      return ret;\n    }\n    function once(emitter, name) {\n      return new Promise(function(resolve, reject) {\n        function errorListener(err) {\n          emitter.removeListener(name, resolver);\n          reject(err);\n        }\n        function resolver() {\n          if (typeof emitter.removeListener === "function") {\n            emitter.removeListener("error", errorListener);\n          }\n          resolve([].slice.call(arguments));\n        }\n        ;\n        eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });\n        if (name !== "error") {\n          addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });\n        }\n      });\n    }\n    function addErrorHandlerIfEventEmitter(emitter, handler, flags) {\n      if (typeof emitter.on === "function") {\n        eventTargetAgnosticAddListener(emitter, "error", handler, flags);\n      }\n    }\n    function eventTargetAgnosticAddListener(emitter, name, listener, flags) {\n      if (typeof emitter.on === "function") {\n        if (flags.once) {\n          emitter.once(name, listener);\n        } else {\n          emitter.on(name, listener);\n        }\n      } else if (typeof emitter.addEventListener === "function") {\n        emitter.addEventListener(name, function wrapListener(arg) {\n          if (flags.once) {\n            emitter.removeEventListener(name, wrapListener);\n          }\n          listener(arg);\n        });\n      } else {\n        throw new TypeError(\'The "emitter" argument must be of type EventEmitter. Received type \' + typeof emitter);\n      }\n    }\n  }\n});\n\n// node_modules/readable-stream/lib/ours/util.js\nvar require_util = __commonJS({\n  "node_modules/readable-stream/lib/ours/util.js"(exports2, module2) {\n    "use strict";\n    var bufferModule = require_buffer();\n    var { format, inspect } = require_inspect();\n    var {\n      codes: { ERR_INVALID_ARG_TYPE }\n    } = require_errors();\n    var { kResistStopPropagation, AggregateError, SymbolDispose } = require_primordials();\n    var AbortSignal = globalThis.AbortSignal || require_abort_controller().AbortSignal;\n    var AbortController = globalThis.AbortController || require_abort_controller().AbortController;\n    var AsyncFunction = Object.getPrototypeOf(async function() {\n    }).constructor;\n    var Blob = globalThis.Blob || bufferModule.Blob;\n    var isBlob = typeof Blob !== "undefined" ? function isBlob2(b) {\n      return b instanceof Blob;\n    } : function isBlob2(b) {\n      return false;\n    };\n    var validateAbortSignal = (signal, name) => {\n      if (signal !== void 0 && (signal === null || typeof signal !== "object" || !("aborted" in signal))) {\n        throw new ERR_INVALID_ARG_TYPE(name, "AbortSignal", signal);\n      }\n    };\n    var validateFunction = (value, name) => {\n      if (typeof value !== "function") {\n        throw new ERR_INVALID_ARG_TYPE(name, "Function", value);\n      }\n    };\n    module2.exports = {\n      AggregateError,\n      kEmptyObject: Object.freeze({}),\n      once(callback) {\n        let called = false;\n        return function(...args) {\n          if (called) {\n            return;\n          }\n          called = true;\n          callback.apply(this, args);\n        };\n      },\n      createDeferredPromise: function() {\n        let resolve;\n        let reject;\n        const promise = new Promise((res, rej) => {\n          resolve = res;\n          reject = rej;\n        });\n        return {\n          promise,\n          resolve,\n          reject\n        };\n      },\n      promisify(fn) {\n        return new Promise((resolve, reject) => {\n          fn((err, ...args) => {\n            if (err) {\n              return reject(err);\n            }\n            return resolve(...args);\n          });\n        });\n      },\n      debuglog() {\n        return function() {\n        };\n      },\n      format,\n      inspect,\n      types: {\n        isAsyncFunction(fn) {\n          return fn instanceof AsyncFunction;\n        },\n        isArrayBufferView(arr) {\n          return ArrayBuffer.isView(arr);\n        }\n      },\n      isBlob,\n      deprecate(fn, message) {\n        return fn;\n      },\n      addAbortListener: require_events().addAbortListener || function addAbortListener(signal, listener) {\n        if (signal === void 0) {\n          throw new ERR_INVALID_ARG_TYPE("signal", "AbortSignal", signal);\n        }\n        validateAbortSignal(signal, "signal");\n        validateFunction(listener, "listener");\n        let removeEventListener;\n        if (signal.aborted) {\n          queueMicrotask(() => listener());\n        } else {\n          signal.addEventListener("abort", listener, {\n            __proto__: null,\n            once: true,\n            [kResistStopPropagation]: true\n          });\n          removeEventListener = () => {\n            signal.removeEventListener("abort", listener);\n          };\n        }\n        return {\n          __proto__: null,\n          [SymbolDispose]() {\n            var _removeEventListener;\n            (_removeEventListener = removeEventListener) === null || _removeEventListener === void 0 ? void 0 : _removeEventListener();\n          }\n        };\n      },\n      AbortSignalAny: AbortSignal.any || function AbortSignalAny(signals) {\n        if (signals.length === 1) {\n          return signals[0];\n        }\n        const ac = new AbortController();\n        const abort = () => ac.abort();\n        signals.forEach((signal) => {\n          validateAbortSignal(signal, "signals");\n          signal.addEventListener("abort", abort, {\n            once: true\n          });\n        });\n        ac.signal.addEventListener(\n          "abort",\n          () => {\n            signals.forEach((signal) => signal.removeEventListener("abort", abort));\n          },\n          {\n            once: true\n          }\n        );\n        return ac.signal;\n      }\n    };\n    module2.exports.promisify.custom = /* @__PURE__ */ Symbol.for("nodejs.util.promisify.custom");\n  }\n});\n\n// node_modules/readable-stream/lib/internal/validators.js\nvar require_validators = __commonJS({\n  "node_modules/readable-stream/lib/internal/validators.js"(exports2, module2) {\n    "use strict";\n    var {\n      ArrayIsArray,\n      ArrayPrototypeIncludes,\n      ArrayPrototypeJoin,\n      ArrayPrototypeMap,\n      NumberIsInteger,\n      NumberIsNaN,\n      NumberMAX_SAFE_INTEGER,\n      NumberMIN_SAFE_INTEGER,\n      NumberParseInt,\n      ObjectPrototypeHasOwnProperty,\n      RegExpPrototypeExec,\n      String: String2,\n      StringPrototypeToUpperCase,\n      StringPrototypeTrim\n    } = require_primordials();\n    var {\n      hideStackFrames,\n      codes: { ERR_SOCKET_BAD_PORT, ERR_INVALID_ARG_TYPE, ERR_INVALID_ARG_VALUE, ERR_OUT_OF_RANGE, ERR_UNKNOWN_SIGNAL }\n    } = require_errors();\n    var { normalizeEncoding } = require_util();\n    var { isAsyncFunction, isArrayBufferView } = require_util().types;\n    var signals = {};\n    function isInt32(value) {\n      return value === (value | 0);\n    }\n    function isUint32(value) {\n      return value === value >>> 0;\n    }\n    var octalReg = /^[0-7]+$/;\n    var modeDesc = "must be a 32-bit unsigned integer or an octal string";\n    function parseFileMode(value, name, def) {\n      if (typeof value === "undefined") {\n        value = def;\n      }\n      if (typeof value === "string") {\n        if (RegExpPrototypeExec(octalReg, value) === null) {\n          throw new ERR_INVALID_ARG_VALUE(name, value, modeDesc);\n        }\n        value = NumberParseInt(value, 8);\n      }\n      validateUint32(value, name);\n      return value;\n    }\n    var validateInteger = hideStackFrames((value, name, min = NumberMIN_SAFE_INTEGER, max = NumberMAX_SAFE_INTEGER) => {\n      if (typeof value !== "number") throw new ERR_INVALID_ARG_TYPE(name, "number", value);\n      if (!NumberIsInteger(value)) throw new ERR_OUT_OF_RANGE(name, "an integer", value);\n      if (value < min || value > max) throw new ERR_OUT_OF_RANGE(name, `>= ${min} && <= ${max}`, value);\n    });\n    var validateInt32 = hideStackFrames((value, name, min = -2147483648, max = 2147483647) => {\n      if (typeof value !== "number") {\n        throw new ERR_INVALID_ARG_TYPE(name, "number", value);\n      }\n      if (!NumberIsInteger(value)) {\n        throw new ERR_OUT_OF_RANGE(name, "an integer", value);\n      }\n      if (value < min || value > max) {\n        throw new ERR_OUT_OF_RANGE(name, `>= ${min} && <= ${max}`, value);\n      }\n    });\n    var validateUint32 = hideStackFrames((value, name, positive = false) => {\n      if (typeof value !== "number") {\n        throw new ERR_INVALID_ARG_TYPE(name, "number", value);\n      }\n      if (!NumberIsInteger(value)) {\n        throw new ERR_OUT_OF_RANGE(name, "an integer", value);\n      }\n      const min = positive ? 1 : 0;\n      const max = 4294967295;\n      if (value < min || value > max) {\n        throw new ERR_OUT_OF_RANGE(name, `>= ${min} && <= ${max}`, value);\n      }\n    });\n    function validateString(value, name) {\n      if (typeof value !== "string") throw new ERR_INVALID_ARG_TYPE(name, "string", value);\n    }\n    function validateNumber(value, name, min = void 0, max) {\n      if (typeof value !== "number") throw new ERR_INVALID_ARG_TYPE(name, "number", value);\n      if (min != null && value < min || max != null && value > max || (min != null || max != null) && NumberIsNaN(value)) {\n        throw new ERR_OUT_OF_RANGE(\n          name,\n          `${min != null ? `>= ${min}` : ""}${min != null && max != null ? " && " : ""}${max != null ? `<= ${max}` : ""}`,\n          value\n        );\n      }\n    }\n    var validateOneOf = hideStackFrames((value, name, oneOf) => {\n      if (!ArrayPrototypeIncludes(oneOf, value)) {\n        const allowed = ArrayPrototypeJoin(\n          ArrayPrototypeMap(oneOf, (v) => typeof v === "string" ? `\'${v}\'` : String2(v)),\n          ", "\n        );\n        const reason = "must be one of: " + allowed;\n        throw new ERR_INVALID_ARG_VALUE(name, value, reason);\n      }\n    });\n    function validateBoolean(value, name) {\n      if (typeof value !== "boolean") throw new ERR_INVALID_ARG_TYPE(name, "boolean", value);\n    }\n    function getOwnPropertyValueOrDefault(options, key, defaultValue) {\n      return options == null || !ObjectPrototypeHasOwnProperty(options, key) ? defaultValue : options[key];\n    }\n    var validateObject = hideStackFrames((value, name, options = null) => {\n      const allowArray = getOwnPropertyValueOrDefault(options, "allowArray", false);\n      const allowFunction = getOwnPropertyValueOrDefault(options, "allowFunction", false);\n      const nullable = getOwnPropertyValueOrDefault(options, "nullable", false);\n      if (!nullable && value === null || !allowArray && ArrayIsArray(value) || typeof value !== "object" && (!allowFunction || typeof value !== "function")) {\n        throw new ERR_INVALID_ARG_TYPE(name, "Object", value);\n      }\n    });\n    var validateDictionary = hideStackFrames((value, name) => {\n      if (value != null && typeof value !== "object" && typeof value !== "function") {\n        throw new ERR_INVALID_ARG_TYPE(name, "a dictionary", value);\n      }\n    });\n    var validateArray = hideStackFrames((value, name, minLength = 0) => {\n      if (!ArrayIsArray(value)) {\n        throw new ERR_INVALID_ARG_TYPE(name, "Array", value);\n      }\n      if (value.length < minLength) {\n        const reason = `must be longer than ${minLength}`;\n        throw new ERR_INVALID_ARG_VALUE(name, value, reason);\n      }\n    });\n    function validateStringArray(value, name) {\n      validateArray(value, name);\n      for (let i = 0; i < value.length; i++) {\n        validateString(value[i], `${name}[${i}]`);\n      }\n    }\n    function validateBooleanArray(value, name) {\n      validateArray(value, name);\n      for (let i = 0; i < value.length; i++) {\n        validateBoolean(value[i], `${name}[${i}]`);\n      }\n    }\n    function validateAbortSignalArray(value, name) {\n      validateArray(value, name);\n      for (let i = 0; i < value.length; i++) {\n        const signal = value[i];\n        const indexedName = `${name}[${i}]`;\n        if (signal == null) {\n          throw new ERR_INVALID_ARG_TYPE(indexedName, "AbortSignal", signal);\n        }\n        validateAbortSignal(signal, indexedName);\n      }\n    }\n    function validateSignalName(signal, name = "signal") {\n      validateString(signal, name);\n      if (signals[signal] === void 0) {\n        if (signals[StringPrototypeToUpperCase(signal)] !== void 0) {\n          throw new ERR_UNKNOWN_SIGNAL(signal + " (signals must use all capital letters)");\n        }\n        throw new ERR_UNKNOWN_SIGNAL(signal);\n      }\n    }\n    var validateBuffer = hideStackFrames((buffer, name = "buffer") => {\n      if (!isArrayBufferView(buffer)) {\n        throw new ERR_INVALID_ARG_TYPE(name, ["Buffer", "TypedArray", "DataView"], buffer);\n      }\n    });\n    function validateEncoding(data, encoding) {\n      const normalizedEncoding = normalizeEncoding(encoding);\n      const length = data.length;\n      if (normalizedEncoding === "hex" && length % 2 !== 0) {\n        throw new ERR_INVALID_ARG_VALUE("encoding", encoding, `is invalid for data of length ${length}`);\n      }\n    }\n    function validatePort(port, name = "Port", allowZero = true) {\n      if (typeof port !== "number" && typeof port !== "string" || typeof port === "string" && StringPrototypeTrim(port).length === 0 || +port !== +port >>> 0 || port > 65535 || port === 0 && !allowZero) {\n        throw new ERR_SOCKET_BAD_PORT(name, port, allowZero);\n      }\n      return port | 0;\n    }\n    var validateAbortSignal = hideStackFrames((signal, name) => {\n      if (signal !== void 0 && (signal === null || typeof signal !== "object" || !("aborted" in signal))) {\n        throw new ERR_INVALID_ARG_TYPE(name, "AbortSignal", signal);\n      }\n    });\n    var validateFunction = hideStackFrames((value, name) => {\n      if (typeof value !== "function") throw new ERR_INVALID_ARG_TYPE(name, "Function", value);\n    });\n    var validatePlainFunction = hideStackFrames((value, name) => {\n      if (typeof value !== "function" || isAsyncFunction(value)) throw new ERR_INVALID_ARG_TYPE(name, "Function", value);\n    });\n    var validateUndefined = hideStackFrames((value, name) => {\n      if (value !== void 0) throw new ERR_INVALID_ARG_TYPE(name, "undefined", value);\n    });\n    function validateUnion(value, name, union) {\n      if (!ArrayPrototypeIncludes(union, value)) {\n        throw new ERR_INVALID_ARG_TYPE(name, `(\'${ArrayPrototypeJoin(union, "|")}\')`, value);\n      }\n    }\n    var linkValueRegExp = /^(?:<[^>]*>)(?:\\s*;\\s*[^;"\\s]+(?:=(")?[^;"\\s]*\\1)?)*$/;\n    function validateLinkHeaderFormat(value, name) {\n      if (typeof value === "undefined" || !RegExpPrototypeExec(linkValueRegExp, value)) {\n        throw new ERR_INVALID_ARG_VALUE(\n          name,\n          value,\n          \'must be an array or string of format "</styles.css>; rel=preload; as=style"\'\n        );\n      }\n    }\n    function validateLinkHeaderValue(hints) {\n      if (typeof hints === "string") {\n        validateLinkHeaderFormat(hints, "hints");\n        return hints;\n      } else if (ArrayIsArray(hints)) {\n        const hintsLength = hints.length;\n        let result = "";\n        if (hintsLength === 0) {\n          return result;\n        }\n        for (let i = 0; i < hintsLength; i++) {\n          const link = hints[i];\n          validateLinkHeaderFormat(link, "hints");\n          result += link;\n          if (i !== hintsLength - 1) {\n            result += ", ";\n          }\n        }\n        return result;\n      }\n      throw new ERR_INVALID_ARG_VALUE(\n        "hints",\n        hints,\n        \'must be an array or string of format "</styles.css>; rel=preload; as=style"\'\n      );\n    }\n    module2.exports = {\n      isInt32,\n      isUint32,\n      parseFileMode,\n      validateArray,\n      validateStringArray,\n      validateBooleanArray,\n      validateAbortSignalArray,\n      validateBoolean,\n      validateBuffer,\n      validateDictionary,\n      validateEncoding,\n      validateFunction,\n      validateInt32,\n      validateInteger,\n      validateNumber,\n      validateObject,\n      validateOneOf,\n      validatePlainFunction,\n      validatePort,\n      validateSignalName,\n      validateString,\n      validateUint32,\n      validateUndefined,\n      validateUnion,\n      validateAbortSignal,\n      validateLinkHeaderValue\n    };\n  }\n});\n\n// node_modules/process/index.js\nvar require_process = __commonJS({\n  "node_modules/process/index.js"(exports2, module2) {\n    module2.exports = global.process;\n  }\n});\n\n// node_modules/readable-stream/lib/internal/shims/process.js\nvar require_process2 = __commonJS({\n  "node_modules/readable-stream/lib/internal/shims/process.js"(exports2, module2) {\n    "use strict";\n    var process = ((base, esmKey, keys, isValid) => {\n      if (esmKey in base && base[esmKey] === true) {\n        let candidate;\n        for (const key of keys) {\n          if (!(key in base)) {\n            continue;\n          }\n          candidate = base[key];\n          if (isValid(candidate)) {\n            return candidate;\n          }\n        }\n      }\n      return base;\n    })(require_process(), "__esModule", ["default", "process"], (candidate) => "nextTick" in candidate);\n    module2.exports = process;\n  }\n});\n\n// node_modules/readable-stream/lib/internal/streams/utils.js\nvar require_utils = __commonJS({\n  "node_modules/readable-stream/lib/internal/streams/utils.js"(exports2, module2) {\n    "use strict";\n    var { SymbolAsyncIterator, SymbolIterator, SymbolFor } = require_primordials();\n    var kIsDestroyed = SymbolFor("nodejs.stream.destroyed");\n    var kIsErrored = SymbolFor("nodejs.stream.errored");\n    var kIsReadable = SymbolFor("nodejs.stream.readable");\n    var kIsWritable = SymbolFor("nodejs.stream.writable");\n    var kIsDisturbed = SymbolFor("nodejs.stream.disturbed");\n    var kIsClosedPromise = SymbolFor("nodejs.webstream.isClosedPromise");\n    var kControllerErrorFunction = SymbolFor("nodejs.webstream.controllerErrorFunction");\n    function isReadableNodeStream(obj, strict = false) {\n      var _obj$_readableState;\n      return !!(obj && typeof obj.pipe === "function" && typeof obj.on === "function" && (!strict || typeof obj.pause === "function" && typeof obj.resume === "function") && (!obj._writableState || ((_obj$_readableState = obj._readableState) === null || _obj$_readableState === void 0 ? void 0 : _obj$_readableState.readable) !== false) && // Duplex\n      (!obj._writableState || obj._readableState));\n    }\n    function isWritableNodeStream(obj) {\n      var _obj$_writableState;\n      return !!(obj && typeof obj.write === "function" && typeof obj.on === "function" && (!obj._readableState || ((_obj$_writableState = obj._writableState) === null || _obj$_writableState === void 0 ? void 0 : _obj$_writableState.writable) !== false));\n    }\n    function isDuplexNodeStream(obj) {\n      return !!(obj && typeof obj.pipe === "function" && obj._readableState && typeof obj.on === "function" && typeof obj.write === "function");\n    }\n    function isNodeStream(obj) {\n      return obj && (obj._readableState || obj._writableState || typeof obj.write === "function" && typeof obj.on === "function" || typeof obj.pipe === "function" && typeof obj.on === "function");\n    }\n    function isReadableStream(obj) {\n      return !!(obj && !isNodeStream(obj) && typeof obj.pipeThrough === "function" && typeof obj.getReader === "function" && typeof obj.cancel === "function");\n    }\n    function isWritableStream(obj) {\n      return !!(obj && !isNodeStream(obj) && typeof obj.getWriter === "function" && typeof obj.abort === "function");\n    }\n    function isTransformStream(obj) {\n      return !!(obj && !isNodeStream(obj) && typeof obj.readable === "object" && typeof obj.writable === "object");\n    }\n    function isWebStream(obj) {\n      return isReadableStream(obj) || isWritableStream(obj) || isTransformStream(obj);\n    }\n    function isIterable(obj, isAsync) {\n      if (obj == null) return false;\n      if (isAsync === true) return typeof obj[SymbolAsyncIterator] === "function";\n      if (isAsync === false) return typeof obj[SymbolIterator] === "function";\n      return typeof obj[SymbolAsyncIterator] === "function" || typeof obj[SymbolIterator] === "function";\n    }\n    function isDestroyed(stream) {\n      if (!isNodeStream(stream)) return null;\n      const wState = stream._writableState;\n      const rState = stream._readableState;\n      const state = wState || rState;\n      return !!(stream.destroyed || stream[kIsDestroyed] || state !== null && state !== void 0 && state.destroyed);\n    }\n    function isWritableEnded(stream) {\n      if (!isWritableNodeStream(stream)) return null;\n      if (stream.writableEnded === true) return true;\n      const wState = stream._writableState;\n      if (wState !== null && wState !== void 0 && wState.errored) return false;\n      if (typeof (wState === null || wState === void 0 ? void 0 : wState.ended) !== "boolean") return null;\n      return wState.ended;\n    }\n    function isWritableFinished(stream, strict) {\n      if (!isWritableNodeStream(stream)) return null;\n      if (stream.writableFinished === true) return true;\n      const wState = stream._writableState;\n      if (wState !== null && wState !== void 0 && wState.errored) return false;\n      if (typeof (wState === null || wState === void 0 ? void 0 : wState.finished) !== "boolean") return null;\n      return !!(wState.finished || strict === false && wState.ended === true && wState.length === 0);\n    }\n    function isReadableEnded(stream) {\n      if (!isReadableNodeStream(stream)) return null;\n      if (stream.readableEnded === true) return true;\n      const rState = stream._readableState;\n      if (!rState || rState.errored) return false;\n      if (typeof (rState === null || rState === void 0 ? void 0 : rState.ended) !== "boolean") return null;\n      return rState.ended;\n    }\n    function isReadableFinished(stream, strict) {\n      if (!isReadableNodeStream(stream)) return null;\n      const rState = stream._readableState;\n      if (rState !== null && rState !== void 0 && rState.errored) return false;\n      if (typeof (rState === null || rState === void 0 ? void 0 : rState.endEmitted) !== "boolean") return null;\n      return !!(rState.endEmitted || strict === false && rState.ended === true && rState.length === 0);\n    }\n    function isReadable(stream) {\n      if (stream && stream[kIsReadable] != null) return stream[kIsReadable];\n      if (typeof (stream === null || stream === void 0 ? void 0 : stream.readable) !== "boolean") return null;\n      if (isDestroyed(stream)) return false;\n      return isReadableNodeStream(stream) && stream.readable && !isReadableFinished(stream);\n    }\n    function isWritable(stream) {\n      if (stream && stream[kIsWritable] != null) return stream[kIsWritable];\n      if (typeof (stream === null || stream === void 0 ? void 0 : stream.writable) !== "boolean") return null;\n      if (isDestroyed(stream)) return false;\n      return isWritableNodeStream(stream) && stream.writable && !isWritableEnded(stream);\n    }\n    function isFinished(stream, opts) {\n      if (!isNodeStream(stream)) {\n        return null;\n      }\n      if (isDestroyed(stream)) {\n        return true;\n      }\n      if ((opts === null || opts === void 0 ? void 0 : opts.readable) !== false && isReadable(stream)) {\n        return false;\n      }\n      if ((opts === null || opts === void 0 ? void 0 : opts.writable) !== false && isWritable(stream)) {\n        return false;\n      }\n      return true;\n    }\n    function isWritableErrored(stream) {\n      var _stream$_writableStat, _stream$_writableStat2;\n      if (!isNodeStream(stream)) {\n        return null;\n      }\n      if (stream.writableErrored) {\n        return stream.writableErrored;\n      }\n      return (_stream$_writableStat = (_stream$_writableStat2 = stream._writableState) === null || _stream$_writableStat2 === void 0 ? void 0 : _stream$_writableStat2.errored) !== null && _stream$_writableStat !== void 0 ? _stream$_writableStat : null;\n    }\n    function isReadableErrored(stream) {\n      var _stream$_readableStat, _stream$_readableStat2;\n      if (!isNodeStream(stream)) {\n        return null;\n      }\n      if (stream.readableErrored) {\n        return stream.readableErrored;\n      }\n      return (_stream$_readableStat = (_stream$_readableStat2 = stream._readableState) === null || _stream$_readableStat2 === void 0 ? void 0 : _stream$_readableStat2.errored) !== null && _stream$_readableStat !== void 0 ? _stream$_readableStat : null;\n    }\n    function isClosed(stream) {\n      if (!isNodeStream(stream)) {\n        return null;\n      }\n      if (typeof stream.closed === "boolean") {\n        return stream.closed;\n      }\n      const wState = stream._writableState;\n      const rState = stream._readableState;\n      if (typeof (wState === null || wState === void 0 ? void 0 : wState.closed) === "boolean" || typeof (rState === null || rState === void 0 ? void 0 : rState.closed) === "boolean") {\n        return (wState === null || wState === void 0 ? void 0 : wState.closed) || (rState === null || rState === void 0 ? void 0 : rState.closed);\n      }\n      if (typeof stream._closed === "boolean" && isOutgoingMessage(stream)) {\n        return stream._closed;\n      }\n      return null;\n    }\n    function isOutgoingMessage(stream) {\n      return typeof stream._closed === "boolean" && typeof stream._defaultKeepAlive === "boolean" && typeof stream._removedConnection === "boolean" && typeof stream._removedContLen === "boolean";\n    }\n    function isServerResponse(stream) {\n      return typeof stream._sent100 === "boolean" && isOutgoingMessage(stream);\n    }\n    function isServerRequest(stream) {\n      var _stream$req;\n      return typeof stream._consuming === "boolean" && typeof stream._dumped === "boolean" && ((_stream$req = stream.req) === null || _stream$req === void 0 ? void 0 : _stream$req.upgradeOrConnect) === void 0;\n    }\n    function willEmitClose(stream) {\n      if (!isNodeStream(stream)) return null;\n      const wState = stream._writableState;\n      const rState = stream._readableState;\n      const state = wState || rState;\n      return !state && isServerResponse(stream) || !!(state && state.autoDestroy && state.emitClose && state.closed === false);\n    }\n    function isDisturbed(stream) {\n      var _stream$kIsDisturbed;\n      return !!(stream && ((_stream$kIsDisturbed = stream[kIsDisturbed]) !== null && _stream$kIsDisturbed !== void 0 ? _stream$kIsDisturbed : stream.readableDidRead || stream.readableAborted));\n    }\n    function isErrored(stream) {\n      var _ref, _ref2, _ref3, _ref4, _ref5, _stream$kIsErrored, _stream$_readableStat3, _stream$_writableStat3, _stream$_readableStat4, _stream$_writableStat4;\n      return !!(stream && ((_ref = (_ref2 = (_ref3 = (_ref4 = (_ref5 = (_stream$kIsErrored = stream[kIsErrored]) !== null && _stream$kIsErrored !== void 0 ? _stream$kIsErrored : stream.readableErrored) !== null && _ref5 !== void 0 ? _ref5 : stream.writableErrored) !== null && _ref4 !== void 0 ? _ref4 : (_stream$_readableStat3 = stream._readableState) === null || _stream$_readableStat3 === void 0 ? void 0 : _stream$_readableStat3.errorEmitted) !== null && _ref3 !== void 0 ? _ref3 : (_stream$_writableStat3 = stream._writableState) === null || _stream$_writableStat3 === void 0 ? void 0 : _stream$_writableStat3.errorEmitted) !== null && _ref2 !== void 0 ? _ref2 : (_stream$_readableStat4 = stream._readableState) === null || _stream$_readableStat4 === void 0 ? void 0 : _stream$_readableStat4.errored) !== null && _ref !== void 0 ? _ref : (_stream$_writableStat4 = stream._writableState) === null || _stream$_writableStat4 === void 0 ? void 0 : _stream$_writableStat4.errored));\n    }\n    module2.exports = {\n      isDestroyed,\n      kIsDestroyed,\n      isDisturbed,\n      kIsDisturbed,\n      isErrored,\n      kIsErrored,\n      isReadable,\n      kIsReadable,\n      kIsClosedPromise,\n      kControllerErrorFunction,\n      kIsWritable,\n      isClosed,\n      isDuplexNodeStream,\n      isFinished,\n      isIterable,\n      isReadableNodeStream,\n      isReadableStream,\n      isReadableEnded,\n      isReadableFinished,\n      isReadableErrored,\n      isNodeStream,\n      isWebStream,\n      isWritable,\n      isWritableNodeStream,\n      isWritableStream,\n      isWritableEnded,\n      isWritableFinished,\n      isWritableErrored,\n      isServerRequest,\n      isServerResponse,\n      willEmitClose,\n      isTransformStream\n    };\n  }\n});\n\n// node_modules/readable-stream/lib/internal/streams/end-of-stream.js\nvar require_end_of_stream = __commonJS({\n  "node_modules/readable-stream/lib/internal/streams/end-of-stream.js"(exports2, module2) {\n    "use strict";\n    var process = require_process2();\n    var { AbortError, codes } = require_errors();\n    var { ERR_INVALID_ARG_TYPE, ERR_STREAM_PREMATURE_CLOSE } = codes;\n    var { kEmptyObject, once } = require_util();\n    var { validateAbortSignal, validateFunction, validateObject, validateBoolean } = require_validators();\n    var { Promise: Promise2, PromisePrototypeThen, SymbolDispose } = require_primordials();\n    var {\n      isClosed,\n      isReadable,\n      isReadableNodeStream,\n      isReadableStream,\n      isReadableFinished,\n      isReadableErrored,\n      isWritable,\n      isWritableNodeStream,\n      isWritableStream,\n      isWritableFinished,\n      isWritableErrored,\n      isNodeStream,\n      willEmitClose: _willEmitClose,\n      kIsClosedPromise\n    } = require_utils();\n    var addAbortListener;\n    function isRequest(stream) {\n      return stream.setHeader && typeof stream.abort === "function";\n    }\n    var nop = () => {\n    };\n    function eos(stream, options, callback) {\n      var _options$readable, _options$writable;\n      if (arguments.length === 2) {\n        callback = options;\n        options = kEmptyObject;\n      } else if (options == null) {\n        options = kEmptyObject;\n      } else {\n        validateObject(options, "options");\n      }\n      validateFunction(callback, "callback");\n      validateAbortSignal(options.signal, "options.signal");\n      callback = once(callback);\n      if (isReadableStream(stream) || isWritableStream(stream)) {\n        return eosWeb(stream, options, callback);\n      }\n      if (!isNodeStream(stream)) {\n        throw new ERR_INVALID_ARG_TYPE("stream", ["ReadableStream", "WritableStream", "Stream"], stream);\n      }\n      const readable = (_options$readable = options.readable) !== null && _options$readable !== void 0 ? _options$readable : isReadableNodeStream(stream);\n      const writable = (_options$writable = options.writable) !== null && _options$writable !== void 0 ? _options$writable : isWritableNodeStream(stream);\n      const wState = stream._writableState;\n      const rState = stream._readableState;\n      const onlegacyfinish = () => {\n        if (!stream.writable) {\n          onfinish();\n        }\n      };\n      let willEmitClose = _willEmitClose(stream) && isReadableNodeStream(stream) === readable && isWritableNodeStream(stream) === writable;\n      let writableFinished = isWritableFinished(stream, false);\n      const onfinish = () => {\n        writableFinished = true;\n        if (stream.destroyed) {\n          willEmitClose = false;\n        }\n        if (willEmitClose && (!stream.readable || readable)) {\n          return;\n        }\n        if (!readable || readableFinished) {\n          callback.call(stream);\n        }\n      };\n      let readableFinished = isReadableFinished(stream, false);\n      const onend = () => {\n        readableFinished = true;\n        if (stream.destroyed) {\n          willEmitClose = false;\n        }\n        if (willEmitClose && (!stream.writable || writable)) {\n          return;\n        }\n        if (!writable || writableFinished) {\n          callback.call(stream);\n        }\n      };\n      const onerror = (err) => {\n        callback.call(stream, err);\n      };\n      let closed = isClosed(stream);\n      const onclose = () => {\n        closed = true;\n        const errored = isWritableErrored(stream) || isReadableErrored(stream);\n        if (errored && typeof errored !== "boolean") {\n          return callback.call(stream, errored);\n        }\n        if (readable && !readableFinished && isReadableNodeStream(stream, true)) {\n          if (!isReadableFinished(stream, false)) return callback.call(stream, new ERR_STREAM_PREMATURE_CLOSE());\n        }\n        if (writable && !writableFinished) {\n          if (!isWritableFinished(stream, false)) return callback.call(stream, new ERR_STREAM_PREMATURE_CLOSE());\n        }\n        callback.call(stream);\n      };\n      const onclosed = () => {\n        closed = true;\n        const errored = isWritableErrored(stream) || isReadableErrored(stream);\n        if (errored && typeof errored !== "boolean") {\n          return callback.call(stream, errored);\n        }\n        callback.call(stream);\n      };\n      const onrequest = () => {\n        stream.req.on("finish", onfinish);\n      };\n      if (isRequest(stream)) {\n        stream.on("complete", onfinish);\n        if (!willEmitClose) {\n          stream.on("abort", onclose);\n        }\n        if (stream.req) {\n          onrequest();\n        } else {\n          stream.on("request", onrequest);\n        }\n      } else if (writable && !wState) {\n        stream.on("end", onlegacyfinish);\n        stream.on("close", onlegacyfinish);\n      }\n      if (!willEmitClose && typeof stream.aborted === "boolean") {\n        stream.on("aborted", onclose);\n      }\n      stream.on("end", onend);\n      stream.on("finish", onfinish);\n      if (options.error !== false) {\n        stream.on("error", onerror);\n      }\n      stream.on("close", onclose);\n      if (closed) {\n        process.nextTick(onclose);\n      } else if (wState !== null && wState !== void 0 && wState.errorEmitted || rState !== null && rState !== void 0 && rState.errorEmitted) {\n        if (!willEmitClose) {\n          process.nextTick(onclosed);\n        }\n      } else if (!readable && (!willEmitClose || isReadable(stream)) && (writableFinished || isWritable(stream) === false)) {\n        process.nextTick(onclosed);\n      } else if (!writable && (!willEmitClose || isWritable(stream)) && (readableFinished || isReadable(stream) === false)) {\n        process.nextTick(onclosed);\n      } else if (rState && stream.req && stream.aborted) {\n        process.nextTick(onclosed);\n      }\n      const cleanup = () => {\n        callback = nop;\n        stream.removeListener("aborted", onclose);\n        stream.removeListener("complete", onfinish);\n        stream.removeListener("abort", onclose);\n        stream.removeListener("request", onrequest);\n        if (stream.req) stream.req.removeListener("finish", onfinish);\n        stream.removeListener("end", onlegacyfinish);\n        stream.removeListener("close", onlegacyfinish);\n        stream.removeListener("finish", onfinish);\n        stream.removeListener("end", onend);\n        stream.removeListener("error", onerror);\n        stream.removeListener("close", onclose);\n      };\n      if (options.signal && !closed) {\n        const abort = () => {\n          const endCallback = callback;\n          cleanup();\n          endCallback.call(\n            stream,\n            new AbortError(void 0, {\n              cause: options.signal.reason\n            })\n          );\n        };\n        if (options.signal.aborted) {\n          process.nextTick(abort);\n        } else {\n          addAbortListener = addAbortListener || require_util().addAbortListener;\n          const disposable = addAbortListener(options.signal, abort);\n          const originalCallback = callback;\n          callback = once((...args) => {\n            disposable[SymbolDispose]();\n            originalCallback.apply(stream, args);\n          });\n        }\n      }\n      return cleanup;\n    }\n    function eosWeb(stream, options, callback) {\n      let isAborted = false;\n      let abort = nop;\n      if (options.signal) {\n        abort = () => {\n          isAborted = true;\n          callback.call(\n            stream,\n            new AbortError(void 0, {\n              cause: options.signal.reason\n            })\n          );\n        };\n        if (options.signal.aborted) {\n          process.nextTick(abort);\n        } else {\n          addAbortListener = addAbortListener || require_util().addAbortListener;\n          const disposable = addAbortListener(options.signal, abort);\n          const originalCallback = callback;\n          callback = once((...args) => {\n            disposable[SymbolDispose]();\n            originalCallback.apply(stream, args);\n          });\n        }\n      }\n      const resolverFn = (...args) => {\n        if (!isAborted) {\n          process.nextTick(() => callback.apply(stream, args));\n        }\n      };\n      PromisePrototypeThen(stream[kIsClosedPromise].promise, resolverFn, resolverFn);\n      return nop;\n    }\n    function finished(stream, opts) {\n      var _opts;\n      let autoCleanup = false;\n      if (opts === null) {\n        opts = kEmptyObject;\n      }\n      if ((_opts = opts) !== null && _opts !== void 0 && _opts.cleanup) {\n        validateBoolean(opts.cleanup, "cleanup");\n        autoCleanup = opts.cleanup;\n      }\n      return new Promise2((resolve, reject) => {\n        const cleanup = eos(stream, opts, (err) => {\n          if (autoCleanup) {\n            cleanup();\n          }\n          if (err) {\n            reject(err);\n          } else {\n            resolve();\n          }\n        });\n      });\n    }\n    module2.exports = eos;\n    module2.exports.finished = finished;\n  }\n});\n\n// node_modules/readable-stream/lib/internal/streams/destroy.js\nvar require_destroy = __commonJS({\n  "node_modules/readable-stream/lib/internal/streams/destroy.js"(exports2, module2) {\n    "use strict";\n    var process = require_process2();\n    var {\n      aggregateTwoErrors,\n      codes: { ERR_MULTIPLE_CALLBACK },\n      AbortError\n    } = require_errors();\n    var { Symbol: Symbol2 } = require_primordials();\n    var { kIsDestroyed, isDestroyed, isFinished, isServerRequest } = require_utils();\n    var kDestroy = Symbol2("kDestroy");\n    var kConstruct = Symbol2("kConstruct");\n    function checkError(err, w, r) {\n      if (err) {\n        err.stack;\n        if (w && !w.errored) {\n          w.errored = err;\n        }\n        if (r && !r.errored) {\n          r.errored = err;\n        }\n      }\n    }\n    function destroy(err, cb) {\n      const r = this._readableState;\n      const w = this._writableState;\n      const s = w || r;\n      if (w !== null && w !== void 0 && w.destroyed || r !== null && r !== void 0 && r.destroyed) {\n        if (typeof cb === "function") {\n          cb();\n        }\n        return this;\n      }\n      checkError(err, w, r);\n      if (w) {\n        w.destroyed = true;\n      }\n      if (r) {\n        r.destroyed = true;\n      }\n      if (!s.constructed) {\n        this.once(kDestroy, function(er) {\n          _destroy(this, aggregateTwoErrors(er, err), cb);\n        });\n      } else {\n        _destroy(this, err, cb);\n      }\n      return this;\n    }\n    function _destroy(self, err, cb) {\n      let called = false;\n      function onDestroy(err2) {\n        if (called) {\n          return;\n        }\n        called = true;\n        const r = self._readableState;\n        const w = self._writableState;\n        checkError(err2, w, r);\n        if (w) {\n          w.closed = true;\n        }\n        if (r) {\n          r.closed = true;\n        }\n        if (typeof cb === "function") {\n          cb(err2);\n        }\n        if (err2) {\n          process.nextTick(emitErrorCloseNT, self, err2);\n        } else {\n          process.nextTick(emitCloseNT, self);\n        }\n      }\n      try {\n        self._destroy(err || null, onDestroy);\n      } catch (err2) {\n        onDestroy(err2);\n      }\n    }\n    function emitErrorCloseNT(self, err) {\n      emitErrorNT(self, err);\n      emitCloseNT(self);\n    }\n    function emitCloseNT(self) {\n      const r = self._readableState;\n      const w = self._writableState;\n      if (w) {\n        w.closeEmitted = true;\n      }\n      if (r) {\n        r.closeEmitted = true;\n      }\n      if (w !== null && w !== void 0 && w.emitClose || r !== null && r !== void 0 && r.emitClose) {\n        self.emit("close");\n      }\n    }\n    function emitErrorNT(self, err) {\n      const r = self._readableState;\n      const w = self._writableState;\n      if (w !== null && w !== void 0 && w.errorEmitted || r !== null && r !== void 0 && r.errorEmitted) {\n        return;\n      }\n      if (w) {\n        w.errorEmitted = true;\n      }\n      if (r) {\n        r.errorEmitted = true;\n      }\n      self.emit("error", err);\n    }\n    function undestroy() {\n      const r = this._readableState;\n      const w = this._writableState;\n      if (r) {\n        r.constructed = true;\n        r.closed = false;\n        r.closeEmitted = false;\n        r.destroyed = false;\n        r.errored = null;\n        r.errorEmitted = false;\n        r.reading = false;\n        r.ended = r.readable === false;\n        r.endEmitted = r.readable === false;\n      }\n      if (w) {\n        w.constructed = true;\n        w.destroyed = false;\n        w.closed = false;\n        w.closeEmitted = false;\n        w.errored = null;\n        w.errorEmitted = false;\n        w.finalCalled = false;\n        w.prefinished = false;\n        w.ended = w.writable === false;\n        w.ending = w.writable === false;\n        w.finished = w.writable === false;\n      }\n    }\n    function errorOrDestroy(stream, err, sync) {\n      const r = stream._readableState;\n      const w = stream._writableState;\n      if (w !== null && w !== void 0 && w.destroyed || r !== null && r !== void 0 && r.destroyed) {\n        return this;\n      }\n      if (r !== null && r !== void 0 && r.autoDestroy || w !== null && w !== void 0 && w.autoDestroy)\n        stream.destroy(err);\n      else if (err) {\n        err.stack;\n        if (w && !w.errored) {\n          w.errored = err;\n        }\n        if (r && !r.errored) {\n          r.errored = err;\n        }\n        if (sync) {\n          process.nextTick(emitErrorNT, stream, err);\n        } else {\n          emitErrorNT(stream, err);\n        }\n      }\n    }\n    function construct(stream, cb) {\n      if (typeof stream._construct !== "function") {\n        return;\n      }\n      const r = stream._readableState;\n      const w = stream._writableState;\n      if (r) {\n        r.constructed = false;\n      }\n      if (w) {\n        w.constructed = false;\n      }\n      stream.once(kConstruct, cb);\n      if (stream.listenerCount(kConstruct) > 1) {\n        return;\n      }\n      process.nextTick(constructNT, stream);\n    }\n    function constructNT(stream) {\n      let called = false;\n      function onConstruct(err) {\n        if (called) {\n          errorOrDestroy(stream, err !== null && err !== void 0 ? err : new ERR_MULTIPLE_CALLBACK());\n          return;\n        }\n        called = true;\n        const r = stream._readableState;\n        const w = stream._writableState;\n        const s = w || r;\n        if (r) {\n          r.constructed = true;\n        }\n        if (w) {\n          w.constructed = true;\n        }\n        if (s.destroyed) {\n          stream.emit(kDestroy, err);\n        } else if (err) {\n          errorOrDestroy(stream, err, true);\n        } else {\n          process.nextTick(emitConstructNT, stream);\n        }\n      }\n      try {\n        stream._construct((err) => {\n          process.nextTick(onConstruct, err);\n        });\n      } catch (err) {\n        process.nextTick(onConstruct, err);\n      }\n    }\n    function emitConstructNT(stream) {\n      stream.emit(kConstruct);\n    }\n    function isRequest(stream) {\n      return (stream === null || stream === void 0 ? void 0 : stream.setHeader) && typeof stream.abort === "function";\n    }\n    function emitCloseLegacy(stream) {\n      stream.emit("close");\n    }\n    function emitErrorCloseLegacy(stream, err) {\n      stream.emit("error", err);\n      process.nextTick(emitCloseLegacy, stream);\n    }\n    function destroyer(stream, err) {\n      if (!stream || isDestroyed(stream)) {\n        return;\n      }\n      if (!err && !isFinished(stream)) {\n        err = new AbortError();\n      }\n      if (isServerRequest(stream)) {\n        stream.socket = null;\n        stream.destroy(err);\n      } else if (isRequest(stream)) {\n        stream.abort();\n      } else if (isRequest(stream.req)) {\n        stream.req.abort();\n      } else if (typeof stream.destroy === "function") {\n        stream.destroy(err);\n      } else if (typeof stream.close === "function") {\n        stream.close();\n      } else if (err) {\n        process.nextTick(emitErrorCloseLegacy, stream, err);\n      } else {\n        process.nextTick(emitCloseLegacy, stream);\n      }\n      if (!stream.destroyed) {\n        stream[kIsDestroyed] = true;\n      }\n    }\n    module2.exports = {\n      construct,\n      destroyer,\n      destroy,\n      undestroy,\n      errorOrDestroy\n    };\n  }\n});\n\n// node_modules/readable-stream/lib/internal/streams/legacy.js\nvar require_legacy = __commonJS({\n  "node_modules/readable-stream/lib/internal/streams/legacy.js"(exports2, module2) {\n    "use strict";\n    var { ArrayIsArray, ObjectSetPrototypeOf } = require_primordials();\n    var { EventEmitter: EE } = require_events();\n    function Stream(opts) {\n      EE.call(this, opts);\n    }\n    ObjectSetPrototypeOf(Stream.prototype, EE.prototype);\n    ObjectSetPrototypeOf(Stream, EE);\n    Stream.prototype.pipe = function(dest, options) {\n      const source = this;\n      function ondata(chunk) {\n        if (dest.writable && dest.write(chunk) === false && source.pause) {\n          source.pause();\n        }\n      }\n      source.on("data", ondata);\n      function ondrain() {\n        if (source.readable && source.resume) {\n          source.resume();\n        }\n      }\n      dest.on("drain", ondrain);\n      if (!dest._isStdio && (!options || options.end !== false)) {\n        source.on("end", onend);\n        source.on("close", onclose);\n      }\n      let didOnEnd = false;\n      function onend() {\n        if (didOnEnd) return;\n        didOnEnd = true;\n        dest.end();\n      }\n      function onclose() {\n        if (didOnEnd) return;\n        didOnEnd = true;\n        if (typeof dest.destroy === "function") dest.destroy();\n      }\n      function onerror(er) {\n        var _this$listenerCount;\n        cleanup();\n        if (((_this$listenerCount = this.listenerCount) === null || _this$listenerCount === void 0 ? void 0 : _this$listenerCount.call(this, "error")) === 0) {\n          this.emit("error", er);\n        }\n      }\n      prependListener(source, "error", onerror);\n      prependListener(dest, "error", onerror);\n      function cleanup() {\n        source.removeListener("data", ondata);\n        dest.removeListener("drain", ondrain);\n        source.removeListener("end", onend);\n        source.removeListener("close", onclose);\n        source.removeListener("error", onerror);\n        dest.removeListener("error", onerror);\n        source.removeListener("end", cleanup);\n        source.removeListener("close", cleanup);\n        dest.removeListener("close", cleanup);\n      }\n      source.on("end", cleanup);\n      source.on("close", cleanup);\n      dest.on("close", cleanup);\n      dest.emit("pipe", source);\n      return dest;\n    };\n    function prependListener(emitter, event, fn) {\n      if (typeof emitter.prependListener === "function") return emitter.prependListener(event, fn);\n      if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);\n      else if (ArrayIsArray(emitter._events[event])) emitter._events[event].unshift(fn);\n      else emitter._events[event] = [fn, emitter._events[event]];\n    }\n    module2.exports = {\n      Stream,\n      prependListener\n    };\n  }\n});\n\n// node_modules/readable-stream/lib/internal/streams/add-abort-signal.js\nvar require_add_abort_signal = __commonJS({\n  "node_modules/readable-stream/lib/internal/streams/add-abort-signal.js"(exports2, module2) {\n    "use strict";\n    var { SymbolDispose } = require_primordials();\n    var { AbortError, codes } = require_errors();\n    var { isNodeStream, isWebStream, kControllerErrorFunction } = require_utils();\n    var eos = require_end_of_stream();\n    var { ERR_INVALID_ARG_TYPE } = codes;\n    var addAbortListener;\n    var validateAbortSignal = (signal, name) => {\n      if (typeof signal !== "object" || !("aborted" in signal)) {\n        throw new ERR_INVALID_ARG_TYPE(name, "AbortSignal", signal);\n      }\n    };\n    module2.exports.addAbortSignal = function addAbortSignal(signal, stream) {\n      validateAbortSignal(signal, "signal");\n      if (!isNodeStream(stream) && !isWebStream(stream)) {\n        throw new ERR_INVALID_ARG_TYPE("stream", ["ReadableStream", "WritableStream", "Stream"], stream);\n      }\n      return module2.exports.addAbortSignalNoValidate(signal, stream);\n    };\n    module2.exports.addAbortSignalNoValidate = function(signal, stream) {\n      if (typeof signal !== "object" || !("aborted" in signal)) {\n        return stream;\n      }\n      const onAbort = isNodeStream(stream) ? () => {\n        stream.destroy(\n          new AbortError(void 0, {\n            cause: signal.reason\n          })\n        );\n      } : () => {\n        stream[kControllerErrorFunction](\n          new AbortError(void 0, {\n            cause: signal.reason\n          })\n        );\n      };\n      if (signal.aborted) {\n        onAbort();\n      } else {\n        addAbortListener = addAbortListener || require_util().addAbortListener;\n        const disposable = addAbortListener(signal, onAbort);\n        eos(stream, disposable[SymbolDispose]);\n      }\n      return stream;\n    };\n  }\n});\n\n// node_modules/readable-stream/lib/internal/streams/buffer_list.js\nvar require_buffer_list = __commonJS({\n  "node_modules/readable-stream/lib/internal/streams/buffer_list.js"(exports2, module2) {\n    "use strict";\n    var { StringPrototypeSlice, SymbolIterator, TypedArrayPrototypeSet, Uint8Array: Uint8Array2 } = require_primordials();\n    var { Buffer: Buffer2 } = require_buffer();\n    var { inspect } = require_util();\n    module2.exports = class BufferList {\n      constructor() {\n        this.head = null;\n        this.tail = null;\n        this.length = 0;\n      }\n      push(v) {\n        const entry = {\n          data: v,\n          next: null\n        };\n        if (this.length > 0) this.tail.next = entry;\n        else this.head = entry;\n        this.tail = entry;\n        ++this.length;\n      }\n      unshift(v) {\n        const entry = {\n          data: v,\n          next: this.head\n        };\n        if (this.length === 0) this.tail = entry;\n        this.head = entry;\n        ++this.length;\n      }\n      shift() {\n        if (this.length === 0) return;\n        const ret = this.head.data;\n        if (this.length === 1) this.head = this.tail = null;\n        else this.head = this.head.next;\n        --this.length;\n        return ret;\n      }\n      clear() {\n        this.head = this.tail = null;\n        this.length = 0;\n      }\n      join(s) {\n        if (this.length === 0) return "";\n        let p = this.head;\n        let ret = "" + p.data;\n        while ((p = p.next) !== null) ret += s + p.data;\n        return ret;\n      }\n      concat(n) {\n        if (this.length === 0) return Buffer2.alloc(0);\n        const ret = Buffer2.allocUnsafe(n >>> 0);\n        let p = this.head;\n        let i = 0;\n        while (p) {\n          TypedArrayPrototypeSet(ret, p.data, i);\n          i += p.data.length;\n          p = p.next;\n        }\n        return ret;\n      }\n      // Consumes a specified amount of bytes or characters from the buffered data.\n      consume(n, hasStrings) {\n        const data = this.head.data;\n        if (n < data.length) {\n          const slice = data.slice(0, n);\n          this.head.data = data.slice(n);\n          return slice;\n        }\n        if (n === data.length) {\n          return this.shift();\n        }\n        return hasStrings ? this._getString(n) : this._getBuffer(n);\n      }\n      first() {\n        return this.head.data;\n      }\n      *[SymbolIterator]() {\n        for (let p = this.head; p; p = p.next) {\n          yield p.data;\n        }\n      }\n      // Consumes a specified amount of characters from the buffered data.\n      _getString(n) {\n        let ret = "";\n        let p = this.head;\n        let c = 0;\n        do {\n          const str = p.data;\n          if (n > str.length) {\n            ret += str;\n            n -= str.length;\n          } else {\n            if (n === str.length) {\n              ret += str;\n              ++c;\n              if (p.next) this.head = p.next;\n              else this.head = this.tail = null;\n            } else {\n              ret += StringPrototypeSlice(str, 0, n);\n              this.head = p;\n              p.data = StringPrototypeSlice(str, n);\n            }\n            break;\n          }\n          ++c;\n        } while ((p = p.next) !== null);\n        this.length -= c;\n        return ret;\n      }\n      // Consumes a specified amount of bytes from the buffered data.\n      _getBuffer(n) {\n        const ret = Buffer2.allocUnsafe(n);\n        const retLen = n;\n        let p = this.head;\n        let c = 0;\n        do {\n          const buf = p.data;\n          if (n > buf.length) {\n            TypedArrayPrototypeSet(ret, buf, retLen - n);\n            n -= buf.length;\n          } else {\n            if (n === buf.length) {\n              TypedArrayPrototypeSet(ret, buf, retLen - n);\n              ++c;\n              if (p.next) this.head = p.next;\n              else this.head = this.tail = null;\n            } else {\n              TypedArrayPrototypeSet(ret, new Uint8Array2(buf.buffer, buf.byteOffset, n), retLen - n);\n              this.head = p;\n              p.data = buf.slice(n);\n            }\n            break;\n          }\n          ++c;\n        } while ((p = p.next) !== null);\n        this.length -= c;\n        return ret;\n      }\n      // Make sure the linked list only shows the minimal necessary information.\n      [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")](_, options) {\n        return inspect(this, {\n          ...options,\n          // Only inspect one level.\n          depth: 0,\n          // It should not recurse.\n          customInspect: false\n        });\n      }\n    };\n  }\n});\n\n// node_modules/readable-stream/lib/internal/streams/state.js\nvar require_state = __commonJS({\n  "node_modules/readable-stream/lib/internal/streams/state.js"(exports2, module2) {\n    "use strict";\n    var { MathFloor, NumberIsInteger } = require_primordials();\n    var { validateInteger } = require_validators();\n    var { ERR_INVALID_ARG_VALUE } = require_errors().codes;\n    var defaultHighWaterMarkBytes = 64 * 1024;\n    var defaultHighWaterMarkObjectMode = 16;\n    function highWaterMarkFrom(options, isDuplex, duplexKey) {\n      return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;\n    }\n    function getDefaultHighWaterMark(objectMode) {\n      return objectMode ? defaultHighWaterMarkObjectMode : defaultHighWaterMarkBytes;\n    }\n    function setDefaultHighWaterMark(objectMode, value) {\n      validateInteger(value, "value", 0);\n      if (objectMode) {\n        defaultHighWaterMarkObjectMode = value;\n      } else {\n        defaultHighWaterMarkBytes = value;\n      }\n    }\n    function getHighWaterMark(state, options, duplexKey, isDuplex) {\n      const hwm = highWaterMarkFrom(options, isDuplex, duplexKey);\n      if (hwm != null) {\n        if (!NumberIsInteger(hwm) || hwm < 0) {\n          const name = isDuplex ? `options.${duplexKey}` : "options.highWaterMark";\n          throw new ERR_INVALID_ARG_VALUE(name, hwm);\n        }\n        return MathFloor(hwm);\n      }\n      return getDefaultHighWaterMark(state.objectMode);\n    }\n    module2.exports = {\n      getHighWaterMark,\n      getDefaultHighWaterMark,\n      setDefaultHighWaterMark\n    };\n  }\n});\n\n// node_modules/string_decoder/lib/string_decoder.js\nvar require_string_decoder = __commonJS({\n  "node_modules/string_decoder/lib/string_decoder.js"(exports2) {\n    "use strict";\n    var Buffer2 = require_buffer().Buffer;\n    var isEncoding = Buffer2.isEncoding || function(encoding) {\n      encoding = "" + encoding;\n      switch (encoding && encoding.toLowerCase()) {\n        case "hex":\n        case "utf8":\n        case "utf-8":\n        case "ascii":\n        case "binary":\n        case "base64":\n        case "ucs2":\n        case "ucs-2":\n        case "utf16le":\n        case "utf-16le":\n        case "raw":\n          return true;\n        default:\n          return false;\n      }\n    };\n    function _normalizeEncoding(enc) {\n      if (!enc) return "utf8";\n      var retried;\n      while (true) {\n        switch (enc) {\n          case "utf8":\n          case "utf-8":\n            return "utf8";\n          case "ucs2":\n          case "ucs-2":\n          case "utf16le":\n          case "utf-16le":\n            return "utf16le";\n          case "latin1":\n          case "binary":\n            return "latin1";\n          case "base64":\n          case "ascii":\n          case "hex":\n            return enc;\n          default:\n            if (retried) return;\n            enc = ("" + enc).toLowerCase();\n            retried = true;\n        }\n      }\n    }\n    function normalizeEncoding(enc) {\n      var nenc = _normalizeEncoding(enc);\n      if (typeof nenc !== "string" && (Buffer2.isEncoding === isEncoding || !isEncoding(enc))) throw new Error("Unknown encoding: " + enc);\n      return nenc || enc;\n    }\n    exports2.StringDecoder = StringDecoder;\n    function StringDecoder(encoding) {\n      this.encoding = normalizeEncoding(encoding);\n      var nb;\n      switch (this.encoding) {\n        case "utf16le":\n          this.text = utf16Text;\n          this.end = utf16End;\n          nb = 4;\n          break;\n        case "utf8":\n          this.fillLast = utf8FillLast;\n          nb = 4;\n          break;\n        case "base64":\n          this.text = base64Text;\n          this.end = base64End;\n          nb = 3;\n          break;\n        default:\n          this.write = simpleWrite;\n          this.end = simpleEnd;\n          return;\n      }\n      this.lastNeed = 0;\n      this.lastTotal = 0;\n      this.lastChar = Buffer2.allocUnsafe(nb);\n    }\n    StringDecoder.prototype.write = function(buf) {\n      if (buf.length === 0) return "";\n      var r;\n      var i;\n      if (this.lastNeed) {\n        r = this.fillLast(buf);\n        if (r === void 0) return "";\n        i = this.lastNeed;\n        this.lastNeed = 0;\n      } else {\n        i = 0;\n      }\n      if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);\n      return r || "";\n    };\n    StringDecoder.prototype.end = utf8End;\n    StringDecoder.prototype.text = utf8Text;\n    StringDecoder.prototype.fillLast = function(buf) {\n      if (this.lastNeed <= buf.length) {\n        buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);\n        return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n      }\n      buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);\n      this.lastNeed -= buf.length;\n    };\n    function utf8CheckByte(byte) {\n      if (byte <= 127) return 0;\n      else if (byte >> 5 === 6) return 2;\n      else if (byte >> 4 === 14) return 3;\n      else if (byte >> 3 === 30) return 4;\n      return byte >> 6 === 2 ? -1 : -2;\n    }\n    function utf8CheckIncomplete(self, buf, i) {\n      var j = buf.length - 1;\n      if (j < i) return 0;\n      var nb = utf8CheckByte(buf[j]);\n      if (nb >= 0) {\n        if (nb > 0) self.lastNeed = nb - 1;\n        return nb;\n      }\n      if (--j < i || nb === -2) return 0;\n      nb = utf8CheckByte(buf[j]);\n      if (nb >= 0) {\n        if (nb > 0) self.lastNeed = nb - 2;\n        return nb;\n      }\n      if (--j < i || nb === -2) return 0;\n      nb = utf8CheckByte(buf[j]);\n      if (nb >= 0) {\n        if (nb > 0) {\n          if (nb === 2) nb = 0;\n          else self.lastNeed = nb - 3;\n        }\n        return nb;\n      }\n      return 0;\n    }\n    function utf8CheckExtraBytes(self, buf, p) {\n      if ((buf[0] & 192) !== 128) {\n        self.lastNeed = 0;\n        return "\\uFFFD";\n      }\n      if (self.lastNeed > 1 && buf.length > 1) {\n        if ((buf[1] & 192) !== 128) {\n          self.lastNeed = 1;\n          return "\\uFFFD";\n        }\n        if (self.lastNeed > 2 && buf.length > 2) {\n          if ((buf[2] & 192) !== 128) {\n            self.lastNeed = 2;\n            return "\\uFFFD";\n          }\n        }\n      }\n    }\n    function utf8FillLast(buf) {\n      var p = this.lastTotal - this.lastNeed;\n      var r = utf8CheckExtraBytes(this, buf, p);\n      if (r !== void 0) return r;\n      if (this.lastNeed <= buf.length) {\n        buf.copy(this.lastChar, p, 0, this.lastNeed);\n        return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n      }\n      buf.copy(this.lastChar, p, 0, buf.length);\n      this.lastNeed -= buf.length;\n    }\n    function utf8Text(buf, i) {\n      var total = utf8CheckIncomplete(this, buf, i);\n      if (!this.lastNeed) return buf.toString("utf8", i);\n      this.lastTotal = total;\n      var end = buf.length - (total - this.lastNeed);\n      buf.copy(this.lastChar, 0, end);\n      return buf.toString("utf8", i, end);\n    }\n    function utf8End(buf) {\n      var r = buf && buf.length ? this.write(buf) : "";\n      if (this.lastNeed) return r + "\\uFFFD";\n      return r;\n    }\n    function utf16Text(buf, i) {\n      if ((buf.length - i) % 2 === 0) {\n        var r = buf.toString("utf16le", i);\n        if (r) {\n          var c = r.charCodeAt(r.length - 1);\n          if (c >= 55296 && c <= 56319) {\n            this.lastNeed = 2;\n            this.lastTotal = 4;\n            this.lastChar[0] = buf[buf.length - 2];\n            this.lastChar[1] = buf[buf.length - 1];\n            return r.slice(0, -1);\n          }\n        }\n        return r;\n      }\n      this.lastNeed = 1;\n      this.lastTotal = 2;\n      this.lastChar[0] = buf[buf.length - 1];\n      return buf.toString("utf16le", i, buf.length - 1);\n    }\n    function utf16End(buf) {\n      var r = buf && buf.length ? this.write(buf) : "";\n      if (this.lastNeed) {\n        var end = this.lastTotal - this.lastNeed;\n        return r + this.lastChar.toString("utf16le", 0, end);\n      }\n      return r;\n    }\n    function base64Text(buf, i) {\n      var n = (buf.length - i) % 3;\n      if (n === 0) return buf.toString("base64", i);\n      this.lastNeed = 3 - n;\n      this.lastTotal = 3;\n      if (n === 1) {\n        this.lastChar[0] = buf[buf.length - 1];\n      } else {\n        this.lastChar[0] = buf[buf.length - 2];\n        this.lastChar[1] = buf[buf.length - 1];\n      }\n      return buf.toString("base64", i, buf.length - n);\n    }\n    function base64End(buf) {\n      var r = buf && buf.length ? this.write(buf) : "";\n      if (this.lastNeed) return r + this.lastChar.toString("base64", 0, 3 - this.lastNeed);\n      return r;\n    }\n    function simpleWrite(buf) {\n      return buf.toString(this.encoding);\n    }\n    function simpleEnd(buf) {\n      return buf && buf.length ? this.write(buf) : "";\n    }\n  }\n});\n\n// node_modules/readable-stream/lib/internal/streams/from.js\nvar require_from = __commonJS({\n  "node_modules/readable-stream/lib/internal/streams/from.js"(exports2, module2) {\n    "use strict";\n    var process = require_process2();\n    var { PromisePrototypeThen, SymbolAsyncIterator, SymbolIterator } = require_primordials();\n    var { Buffer: Buffer2 } = require_buffer();\n    var { ERR_INVALID_ARG_TYPE, ERR_STREAM_NULL_VALUES } = require_errors().codes;\n    function from(Readable, iterable, opts) {\n      let iterator;\n      if (typeof iterable === "string" || iterable instanceof Buffer2) {\n        return new Readable({\n          objectMode: true,\n          ...opts,\n          read() {\n            this.push(iterable);\n            this.push(null);\n          }\n        });\n      }\n      let isAsync;\n      if (iterable && iterable[SymbolAsyncIterator]) {\n        isAsync = true;\n        iterator = iterable[SymbolAsyncIterator]();\n      } else if (iterable && iterable[SymbolIterator]) {\n        isAsync = false;\n        iterator = iterable[SymbolIterator]();\n      } else {\n        throw new ERR_INVALID_ARG_TYPE("iterable", ["Iterable"], iterable);\n      }\n      const readable = new Readable({\n        objectMode: true,\n        highWaterMark: 1,\n        // TODO(ronag): What options should be allowed?\n        ...opts\n      });\n      let reading = false;\n      readable._read = function() {\n        if (!reading) {\n          reading = true;\n          next();\n        }\n      };\n      readable._destroy = function(error, cb) {\n        PromisePrototypeThen(\n          close(error),\n          () => process.nextTick(cb, error),\n          // nextTick is here in case cb throws\n          (e) => process.nextTick(cb, e || error)\n        );\n      };\n      async function close(error) {\n        const hadError = error !== void 0 && error !== null;\n        const hasThrow = typeof iterator.throw === "function";\n        if (hadError && hasThrow) {\n          const { value, done } = await iterator.throw(error);\n          await value;\n          if (done) {\n            return;\n          }\n        }\n        if (typeof iterator.return === "function") {\n          const { value } = await iterator.return();\n          await value;\n        }\n      }\n      async function next() {\n        for (; ; ) {\n          try {\n            const { value, done } = isAsync ? await iterator.next() : iterator.next();\n            if (done) {\n              readable.push(null);\n            } else {\n              const res = value && typeof value.then === "function" ? await value : value;\n              if (res === null) {\n                reading = false;\n                throw new ERR_STREAM_NULL_VALUES();\n              } else if (readable.push(res)) {\n                continue;\n              } else {\n                reading = false;\n              }\n            }\n          } catch (err) {\n            readable.destroy(err);\n          }\n          break;\n        }\n      }\n      return readable;\n    }\n    module2.exports = from;\n  }\n});\n\n// node_modules/readable-stream/lib/internal/streams/readable.js\nvar require_readable = __commonJS({\n  "node_modules/readable-stream/lib/internal/streams/readable.js"(exports2, module2) {\n    "use strict";\n    var process = require_process2();\n    var {\n      ArrayPrototypeIndexOf,\n      NumberIsInteger,\n      NumberIsNaN,\n      NumberParseInt,\n      ObjectDefineProperties,\n      ObjectKeys,\n      ObjectSetPrototypeOf,\n      Promise: Promise2,\n      SafeSet,\n      SymbolAsyncDispose,\n      SymbolAsyncIterator,\n      Symbol: Symbol2\n    } = require_primordials();\n    module2.exports = Readable;\n    Readable.ReadableState = ReadableState;\n    var { EventEmitter: EE } = require_events();\n    var { Stream, prependListener } = require_legacy();\n    var { Buffer: Buffer2 } = require_buffer();\n    var { addAbortSignal } = require_add_abort_signal();\n    var eos = require_end_of_stream();\n    var debug = require_util().debuglog("stream", (fn) => {\n      debug = fn;\n    });\n    var BufferList = require_buffer_list();\n    var destroyImpl = require_destroy();\n    var { getHighWaterMark, getDefaultHighWaterMark } = require_state();\n    var {\n      aggregateTwoErrors,\n      codes: {\n        ERR_INVALID_ARG_TYPE,\n        ERR_METHOD_NOT_IMPLEMENTED,\n        ERR_OUT_OF_RANGE,\n        ERR_STREAM_PUSH_AFTER_EOF,\n        ERR_STREAM_UNSHIFT_AFTER_END_EVENT\n      },\n      AbortError\n    } = require_errors();\n    var { validateObject } = require_validators();\n    var kPaused = Symbol2("kPaused");\n    var { StringDecoder } = require_string_decoder();\n    var from = require_from();\n    ObjectSetPrototypeOf(Readable.prototype, Stream.prototype);\n    ObjectSetPrototypeOf(Readable, Stream);\n    var nop = () => {\n    };\n    var { errorOrDestroy } = destroyImpl;\n    var kObjectMode = 1 << 0;\n    var kEnded = 1 << 1;\n    var kEndEmitted = 1 << 2;\n    var kReading = 1 << 3;\n    var kConstructed = 1 << 4;\n    var kSync = 1 << 5;\n    var kNeedReadable = 1 << 6;\n    var kEmittedReadable = 1 << 7;\n    var kReadableListening = 1 << 8;\n    var kResumeScheduled = 1 << 9;\n    var kErrorEmitted = 1 << 10;\n    var kEmitClose = 1 << 11;\n    var kAutoDestroy = 1 << 12;\n    var kDestroyed = 1 << 13;\n    var kClosed = 1 << 14;\n    var kCloseEmitted = 1 << 15;\n    var kMultiAwaitDrain = 1 << 16;\n    var kReadingMore = 1 << 17;\n    var kDataEmitted = 1 << 18;\n    function makeBitMapDescriptor(bit) {\n      return {\n        enumerable: false,\n        get() {\n          return (this.state & bit) !== 0;\n        },\n        set(value) {\n          if (value) this.state |= bit;\n          else this.state &= ~bit;\n        }\n      };\n    }\n    ObjectDefineProperties(ReadableState.prototype, {\n      objectMode: makeBitMapDescriptor(kObjectMode),\n      ended: makeBitMapDescriptor(kEnded),\n      endEmitted: makeBitMapDescriptor(kEndEmitted),\n      reading: makeBitMapDescriptor(kReading),\n      // Stream is still being constructed and cannot be\n      // destroyed until construction finished or failed.\n      // Async construction is opt in, therefore we start as\n      // constructed.\n      constructed: makeBitMapDescriptor(kConstructed),\n      // A flag to be able to tell if the event \'readable\'/\'data\' is emitted\n      // immediately, or on a later tick.  We set this to true at first, because\n      // any actions that shouldn\'t happen until "later" should generally also\n      // not happen before the first read call.\n      sync: makeBitMapDescriptor(kSync),\n      // Whenever we return null, then we set a flag to say\n      // that we\'re awaiting a \'readable\' event emission.\n      needReadable: makeBitMapDescriptor(kNeedReadable),\n      emittedReadable: makeBitMapDescriptor(kEmittedReadable),\n      readableListening: makeBitMapDescriptor(kReadableListening),\n      resumeScheduled: makeBitMapDescriptor(kResumeScheduled),\n      // True if the error was already emitted and should not be thrown again.\n      errorEmitted: makeBitMapDescriptor(kErrorEmitted),\n      emitClose: makeBitMapDescriptor(kEmitClose),\n      autoDestroy: makeBitMapDescriptor(kAutoDestroy),\n      // Has it been destroyed.\n      destroyed: makeBitMapDescriptor(kDestroyed),\n      // Indicates whether the stream has finished destroying.\n      closed: makeBitMapDescriptor(kClosed),\n      // True if close has been emitted or would have been emitted\n      // depending on emitClose.\n      closeEmitted: makeBitMapDescriptor(kCloseEmitted),\n      multiAwaitDrain: makeBitMapDescriptor(kMultiAwaitDrain),\n      // If true, a maybeReadMore has been scheduled.\n      readingMore: makeBitMapDescriptor(kReadingMore),\n      dataEmitted: makeBitMapDescriptor(kDataEmitted)\n    });\n    function ReadableState(options, stream, isDuplex) {\n      if (typeof isDuplex !== "boolean") isDuplex = stream instanceof require_duplex();\n      this.state = kEmitClose | kAutoDestroy | kConstructed | kSync;\n      if (options && options.objectMode) this.state |= kObjectMode;\n      if (isDuplex && options && options.readableObjectMode) this.state |= kObjectMode;\n      this.highWaterMark = options ? getHighWaterMark(this, options, "readableHighWaterMark", isDuplex) : getDefaultHighWaterMark(false);\n      this.buffer = new BufferList();\n      this.length = 0;\n      this.pipes = [];\n      this.flowing = null;\n      this[kPaused] = null;\n      if (options && options.emitClose === false) this.state &= ~kEmitClose;\n      if (options && options.autoDestroy === false) this.state &= ~kAutoDestroy;\n      this.errored = null;\n      this.defaultEncoding = options && options.defaultEncoding || "utf8";\n      this.awaitDrainWriters = null;\n      this.decoder = null;\n      this.encoding = null;\n      if (options && options.encoding) {\n        this.decoder = new StringDecoder(options.encoding);\n        this.encoding = options.encoding;\n      }\n    }\n    function Readable(options) {\n      if (!(this instanceof Readable)) return new Readable(options);\n      const isDuplex = this instanceof require_duplex();\n      this._readableState = new ReadableState(options, this, isDuplex);\n      if (options) {\n        if (typeof options.read === "function") this._read = options.read;\n        if (typeof options.destroy === "function") this._destroy = options.destroy;\n        if (typeof options.construct === "function") this._construct = options.construct;\n        if (options.signal && !isDuplex) addAbortSignal(options.signal, this);\n      }\n      Stream.call(this, options);\n      destroyImpl.construct(this, () => {\n        if (this._readableState.needReadable) {\n          maybeReadMore(this, this._readableState);\n        }\n      });\n    }\n    Readable.prototype.destroy = destroyImpl.destroy;\n    Readable.prototype._undestroy = destroyImpl.undestroy;\n    Readable.prototype._destroy = function(err, cb) {\n      cb(err);\n    };\n    Readable.prototype[EE.captureRejectionSymbol] = function(err) {\n      this.destroy(err);\n    };\n    Readable.prototype[SymbolAsyncDispose] = function() {\n      let error;\n      if (!this.destroyed) {\n        error = this.readableEnded ? null : new AbortError();\n        this.destroy(error);\n      }\n      return new Promise2((resolve, reject) => eos(this, (err) => err && err !== error ? reject(err) : resolve(null)));\n    };\n    Readable.prototype.push = function(chunk, encoding) {\n      return readableAddChunk(this, chunk, encoding, false);\n    };\n    Readable.prototype.unshift = function(chunk, encoding) {\n      return readableAddChunk(this, chunk, encoding, true);\n    };\n    function readableAddChunk(stream, chunk, encoding, addToFront) {\n      debug("readableAddChunk", chunk);\n      const state = stream._readableState;\n      let err;\n      if ((state.state & kObjectMode) === 0) {\n        if (typeof chunk === "string") {\n          encoding = encoding || state.defaultEncoding;\n          if (state.encoding !== encoding) {\n            if (addToFront && state.encoding) {\n              chunk = Buffer2.from(chunk, encoding).toString(state.encoding);\n            } else {\n              chunk = Buffer2.from(chunk, encoding);\n              encoding = "";\n            }\n          }\n        } else if (chunk instanceof Buffer2) {\n          encoding = "";\n        } else if (Stream._isUint8Array(chunk)) {\n          chunk = Stream._uint8ArrayToBuffer(chunk);\n          encoding = "";\n        } else if (chunk != null) {\n          err = new ERR_INVALID_ARG_TYPE("chunk", ["string", "Buffer", "Uint8Array"], chunk);\n        }\n      }\n      if (err) {\n        errorOrDestroy(stream, err);\n      } else if (chunk === null) {\n        state.state &= ~kReading;\n        onEofChunk(stream, state);\n      } else if ((state.state & kObjectMode) !== 0 || chunk && chunk.length > 0) {\n        if (addToFront) {\n          if ((state.state & kEndEmitted) !== 0) errorOrDestroy(stream, new ERR_STREAM_UNSHIFT_AFTER_END_EVENT());\n          else if (state.destroyed || state.errored) return false;\n          else addChunk(stream, state, chunk, true);\n        } else if (state.ended) {\n          errorOrDestroy(stream, new ERR_STREAM_PUSH_AFTER_EOF());\n        } else if (state.destroyed || state.errored) {\n          return false;\n        } else {\n          state.state &= ~kReading;\n          if (state.decoder && !encoding) {\n            chunk = state.decoder.write(chunk);\n            if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);\n            else maybeReadMore(stream, state);\n          } else {\n            addChunk(stream, state, chunk, false);\n          }\n        }\n      } else if (!addToFront) {\n        state.state &= ~kReading;\n        maybeReadMore(stream, state);\n      }\n      return !state.ended && (state.length < state.highWaterMark || state.length === 0);\n    }\n    function addChunk(stream, state, chunk, addToFront) {\n      if (state.flowing && state.length === 0 && !state.sync && stream.listenerCount("data") > 0) {\n        if ((state.state & kMultiAwaitDrain) !== 0) {\n          state.awaitDrainWriters.clear();\n        } else {\n          state.awaitDrainWriters = null;\n        }\n        state.dataEmitted = true;\n        stream.emit("data", chunk);\n      } else {\n        state.length += state.objectMode ? 1 : chunk.length;\n        if (addToFront) state.buffer.unshift(chunk);\n        else state.buffer.push(chunk);\n        if ((state.state & kNeedReadable) !== 0) emitReadable(stream);\n      }\n      maybeReadMore(stream, state);\n    }\n    Readable.prototype.isPaused = function() {\n      const state = this._readableState;\n      return state[kPaused] === true || state.flowing === false;\n    };\n    Readable.prototype.setEncoding = function(enc) {\n      const decoder = new StringDecoder(enc);\n      this._readableState.decoder = decoder;\n      this._readableState.encoding = this._readableState.decoder.encoding;\n      const buffer = this._readableState.buffer;\n      let content = "";\n      for (const data of buffer) {\n        content += decoder.write(data);\n      }\n      buffer.clear();\n      if (content !== "") buffer.push(content);\n      this._readableState.length = content.length;\n      return this;\n    };\n    var MAX_HWM = 1073741824;\n    function computeNewHighWaterMark(n) {\n      if (n > MAX_HWM) {\n        throw new ERR_OUT_OF_RANGE("size", "<= 1GiB", n);\n      } else {\n        n--;\n        n |= n >>> 1;\n        n |= n >>> 2;\n        n |= n >>> 4;\n        n |= n >>> 8;\n        n |= n >>> 16;\n        n++;\n      }\n      return n;\n    }\n    function howMuchToRead(n, state) {\n      if (n <= 0 || state.length === 0 && state.ended) return 0;\n      if ((state.state & kObjectMode) !== 0) return 1;\n      if (NumberIsNaN(n)) {\n        if (state.flowing && state.length) return state.buffer.first().length;\n        return state.length;\n      }\n      if (n <= state.length) return n;\n      return state.ended ? state.length : 0;\n    }\n    Readable.prototype.read = function(n) {\n      debug("read", n);\n      if (n === void 0) {\n        n = NaN;\n      } else if (!NumberIsInteger(n)) {\n        n = NumberParseInt(n, 10);\n      }\n      const state = this._readableState;\n      const nOrig = n;\n      if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);\n      if (n !== 0) state.state &= ~kEmittedReadable;\n      if (n === 0 && state.needReadable && ((state.highWaterMark !== 0 ? state.length >= state.highWaterMark : state.length > 0) || state.ended)) {\n        debug("read: emitReadable", state.length, state.ended);\n        if (state.length === 0 && state.ended) endReadable(this);\n        else emitReadable(this);\n        return null;\n      }\n      n = howMuchToRead(n, state);\n      if (n === 0 && state.ended) {\n        if (state.length === 0) endReadable(this);\n        return null;\n      }\n      let doRead = (state.state & kNeedReadable) !== 0;\n      debug("need readable", doRead);\n      if (state.length === 0 || state.length - n < state.highWaterMark) {\n        doRead = true;\n        debug("length less than watermark", doRead);\n      }\n      if (state.ended || state.reading || state.destroyed || state.errored || !state.constructed) {\n        doRead = false;\n        debug("reading, ended or constructing", doRead);\n      } else if (doRead) {\n        debug("do read");\n        state.state |= kReading | kSync;\n        if (state.length === 0) state.state |= kNeedReadable;\n        try {\n          this._read(state.highWaterMark);\n        } catch (err) {\n          errorOrDestroy(this, err);\n        }\n        state.state &= ~kSync;\n        if (!state.reading) n = howMuchToRead(nOrig, state);\n      }\n      let ret;\n      if (n > 0) ret = fromList(n, state);\n      else ret = null;\n      if (ret === null) {\n        state.needReadable = state.length <= state.highWaterMark;\n        n = 0;\n      } else {\n        state.length -= n;\n        if (state.multiAwaitDrain) {\n          state.awaitDrainWriters.clear();\n        } else {\n          state.awaitDrainWriters = null;\n        }\n      }\n      if (state.length === 0) {\n        if (!state.ended) state.needReadable = true;\n        if (nOrig !== n && state.ended) endReadable(this);\n      }\n      if (ret !== null && !state.errorEmitted && !state.closeEmitted) {\n        state.dataEmitted = true;\n        this.emit("data", ret);\n      }\n      return ret;\n    };\n    function onEofChunk(stream, state) {\n      debug("onEofChunk");\n      if (state.ended) return;\n      if (state.decoder) {\n        const chunk = state.decoder.end();\n        if (chunk && chunk.length) {\n          state.buffer.push(chunk);\n          state.length += state.objectMode ? 1 : chunk.length;\n        }\n      }\n      state.ended = true;\n      if (state.sync) {\n        emitReadable(stream);\n      } else {\n        state.needReadable = false;\n        state.emittedReadable = true;\n        emitReadable_(stream);\n      }\n    }\n    function emitReadable(stream) {\n      const state = stream._readableState;\n      debug("emitReadable", state.needReadable, state.emittedReadable);\n      state.needReadable = false;\n      if (!state.emittedReadable) {\n        debug("emitReadable", state.flowing);\n        state.emittedReadable = true;\n        process.nextTick(emitReadable_, stream);\n      }\n    }\n    function emitReadable_(stream) {\n      const state = stream._readableState;\n      debug("emitReadable_", state.destroyed, state.length, state.ended);\n      if (!state.destroyed && !state.errored && (state.length || state.ended)) {\n        stream.emit("readable");\n        state.emittedReadable = false;\n      }\n      state.needReadable = !state.flowing && !state.ended && state.length <= state.highWaterMark;\n      flow(stream);\n    }\n    function maybeReadMore(stream, state) {\n      if (!state.readingMore && state.constructed) {\n        state.readingMore = true;\n        process.nextTick(maybeReadMore_, stream, state);\n      }\n    }\n    function maybeReadMore_(stream, state) {\n      while (!state.reading && !state.ended && (state.length < state.highWaterMark || state.flowing && state.length === 0)) {\n        const len = state.length;\n        debug("maybeReadMore read 0");\n        stream.read(0);\n        if (len === state.length)\n          break;\n      }\n      state.readingMore = false;\n    }\n    Readable.prototype._read = function(n) {\n      throw new ERR_METHOD_NOT_IMPLEMENTED("_read()");\n    };\n    Readable.prototype.pipe = function(dest, pipeOpts) {\n      const src = this;\n      const state = this._readableState;\n      if (state.pipes.length === 1) {\n        if (!state.multiAwaitDrain) {\n          state.multiAwaitDrain = true;\n          state.awaitDrainWriters = new SafeSet(state.awaitDrainWriters ? [state.awaitDrainWriters] : []);\n        }\n      }\n      state.pipes.push(dest);\n      debug("pipe count=%d opts=%j", state.pipes.length, pipeOpts);\n      const doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;\n      const endFn = doEnd ? onend : unpipe;\n      if (state.endEmitted) process.nextTick(endFn);\n      else src.once("end", endFn);\n      dest.on("unpipe", onunpipe);\n      function onunpipe(readable, unpipeInfo) {\n        debug("onunpipe");\n        if (readable === src) {\n          if (unpipeInfo && unpipeInfo.hasUnpiped === false) {\n            unpipeInfo.hasUnpiped = true;\n            cleanup();\n          }\n        }\n      }\n      function onend() {\n        debug("onend");\n        dest.end();\n      }\n      let ondrain;\n      let cleanedUp = false;\n      function cleanup() {\n        debug("cleanup");\n        dest.removeListener("close", onclose);\n        dest.removeListener("finish", onfinish);\n        if (ondrain) {\n          dest.removeListener("drain", ondrain);\n        }\n        dest.removeListener("error", onerror);\n        dest.removeListener("unpipe", onunpipe);\n        src.removeListener("end", onend);\n        src.removeListener("end", unpipe);\n        src.removeListener("data", ondata);\n        cleanedUp = true;\n        if (ondrain && state.awaitDrainWriters && (!dest._writableState || dest._writableState.needDrain)) ondrain();\n      }\n      function pause() {\n        if (!cleanedUp) {\n          if (state.pipes.length === 1 && state.pipes[0] === dest) {\n            debug("false write response, pause", 0);\n            state.awaitDrainWriters = dest;\n            state.multiAwaitDrain = false;\n          } else if (state.pipes.length > 1 && state.pipes.includes(dest)) {\n            debug("false write response, pause", state.awaitDrainWriters.size);\n            state.awaitDrainWriters.add(dest);\n          }\n          src.pause();\n        }\n        if (!ondrain) {\n          ondrain = pipeOnDrain(src, dest);\n          dest.on("drain", ondrain);\n        }\n      }\n      src.on("data", ondata);\n      function ondata(chunk) {\n        debug("ondata");\n        const ret = dest.write(chunk);\n        debug("dest.write", ret);\n        if (ret === false) {\n          pause();\n        }\n      }\n      function onerror(er) {\n        debug("onerror", er);\n        unpipe();\n        dest.removeListener("error", onerror);\n        if (dest.listenerCount("error") === 0) {\n          const s = dest._writableState || dest._readableState;\n          if (s && !s.errorEmitted) {\n            errorOrDestroy(dest, er);\n          } else {\n            dest.emit("error", er);\n          }\n        }\n      }\n      prependListener(dest, "error", onerror);\n      function onclose() {\n        dest.removeListener("finish", onfinish);\n        unpipe();\n      }\n      dest.once("close", onclose);\n      function onfinish() {\n        debug("onfinish");\n        dest.removeListener("close", onclose);\n        unpipe();\n      }\n      dest.once("finish", onfinish);\n      function unpipe() {\n        debug("unpipe");\n        src.unpipe(dest);\n      }\n      dest.emit("pipe", src);\n      if (dest.writableNeedDrain === true) {\n        pause();\n      } else if (!state.flowing) {\n        debug("pipe resume");\n        src.resume();\n      }\n      return dest;\n    };\n    function pipeOnDrain(src, dest) {\n      return function pipeOnDrainFunctionResult() {\n        const state = src._readableState;\n        if (state.awaitDrainWriters === dest) {\n          debug("pipeOnDrain", 1);\n          state.awaitDrainWriters = null;\n        } else if (state.multiAwaitDrain) {\n          debug("pipeOnDrain", state.awaitDrainWriters.size);\n          state.awaitDrainWriters.delete(dest);\n        }\n        if ((!state.awaitDrainWriters || state.awaitDrainWriters.size === 0) && src.listenerCount("data")) {\n          src.resume();\n        }\n      };\n    }\n    Readable.prototype.unpipe = function(dest) {\n      const state = this._readableState;\n      const unpipeInfo = {\n        hasUnpiped: false\n      };\n      if (state.pipes.length === 0) return this;\n      if (!dest) {\n        const dests = state.pipes;\n        state.pipes = [];\n        this.pause();\n        for (let i = 0; i < dests.length; i++)\n          dests[i].emit("unpipe", this, {\n            hasUnpiped: false\n          });\n        return this;\n      }\n      const index = ArrayPrototypeIndexOf(state.pipes, dest);\n      if (index === -1) return this;\n      state.pipes.splice(index, 1);\n      if (state.pipes.length === 0) this.pause();\n      dest.emit("unpipe", this, unpipeInfo);\n      return this;\n    };\n    Readable.prototype.on = function(ev, fn) {\n      const res = Stream.prototype.on.call(this, ev, fn);\n      const state = this._readableState;\n      if (ev === "data") {\n        state.readableListening = this.listenerCount("readable") > 0;\n        if (state.flowing !== false) this.resume();\n      } else if (ev === "readable") {\n        if (!state.endEmitted && !state.readableListening) {\n          state.readableListening = state.needReadable = true;\n          state.flowing = false;\n          state.emittedReadable = false;\n          debug("on readable", state.length, state.reading);\n          if (state.length) {\n            emitReadable(this);\n          } else if (!state.reading) {\n            process.nextTick(nReadingNextTick, this);\n          }\n        }\n      }\n      return res;\n    };\n    Readable.prototype.addListener = Readable.prototype.on;\n    Readable.prototype.removeListener = function(ev, fn) {\n      const res = Stream.prototype.removeListener.call(this, ev, fn);\n      if (ev === "readable") {\n        process.nextTick(updateReadableListening, this);\n      }\n      return res;\n    };\n    Readable.prototype.off = Readable.prototype.removeListener;\n    Readable.prototype.removeAllListeners = function(ev) {\n      const res = Stream.prototype.removeAllListeners.apply(this, arguments);\n      if (ev === "readable" || ev === void 0) {\n        process.nextTick(updateReadableListening, this);\n      }\n      return res;\n    };\n    function updateReadableListening(self) {\n      const state = self._readableState;\n      state.readableListening = self.listenerCount("readable") > 0;\n      if (state.resumeScheduled && state[kPaused] === false) {\n        state.flowing = true;\n      } else if (self.listenerCount("data") > 0) {\n        self.resume();\n      } else if (!state.readableListening) {\n        state.flowing = null;\n      }\n    }\n    function nReadingNextTick(self) {\n      debug("readable nexttick read 0");\n      self.read(0);\n    }\n    Readable.prototype.resume = function() {\n      const state = this._readableState;\n      if (!state.flowing) {\n        debug("resume");\n        state.flowing = !state.readableListening;\n        resume(this, state);\n      }\n      state[kPaused] = false;\n      return this;\n    };\n    function resume(stream, state) {\n      if (!state.resumeScheduled) {\n        state.resumeScheduled = true;\n        process.nextTick(resume_, stream, state);\n      }\n    }\n    function resume_(stream, state) {\n      debug("resume", state.reading);\n      if (!state.reading) {\n        stream.read(0);\n      }\n      state.resumeScheduled = false;\n      stream.emit("resume");\n      flow(stream);\n      if (state.flowing && !state.reading) stream.read(0);\n    }\n    Readable.prototype.pause = function() {\n      debug("call pause flowing=%j", this._readableState.flowing);\n      if (this._readableState.flowing !== false) {\n        debug("pause");\n        this._readableState.flowing = false;\n        this.emit("pause");\n      }\n      this._readableState[kPaused] = true;\n      return this;\n    };\n    function flow(stream) {\n      const state = stream._readableState;\n      debug("flow", state.flowing);\n      while (state.flowing && stream.read() !== null) ;\n    }\n    Readable.prototype.wrap = function(stream) {\n      let paused = false;\n      stream.on("data", (chunk) => {\n        if (!this.push(chunk) && stream.pause) {\n          paused = true;\n          stream.pause();\n        }\n      });\n      stream.on("end", () => {\n        this.push(null);\n      });\n      stream.on("error", (err) => {\n        errorOrDestroy(this, err);\n      });\n      stream.on("close", () => {\n        this.destroy();\n      });\n      stream.on("destroy", () => {\n        this.destroy();\n      });\n      this._read = () => {\n        if (paused && stream.resume) {\n          paused = false;\n          stream.resume();\n        }\n      };\n      const streamKeys = ObjectKeys(stream);\n      for (let j = 1; j < streamKeys.length; j++) {\n        const i = streamKeys[j];\n        if (this[i] === void 0 && typeof stream[i] === "function") {\n          this[i] = stream[i].bind(stream);\n        }\n      }\n      return this;\n    };\n    Readable.prototype[SymbolAsyncIterator] = function() {\n      return streamToAsyncIterator(this);\n    };\n    Readable.prototype.iterator = function(options) {\n      if (options !== void 0) {\n        validateObject(options, "options");\n      }\n      return streamToAsyncIterator(this, options);\n    };\n    function streamToAsyncIterator(stream, options) {\n      if (typeof stream.read !== "function") {\n        stream = Readable.wrap(stream, {\n          objectMode: true\n        });\n      }\n      const iter = createAsyncIterator(stream, options);\n      iter.stream = stream;\n      return iter;\n    }\n    async function* createAsyncIterator(stream, options) {\n      let callback = nop;\n      function next(resolve) {\n        if (this === stream) {\n          callback();\n          callback = nop;\n        } else {\n          callback = resolve;\n        }\n      }\n      stream.on("readable", next);\n      let error;\n      const cleanup = eos(\n        stream,\n        {\n          writable: false\n        },\n        (err) => {\n          error = err ? aggregateTwoErrors(error, err) : null;\n          callback();\n          callback = nop;\n        }\n      );\n      try {\n        while (true) {\n          const chunk = stream.destroyed ? null : stream.read();\n          if (chunk !== null) {\n            yield chunk;\n          } else if (error) {\n            throw error;\n          } else if (error === null) {\n            return;\n          } else {\n            await new Promise2(next);\n          }\n        }\n      } catch (err) {\n        error = aggregateTwoErrors(error, err);\n        throw error;\n      } finally {\n        if ((error || (options === null || options === void 0 ? void 0 : options.destroyOnReturn) !== false) && (error === void 0 || stream._readableState.autoDestroy)) {\n          destroyImpl.destroyer(stream, null);\n        } else {\n          stream.off("readable", next);\n          cleanup();\n        }\n      }\n    }\n    ObjectDefineProperties(Readable.prototype, {\n      readable: {\n        __proto__: null,\n        get() {\n          const r = this._readableState;\n          return !!r && r.readable !== false && !r.destroyed && !r.errorEmitted && !r.endEmitted;\n        },\n        set(val) {\n          if (this._readableState) {\n            this._readableState.readable = !!val;\n          }\n        }\n      },\n      readableDidRead: {\n        __proto__: null,\n        enumerable: false,\n        get: function() {\n          return this._readableState.dataEmitted;\n        }\n      },\n      readableAborted: {\n        __proto__: null,\n        enumerable: false,\n        get: function() {\n          return !!(this._readableState.readable !== false && (this._readableState.destroyed || this._readableState.errored) && !this._readableState.endEmitted);\n        }\n      },\n      readableHighWaterMark: {\n        __proto__: null,\n        enumerable: false,\n        get: function() {\n          return this._readableState.highWaterMark;\n        }\n      },\n      readableBuffer: {\n        __proto__: null,\n        enumerable: false,\n        get: function() {\n          return this._readableState && this._readableState.buffer;\n        }\n      },\n      readableFlowing: {\n        __proto__: null,\n        enumerable: false,\n        get: function() {\n          return this._readableState.flowing;\n        },\n        set: function(state) {\n          if (this._readableState) {\n            this._readableState.flowing = state;\n          }\n        }\n      },\n      readableLength: {\n        __proto__: null,\n        enumerable: false,\n        get() {\n          return this._readableState.length;\n        }\n      },\n      readableObjectMode: {\n        __proto__: null,\n        enumerable: false,\n        get() {\n          return this._readableState ? this._readableState.objectMode : false;\n        }\n      },\n      readableEncoding: {\n        __proto__: null,\n        enumerable: false,\n        get() {\n          return this._readableState ? this._readableState.encoding : null;\n        }\n      },\n      errored: {\n        __proto__: null,\n        enumerable: false,\n        get() {\n          return this._readableState ? this._readableState.errored : null;\n        }\n      },\n      closed: {\n        __proto__: null,\n        get() {\n          return this._readableState ? this._readableState.closed : false;\n        }\n      },\n      destroyed: {\n        __proto__: null,\n        enumerable: false,\n        get() {\n          return this._readableState ? this._readableState.destroyed : false;\n        },\n        set(value) {\n          if (!this._readableState) {\n            return;\n          }\n          this._readableState.destroyed = value;\n        }\n      },\n      readableEnded: {\n        __proto__: null,\n        enumerable: false,\n        get() {\n          return this._readableState ? this._readableState.endEmitted : false;\n        }\n      }\n    });\n    ObjectDefineProperties(ReadableState.prototype, {\n      // Legacy getter for `pipesCount`.\n      pipesCount: {\n        __proto__: null,\n        get() {\n          return this.pipes.length;\n        }\n      },\n      // Legacy property for `paused`.\n      paused: {\n        __proto__: null,\n        get() {\n          return this[kPaused] !== false;\n        },\n        set(value) {\n          this[kPaused] = !!value;\n        }\n      }\n    });\n    Readable._fromList = fromList;\n    function fromList(n, state) {\n      if (state.length === 0) return null;\n      let ret;\n      if (state.objectMode) ret = state.buffer.shift();\n      else if (!n || n >= state.length) {\n        if (state.decoder) ret = state.buffer.join("");\n        else if (state.buffer.length === 1) ret = state.buffer.first();\n        else ret = state.buffer.concat(state.length);\n        state.buffer.clear();\n      } else {\n        ret = state.buffer.consume(n, state.decoder);\n      }\n      return ret;\n    }\n    function endReadable(stream) {\n      const state = stream._readableState;\n      debug("endReadable", state.endEmitted);\n      if (!state.endEmitted) {\n        state.ended = true;\n        process.nextTick(endReadableNT, state, stream);\n      }\n    }\n    function endReadableNT(state, stream) {\n      debug("endReadableNT", state.endEmitted, state.length);\n      if (!state.errored && !state.closeEmitted && !state.endEmitted && state.length === 0) {\n        state.endEmitted = true;\n        stream.emit("end");\n        if (stream.writable && stream.allowHalfOpen === false) {\n          process.nextTick(endWritableNT, stream);\n        } else if (state.autoDestroy) {\n          const wState = stream._writableState;\n          const autoDestroy = !wState || wState.autoDestroy && // We don\'t expect the writable to ever \'finish\'\n          // if writable is explicitly set to false.\n          (wState.finished || wState.writable === false);\n          if (autoDestroy) {\n            stream.destroy();\n          }\n        }\n      }\n    }\n    function endWritableNT(stream) {\n      const writable = stream.writable && !stream.writableEnded && !stream.destroyed;\n      if (writable) {\n        stream.end();\n      }\n    }\n    Readable.from = function(iterable, opts) {\n      return from(Readable, iterable, opts);\n    };\n    var webStreamsAdapters;\n    function lazyWebStreams() {\n      if (webStreamsAdapters === void 0) webStreamsAdapters = {};\n      return webStreamsAdapters;\n    }\n    Readable.fromWeb = function(readableStream, options) {\n      return lazyWebStreams().newStreamReadableFromReadableStream(readableStream, options);\n    };\n    Readable.toWeb = function(streamReadable, options) {\n      return lazyWebStreams().newReadableStreamFromStreamReadable(streamReadable, options);\n    };\n    Readable.wrap = function(src, options) {\n      var _ref, _src$readableObjectMo;\n      return new Readable({\n        objectMode: (_ref = (_src$readableObjectMo = src.readableObjectMode) !== null && _src$readableObjectMo !== void 0 ? _src$readableObjectMo : src.objectMode) !== null && _ref !== void 0 ? _ref : true,\n        ...options,\n        destroy(err, callback) {\n          destroyImpl.destroyer(src, err);\n          callback(err);\n        }\n      }).wrap(src);\n    };\n  }\n});\n\n// node_modules/readable-stream/lib/internal/streams/writable.js\nvar require_writable = __commonJS({\n  "node_modules/readable-stream/lib/internal/streams/writable.js"(exports2, module2) {\n    "use strict";\n    var process = require_process2();\n    var {\n      ArrayPrototypeSlice,\n      Error: Error2,\n      FunctionPrototypeSymbolHasInstance,\n      ObjectDefineProperty,\n      ObjectDefineProperties,\n      ObjectSetPrototypeOf,\n      StringPrototypeToLowerCase,\n      Symbol: Symbol2,\n      SymbolHasInstance\n    } = require_primordials();\n    module2.exports = Writable;\n    Writable.WritableState = WritableState;\n    var { EventEmitter: EE } = require_events();\n    var Stream = require_legacy().Stream;\n    var { Buffer: Buffer2 } = require_buffer();\n    var destroyImpl = require_destroy();\n    var { addAbortSignal } = require_add_abort_signal();\n    var { getHighWaterMark, getDefaultHighWaterMark } = require_state();\n    var {\n      ERR_INVALID_ARG_TYPE,\n      ERR_METHOD_NOT_IMPLEMENTED,\n      ERR_MULTIPLE_CALLBACK,\n      ERR_STREAM_CANNOT_PIPE,\n      ERR_STREAM_DESTROYED,\n      ERR_STREAM_ALREADY_FINISHED,\n      ERR_STREAM_NULL_VALUES,\n      ERR_STREAM_WRITE_AFTER_END,\n      ERR_UNKNOWN_ENCODING\n    } = require_errors().codes;\n    var { errorOrDestroy } = destroyImpl;\n    ObjectSetPrototypeOf(Writable.prototype, Stream.prototype);\n    ObjectSetPrototypeOf(Writable, Stream);\n    function nop() {\n    }\n    var kOnFinished = Symbol2("kOnFinished");\n    function WritableState(options, stream, isDuplex) {\n      if (typeof isDuplex !== "boolean") isDuplex = stream instanceof require_duplex();\n      this.objectMode = !!(options && options.objectMode);\n      if (isDuplex) this.objectMode = this.objectMode || !!(options && options.writableObjectMode);\n      this.highWaterMark = options ? getHighWaterMark(this, options, "writableHighWaterMark", isDuplex) : getDefaultHighWaterMark(false);\n      this.finalCalled = false;\n      this.needDrain = false;\n      this.ending = false;\n      this.ended = false;\n      this.finished = false;\n      this.destroyed = false;\n      const noDecode = !!(options && options.decodeStrings === false);\n      this.decodeStrings = !noDecode;\n      this.defaultEncoding = options && options.defaultEncoding || "utf8";\n      this.length = 0;\n      this.writing = false;\n      this.corked = 0;\n      this.sync = true;\n      this.bufferProcessing = false;\n      this.onwrite = onwrite.bind(void 0, stream);\n      this.writecb = null;\n      this.writelen = 0;\n      this.afterWriteTickInfo = null;\n      resetBuffer(this);\n      this.pendingcb = 0;\n      this.constructed = true;\n      this.prefinished = false;\n      this.errorEmitted = false;\n      this.emitClose = !options || options.emitClose !== false;\n      this.autoDestroy = !options || options.autoDestroy !== false;\n      this.errored = null;\n      this.closed = false;\n      this.closeEmitted = false;\n      this[kOnFinished] = [];\n    }\n    function resetBuffer(state) {\n      state.buffered = [];\n      state.bufferedIndex = 0;\n      state.allBuffers = true;\n      state.allNoop = true;\n    }\n    WritableState.prototype.getBuffer = function getBuffer() {\n      return ArrayPrototypeSlice(this.buffered, this.bufferedIndex);\n    };\n    ObjectDefineProperty(WritableState.prototype, "bufferedRequestCount", {\n      __proto__: null,\n      get() {\n        return this.buffered.length - this.bufferedIndex;\n      }\n    });\n    function Writable(options) {\n      const isDuplex = this instanceof require_duplex();\n      if (!isDuplex && !FunctionPrototypeSymbolHasInstance(Writable, this)) return new Writable(options);\n      this._writableState = new WritableState(options, this, isDuplex);\n      if (options) {\n        if (typeof options.write === "function") this._write = options.write;\n        if (typeof options.writev === "function") this._writev = options.writev;\n        if (typeof options.destroy === "function") this._destroy = options.destroy;\n        if (typeof options.final === "function") this._final = options.final;\n        if (typeof options.construct === "function") this._construct = options.construct;\n        if (options.signal) addAbortSignal(options.signal, this);\n      }\n      Stream.call(this, options);\n      destroyImpl.construct(this, () => {\n        const state = this._writableState;\n        if (!state.writing) {\n          clearBuffer(this, state);\n        }\n        finishMaybe(this, state);\n      });\n    }\n    ObjectDefineProperty(Writable, SymbolHasInstance, {\n      __proto__: null,\n      value: function(object) {\n        if (FunctionPrototypeSymbolHasInstance(this, object)) return true;\n        if (this !== Writable) return false;\n        return object && object._writableState instanceof WritableState;\n      }\n    });\n    Writable.prototype.pipe = function() {\n      errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE());\n    };\n    function _write(stream, chunk, encoding, cb) {\n      const state = stream._writableState;\n      if (typeof encoding === "function") {\n        cb = encoding;\n        encoding = state.defaultEncoding;\n      } else {\n        if (!encoding) encoding = state.defaultEncoding;\n        else if (encoding !== "buffer" && !Buffer2.isEncoding(encoding)) throw new ERR_UNKNOWN_ENCODING(encoding);\n        if (typeof cb !== "function") cb = nop;\n      }\n      if (chunk === null) {\n        throw new ERR_STREAM_NULL_VALUES();\n      } else if (!state.objectMode) {\n        if (typeof chunk === "string") {\n          if (state.decodeStrings !== false) {\n            chunk = Buffer2.from(chunk, encoding);\n            encoding = "buffer";\n          }\n        } else if (chunk instanceof Buffer2) {\n          encoding = "buffer";\n        } else if (Stream._isUint8Array(chunk)) {\n          chunk = Stream._uint8ArrayToBuffer(chunk);\n          encoding = "buffer";\n        } else {\n          throw new ERR_INVALID_ARG_TYPE("chunk", ["string", "Buffer", "Uint8Array"], chunk);\n        }\n      }\n      let err;\n      if (state.ending) {\n        err = new ERR_STREAM_WRITE_AFTER_END();\n      } else if (state.destroyed) {\n        err = new ERR_STREAM_DESTROYED("write");\n      }\n      if (err) {\n        process.nextTick(cb, err);\n        errorOrDestroy(stream, err, true);\n        return err;\n      }\n      state.pendingcb++;\n      return writeOrBuffer(stream, state, chunk, encoding, cb);\n    }\n    Writable.prototype.write = function(chunk, encoding, cb) {\n      return _write(this, chunk, encoding, cb) === true;\n    };\n    Writable.prototype.cork = function() {\n      this._writableState.corked++;\n    };\n    Writable.prototype.uncork = function() {\n      const state = this._writableState;\n      if (state.corked) {\n        state.corked--;\n        if (!state.writing) clearBuffer(this, state);\n      }\n    };\n    Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {\n      if (typeof encoding === "string") encoding = StringPrototypeToLowerCase(encoding);\n      if (!Buffer2.isEncoding(encoding)) throw new ERR_UNKNOWN_ENCODING(encoding);\n      this._writableState.defaultEncoding = encoding;\n      return this;\n    };\n    function writeOrBuffer(stream, state, chunk, encoding, callback) {\n      const len = state.objectMode ? 1 : chunk.length;\n      state.length += len;\n      const ret = state.length < state.highWaterMark;\n      if (!ret) state.needDrain = true;\n      if (state.writing || state.corked || state.errored || !state.constructed) {\n        state.buffered.push({\n          chunk,\n          encoding,\n          callback\n        });\n        if (state.allBuffers && encoding !== "buffer") {\n          state.allBuffers = false;\n        }\n        if (state.allNoop && callback !== nop) {\n          state.allNoop = false;\n        }\n      } else {\n        state.writelen = len;\n        state.writecb = callback;\n        state.writing = true;\n        state.sync = true;\n        stream._write(chunk, encoding, state.onwrite);\n        state.sync = false;\n      }\n      return ret && !state.errored && !state.destroyed;\n    }\n    function doWrite(stream, state, writev, len, chunk, encoding, cb) {\n      state.writelen = len;\n      state.writecb = cb;\n      state.writing = true;\n      state.sync = true;\n      if (state.destroyed) state.onwrite(new ERR_STREAM_DESTROYED("write"));\n      else if (writev) stream._writev(chunk, state.onwrite);\n      else stream._write(chunk, encoding, state.onwrite);\n      state.sync = false;\n    }\n    function onwriteError(stream, state, er, cb) {\n      --state.pendingcb;\n      cb(er);\n      errorBuffer(state);\n      errorOrDestroy(stream, er);\n    }\n    function onwrite(stream, er) {\n      const state = stream._writableState;\n      const sync = state.sync;\n      const cb = state.writecb;\n      if (typeof cb !== "function") {\n        errorOrDestroy(stream, new ERR_MULTIPLE_CALLBACK());\n        return;\n      }\n      state.writing = false;\n      state.writecb = null;\n      state.length -= state.writelen;\n      state.writelen = 0;\n      if (er) {\n        er.stack;\n        if (!state.errored) {\n          state.errored = er;\n        }\n        if (stream._readableState && !stream._readableState.errored) {\n          stream._readableState.errored = er;\n        }\n        if (sync) {\n          process.nextTick(onwriteError, stream, state, er, cb);\n        } else {\n          onwriteError(stream, state, er, cb);\n        }\n      } else {\n        if (state.buffered.length > state.bufferedIndex) {\n          clearBuffer(stream, state);\n        }\n        if (sync) {\n          if (state.afterWriteTickInfo !== null && state.afterWriteTickInfo.cb === cb) {\n            state.afterWriteTickInfo.count++;\n          } else {\n            state.afterWriteTickInfo = {\n              count: 1,\n              cb,\n              stream,\n              state\n            };\n            process.nextTick(afterWriteTick, state.afterWriteTickInfo);\n          }\n        } else {\n          afterWrite(stream, state, 1, cb);\n        }\n      }\n    }\n    function afterWriteTick({ stream, state, count, cb }) {\n      state.afterWriteTickInfo = null;\n      return afterWrite(stream, state, count, cb);\n    }\n    function afterWrite(stream, state, count, cb) {\n      const needDrain = !state.ending && !stream.destroyed && state.length === 0 && state.needDrain;\n      if (needDrain) {\n        state.needDrain = false;\n        stream.emit("drain");\n      }\n      while (count-- > 0) {\n        state.pendingcb--;\n        cb();\n      }\n      if (state.destroyed) {\n        errorBuffer(state);\n      }\n      finishMaybe(stream, state);\n    }\n    function errorBuffer(state) {\n      if (state.writing) {\n        return;\n      }\n      for (let n = state.bufferedIndex; n < state.buffered.length; ++n) {\n        var _state$errored;\n        const { chunk, callback } = state.buffered[n];\n        const len = state.objectMode ? 1 : chunk.length;\n        state.length -= len;\n        callback(\n          (_state$errored = state.errored) !== null && _state$errored !== void 0 ? _state$errored : new ERR_STREAM_DESTROYED("write")\n        );\n      }\n      const onfinishCallbacks = state[kOnFinished].splice(0);\n      for (let i = 0; i < onfinishCallbacks.length; i++) {\n        var _state$errored2;\n        onfinishCallbacks[i](\n          (_state$errored2 = state.errored) !== null && _state$errored2 !== void 0 ? _state$errored2 : new ERR_STREAM_DESTROYED("end")\n        );\n      }\n      resetBuffer(state);\n    }\n    function clearBuffer(stream, state) {\n      if (state.corked || state.bufferProcessing || state.destroyed || !state.constructed) {\n        return;\n      }\n      const { buffered, bufferedIndex, objectMode } = state;\n      const bufferedLength = buffered.length - bufferedIndex;\n      if (!bufferedLength) {\n        return;\n      }\n      let i = bufferedIndex;\n      state.bufferProcessing = true;\n      if (bufferedLength > 1 && stream._writev) {\n        state.pendingcb -= bufferedLength - 1;\n        const callback = state.allNoop ? nop : (err) => {\n          for (let n = i; n < buffered.length; ++n) {\n            buffered[n].callback(err);\n          }\n        };\n        const chunks = state.allNoop && i === 0 ? buffered : ArrayPrototypeSlice(buffered, i);\n        chunks.allBuffers = state.allBuffers;\n        doWrite(stream, state, true, state.length, chunks, "", callback);\n        resetBuffer(state);\n      } else {\n        do {\n          const { chunk, encoding, callback } = buffered[i];\n          buffered[i++] = null;\n          const len = objectMode ? 1 : chunk.length;\n          doWrite(stream, state, false, len, chunk, encoding, callback);\n        } while (i < buffered.length && !state.writing);\n        if (i === buffered.length) {\n          resetBuffer(state);\n        } else if (i > 256) {\n          buffered.splice(0, i);\n          state.bufferedIndex = 0;\n        } else {\n          state.bufferedIndex = i;\n        }\n      }\n      state.bufferProcessing = false;\n    }\n    Writable.prototype._write = function(chunk, encoding, cb) {\n      if (this._writev) {\n        this._writev(\n          [\n            {\n              chunk,\n              encoding\n            }\n          ],\n          cb\n        );\n      } else {\n        throw new ERR_METHOD_NOT_IMPLEMENTED("_write()");\n      }\n    };\n    Writable.prototype._writev = null;\n    Writable.prototype.end = function(chunk, encoding, cb) {\n      const state = this._writableState;\n      if (typeof chunk === "function") {\n        cb = chunk;\n        chunk = null;\n        encoding = null;\n      } else if (typeof encoding === "function") {\n        cb = encoding;\n        encoding = null;\n      }\n      let err;\n      if (chunk !== null && chunk !== void 0) {\n        const ret = _write(this, chunk, encoding);\n        if (ret instanceof Error2) {\n          err = ret;\n        }\n      }\n      if (state.corked) {\n        state.corked = 1;\n        this.uncork();\n      }\n      if (err) {\n      } else if (!state.errored && !state.ending) {\n        state.ending = true;\n        finishMaybe(this, state, true);\n        state.ended = true;\n      } else if (state.finished) {\n        err = new ERR_STREAM_ALREADY_FINISHED("end");\n      } else if (state.destroyed) {\n        err = new ERR_STREAM_DESTROYED("end");\n      }\n      if (typeof cb === "function") {\n        if (err || state.finished) {\n          process.nextTick(cb, err);\n        } else {\n          state[kOnFinished].push(cb);\n        }\n      }\n      return this;\n    };\n    function needFinish(state) {\n      return state.ending && !state.destroyed && state.constructed && state.length === 0 && !state.errored && state.buffered.length === 0 && !state.finished && !state.writing && !state.errorEmitted && !state.closeEmitted;\n    }\n    function callFinal(stream, state) {\n      let called = false;\n      function onFinish(err) {\n        if (called) {\n          errorOrDestroy(stream, err !== null && err !== void 0 ? err : ERR_MULTIPLE_CALLBACK());\n          return;\n        }\n        called = true;\n        state.pendingcb--;\n        if (err) {\n          const onfinishCallbacks = state[kOnFinished].splice(0);\n          for (let i = 0; i < onfinishCallbacks.length; i++) {\n            onfinishCallbacks[i](err);\n          }\n          errorOrDestroy(stream, err, state.sync);\n        } else if (needFinish(state)) {\n          state.prefinished = true;\n          stream.emit("prefinish");\n          state.pendingcb++;\n          process.nextTick(finish, stream, state);\n        }\n      }\n      state.sync = true;\n      state.pendingcb++;\n      try {\n        stream._final(onFinish);\n      } catch (err) {\n        onFinish(err);\n      }\n      state.sync = false;\n    }\n    function prefinish(stream, state) {\n      if (!state.prefinished && !state.finalCalled) {\n        if (typeof stream._final === "function" && !state.destroyed) {\n          state.finalCalled = true;\n          callFinal(stream, state);\n        } else {\n          state.prefinished = true;\n          stream.emit("prefinish");\n        }\n      }\n    }\n    function finishMaybe(stream, state, sync) {\n      if (needFinish(state)) {\n        prefinish(stream, state);\n        if (state.pendingcb === 0) {\n          if (sync) {\n            state.pendingcb++;\n            process.nextTick(\n              (stream2, state2) => {\n                if (needFinish(state2)) {\n                  finish(stream2, state2);\n                } else {\n                  state2.pendingcb--;\n                }\n              },\n              stream,\n              state\n            );\n          } else if (needFinish(state)) {\n            state.pendingcb++;\n            finish(stream, state);\n          }\n        }\n      }\n    }\n    function finish(stream, state) {\n      state.pendingcb--;\n      state.finished = true;\n      const onfinishCallbacks = state[kOnFinished].splice(0);\n      for (let i = 0; i < onfinishCallbacks.length; i++) {\n        onfinishCallbacks[i]();\n      }\n      stream.emit("finish");\n      if (state.autoDestroy) {\n        const rState = stream._readableState;\n        const autoDestroy = !rState || rState.autoDestroy && // We don\'t expect the readable to ever \'end\'\n        // if readable is explicitly set to false.\n        (rState.endEmitted || rState.readable === false);\n        if (autoDestroy) {\n          stream.destroy();\n        }\n      }\n    }\n    ObjectDefineProperties(Writable.prototype, {\n      closed: {\n        __proto__: null,\n        get() {\n          return this._writableState ? this._writableState.closed : false;\n        }\n      },\n      destroyed: {\n        __proto__: null,\n        get() {\n          return this._writableState ? this._writableState.destroyed : false;\n        },\n        set(value) {\n          if (this._writableState) {\n            this._writableState.destroyed = value;\n          }\n        }\n      },\n      writable: {\n        __proto__: null,\n        get() {\n          const w = this._writableState;\n          return !!w && w.writable !== false && !w.destroyed && !w.errored && !w.ending && !w.ended;\n        },\n        set(val) {\n          if (this._writableState) {\n            this._writableState.writable = !!val;\n          }\n        }\n      },\n      writableFinished: {\n        __proto__: null,\n        get() {\n          return this._writableState ? this._writableState.finished : false;\n        }\n      },\n      writableObjectMode: {\n        __proto__: null,\n        get() {\n          return this._writableState ? this._writableState.objectMode : false;\n        }\n      },\n      writableBuffer: {\n        __proto__: null,\n        get() {\n          return this._writableState && this._writableState.getBuffer();\n        }\n      },\n      writableEnded: {\n        __proto__: null,\n        get() {\n          return this._writableState ? this._writableState.ending : false;\n        }\n      },\n      writableNeedDrain: {\n        __proto__: null,\n        get() {\n          const wState = this._writableState;\n          if (!wState) return false;\n          return !wState.destroyed && !wState.ending && wState.needDrain;\n        }\n      },\n      writableHighWaterMark: {\n        __proto__: null,\n        get() {\n          return this._writableState && this._writableState.highWaterMark;\n        }\n      },\n      writableCorked: {\n        __proto__: null,\n        get() {\n          return this._writableState ? this._writableState.corked : 0;\n        }\n      },\n      writableLength: {\n        __proto__: null,\n        get() {\n          return this._writableState && this._writableState.length;\n        }\n      },\n      errored: {\n        __proto__: null,\n        enumerable: false,\n        get() {\n          return this._writableState ? this._writableState.errored : null;\n        }\n      },\n      writableAborted: {\n        __proto__: null,\n        enumerable: false,\n        get: function() {\n          return !!(this._writableState.writable !== false && (this._writableState.destroyed || this._writableState.errored) && !this._writableState.finished);\n        }\n      }\n    });\n    var destroy = destroyImpl.destroy;\n    Writable.prototype.destroy = function(err, cb) {\n      const state = this._writableState;\n      if (!state.destroyed && (state.bufferedIndex < state.buffered.length || state[kOnFinished].length)) {\n        process.nextTick(errorBuffer, state);\n      }\n      destroy.call(this, err, cb);\n      return this;\n    };\n    Writable.prototype._undestroy = destroyImpl.undestroy;\n    Writable.prototype._destroy = function(err, cb) {\n      cb(err);\n    };\n    Writable.prototype[EE.captureRejectionSymbol] = function(err) {\n      this.destroy(err);\n    };\n    var webStreamsAdapters;\n    function lazyWebStreams() {\n      if (webStreamsAdapters === void 0) webStreamsAdapters = {};\n      return webStreamsAdapters;\n    }\n    Writable.fromWeb = function(writableStream, options) {\n      return lazyWebStreams().newStreamWritableFromWritableStream(writableStream, options);\n    };\n    Writable.toWeb = function(streamWritable) {\n      return lazyWebStreams().newWritableStreamFromStreamWritable(streamWritable);\n    };\n  }\n});\n\n// node_modules/readable-stream/lib/internal/streams/duplexify.js\nvar require_duplexify = __commonJS({\n  "node_modules/readable-stream/lib/internal/streams/duplexify.js"(exports2, module2) {\n    var process = require_process2();\n    var bufferModule = require_buffer();\n    var {\n      isReadable,\n      isWritable,\n      isIterable,\n      isNodeStream,\n      isReadableNodeStream,\n      isWritableNodeStream,\n      isDuplexNodeStream,\n      isReadableStream,\n      isWritableStream\n    } = require_utils();\n    var eos = require_end_of_stream();\n    var {\n      AbortError,\n      codes: { ERR_INVALID_ARG_TYPE, ERR_INVALID_RETURN_VALUE }\n    } = require_errors();\n    var { destroyer } = require_destroy();\n    var Duplex = require_duplex();\n    var Readable = require_readable();\n    var Writable = require_writable();\n    var { createDeferredPromise } = require_util();\n    var from = require_from();\n    var Blob = globalThis.Blob || bufferModule.Blob;\n    var isBlob = typeof Blob !== "undefined" ? function isBlob2(b) {\n      return b instanceof Blob;\n    } : function isBlob2(b) {\n      return false;\n    };\n    var AbortController = globalThis.AbortController || require_abort_controller().AbortController;\n    var { FunctionPrototypeCall } = require_primordials();\n    var Duplexify = class extends Duplex {\n      constructor(options) {\n        super(options);\n        if ((options === null || options === void 0 ? void 0 : options.readable) === false) {\n          this._readableState.readable = false;\n          this._readableState.ended = true;\n          this._readableState.endEmitted = true;\n        }\n        if ((options === null || options === void 0 ? void 0 : options.writable) === false) {\n          this._writableState.writable = false;\n          this._writableState.ending = true;\n          this._writableState.ended = true;\n          this._writableState.finished = true;\n        }\n      }\n    };\n    module2.exports = function duplexify(body, name) {\n      if (isDuplexNodeStream(body)) {\n        return body;\n      }\n      if (isReadableNodeStream(body)) {\n        return _duplexify({\n          readable: body\n        });\n      }\n      if (isWritableNodeStream(body)) {\n        return _duplexify({\n          writable: body\n        });\n      }\n      if (isNodeStream(body)) {\n        return _duplexify({\n          writable: false,\n          readable: false\n        });\n      }\n      if (isReadableStream(body)) {\n        return _duplexify({\n          readable: Readable.fromWeb(body)\n        });\n      }\n      if (isWritableStream(body)) {\n        return _duplexify({\n          writable: Writable.fromWeb(body)\n        });\n      }\n      if (typeof body === "function") {\n        const { value, write, final, destroy } = fromAsyncGen(body);\n        if (isIterable(value)) {\n          return from(Duplexify, value, {\n            // TODO (ronag): highWaterMark?\n            objectMode: true,\n            write,\n            final,\n            destroy\n          });\n        }\n        const then2 = value === null || value === void 0 ? void 0 : value.then;\n        if (typeof then2 === "function") {\n          let d;\n          const promise = FunctionPrototypeCall(\n            then2,\n            value,\n            (val) => {\n              if (val != null) {\n                throw new ERR_INVALID_RETURN_VALUE("nully", "body", val);\n              }\n            },\n            (err) => {\n              destroyer(d, err);\n            }\n          );\n          return d = new Duplexify({\n            // TODO (ronag): highWaterMark?\n            objectMode: true,\n            readable: false,\n            write,\n            final(cb) {\n              final(async () => {\n                try {\n                  await promise;\n                  process.nextTick(cb, null);\n                } catch (err) {\n                  process.nextTick(cb, err);\n                }\n              });\n            },\n            destroy\n          });\n        }\n        throw new ERR_INVALID_RETURN_VALUE("Iterable, AsyncIterable or AsyncFunction", name, value);\n      }\n      if (isBlob(body)) {\n        return duplexify(body.arrayBuffer());\n      }\n      if (isIterable(body)) {\n        return from(Duplexify, body, {\n          // TODO (ronag): highWaterMark?\n          objectMode: true,\n          writable: false\n        });\n      }\n      if (isReadableStream(body === null || body === void 0 ? void 0 : body.readable) && isWritableStream(body === null || body === void 0 ? void 0 : body.writable)) {\n        return Duplexify.fromWeb(body);\n      }\n      if (typeof (body === null || body === void 0 ? void 0 : body.writable) === "object" || typeof (body === null || body === void 0 ? void 0 : body.readable) === "object") {\n        const readable = body !== null && body !== void 0 && body.readable ? isReadableNodeStream(body === null || body === void 0 ? void 0 : body.readable) ? body === null || body === void 0 ? void 0 : body.readable : duplexify(body.readable) : void 0;\n        const writable = body !== null && body !== void 0 && body.writable ? isWritableNodeStream(body === null || body === void 0 ? void 0 : body.writable) ? body === null || body === void 0 ? void 0 : body.writable : duplexify(body.writable) : void 0;\n        return _duplexify({\n          readable,\n          writable\n        });\n      }\n      const then = body === null || body === void 0 ? void 0 : body.then;\n      if (typeof then === "function") {\n        let d;\n        FunctionPrototypeCall(\n          then,\n          body,\n          (val) => {\n            if (val != null) {\n              d.push(val);\n            }\n            d.push(null);\n          },\n          (err) => {\n            destroyer(d, err);\n          }\n        );\n        return d = new Duplexify({\n          objectMode: true,\n          writable: false,\n          read() {\n          }\n        });\n      }\n      throw new ERR_INVALID_ARG_TYPE(\n        name,\n        [\n          "Blob",\n          "ReadableStream",\n          "WritableStream",\n          "Stream",\n          "Iterable",\n          "AsyncIterable",\n          "Function",\n          "{ readable, writable } pair",\n          "Promise"\n        ],\n        body\n      );\n    };\n    function fromAsyncGen(fn) {\n      let { promise, resolve } = createDeferredPromise();\n      const ac = new AbortController();\n      const signal = ac.signal;\n      const value = fn(\n        (async function* () {\n          while (true) {\n            const _promise = promise;\n            promise = null;\n            const { chunk, done, cb } = await _promise;\n            process.nextTick(cb);\n            if (done) return;\n            if (signal.aborted)\n              throw new AbortError(void 0, {\n                cause: signal.reason\n              });\n            ({ promise, resolve } = createDeferredPromise());\n            yield chunk;\n          }\n        })(),\n        {\n          signal\n        }\n      );\n      return {\n        value,\n        write(chunk, encoding, cb) {\n          const _resolve = resolve;\n          resolve = null;\n          _resolve({\n            chunk,\n            done: false,\n            cb\n          });\n        },\n        final(cb) {\n          const _resolve = resolve;\n          resolve = null;\n          _resolve({\n            done: true,\n            cb\n          });\n        },\n        destroy(err, cb) {\n          ac.abort();\n          cb(err);\n        }\n      };\n    }\n    function _duplexify(pair) {\n      const r = pair.readable && typeof pair.readable.read !== "function" ? Readable.wrap(pair.readable) : pair.readable;\n      const w = pair.writable;\n      let readable = !!isReadable(r);\n      let writable = !!isWritable(w);\n      let ondrain;\n      let onfinish;\n      let onreadable;\n      let onclose;\n      let d;\n      function onfinished(err) {\n        const cb = onclose;\n        onclose = null;\n        if (cb) {\n          cb(err);\n        } else if (err) {\n          d.destroy(err);\n        }\n      }\n      d = new Duplexify({\n        // TODO (ronag): highWaterMark?\n        readableObjectMode: !!(r !== null && r !== void 0 && r.readableObjectMode),\n        writableObjectMode: !!(w !== null && w !== void 0 && w.writableObjectMode),\n        readable,\n        writable\n      });\n      if (writable) {\n        eos(w, (err) => {\n          writable = false;\n          if (err) {\n            destroyer(r, err);\n          }\n          onfinished(err);\n        });\n        d._write = function(chunk, encoding, callback) {\n          if (w.write(chunk, encoding)) {\n            callback();\n          } else {\n            ondrain = callback;\n          }\n        };\n        d._final = function(callback) {\n          w.end();\n          onfinish = callback;\n        };\n        w.on("drain", function() {\n          if (ondrain) {\n            const cb = ondrain;\n            ondrain = null;\n            cb();\n          }\n        });\n        w.on("finish", function() {\n          if (onfinish) {\n            const cb = onfinish;\n            onfinish = null;\n            cb();\n          }\n        });\n      }\n      if (readable) {\n        eos(r, (err) => {\n          readable = false;\n          if (err) {\n            destroyer(r, err);\n          }\n          onfinished(err);\n        });\n        r.on("readable", function() {\n          if (onreadable) {\n            const cb = onreadable;\n            onreadable = null;\n            cb();\n          }\n        });\n        r.on("end", function() {\n          d.push(null);\n        });\n        d._read = function() {\n          while (true) {\n            const buf = r.read();\n            if (buf === null) {\n              onreadable = d._read;\n              return;\n            }\n            if (!d.push(buf)) {\n              return;\n            }\n          }\n        };\n      }\n      d._destroy = function(err, callback) {\n        if (!err && onclose !== null) {\n          err = new AbortError();\n        }\n        onreadable = null;\n        ondrain = null;\n        onfinish = null;\n        if (onclose === null) {\n          callback(err);\n        } else {\n          onclose = callback;\n          destroyer(w, err);\n          destroyer(r, err);\n        }\n      };\n      return d;\n    }\n  }\n});\n\n// node_modules/readable-stream/lib/internal/streams/duplex.js\nvar require_duplex = __commonJS({\n  "node_modules/readable-stream/lib/internal/streams/duplex.js"(exports2, module2) {\n    "use strict";\n    var {\n      ObjectDefineProperties,\n      ObjectGetOwnPropertyDescriptor,\n      ObjectKeys,\n      ObjectSetPrototypeOf\n    } = require_primordials();\n    module2.exports = Duplex;\n    var Readable = require_readable();\n    var Writable = require_writable();\n    ObjectSetPrototypeOf(Duplex.prototype, Readable.prototype);\n    ObjectSetPrototypeOf(Duplex, Readable);\n    {\n      const keys = ObjectKeys(Writable.prototype);\n      for (let i = 0; i < keys.length; i++) {\n        const method = keys[i];\n        if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];\n      }\n    }\n    function Duplex(options) {\n      if (!(this instanceof Duplex)) return new Duplex(options);\n      Readable.call(this, options);\n      Writable.call(this, options);\n      if (options) {\n        this.allowHalfOpen = options.allowHalfOpen !== false;\n        if (options.readable === false) {\n          this._readableState.readable = false;\n          this._readableState.ended = true;\n          this._readableState.endEmitted = true;\n        }\n        if (options.writable === false) {\n          this._writableState.writable = false;\n          this._writableState.ending = true;\n          this._writableState.ended = true;\n          this._writableState.finished = true;\n        }\n      } else {\n        this.allowHalfOpen = true;\n      }\n    }\n    ObjectDefineProperties(Duplex.prototype, {\n      writable: {\n        __proto__: null,\n        ...ObjectGetOwnPropertyDescriptor(Writable.prototype, "writable")\n      },\n      writableHighWaterMark: {\n        __proto__: null,\n        ...ObjectGetOwnPropertyDescriptor(Writable.prototype, "writableHighWaterMark")\n      },\n      writableObjectMode: {\n        __proto__: null,\n        ...ObjectGetOwnPropertyDescriptor(Writable.prototype, "writableObjectMode")\n      },\n      writableBuffer: {\n        __proto__: null,\n        ...ObjectGetOwnPropertyDescriptor(Writable.prototype, "writableBuffer")\n      },\n      writableLength: {\n        __proto__: null,\n        ...ObjectGetOwnPropertyDescriptor(Writable.prototype, "writableLength")\n      },\n      writableFinished: {\n        __proto__: null,\n        ...ObjectGetOwnPropertyDescriptor(Writable.prototype, "writableFinished")\n      },\n      writableCorked: {\n        __proto__: null,\n        ...ObjectGetOwnPropertyDescriptor(Writable.prototype, "writableCorked")\n      },\n      writableEnded: {\n        __proto__: null,\n        ...ObjectGetOwnPropertyDescriptor(Writable.prototype, "writableEnded")\n      },\n      writableNeedDrain: {\n        __proto__: null,\n        ...ObjectGetOwnPropertyDescriptor(Writable.prototype, "writableNeedDrain")\n      },\n      destroyed: {\n        __proto__: null,\n        get() {\n          if (this._readableState === void 0 || this._writableState === void 0) {\n            return false;\n          }\n          return this._readableState.destroyed && this._writableState.destroyed;\n        },\n        set(value) {\n          if (this._readableState && this._writableState) {\n            this._readableState.destroyed = value;\n            this._writableState.destroyed = value;\n          }\n        }\n      }\n    });\n    var webStreamsAdapters;\n    function lazyWebStreams() {\n      if (webStreamsAdapters === void 0) webStreamsAdapters = {};\n      return webStreamsAdapters;\n    }\n    Duplex.fromWeb = function(pair, options) {\n      return lazyWebStreams().newStreamDuplexFromReadableWritablePair(pair, options);\n    };\n    Duplex.toWeb = function(duplex) {\n      return lazyWebStreams().newReadableWritablePairFromDuplex(duplex);\n    };\n    var duplexify;\n    Duplex.from = function(body) {\n      if (!duplexify) {\n        duplexify = require_duplexify();\n      }\n      return duplexify(body, "body");\n    };\n  }\n});\n\n// node_modules/readable-stream/lib/internal/streams/transform.js\nvar require_transform = __commonJS({\n  "node_modules/readable-stream/lib/internal/streams/transform.js"(exports2, module2) {\n    "use strict";\n    var { ObjectSetPrototypeOf, Symbol: Symbol2 } = require_primordials();\n    module2.exports = Transform;\n    var { ERR_METHOD_NOT_IMPLEMENTED } = require_errors().codes;\n    var Duplex = require_duplex();\n    var { getHighWaterMark } = require_state();\n    ObjectSetPrototypeOf(Transform.prototype, Duplex.prototype);\n    ObjectSetPrototypeOf(Transform, Duplex);\n    var kCallback = Symbol2("kCallback");\n    function Transform(options) {\n      if (!(this instanceof Transform)) return new Transform(options);\n      const readableHighWaterMark = options ? getHighWaterMark(this, options, "readableHighWaterMark", true) : null;\n      if (readableHighWaterMark === 0) {\n        options = {\n          ...options,\n          highWaterMark: null,\n          readableHighWaterMark,\n          // TODO (ronag): 0 is not optimal since we have\n          // a "bug" where we check needDrain before calling _write and not after.\n          // Refs: https://github.com/nodejs/node/pull/32887\n          // Refs: https://github.com/nodejs/node/pull/35941\n          writableHighWaterMark: options.writableHighWaterMark || 0\n        };\n      }\n      Duplex.call(this, options);\n      this._readableState.sync = false;\n      this[kCallback] = null;\n      if (options) {\n        if (typeof options.transform === "function") this._transform = options.transform;\n        if (typeof options.flush === "function") this._flush = options.flush;\n      }\n      this.on("prefinish", prefinish);\n    }\n    function final(cb) {\n      if (typeof this._flush === "function" && !this.destroyed) {\n        this._flush((er, data) => {\n          if (er) {\n            if (cb) {\n              cb(er);\n            } else {\n              this.destroy(er);\n            }\n            return;\n          }\n          if (data != null) {\n            this.push(data);\n          }\n          this.push(null);\n          if (cb) {\n            cb();\n          }\n        });\n      } else {\n        this.push(null);\n        if (cb) {\n          cb();\n        }\n      }\n    }\n    function prefinish() {\n      if (this._final !== final) {\n        final.call(this);\n      }\n    }\n    Transform.prototype._final = final;\n    Transform.prototype._transform = function(chunk, encoding, callback) {\n      throw new ERR_METHOD_NOT_IMPLEMENTED("_transform()");\n    };\n    Transform.prototype._write = function(chunk, encoding, callback) {\n      const rState = this._readableState;\n      const wState = this._writableState;\n      const length = rState.length;\n      this._transform(chunk, encoding, (err, val) => {\n        if (err) {\n          callback(err);\n          return;\n        }\n        if (val != null) {\n          this.push(val);\n        }\n        if (wState.ended || // Backwards compat.\n        length === rState.length || // Backwards compat.\n        rState.length < rState.highWaterMark) {\n          callback();\n        } else {\n          this[kCallback] = callback;\n        }\n      });\n    };\n    Transform.prototype._read = function() {\n      if (this[kCallback]) {\n        const callback = this[kCallback];\n        this[kCallback] = null;\n        callback();\n      }\n    };\n  }\n});\n\n// node_modules/readable-stream/lib/internal/streams/passthrough.js\nvar require_passthrough = __commonJS({\n  "node_modules/readable-stream/lib/internal/streams/passthrough.js"(exports2, module2) {\n    "use strict";\n    var { ObjectSetPrototypeOf } = require_primordials();\n    module2.exports = PassThrough;\n    var Transform = require_transform();\n    ObjectSetPrototypeOf(PassThrough.prototype, Transform.prototype);\n    ObjectSetPrototypeOf(PassThrough, Transform);\n    function PassThrough(options) {\n      if (!(this instanceof PassThrough)) return new PassThrough(options);\n      Transform.call(this, options);\n    }\n    PassThrough.prototype._transform = function(chunk, encoding, cb) {\n      cb(null, chunk);\n    };\n  }\n});\n\n// node_modules/readable-stream/lib/internal/streams/pipeline.js\nvar require_pipeline = __commonJS({\n  "node_modules/readable-stream/lib/internal/streams/pipeline.js"(exports2, module2) {\n    var process = require_process2();\n    var { ArrayIsArray, Promise: Promise2, SymbolAsyncIterator, SymbolDispose } = require_primordials();\n    var eos = require_end_of_stream();\n    var { once } = require_util();\n    var destroyImpl = require_destroy();\n    var Duplex = require_duplex();\n    var {\n      aggregateTwoErrors,\n      codes: {\n        ERR_INVALID_ARG_TYPE,\n        ERR_INVALID_RETURN_VALUE,\n        ERR_MISSING_ARGS,\n        ERR_STREAM_DESTROYED,\n        ERR_STREAM_PREMATURE_CLOSE\n      },\n      AbortError\n    } = require_errors();\n    var { validateFunction, validateAbortSignal } = require_validators();\n    var {\n      isIterable,\n      isReadable,\n      isReadableNodeStream,\n      isNodeStream,\n      isTransformStream,\n      isWebStream,\n      isReadableStream,\n      isReadableFinished\n    } = require_utils();\n    var AbortController = globalThis.AbortController || require_abort_controller().AbortController;\n    var PassThrough;\n    var Readable;\n    var addAbortListener;\n    function destroyer(stream, reading, writing) {\n      let finished = false;\n      stream.on("close", () => {\n        finished = true;\n      });\n      const cleanup = eos(\n        stream,\n        {\n          readable: reading,\n          writable: writing\n        },\n        (err) => {\n          finished = !err;\n        }\n      );\n      return {\n        destroy: (err) => {\n          if (finished) return;\n          finished = true;\n          destroyImpl.destroyer(stream, err || new ERR_STREAM_DESTROYED("pipe"));\n        },\n        cleanup\n      };\n    }\n    function popCallback(streams) {\n      validateFunction(streams[streams.length - 1], "streams[stream.length - 1]");\n      return streams.pop();\n    }\n    function makeAsyncIterable(val) {\n      if (isIterable(val)) {\n        return val;\n      } else if (isReadableNodeStream(val)) {\n        return fromReadable(val);\n      }\n      throw new ERR_INVALID_ARG_TYPE("val", ["Readable", "Iterable", "AsyncIterable"], val);\n    }\n    async function* fromReadable(val) {\n      if (!Readable) {\n        Readable = require_readable();\n      }\n      yield* Readable.prototype[SymbolAsyncIterator].call(val);\n    }\n    async function pumpToNode(iterable, writable, finish, { end }) {\n      let error;\n      let onresolve = null;\n      const resume = (err) => {\n        if (err) {\n          error = err;\n        }\n        if (onresolve) {\n          const callback = onresolve;\n          onresolve = null;\n          callback();\n        }\n      };\n      const wait = () => new Promise2((resolve, reject) => {\n        if (error) {\n          reject(error);\n        } else {\n          onresolve = () => {\n            if (error) {\n              reject(error);\n            } else {\n              resolve();\n            }\n          };\n        }\n      });\n      writable.on("drain", resume);\n      const cleanup = eos(\n        writable,\n        {\n          readable: false\n        },\n        resume\n      );\n      try {\n        if (writable.writableNeedDrain) {\n          await wait();\n        }\n        for await (const chunk of iterable) {\n          if (!writable.write(chunk)) {\n            await wait();\n          }\n        }\n        if (end) {\n          writable.end();\n          await wait();\n        }\n        finish();\n      } catch (err) {\n        finish(error !== err ? aggregateTwoErrors(error, err) : err);\n      } finally {\n        cleanup();\n        writable.off("drain", resume);\n      }\n    }\n    async function pumpToWeb(readable, writable, finish, { end }) {\n      if (isTransformStream(writable)) {\n        writable = writable.writable;\n      }\n      const writer = writable.getWriter();\n      try {\n        for await (const chunk of readable) {\n          await writer.ready;\n          writer.write(chunk).catch(() => {\n          });\n        }\n        await writer.ready;\n        if (end) {\n          await writer.close();\n        }\n        finish();\n      } catch (err) {\n        try {\n          await writer.abort(err);\n          finish(err);\n        } catch (err2) {\n          finish(err2);\n        }\n      }\n    }\n    function pipeline(...streams) {\n      return pipelineImpl(streams, once(popCallback(streams)));\n    }\n    function pipelineImpl(streams, callback, opts) {\n      if (streams.length === 1 && ArrayIsArray(streams[0])) {\n        streams = streams[0];\n      }\n      if (streams.length < 2) {\n        throw new ERR_MISSING_ARGS("streams");\n      }\n      const ac = new AbortController();\n      const signal = ac.signal;\n      const outerSignal = opts === null || opts === void 0 ? void 0 : opts.signal;\n      const lastStreamCleanup = [];\n      validateAbortSignal(outerSignal, "options.signal");\n      function abort() {\n        finishImpl(new AbortError());\n      }\n      addAbortListener = addAbortListener || require_util().addAbortListener;\n      let disposable;\n      if (outerSignal) {\n        disposable = addAbortListener(outerSignal, abort);\n      }\n      let error;\n      let value;\n      const destroys = [];\n      let finishCount = 0;\n      function finish(err) {\n        finishImpl(err, --finishCount === 0);\n      }\n      function finishImpl(err, final) {\n        var _disposable;\n        if (err && (!error || error.code === "ERR_STREAM_PREMATURE_CLOSE")) {\n          error = err;\n        }\n        if (!error && !final) {\n          return;\n        }\n        while (destroys.length) {\n          destroys.shift()(error);\n        }\n        ;\n        (_disposable = disposable) === null || _disposable === void 0 ? void 0 : _disposable[SymbolDispose]();\n        ac.abort();\n        if (final) {\n          if (!error) {\n            lastStreamCleanup.forEach((fn) => fn());\n          }\n          process.nextTick(callback, error, value);\n        }\n      }\n      let ret;\n      for (let i = 0; i < streams.length; i++) {\n        const stream = streams[i];\n        const reading = i < streams.length - 1;\n        const writing = i > 0;\n        const end = reading || (opts === null || opts === void 0 ? void 0 : opts.end) !== false;\n        const isLastStream = i === streams.length - 1;\n        if (isNodeStream(stream)) {\n          let onError2 = function(err) {\n            if (err && err.name !== "AbortError" && err.code !== "ERR_STREAM_PREMATURE_CLOSE") {\n              finish(err);\n            }\n          };\n          var onError = onError2;\n          if (end) {\n            const { destroy, cleanup } = destroyer(stream, reading, writing);\n            destroys.push(destroy);\n            if (isReadable(stream) && isLastStream) {\n              lastStreamCleanup.push(cleanup);\n            }\n          }\n          stream.on("error", onError2);\n          if (isReadable(stream) && isLastStream) {\n            lastStreamCleanup.push(() => {\n              stream.removeListener("error", onError2);\n            });\n          }\n        }\n        if (i === 0) {\n          if (typeof stream === "function") {\n            ret = stream({\n              signal\n            });\n            if (!isIterable(ret)) {\n              throw new ERR_INVALID_RETURN_VALUE("Iterable, AsyncIterable or Stream", "source", ret);\n            }\n          } else if (isIterable(stream) || isReadableNodeStream(stream) || isTransformStream(stream)) {\n            ret = stream;\n          } else {\n            ret = Duplex.from(stream);\n          }\n        } else if (typeof stream === "function") {\n          if (isTransformStream(ret)) {\n            var _ret;\n            ret = makeAsyncIterable((_ret = ret) === null || _ret === void 0 ? void 0 : _ret.readable);\n          } else {\n            ret = makeAsyncIterable(ret);\n          }\n          ret = stream(ret, {\n            signal\n          });\n          if (reading) {\n            if (!isIterable(ret, true)) {\n              throw new ERR_INVALID_RETURN_VALUE("AsyncIterable", `transform[${i - 1}]`, ret);\n            }\n          } else {\n            var _ret2;\n            if (!PassThrough) {\n              PassThrough = require_passthrough();\n            }\n            const pt = new PassThrough({\n              objectMode: true\n            });\n            const then = (_ret2 = ret) === null || _ret2 === void 0 ? void 0 : _ret2.then;\n            if (typeof then === "function") {\n              finishCount++;\n              then.call(\n                ret,\n                (val) => {\n                  value = val;\n                  if (val != null) {\n                    pt.write(val);\n                  }\n                  if (end) {\n                    pt.end();\n                  }\n                  process.nextTick(finish);\n                },\n                (err) => {\n                  pt.destroy(err);\n                  process.nextTick(finish, err);\n                }\n              );\n            } else if (isIterable(ret, true)) {\n              finishCount++;\n              pumpToNode(ret, pt, finish, {\n                end\n              });\n            } else if (isReadableStream(ret) || isTransformStream(ret)) {\n              const toRead = ret.readable || ret;\n              finishCount++;\n              pumpToNode(toRead, pt, finish, {\n                end\n              });\n            } else {\n              throw new ERR_INVALID_RETURN_VALUE("AsyncIterable or Promise", "destination", ret);\n            }\n            ret = pt;\n            const { destroy, cleanup } = destroyer(ret, false, true);\n            destroys.push(destroy);\n            if (isLastStream) {\n              lastStreamCleanup.push(cleanup);\n            }\n          }\n        } else if (isNodeStream(stream)) {\n          if (isReadableNodeStream(ret)) {\n            finishCount += 2;\n            const cleanup = pipe(ret, stream, finish, {\n              end\n            });\n            if (isReadable(stream) && isLastStream) {\n              lastStreamCleanup.push(cleanup);\n            }\n          } else if (isTransformStream(ret) || isReadableStream(ret)) {\n            const toRead = ret.readable || ret;\n            finishCount++;\n            pumpToNode(toRead, stream, finish, {\n              end\n            });\n          } else if (isIterable(ret)) {\n            finishCount++;\n            pumpToNode(ret, stream, finish, {\n              end\n            });\n          } else {\n            throw new ERR_INVALID_ARG_TYPE(\n              "val",\n              ["Readable", "Iterable", "AsyncIterable", "ReadableStream", "TransformStream"],\n              ret\n            );\n          }\n          ret = stream;\n        } else if (isWebStream(stream)) {\n          if (isReadableNodeStream(ret)) {\n            finishCount++;\n            pumpToWeb(makeAsyncIterable(ret), stream, finish, {\n              end\n            });\n          } else if (isReadableStream(ret) || isIterable(ret)) {\n            finishCount++;\n            pumpToWeb(ret, stream, finish, {\n              end\n            });\n          } else if (isTransformStream(ret)) {\n            finishCount++;\n            pumpToWeb(ret.readable, stream, finish, {\n              end\n            });\n          } else {\n            throw new ERR_INVALID_ARG_TYPE(\n              "val",\n              ["Readable", "Iterable", "AsyncIterable", "ReadableStream", "TransformStream"],\n              ret\n            );\n          }\n          ret = stream;\n        } else {\n          ret = Duplex.from(stream);\n        }\n      }\n      if (signal !== null && signal !== void 0 && signal.aborted || outerSignal !== null && outerSignal !== void 0 && outerSignal.aborted) {\n        process.nextTick(abort);\n      }\n      return ret;\n    }\n    function pipe(src, dst, finish, { end }) {\n      let ended = false;\n      dst.on("close", () => {\n        if (!ended) {\n          finish(new ERR_STREAM_PREMATURE_CLOSE());\n        }\n      });\n      src.pipe(dst, {\n        end: false\n      });\n      if (end) {\n        let endFn2 = function() {\n          ended = true;\n          dst.end();\n        };\n        var endFn = endFn2;\n        if (isReadableFinished(src)) {\n          process.nextTick(endFn2);\n        } else {\n          src.once("end", endFn2);\n        }\n      } else {\n        finish();\n      }\n      eos(\n        src,\n        {\n          readable: true,\n          writable: false\n        },\n        (err) => {\n          const rState = src._readableState;\n          if (err && err.code === "ERR_STREAM_PREMATURE_CLOSE" && rState && rState.ended && !rState.errored && !rState.errorEmitted) {\n            src.once("end", finish).once("error", finish);\n          } else {\n            finish(err);\n          }\n        }\n      );\n      return eos(\n        dst,\n        {\n          readable: false,\n          writable: true\n        },\n        finish\n      );\n    }\n    module2.exports = {\n      pipelineImpl,\n      pipeline\n    };\n  }\n});\n\n// node_modules/readable-stream/lib/internal/streams/compose.js\nvar require_compose = __commonJS({\n  "node_modules/readable-stream/lib/internal/streams/compose.js"(exports2, module2) {\n    "use strict";\n    var { pipeline } = require_pipeline();\n    var Duplex = require_duplex();\n    var { destroyer } = require_destroy();\n    var {\n      isNodeStream,\n      isReadable,\n      isWritable,\n      isWebStream,\n      isTransformStream,\n      isWritableStream,\n      isReadableStream\n    } = require_utils();\n    var {\n      AbortError,\n      codes: { ERR_INVALID_ARG_VALUE, ERR_MISSING_ARGS }\n    } = require_errors();\n    var eos = require_end_of_stream();\n    module2.exports = function compose(...streams) {\n      if (streams.length === 0) {\n        throw new ERR_MISSING_ARGS("streams");\n      }\n      if (streams.length === 1) {\n        return Duplex.from(streams[0]);\n      }\n      const orgStreams = [...streams];\n      if (typeof streams[0] === "function") {\n        streams[0] = Duplex.from(streams[0]);\n      }\n      if (typeof streams[streams.length - 1] === "function") {\n        const idx = streams.length - 1;\n        streams[idx] = Duplex.from(streams[idx]);\n      }\n      for (let n = 0; n < streams.length; ++n) {\n        if (!isNodeStream(streams[n]) && !isWebStream(streams[n])) {\n          continue;\n        }\n        if (n < streams.length - 1 && !(isReadable(streams[n]) || isReadableStream(streams[n]) || isTransformStream(streams[n]))) {\n          throw new ERR_INVALID_ARG_VALUE(`streams[${n}]`, orgStreams[n], "must be readable");\n        }\n        if (n > 0 && !(isWritable(streams[n]) || isWritableStream(streams[n]) || isTransformStream(streams[n]))) {\n          throw new ERR_INVALID_ARG_VALUE(`streams[${n}]`, orgStreams[n], "must be writable");\n        }\n      }\n      let ondrain;\n      let onfinish;\n      let onreadable;\n      let onclose;\n      let d;\n      function onfinished(err) {\n        const cb = onclose;\n        onclose = null;\n        if (cb) {\n          cb(err);\n        } else if (err) {\n          d.destroy(err);\n        } else if (!readable && !writable) {\n          d.destroy();\n        }\n      }\n      const head = streams[0];\n      const tail = pipeline(streams, onfinished);\n      const writable = !!(isWritable(head) || isWritableStream(head) || isTransformStream(head));\n      const readable = !!(isReadable(tail) || isReadableStream(tail) || isTransformStream(tail));\n      d = new Duplex({\n        // TODO (ronag): highWaterMark?\n        writableObjectMode: !!(head !== null && head !== void 0 && head.writableObjectMode),\n        readableObjectMode: !!(tail !== null && tail !== void 0 && tail.readableObjectMode),\n        writable,\n        readable\n      });\n      if (writable) {\n        if (isNodeStream(head)) {\n          d._write = function(chunk, encoding, callback) {\n            if (head.write(chunk, encoding)) {\n              callback();\n            } else {\n              ondrain = callback;\n            }\n          };\n          d._final = function(callback) {\n            head.end();\n            onfinish = callback;\n          };\n          head.on("drain", function() {\n            if (ondrain) {\n              const cb = ondrain;\n              ondrain = null;\n              cb();\n            }\n          });\n        } else if (isWebStream(head)) {\n          const writable2 = isTransformStream(head) ? head.writable : head;\n          const writer = writable2.getWriter();\n          d._write = async function(chunk, encoding, callback) {\n            try {\n              await writer.ready;\n              writer.write(chunk).catch(() => {\n              });\n              callback();\n            } catch (err) {\n              callback(err);\n            }\n          };\n          d._final = async function(callback) {\n            try {\n              await writer.ready;\n              writer.close().catch(() => {\n              });\n              onfinish = callback;\n            } catch (err) {\n              callback(err);\n            }\n          };\n        }\n        const toRead = isTransformStream(tail) ? tail.readable : tail;\n        eos(toRead, () => {\n          if (onfinish) {\n            const cb = onfinish;\n            onfinish = null;\n            cb();\n          }\n        });\n      }\n      if (readable) {\n        if (isNodeStream(tail)) {\n          tail.on("readable", function() {\n            if (onreadable) {\n              const cb = onreadable;\n              onreadable = null;\n              cb();\n            }\n          });\n          tail.on("end", function() {\n            d.push(null);\n          });\n          d._read = function() {\n            while (true) {\n              const buf = tail.read();\n              if (buf === null) {\n                onreadable = d._read;\n                return;\n              }\n              if (!d.push(buf)) {\n                return;\n              }\n            }\n          };\n        } else if (isWebStream(tail)) {\n          const readable2 = isTransformStream(tail) ? tail.readable : tail;\n          const reader = readable2.getReader();\n          d._read = async function() {\n            while (true) {\n              try {\n                const { value, done } = await reader.read();\n                if (!d.push(value)) {\n                  return;\n                }\n                if (done) {\n                  d.push(null);\n                  return;\n                }\n              } catch {\n                return;\n              }\n            }\n          };\n        }\n      }\n      d._destroy = function(err, callback) {\n        if (!err && onclose !== null) {\n          err = new AbortError();\n        }\n        onreadable = null;\n        ondrain = null;\n        onfinish = null;\n        if (onclose === null) {\n          callback(err);\n        } else {\n          onclose = callback;\n          if (isNodeStream(tail)) {\n            destroyer(tail, err);\n          }\n        }\n      };\n      return d;\n    };\n  }\n});\n\n// node_modules/readable-stream/lib/internal/streams/operators.js\nvar require_operators = __commonJS({\n  "node_modules/readable-stream/lib/internal/streams/operators.js"(exports2, module2) {\n    "use strict";\n    var AbortController = globalThis.AbortController || require_abort_controller().AbortController;\n    var {\n      codes: { ERR_INVALID_ARG_VALUE, ERR_INVALID_ARG_TYPE, ERR_MISSING_ARGS, ERR_OUT_OF_RANGE },\n      AbortError\n    } = require_errors();\n    var { validateAbortSignal, validateInteger, validateObject } = require_validators();\n    var kWeakHandler = require_primordials().Symbol("kWeak");\n    var kResistStopPropagation = require_primordials().Symbol("kResistStopPropagation");\n    var { finished } = require_end_of_stream();\n    var staticCompose = require_compose();\n    var { addAbortSignalNoValidate } = require_add_abort_signal();\n    var { isWritable, isNodeStream } = require_utils();\n    var { deprecate } = require_util();\n    var {\n      ArrayPrototypePush,\n      Boolean: Boolean2,\n      MathFloor,\n      Number: Number2,\n      NumberIsNaN,\n      Promise: Promise2,\n      PromiseReject,\n      PromiseResolve,\n      PromisePrototypeThen,\n      Symbol: Symbol2\n    } = require_primordials();\n    var kEmpty = Symbol2("kEmpty");\n    var kEof = Symbol2("kEof");\n    function compose(stream, options) {\n      if (options != null) {\n        validateObject(options, "options");\n      }\n      if ((options === null || options === void 0 ? void 0 : options.signal) != null) {\n        validateAbortSignal(options.signal, "options.signal");\n      }\n      if (isNodeStream(stream) && !isWritable(stream)) {\n        throw new ERR_INVALID_ARG_VALUE("stream", stream, "must be writable");\n      }\n      const composedStream = staticCompose(this, stream);\n      if (options !== null && options !== void 0 && options.signal) {\n        addAbortSignalNoValidate(options.signal, composedStream);\n      }\n      return composedStream;\n    }\n    function map(fn, options) {\n      if (typeof fn !== "function") {\n        throw new ERR_INVALID_ARG_TYPE("fn", ["Function", "AsyncFunction"], fn);\n      }\n      if (options != null) {\n        validateObject(options, "options");\n      }\n      if ((options === null || options === void 0 ? void 0 : options.signal) != null) {\n        validateAbortSignal(options.signal, "options.signal");\n      }\n      let concurrency = 1;\n      if ((options === null || options === void 0 ? void 0 : options.concurrency) != null) {\n        concurrency = MathFloor(options.concurrency);\n      }\n      let highWaterMark = concurrency - 1;\n      if ((options === null || options === void 0 ? void 0 : options.highWaterMark) != null) {\n        highWaterMark = MathFloor(options.highWaterMark);\n      }\n      validateInteger(concurrency, "options.concurrency", 1);\n      validateInteger(highWaterMark, "options.highWaterMark", 0);\n      highWaterMark += concurrency;\n      return async function* map2() {\n        const signal = require_util().AbortSignalAny(\n          [options === null || options === void 0 ? void 0 : options.signal].filter(Boolean2)\n        );\n        const stream = this;\n        const queue = [];\n        const signalOpt = {\n          signal\n        };\n        let next;\n        let resume;\n        let done = false;\n        let cnt = 0;\n        function onCatch() {\n          done = true;\n          afterItemProcessed();\n        }\n        function afterItemProcessed() {\n          cnt -= 1;\n          maybeResume();\n        }\n        function maybeResume() {\n          if (resume && !done && cnt < concurrency && queue.length < highWaterMark) {\n            resume();\n            resume = null;\n          }\n        }\n        async function pump() {\n          try {\n            for await (let val of stream) {\n              if (done) {\n                return;\n              }\n              if (signal.aborted) {\n                throw new AbortError();\n              }\n              try {\n                val = fn(val, signalOpt);\n                if (val === kEmpty) {\n                  continue;\n                }\n                val = PromiseResolve(val);\n              } catch (err) {\n                val = PromiseReject(err);\n              }\n              cnt += 1;\n              PromisePrototypeThen(val, afterItemProcessed, onCatch);\n              queue.push(val);\n              if (next) {\n                next();\n                next = null;\n              }\n              if (!done && (queue.length >= highWaterMark || cnt >= concurrency)) {\n                await new Promise2((resolve) => {\n                  resume = resolve;\n                });\n              }\n            }\n            queue.push(kEof);\n          } catch (err) {\n            const val = PromiseReject(err);\n            PromisePrototypeThen(val, afterItemProcessed, onCatch);\n            queue.push(val);\n          } finally {\n            done = true;\n            if (next) {\n              next();\n              next = null;\n            }\n          }\n        }\n        pump();\n        try {\n          while (true) {\n            while (queue.length > 0) {\n              const val = await queue[0];\n              if (val === kEof) {\n                return;\n              }\n              if (signal.aborted) {\n                throw new AbortError();\n              }\n              if (val !== kEmpty) {\n                yield val;\n              }\n              queue.shift();\n              maybeResume();\n            }\n            await new Promise2((resolve) => {\n              next = resolve;\n            });\n          }\n        } finally {\n          done = true;\n          if (resume) {\n            resume();\n            resume = null;\n          }\n        }\n      }.call(this);\n    }\n    function asIndexedPairs(options = void 0) {\n      if (options != null) {\n        validateObject(options, "options");\n      }\n      if ((options === null || options === void 0 ? void 0 : options.signal) != null) {\n        validateAbortSignal(options.signal, "options.signal");\n      }\n      return async function* asIndexedPairs2() {\n        let index = 0;\n        for await (const val of this) {\n          var _options$signal;\n          if (options !== null && options !== void 0 && (_options$signal = options.signal) !== null && _options$signal !== void 0 && _options$signal.aborted) {\n            throw new AbortError({\n              cause: options.signal.reason\n            });\n          }\n          yield [index++, val];\n        }\n      }.call(this);\n    }\n    async function some(fn, options = void 0) {\n      for await (const unused of filter.call(this, fn, options)) {\n        return true;\n      }\n      return false;\n    }\n    async function every(fn, options = void 0) {\n      if (typeof fn !== "function") {\n        throw new ERR_INVALID_ARG_TYPE("fn", ["Function", "AsyncFunction"], fn);\n      }\n      return !await some.call(\n        this,\n        async (...args) => {\n          return !await fn(...args);\n        },\n        options\n      );\n    }\n    async function find(fn, options) {\n      for await (const result of filter.call(this, fn, options)) {\n        return result;\n      }\n      return void 0;\n    }\n    async function forEach(fn, options) {\n      if (typeof fn !== "function") {\n        throw new ERR_INVALID_ARG_TYPE("fn", ["Function", "AsyncFunction"], fn);\n      }\n      async function forEachFn(value, options2) {\n        await fn(value, options2);\n        return kEmpty;\n      }\n      for await (const unused of map.call(this, forEachFn, options)) ;\n    }\n    function filter(fn, options) {\n      if (typeof fn !== "function") {\n        throw new ERR_INVALID_ARG_TYPE("fn", ["Function", "AsyncFunction"], fn);\n      }\n      async function filterFn(value, options2) {\n        if (await fn(value, options2)) {\n          return value;\n        }\n        return kEmpty;\n      }\n      return map.call(this, filterFn, options);\n    }\n    var ReduceAwareErrMissingArgs = class extends ERR_MISSING_ARGS {\n      constructor() {\n        super("reduce");\n        this.message = "Reduce of an empty stream requires an initial value";\n      }\n    };\n    async function reduce(reducer, initialValue, options) {\n      var _options$signal2;\n      if (typeof reducer !== "function") {\n        throw new ERR_INVALID_ARG_TYPE("reducer", ["Function", "AsyncFunction"], reducer);\n      }\n      if (options != null) {\n        validateObject(options, "options");\n      }\n      if ((options === null || options === void 0 ? void 0 : options.signal) != null) {\n        validateAbortSignal(options.signal, "options.signal");\n      }\n      let hasInitialValue = arguments.length > 1;\n      if (options !== null && options !== void 0 && (_options$signal2 = options.signal) !== null && _options$signal2 !== void 0 && _options$signal2.aborted) {\n        const err = new AbortError(void 0, {\n          cause: options.signal.reason\n        });\n        this.once("error", () => {\n        });\n        await finished(this.destroy(err));\n        throw err;\n      }\n      const ac = new AbortController();\n      const signal = ac.signal;\n      if (options !== null && options !== void 0 && options.signal) {\n        const opts = {\n          once: true,\n          [kWeakHandler]: this,\n          [kResistStopPropagation]: true\n        };\n        options.signal.addEventListener("abort", () => ac.abort(), opts);\n      }\n      let gotAnyItemFromStream = false;\n      try {\n        for await (const value of this) {\n          var _options$signal3;\n          gotAnyItemFromStream = true;\n          if (options !== null && options !== void 0 && (_options$signal3 = options.signal) !== null && _options$signal3 !== void 0 && _options$signal3.aborted) {\n            throw new AbortError();\n          }\n          if (!hasInitialValue) {\n            initialValue = value;\n            hasInitialValue = true;\n          } else {\n            initialValue = await reducer(initialValue, value, {\n              signal\n            });\n          }\n        }\n        if (!gotAnyItemFromStream && !hasInitialValue) {\n          throw new ReduceAwareErrMissingArgs();\n        }\n      } finally {\n        ac.abort();\n      }\n      return initialValue;\n    }\n    async function toArray(options) {\n      if (options != null) {\n        validateObject(options, "options");\n      }\n      if ((options === null || options === void 0 ? void 0 : options.signal) != null) {\n        validateAbortSignal(options.signal, "options.signal");\n      }\n      const result = [];\n      for await (const val of this) {\n        var _options$signal4;\n        if (options !== null && options !== void 0 && (_options$signal4 = options.signal) !== null && _options$signal4 !== void 0 && _options$signal4.aborted) {\n          throw new AbortError(void 0, {\n            cause: options.signal.reason\n          });\n        }\n        ArrayPrototypePush(result, val);\n      }\n      return result;\n    }\n    function flatMap(fn, options) {\n      const values = map.call(this, fn, options);\n      return async function* flatMap2() {\n        for await (const val of values) {\n          yield* val;\n        }\n      }.call(this);\n    }\n    function toIntegerOrInfinity(number) {\n      number = Number2(number);\n      if (NumberIsNaN(number)) {\n        return 0;\n      }\n      if (number < 0) {\n        throw new ERR_OUT_OF_RANGE("number", ">= 0", number);\n      }\n      return number;\n    }\n    function drop(number, options = void 0) {\n      if (options != null) {\n        validateObject(options, "options");\n      }\n      if ((options === null || options === void 0 ? void 0 : options.signal) != null) {\n        validateAbortSignal(options.signal, "options.signal");\n      }\n      number = toIntegerOrInfinity(number);\n      return async function* drop2() {\n        var _options$signal5;\n        if (options !== null && options !== void 0 && (_options$signal5 = options.signal) !== null && _options$signal5 !== void 0 && _options$signal5.aborted) {\n          throw new AbortError();\n        }\n        for await (const val of this) {\n          var _options$signal6;\n          if (options !== null && options !== void 0 && (_options$signal6 = options.signal) !== null && _options$signal6 !== void 0 && _options$signal6.aborted) {\n            throw new AbortError();\n          }\n          if (number-- <= 0) {\n            yield val;\n          }\n        }\n      }.call(this);\n    }\n    function take(number, options = void 0) {\n      if (options != null) {\n        validateObject(options, "options");\n      }\n      if ((options === null || options === void 0 ? void 0 : options.signal) != null) {\n        validateAbortSignal(options.signal, "options.signal");\n      }\n      number = toIntegerOrInfinity(number);\n      return async function* take2() {\n        var _options$signal7;\n        if (options !== null && options !== void 0 && (_options$signal7 = options.signal) !== null && _options$signal7 !== void 0 && _options$signal7.aborted) {\n          throw new AbortError();\n        }\n        for await (const val of this) {\n          var _options$signal8;\n          if (options !== null && options !== void 0 && (_options$signal8 = options.signal) !== null && _options$signal8 !== void 0 && _options$signal8.aborted) {\n            throw new AbortError();\n          }\n          if (number-- > 0) {\n            yield val;\n          }\n          if (number <= 0) {\n            return;\n          }\n        }\n      }.call(this);\n    }\n    module2.exports.streamReturningOperators = {\n      asIndexedPairs: deprecate(asIndexedPairs, "readable.asIndexedPairs will be removed in a future version."),\n      drop,\n      filter,\n      flatMap,\n      map,\n      take,\n      compose\n    };\n    module2.exports.promiseReturningOperators = {\n      every,\n      forEach,\n      reduce,\n      toArray,\n      some,\n      find\n    };\n  }\n});\n\n// node_modules/readable-stream/lib/stream/promises.js\nvar require_promises = __commonJS({\n  "node_modules/readable-stream/lib/stream/promises.js"(exports2, module2) {\n    "use strict";\n    var { ArrayPrototypePop, Promise: Promise2 } = require_primordials();\n    var { isIterable, isNodeStream, isWebStream } = require_utils();\n    var { pipelineImpl: pl } = require_pipeline();\n    var { finished } = require_end_of_stream();\n    require_stream();\n    function pipeline(...streams) {\n      return new Promise2((resolve, reject) => {\n        let signal;\n        let end;\n        const lastArg = streams[streams.length - 1];\n        if (lastArg && typeof lastArg === "object" && !isNodeStream(lastArg) && !isIterable(lastArg) && !isWebStream(lastArg)) {\n          const options = ArrayPrototypePop(streams);\n          signal = options.signal;\n          end = options.end;\n        }\n        pl(\n          streams,\n          (err, value) => {\n            if (err) {\n              reject(err);\n            } else {\n              resolve(value);\n            }\n          },\n          {\n            signal,\n            end\n          }\n        );\n      });\n    }\n    module2.exports = {\n      finished,\n      pipeline\n    };\n  }\n});\n\n// node_modules/readable-stream/lib/stream.js\nvar require_stream = __commonJS({\n  "node_modules/readable-stream/lib/stream.js"(exports2, module2) {\n    "use strict";\n    var { Buffer: Buffer2 } = require_buffer();\n    var { ObjectDefineProperty, ObjectKeys, ReflectApply } = require_primordials();\n    var {\n      promisify: { custom: customPromisify }\n    } = require_util();\n    var { streamReturningOperators, promiseReturningOperators } = require_operators();\n    var {\n      codes: { ERR_ILLEGAL_CONSTRUCTOR }\n    } = require_errors();\n    var compose = require_compose();\n    var { setDefaultHighWaterMark, getDefaultHighWaterMark } = require_state();\n    var { pipeline } = require_pipeline();\n    var { destroyer } = require_destroy();\n    var eos = require_end_of_stream();\n    var promises2 = require_promises();\n    var utils = require_utils();\n    var Stream = module2.exports = require_legacy().Stream;\n    Stream.isDestroyed = utils.isDestroyed;\n    Stream.isDisturbed = utils.isDisturbed;\n    Stream.isErrored = utils.isErrored;\n    Stream.isReadable = utils.isReadable;\n    Stream.isWritable = utils.isWritable;\n    Stream.Readable = require_readable();\n    for (const key of ObjectKeys(streamReturningOperators)) {\n      let fn = function(...args) {\n        if (new.target) {\n          throw ERR_ILLEGAL_CONSTRUCTOR();\n        }\n        return Stream.Readable.from(ReflectApply(op, this, args));\n      };\n      const op = streamReturningOperators[key];\n      ObjectDefineProperty(fn, "name", {\n        __proto__: null,\n        value: op.name\n      });\n      ObjectDefineProperty(fn, "length", {\n        __proto__: null,\n        value: op.length\n      });\n      ObjectDefineProperty(Stream.Readable.prototype, key, {\n        __proto__: null,\n        value: fn,\n        enumerable: false,\n        configurable: true,\n        writable: true\n      });\n    }\n    for (const key of ObjectKeys(promiseReturningOperators)) {\n      let fn = function(...args) {\n        if (new.target) {\n          throw ERR_ILLEGAL_CONSTRUCTOR();\n        }\n        return ReflectApply(op, this, args);\n      };\n      const op = promiseReturningOperators[key];\n      ObjectDefineProperty(fn, "name", {\n        __proto__: null,\n        value: op.name\n      });\n      ObjectDefineProperty(fn, "length", {\n        __proto__: null,\n        value: op.length\n      });\n      ObjectDefineProperty(Stream.Readable.prototype, key, {\n        __proto__: null,\n        value: fn,\n        enumerable: false,\n        configurable: true,\n        writable: true\n      });\n    }\n    Stream.Writable = require_writable();\n    Stream.Duplex = require_duplex();\n    Stream.Transform = require_transform();\n    Stream.PassThrough = require_passthrough();\n    Stream.pipeline = pipeline;\n    var { addAbortSignal } = require_add_abort_signal();\n    Stream.addAbortSignal = addAbortSignal;\n    Stream.finished = eos;\n    Stream.destroy = destroyer;\n    Stream.compose = compose;\n    Stream.setDefaultHighWaterMark = setDefaultHighWaterMark;\n    Stream.getDefaultHighWaterMark = getDefaultHighWaterMark;\n    ObjectDefineProperty(Stream, "promises", {\n      __proto__: null,\n      configurable: true,\n      enumerable: true,\n      get() {\n        return promises2;\n      }\n    });\n    ObjectDefineProperty(pipeline, customPromisify, {\n      __proto__: null,\n      enumerable: true,\n      get() {\n        return promises2.pipeline;\n      }\n    });\n    ObjectDefineProperty(eos, customPromisify, {\n      __proto__: null,\n      enumerable: true,\n      get() {\n        return promises2.finished;\n      }\n    });\n    Stream.Stream = Stream;\n    Stream._isUint8Array = function isUint8Array(value) {\n      return value instanceof Uint8Array;\n    };\n    Stream._uint8ArrayToBuffer = function _uint8ArrayToBuffer(chunk) {\n      return Buffer2.from(chunk.buffer, chunk.byteOffset, chunk.byteLength);\n    };\n  }\n});\n\n// node_modules/readable-stream/lib/ours/browser.js\nvar CustomStream = require_stream();\nvar promises = require_promises();\nvar originalDestroy = CustomStream.Readable.destroy;\nmodule.exports = CustomStream.Readable;\nmodule.exports._uint8ArrayToBuffer = CustomStream._uint8ArrayToBuffer;\nmodule.exports._isUint8Array = CustomStream._isUint8Array;\nmodule.exports.isDisturbed = CustomStream.isDisturbed;\nmodule.exports.isErrored = CustomStream.isErrored;\nmodule.exports.isReadable = CustomStream.isReadable;\nmodule.exports.Readable = CustomStream.Readable;\nmodule.exports.Writable = CustomStream.Writable;\nmodule.exports.Duplex = CustomStream.Duplex;\nmodule.exports.Transform = CustomStream.Transform;\nmodule.exports.PassThrough = CustomStream.PassThrough;\nmodule.exports.addAbortSignal = CustomStream.addAbortSignal;\nmodule.exports.finished = CustomStream.finished;\nmodule.exports.destroy = CustomStream.destroy;\nmodule.exports.destroy = originalDestroy;\nmodule.exports.pipeline = CustomStream.pipeline;\nmodule.exports.compose = CustomStream.compose;\nObject.defineProperty(CustomStream, "promises", {\n  configurable: true,\n  enumerable: true,\n  get() {\n    return promises;\n  }\n});\nmodule.exports.Stream = CustomStream.Stream;\nmodule.exports.default = module.exports;\n',
+  "string_decoder": '"use strict";\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __commonJS = (cb, mod) => function __require() {\n  try {\n    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;\n  } catch (e) {\n    throw mod = 0, e;\n  }\n};\n\n// src/vendor-shims/buffer.cjs\nvar require_buffer = __commonJS({\n  "src/vendor-shims/buffer.cjs"(exports2, module2) {\n    "use strict";\n    var Buffer3 = globalThis.Buffer;\n    module2.exports = Buffer3;\n    module2.exports.Buffer = Buffer3;\n    module2.exports.SlowBuffer = Buffer3;\n    module2.exports.kMaxLength = 2147483647;\n    module2.exports.INSPECT_MAX_BYTES = 50;\n    if (typeof globalThis.Blob !== "undefined") {\n      module2.exports.Blob = globalThis.Blob;\n    }\n  }\n});\n\n// node_modules/string_decoder/lib/string_decoder.js\nvar Buffer2 = require_buffer().Buffer;\nvar isEncoding = Buffer2.isEncoding || function(encoding) {\n  encoding = "" + encoding;\n  switch (encoding && encoding.toLowerCase()) {\n    case "hex":\n    case "utf8":\n    case "utf-8":\n    case "ascii":\n    case "binary":\n    case "base64":\n    case "ucs2":\n    case "ucs-2":\n    case "utf16le":\n    case "utf-16le":\n    case "raw":\n      return true;\n    default:\n      return false;\n  }\n};\nfunction _normalizeEncoding(enc) {\n  if (!enc) return "utf8";\n  var retried;\n  while (true) {\n    switch (enc) {\n      case "utf8":\n      case "utf-8":\n        return "utf8";\n      case "ucs2":\n      case "ucs-2":\n      case "utf16le":\n      case "utf-16le":\n        return "utf16le";\n      case "latin1":\n      case "binary":\n        return "latin1";\n      case "base64":\n      case "ascii":\n      case "hex":\n        return enc;\n      default:\n        if (retried) return;\n        enc = ("" + enc).toLowerCase();\n        retried = true;\n    }\n  }\n}\nfunction normalizeEncoding(enc) {\n  var nenc = _normalizeEncoding(enc);\n  if (typeof nenc !== "string" && (Buffer2.isEncoding === isEncoding || !isEncoding(enc))) throw new Error("Unknown encoding: " + enc);\n  return nenc || enc;\n}\nexports.StringDecoder = StringDecoder;\nfunction StringDecoder(encoding) {\n  this.encoding = normalizeEncoding(encoding);\n  var nb;\n  switch (this.encoding) {\n    case "utf16le":\n      this.text = utf16Text;\n      this.end = utf16End;\n      nb = 4;\n      break;\n    case "utf8":\n      this.fillLast = utf8FillLast;\n      nb = 4;\n      break;\n    case "base64":\n      this.text = base64Text;\n      this.end = base64End;\n      nb = 3;\n      break;\n    default:\n      this.write = simpleWrite;\n      this.end = simpleEnd;\n      return;\n  }\n  this.lastNeed = 0;\n  this.lastTotal = 0;\n  this.lastChar = Buffer2.allocUnsafe(nb);\n}\nStringDecoder.prototype.write = function(buf) {\n  if (buf.length === 0) return "";\n  var r;\n  var i;\n  if (this.lastNeed) {\n    r = this.fillLast(buf);\n    if (r === void 0) return "";\n    i = this.lastNeed;\n    this.lastNeed = 0;\n  } else {\n    i = 0;\n  }\n  if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);\n  return r || "";\n};\nStringDecoder.prototype.end = utf8End;\nStringDecoder.prototype.text = utf8Text;\nStringDecoder.prototype.fillLast = function(buf) {\n  if (this.lastNeed <= buf.length) {\n    buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);\n    return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n  }\n  buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);\n  this.lastNeed -= buf.length;\n};\nfunction utf8CheckByte(byte) {\n  if (byte <= 127) return 0;\n  else if (byte >> 5 === 6) return 2;\n  else if (byte >> 4 === 14) return 3;\n  else if (byte >> 3 === 30) return 4;\n  return byte >> 6 === 2 ? -1 : -2;\n}\nfunction utf8CheckIncomplete(self, buf, i) {\n  var j = buf.length - 1;\n  if (j < i) return 0;\n  var nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) self.lastNeed = nb - 1;\n    return nb;\n  }\n  if (--j < i || nb === -2) return 0;\n  nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) self.lastNeed = nb - 2;\n    return nb;\n  }\n  if (--j < i || nb === -2) return 0;\n  nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) {\n      if (nb === 2) nb = 0;\n      else self.lastNeed = nb - 3;\n    }\n    return nb;\n  }\n  return 0;\n}\nfunction utf8CheckExtraBytes(self, buf, p) {\n  function replacements(n) {\n    const slice = self.lastChar.slice(0, n);\n    return new TextDecoder("utf-8").decode(slice);\n  }\n  if ((buf[0] & 192) !== 128) {\n    self.lastNeed = 0;\n    return replacements(p > 0 ? p : 1);\n  }\n  if (self.lastNeed > 1 && buf.length > 1) {\n    if ((buf[1] & 192) !== 128) {\n      self.lastChar[p] = buf[0];\n      self.lastNeed = 1;\n      return replacements(p + 1);\n    }\n    if (self.lastNeed > 2 && buf.length > 2) {\n      if ((buf[2] & 192) !== 128) {\n        self.lastChar[p] = buf[0];\n        self.lastChar[p + 1] = buf[1];\n        self.lastNeed = 2;\n        return replacements(p + 2);\n      }\n    }\n  }\n}\nfunction utf8FillLast(buf) {\n  var p = this.lastTotal - this.lastNeed;\n  var r = utf8CheckExtraBytes(this, buf, p);\n  if (r !== void 0) return r;\n  if (this.lastNeed <= buf.length) {\n    buf.copy(this.lastChar, p, 0, this.lastNeed);\n    return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n  }\n  buf.copy(this.lastChar, p, 0, buf.length);\n  this.lastNeed -= buf.length;\n}\nfunction utf8Text(buf, i) {\n  var total = utf8CheckIncomplete(this, buf, i);\n  if (!this.lastNeed) return buf.toString("utf8", i);\n  this.lastTotal = total;\n  var end = buf.length - (total - this.lastNeed);\n  buf.copy(this.lastChar, 0, end);\n  return buf.toString("utf8", i, end);\n}\nfunction utf8End(buf) {\n  var r = buf && buf.length ? this.write(buf) : "";\n  if (this.lastNeed) return r + "\\uFFFD";\n  return r;\n}\nfunction utf16Text(buf, i) {\n  if ((buf.length - i) % 2 === 0) {\n    var r = buf.toString("utf16le", i);\n    if (r) {\n      var c = r.charCodeAt(r.length - 1);\n      if (c >= 55296 && c <= 56319) {\n        this.lastNeed = 2;\n        this.lastTotal = 4;\n        this.lastChar[0] = buf[buf.length - 2];\n        this.lastChar[1] = buf[buf.length - 1];\n        return r.slice(0, -1);\n      }\n    }\n    return r;\n  }\n  this.lastNeed = 1;\n  this.lastTotal = 2;\n  this.lastChar[0] = buf[buf.length - 1];\n  return buf.toString("utf16le", i, buf.length - 1);\n}\nfunction utf16End(buf) {\n  var r = buf && buf.length ? this.write(buf) : "";\n  if (this.lastNeed) {\n    var end = this.lastTotal - this.lastNeed;\n    return r + this.lastChar.toString("utf16le", 0, end);\n  }\n  return r;\n}\nfunction base64Text(buf, i) {\n  var n = (buf.length - i) % 3;\n  if (n === 0) return buf.toString("base64", i);\n  this.lastNeed = 3 - n;\n  this.lastTotal = 3;\n  if (n === 1) {\n    this.lastChar[0] = buf[buf.length - 1];\n  } else {\n    this.lastChar[0] = buf[buf.length - 2];\n    this.lastChar[1] = buf[buf.length - 1];\n  }\n  return buf.toString("base64", i, buf.length - n);\n}\nfunction base64End(buf) {\n  var r = buf && buf.length ? this.write(buf) : "";\n  if (this.lastNeed) return r + this.lastChar.toString("base64", 0, 3 - this.lastNeed);\n  return r;\n}\nfunction simpleWrite(buf) {\n  return buf.toString(this.encoding);\n}\nfunction simpleEnd(buf) {\n  return buf && buf.length ? this.write(buf) : "";\n}\n'
+};
+
 // src/runtime/vendor-load.mjs
 var decoder4 = new TextDecoder();
 var cache = /* @__PURE__ */ new Map();
@@ -13881,12 +13991,69 @@ function evalCjs(source, filename) {
   fn(module.exports, module, require2, filename, "/");
   return module.exports;
 }
-function loadVendorCjs({ ctx, packageRoot, name, globals = {} }) {
-  const key = `${packageRoot}:${name}`;
-  if (cache.has(key)) return cache.get(key);
+function readVendorFile(ctx, packageRoot, name) {
+  if (!ctx?.sync?.fs?.readFile) return null;
   const path = `${packageRoot}/dist/vendor/${name}.cjs`;
-  const bytes = ctx.sync.fs.readFile(path);
-  const source = typeof bytes === "string" ? bytes : decoder4.decode(bytes);
+  try {
+    const bytes = ctx.sync.fs.readFile(path);
+    return typeof bytes === "string" ? bytes : decoder4.decode(bytes);
+  } catch {
+    return null;
+  }
+}
+function packageRoots(packageRoot, process2) {
+  const roots = [];
+  if (packageRoot) roots.push(packageRoot);
+  roots.push("/node_modules/@ai-ecoverse/slicc-jsh");
+  const home = process2?.env?.PNPM_HOME;
+  const homes = [
+    home,
+    "/usr/local/share/pnpm",
+    process2?.env?.HOME ? `${process2.env.HOME}/.local/share/pnpm` : null
+  ].filter(Boolean);
+  return { roots, homes };
+}
+function findOnDisk(ctx, packageRoot, name, process2) {
+  const { roots, homes } = packageRoots(packageRoot, process2);
+  for (const root of roots) {
+    const source = readVendorFile(ctx, root, name);
+    if (source != null) return { source, path: `${root}/dist/vendor/${name}.cjs` };
+  }
+  const syncFs = ctx?.sync?.fs;
+  if (!syncFs?.readdir || !syncFs?.exists) return null;
+  for (const base of homes) {
+    const v11 = `${base}/global/v11`;
+    let hashes;
+    try {
+      hashes = syncFs.readdir(v11);
+    } catch {
+      continue;
+    }
+    for (const hash of hashes) {
+      const root = `${v11}/${hash}/node_modules/@ai-ecoverse/slicc-jsh`;
+      const source = readVendorFile(ctx, root, name);
+      if (source != null) return { source, path: `${root}/dist/vendor/${name}.cjs` };
+    }
+  }
+  return null;
+}
+function loadVendorCjs({ ctx, packageRoot, name, globals = {}, process: process2 } = {}) {
+  const key = name;
+  if (cache.has(key)) return cache.get(key);
+  let source = VENDOR[name];
+  let path = `embedded:${name}`;
+  if (source == null) {
+    const found = findOnDisk(ctx, packageRoot, name, process2 ?? globals.process);
+    if (!found) {
+      const err = new Error(
+        `slicc-jsh: vendor bundle ${name} is not embedded and was not found on disk`
+      );
+      err.code = "ENOENT";
+      throw err;
+    }
+    source = found.source;
+    path = found.path;
+  }
   const saved = {};
   for (const [k, v] of Object.entries(globals)) {
     saved[k] = globalThis[k];
@@ -13913,7 +14080,8 @@ function getStreamApi({ ctx, process: process2, Buffer: Buffer2 }) {
     ctx,
     packageRoot: PACKAGE_ROOT,
     name: "readable-stream",
-    globals: { process: process2, Buffer: Buffer2 }
+    globals: { process: process2, Buffer: Buffer2 },
+    process: process2
   });
   try {
     delete mod.default;
@@ -13997,7 +14165,8 @@ function createStringDecoder({ ctx, process: process2, Buffer: Buffer2 } = {}) {
         ctx,
         packageRoot: PACKAGE_ROOT2,
         name: "string_decoder",
-        globals: { process: process2, Buffer: Buffer2 }
+        globals: { process: process2, Buffer: Buffer2 },
+        process: process2
       });
       const Base = mod.StringDecoder;
       const baseWrite = Base.prototype.write;
@@ -16019,6 +16188,8 @@ function createNextTick() {
 
 // src/runtime/process.mjs
 var NODE_SHIM_VERSION = "22.22.0";
+var SIGNAL_EXIT_CODES = { SIGTERM: 143, SIGINT: 130, SIGHUP: 129, SIGKILL: 137 };
+var SIGNAL_BY_NUMBER = { 1: "SIGHUP", 2: "SIGINT", 9: "SIGKILL", 15: "SIGTERM" };
 function toBytes2(value) {
   if (typeof value === "string") return value;
   if (value instanceof Uint8Array) return value;
@@ -16210,6 +16381,69 @@ function createStdin(ctx, handles, Buffer2) {
     }
   };
 }
+function readProcessCreds(ctx) {
+  const fromProc = (text) => {
+    let uid = 0;
+    let euid = 0;
+    let gid = 0;
+    let egid = 0;
+    let groups = [0];
+    for (const line of text.split("\n")) {
+      if (line.startsWith("Uid:")) {
+        const parts = line.slice(4).trim().split(/\s+/).map(Number);
+        uid = parts[0] ?? 0;
+        euid = parts[1] ?? uid;
+      } else if (line.startsWith("Gid:")) {
+        const parts = line.slice(4).trim().split(/\s+/).map(Number);
+        gid = parts[0] ?? 0;
+        egid = parts[1] ?? gid;
+      } else if (line.startsWith("Groups:")) {
+        const parts = line.slice(7).trim().split(/\s+/).filter(Boolean).map(Number);
+        if (parts.length) groups = parts;
+      }
+    }
+    return { uid, euid, gid, egid, groups };
+  };
+  const tryRead = (path) => {
+    try {
+      const bytes = ctx.sync?.fs?.readFile?.(path);
+      if (!bytes) return null;
+      return typeof bytes === "string" ? bytes : new TextDecoder().decode(bytes);
+    } catch {
+      return null;
+    }
+  };
+  for (const path of [`/proc/self/status`, `/proc/${ctx.pid}/status`]) {
+    const text = tryRead(path);
+    if (text) return fromProc(text);
+  }
+  const name = ctx.env?.USER || ctx.env?.LOGNAME || "root";
+  const passwd = tryRead("/etc/passwd");
+  if (passwd) {
+    for (const line of passwd.split("\n")) {
+      if (!line || line.startsWith("#")) continue;
+      const [user, , uidStr, gidStr] = line.split(":");
+      if (user !== name) continue;
+      const uid = Number(uidStr) || 0;
+      const gid = Number(gidStr) || 0;
+      const groups = [gid];
+      const group = tryRead("/etc/group");
+      if (group) {
+        for (const gline of group.split("\n")) {
+          if (!gline || gline.startsWith("#")) continue;
+          const [gname, , ggid, members] = gline.split(":");
+          const g = Number(ggid);
+          if (!Number.isFinite(g)) continue;
+          if (gname === name || members && members.split(",").includes(name)) {
+            if (!groups.includes(g)) groups.push(g);
+          }
+        }
+      }
+      return { uid, euid: uid, gid, egid: gid, groups };
+    }
+  }
+  return { uid: 0, euid: 0, gid: 0, egid: 0, groups: [0] };
+}
 var Process = class extends EventEmitter {
   constructor({ ctx, argv, nextTick, onExit, handles, Buffer: Buffer2 }) {
     super();
@@ -16325,39 +16559,55 @@ var Process = class extends EventEmitter {
   cwd() {
     return this._cwd;
   }
-  /** Root (0) until credential plumbing is exposed on process. */
+  /** Real kernel credentials (from /proc or /etc/passwd for USER). */
+  _creds() {
+    if (this._credCache) return this._credCache;
+    this._credCache = readProcessCreds(this._ctx);
+    return this._credCache;
+  }
   getuid() {
-    return 0;
+    return this._creds().uid;
   }
   geteuid() {
-    return 0;
+    return this._creds().euid;
   }
   getgid() {
-    return 0;
+    return this._creds().gid;
   }
   getegid() {
-    return 0;
+    return this._creds().egid;
   }
   getgroups() {
-    return [0];
+    return this._creds().groups.slice();
   }
   /**
-   * Minimal process.kill: only this process (pid === this.pid). Used by pnpm
-   * cmd shims to re-raise a child's terminating signal. Unknown pids → ESRCH.
+   * Minimal process.kill: this process, plus signal 0 as a liveness check.
+   * Unknown / dead pids → ESRCH (Node).
    */
   kill(pid, signal = "SIGTERM") {
     const target = Number(pid);
-    if (target !== this.pid) {
+    const esrch = () => {
       const err = new Error(`kill ESRCH`);
       err.code = "ESRCH";
       err.errno = -3;
       err.syscall = "kill";
       throw err;
+    };
+    if (signal === 0 || signal === "0") {
+      if (target !== this.pid) esrch();
+      return true;
+    }
+    if (target !== this.pid) esrch();
+    let name;
+    if (typeof signal === "string") {
+      name = signal.startsWith("SIG") ? signal : `SIG${signal}`;
+    } else if (typeof signal === "number") {
+      name = SIGNAL_BY_NUMBER[signal] ?? "SIGTERM";
+    } else {
+      name = "SIGTERM";
     }
-    const name = typeof signal === "string" ? signal.startsWith("SIG") ? signal : `SIG${signal}` : "SIGTERM";
-    if (name === "SIGTERM" || name === "SIGINT" || name === "SIGHUP" || name === "SIGKILL") {
-      const codes = { SIGTERM: 143, SIGINT: 130, SIGHUP: 129, SIGKILL: 137 };
-      this.exit(codes[name] ?? 1);
+    if (SIGNAL_EXIT_CODES[name] != null) {
+      this.exit(SIGNAL_EXIT_CODES[name]);
     }
     return true;
   }