diff --git a/crates/execution/assets/undici-shims/crypto.cjs b/crates/execution/assets/undici-shims/crypto.cjs
new file mode 100644
index 0000000000..6df49873b9
--- /dev/null
+++ b/crates/execution/assets/undici-shims/crypto.cjs
@@ -0,0 +1,40 @@
+"use strict";
+
+const crypto = require("agentos-legacy-crypto-polyfill");
+
+const RANDOM_INT_LIMIT = 2 ** 48;
+
+function randomInt(min, max, callback) {
+	if (typeof max === "function") {
+		callback = max;
+		max = min;
+		min = 0;
+	} else if (max === undefined) {
+		max = min;
+		min = 0;
+	}
+	if (
+		!Number.isSafeInteger(min) ||
+		!Number.isSafeInteger(max) ||
+		min < 0 ||
+		max <= min ||
+		max - min > RANDOM_INT_LIMIT
+	) {
+		throw new RangeError("The value of max - min is out of range");
+	}
+	const range = max - min;
+	const unbiasedLimit = RANDOM_INT_LIMIT - (RANDOM_INT_LIMIT % range);
+	let value;
+	do {
+		value = crypto.randomBytes(6).readUIntBE(0, 6);
+	} while (value >= unbiasedLimit);
+	const result = min + (value % range);
+	if (typeof callback === "function") {
+		process.nextTick(callback, null, result);
+		return;
+	}
+	return result;
+}
+
+crypto.randomInt = randomInt;
+module.exports = crypto;
diff --git a/crates/execution/assets/undici-shims/web-streams-global.js b/crates/execution/assets/undici-shims/web-streams-global.js
index ef925278b9..f365c4e959 100644
--- a/crates/execution/assets/undici-shims/web-streams-global.js
+++ b/crates/execution/assets/undici-shims/web-streams-global.js
@@ -1,77 +1,23 @@
 "use strict";
 
-import {
-	ReadableStream as WebReadableStream,
-	WritableStream as WebWritableStream,
-	TransformStream as WebTransformStream,
-} from "web-streams-polyfill/ponyfill/es2018";
-
-class FallbackTextEncoderStream {
-	constructor() {
-		const encoder = new globalThis.TextEncoder();
-		const stream = new WebTransformStream({
-			transform(chunk, controller) {
-				controller.enqueue(encoder.encode(chunk));
-			},
-		});
-
-		this.encoding = "utf-8";
-		this.readable = stream.readable;
-		this.writable = stream.writable;
+const WebReadableStream = globalThis.ReadableStream;
+const WebWritableStream = globalThis.WritableStream;
+const WebTransformStream = globalThis.TransformStream;
+const WebTextEncoderStream = globalThis.TextEncoderStream;
+const WebTextDecoderStream = globalThis.TextDecoderStream;
+
+for (const [name, constructor] of Object.entries({
+	ReadableStream: WebReadableStream,
+	WritableStream: WebWritableStream,
+	TransformStream: WebTransformStream,
+	TextEncoderStream: WebTextEncoderStream,
+	TextDecoderStream: WebTextDecoderStream,
+})) {
+	if (typeof constructor !== "function") {
+		throw new Error(`${name} was not installed by the web-platform bootstrap`);
 	}
 }
 
-class FallbackTextDecoderStream {
-	constructor(label = "utf-8", options = undefined) {
-		const decoder = new globalThis.TextDecoder(label, options);
-		const stream = new WebTransformStream({
-			transform(chunk, controller) {
-				const text = decoder.decode(chunk, { stream: true });
-				if (text.length > 0) {
-					controller.enqueue(text);
-				}
-			},
-			flush(controller) {
-				const text = decoder.decode();
-				if (text.length > 0) {
-					controller.enqueue(text);
-				}
-			},
-		});
-
-		this.encoding = decoder.encoding;
-		this.fatal = decoder.fatal;
-		this.ignoreBOM = decoder.ignoreBOM;
-		this.readable = stream.readable;
-		this.writable = stream.writable;
-	}
-}
-
-const WebTextEncoderStream =
-	typeof globalThis.TextEncoderStream === "function"
-		? globalThis.TextEncoderStream
-		: FallbackTextEncoderStream;
-const WebTextDecoderStream =
-	typeof globalThis.TextDecoderStream === "function"
-		? globalThis.TextDecoderStream
-		: FallbackTextDecoderStream;
-
-if (typeof globalThis.ReadableStream === "undefined") {
-	globalThis.ReadableStream = WebReadableStream;
-}
-if (typeof globalThis.WritableStream === "undefined") {
-	globalThis.WritableStream = WebWritableStream;
-}
-if (typeof globalThis.TransformStream === "undefined") {
-	globalThis.TransformStream = WebTransformStream;
-}
-if (typeof globalThis.TextEncoderStream === "undefined") {
-	globalThis.TextEncoderStream = WebTextEncoderStream;
-}
-if (typeof globalThis.TextDecoderStream === "undefined") {
-	globalThis.TextDecoderStream = WebTextDecoderStream;
-}
-
 export {
 	WebReadableStream,
 	WebWritableStream,
diff --git a/crates/execution/src/javascript.rs b/crates/execution/src/javascript.rs
index d71e776327..0f052c5d15 100644
--- a/crates/execution/src/javascript.rs
+++ b/crates/execution/src/javascript.rs
@@ -5483,169 +5483,17 @@ fn polyfill_expression(request: &str) -> Option<String> {
 }
 
 fn build_builtin_module_wrapper(module_name: &str) -> String {
-    if module_name == "assert" || module_name == "assert/strict" {
-        return String::from(
-            r#"class AssertionError extends Error {
-  constructor(message = "Assertion failed") {
-    super(message);
-    this.name = "AssertionError";
-  }
-}
-
-function fail(message) {
-  throw new AssertionError(message);
-}
-
-function ok(value, message) {
-  if (!value) fail(message);
-}
-
-function equal(actual, expected, message) {
-  if (actual != expected) fail(message ?? `Expected ${actual} == ${expected}`);
-}
-
-function notEqual(actual, expected, message) {
-  if (actual == expected) fail(message ?? `Expected ${actual} != ${expected}`);
-}
-
-function strictEqual(actual, expected, message) {
-  if (!Object.is(actual, expected)) fail(message ?? `Expected ${actual} to be strictly equal to ${expected}`);
-}
-
-function notStrictEqual(actual, expected, message) {
-  if (Object.is(actual, expected)) fail(message ?? `Expected ${actual} not to be strictly equal to ${expected}`);
-}
-
-function serialize(value) {
-  return JSON.stringify(value);
-}
-
-function deepEqual(actual, expected, message) {
-  if (serialize(actual) !== serialize(expected)) {
-    fail(message ?? "Expected values to be deeply equal");
-  }
-}
-
-function deepStrictEqual(actual, expected, message) {
-  return deepEqual(actual, expected, message);
-}
-
-function match(actual, expected, message) {
-  if (!(expected instanceof RegExp) || !expected.test(String(actual))) {
-    fail(message ?? `Expected ${actual} to match ${expected}`);
-  }
-}
-
-function matchesExpectedError(error, expected) {
-  if (expected == null) return true;
-  if (expected instanceof RegExp) {
-    return expected.test(String(error?.message ?? error));
-  }
-  if (typeof expected === "function") {
-    if (error instanceof expected) return true;
-    return expected(error) === true;
-  }
-  if (typeof expected === "object") {
-    return Object.entries(expected).every(([key, value]) => serialize(error?.[key]) === serialize(value));
-  }
-  return false;
-}
-
-function throws(fn, expected, message) {
-  if (typeof fn !== "function") {
-    fail(message ?? "assert.throws requires a function");
-  }
-
-  try {
-    fn();
-  } catch (error) {
-    if (!matchesExpectedError(error, expected)) {
-      throw error;
-    }
-    return error;
-  }
-
-  fail(message ?? "Missing expected exception");
-}
-
-async function rejects(promiseOrFn, expected, message) {
-  let promise;
-  if (typeof promiseOrFn === "function") {
-    promise = promiseOrFn();
-  } else {
-    promise = promiseOrFn;
-  }
-
-  try {
-    await promise;
-  } catch (error) {
-    if (!matchesExpectedError(error, expected)) {
-      throw error;
-    }
-    return error;
-  }
-
-  fail(message ?? "Missing expected rejection");
-}
-
-function ifError(error) {
-  if (error != null) {
-    throw error;
-  }
-}
-
-function assert(value, message) {
-  ok(value, message);
-}
-
-const exportedDeepEqual = __ASSERT_STRICT__ ? deepStrictEqual : deepEqual;
-const exportedEqual = __ASSERT_STRICT__ ? strictEqual : equal;
-const exportedNotEqual = __ASSERT_STRICT__ ? notStrictEqual : notEqual;
-
-Object.assign(assert, {
-  AssertionError,
-  deepEqual: exportedDeepEqual,
-  deepStrictEqual,
-  equal: exportedEqual,
-  fail,
-  ifError,
-  match,
-  notEqual: exportedNotEqual,
-  notStrictEqual,
-  ok,
-  rejects,
-  strict: assert,
-  strictEqual,
-  throws,
-});
-
-export {
-  AssertionError,
-  assert as default,
-  exportedDeepEqual as deepEqual,
-  deepStrictEqual,
-  exportedEqual as equal,
-  fail,
-  ifError,
-  match,
-  exportedNotEqual as notEqual,
-  notStrictEqual,
-  ok,
-  rejects,
-  assert as strict,
-  strictEqual,
-  throws,
-};
-"#,
-        )
-		.replace(
-			"__ASSERT_STRICT__",
-			if module_name == "assert/strict" {
-				"true"
-			} else {
-				"false"
-			},
-		);
+    if matches!(
+        module_name,
+        "assert"
+            | "assert/strict"
+            | "path"
+            | "path/posix"
+            | "path/win32"
+            | "string_decoder"
+            | "url"
+    ) {
+        return build_delegating_builtin_module_wrapper(module_name);
     }
 
     if module_name == "test" {
@@ -5773,322 +5621,6 @@ export { empty as dot, empty as junit, empty as spec, empty as tap };
         );
     }
 
-    if module_name == "path" || module_name == "path/posix" || module_name == "path/win32" {
-        return String::from(
-            r#"const sep = "/";
-const delimiter = ":";
-
-function normalizeSegments(parts) {
-  const output = [];
-  for (const part of parts) {
-    if (!part || part === ".") continue;
-    if (part === "..") {
-      if (output.length > 0) output.pop();
-      continue;
-    }
-    output.push(part);
-  }
-  return output;
-}
-
-function isAbsolute(path) {
-  return String(path || "").startsWith(sep);
-}
-
-function join(...parts) {
-  const absolute = parts.some((part, index) => index === 0 && isAbsolute(part));
-  const normalized = normalizeSegments(parts.flatMap((part) => String(part || "").split(sep)));
-  const joined = normalized.join(sep);
-  if (!joined) return absolute ? sep : ".";
-  return absolute ? `${sep}${joined}` : joined;
-}
-
-function dirname(path) {
-  const normalized = String(path || "");
-  if (!normalized || normalized === sep) return sep;
-  const parts = normalizeSegments(normalized.split(sep));
-  if (parts.length <= 1) return isAbsolute(normalized) ? sep : ".";
-  const dir = parts.slice(0, -1).join(sep);
-  return isAbsolute(normalized) ? `${sep}${dir}` : dir;
-}
-
-function basename(path) {
-  const normalized = normalizeSegments(String(path || "").split(sep));
-  return normalized.length === 0 ? "" : normalized[normalized.length - 1];
-}
-
-function extname(path) {
-  const base = basename(path);
-  const index = base.lastIndexOf(".");
-  if (index <= 0) return "";
-  return base.slice(index);
-}
-
-function resolve(...parts) {
-  const absoluteParts = [];
-  for (let index = parts.length - 1; index >= 0; index -= 1) {
-    const part = String(parts[index] || "");
-    if (!part) continue;
-    absoluteParts.unshift(part);
-    if (isAbsolute(part)) break;
-  }
-  if (absoluteParts.length === 0 || !isAbsolute(absoluteParts[0])) {
-    absoluteParts.unshift(typeof process?.cwd === "function" ? process.cwd() : sep);
-  }
-  return join(...absoluteParts);
-}
-
-function relative(from, to) {
-  const fromResolved = resolve(from);
-  const toResolved = resolve(to);
-  if (fromResolved === toResolved) return "";
-
-  const fromParts = normalizeSegments(fromResolved.split(sep));
-  const toParts = normalizeSegments(toResolved.split(sep));
-  let shared = 0;
-  while (
-    shared < fromParts.length &&
-    shared < toParts.length &&
-    fromParts[shared] === toParts[shared]
-  ) {
-    shared += 1;
-  }
-
-  const up = new Array(fromParts.length - shared).fill("..");
-  const down = toParts.slice(shared);
-  const result = [...up, ...down].join(sep);
-  return result || ".";
-}
-
-function parse(path) {
-  const root = isAbsolute(path) ? sep : "";
-  const dir = dirname(path);
-  const base = basename(path);
-  const ext = extname(path);
-  const name = ext ? base.slice(0, -ext.length) : base;
-  return { root, dir, base, ext, name };
-}
-
-function format(pathObject = {}) {
-  const dir = pathObject.dir || pathObject.root || "";
-  const base =
-    pathObject.base ||
-    `${pathObject.name || ""}${pathObject.ext || ""}`;
-  if (!dir) return base;
-  if (!base) return dir;
-  return dir.endsWith(sep) ? `${dir}${base}` : `${dir}${sep}${base}`;
-}
-
-function normalize(path) {
-  return join(String(path || ""));
-}
-
-function toNamespacedPath(path) {
-  return String(path || "");
-}
-
-const pathModule = {
-  basename,
-  delimiter,
-  dirname,
-  extname,
-  format,
-  isAbsolute,
-  join,
-  normalize,
-  parse,
-  relative,
-  resolve,
-  sep,
-  toNamespacedPath,
-};
-const posix = pathModule;
-const win32 = pathModule;
-pathModule.posix = posix;
-pathModule.win32 = win32;
-
-export { basename, delimiter, dirname, extname, format, isAbsolute, join, normalize, parse, posix, relative, resolve, sep, toNamespacedPath, win32 };
-export default pathModule;
-"#,
-        );
-    }
-
-    if module_name == "url" {
-        return String::from(
-            r#"const NativeURL = globalThis.URL;
-
-function normalizeFilePath(value) {
-  let path = String(value ?? "");
-  if (path.length === 0) {
-    return "/";
-  }
-  if (!path.startsWith("/")) path = `/${path}`;
-  const segments = [];
-  for (const segment of path.split("/")) {
-    if (!segment || segment === ".") continue;
-    if (segment === "..") segments.pop();
-    else segments.push(segment);
-  }
-  return `/${segments.join("/")}`;
-}
-
-function encodeFilePath(path) {
-  return encodeURI(path).replace(/#/g, "%23").replace(/\?/g, "%3F");
-}
-
-function buildFileUrlRecord(href, pathname) {
-  const searchParams = new URLSearchParams();
-  return {
-    href,
-    origin: "null",
-    protocol: "file:",
-    username: "",
-    password: "",
-    host: "",
-    hostname: "",
-    port: "",
-    pathname,
-    search: "",
-    searchParams,
-    hash: "",
-    toString() {
-      return href;
-    },
-    toJSON() {
-      return href;
-    },
-    valueOf() {
-      return href;
-    },
-    [Symbol.toPrimitive]() {
-      return href;
-    },
-  };
-}
-
-function fileURLToPath(value) {
-  const raw =
-    typeof value === "string"
-      ? value
-      : value && typeof value.href === "string"
-        ? value.href
-        : String(value ?? "");
-  if (raw.startsWith("/")) {
-    return raw;
-  }
-  if (raw.startsWith("file:")) {
-    let pathname = raw.startsWith("file://")
-      ? raw.slice("file://".length)
-      : raw.slice("file:".length);
-    const terminatorIndex = pathname.search(/[?#]/);
-    if (terminatorIndex >= 0) {
-      pathname = pathname.slice(0, terminatorIndex);
-    }
-    if (!pathname.startsWith("/")) {
-      const slashIndex = pathname.indexOf("/");
-      if (slashIndex === -1) {
-        return "/";
-      }
-      const host = pathname.slice(0, slashIndex);
-      if (host && host !== "localhost") {
-        throw new Error(`Expected file URL with an empty host, received ${host}`);
-      }
-      pathname = pathname.slice(slashIndex);
-    }
-    return decodeURIComponent(pathname || "/");
-  }
-  const url = value instanceof NativeURL ? value : new NativeURL(raw);
-  if (url.protocol !== "file:") {
-    throw new Error(`Expected file URL, received ${url.protocol}`);
-  }
-  return decodeURIComponent(url.pathname);
-}
-
-function pathToFileURL(path) {
-  const absolute = normalizeFilePath(path);
-  const pathname = encodeFilePath(absolute);
-  const href = `file://${pathname}`;
-
-  try {
-    return new NativeURL(href);
-  } catch {}
-
-  return buildFileUrlRecord(href, pathname);
-}
-
-function parse(input, parseQueryString = false) {
-  const parsed = new NativeURL(String(input ?? ""));
-  const queryString = parsed.search.length > 0 ? parsed.search.slice(1) : null;
-  const auth =
-    parsed.username || parsed.password
-      ? `${decodeURIComponent(parsed.username)}${parsed.password ? `:${decodeURIComponent(parsed.password)}` : ""}`
-      : null;
-  return {
-    href: parsed.href,
-    protocol: parsed.protocol,
-    slashes: true,
-    auth,
-    host: parsed.host,
-    port: parsed.port || null,
-    hostname: parsed.hostname,
-    hash: parsed.hash || null,
-    search: parsed.search || null,
-    query: parseQueryString ? Object.fromEntries(parsed.searchParams.entries()) : queryString,
-    pathname: parsed.pathname,
-    path: `${parsed.pathname}${parsed.search}`,
-  };
-}
-
-function format(value) {
-  if (value == null) return "";
-  if (typeof value === "string") return value;
-  if (typeof value.href === "string") return value.href;
-
-  const protocol = typeof value.protocol === "string" ? value.protocol : "http:";
-  const slashes = value.slashes === false ? "" : "//";
-  const auth =
-    typeof value.auth === "string" && value.auth.length > 0 ? `${value.auth}@` : "";
-  const host =
-    typeof value.host === "string" && value.host.length > 0
-      ? value.host
-      : `${value.hostname || ""}${value.port ? `:${value.port}` : ""}`;
-  const pathname =
-    typeof value.pathname === "string"
-      ? value.pathname
-      : typeof value.path === "string"
-        ? value.path
-        : "";
-
-  let search = "";
-  if (typeof value.search === "string") {
-    search = value.search;
-  } else if (typeof value.query === "string" && value.query.length > 0) {
-    search = value.query.startsWith("?") ? value.query : `?${value.query}`;
-  } else if (value.query && typeof value.query === "object") {
-    const params = new URLSearchParams();
-    for (const [key, entry] of Object.entries(value.query)) {
-      if (Array.isArray(entry)) {
-        for (const item of entry) {
-          params.append(key, String(item));
-        }
-      } else if (entry != null) {
-        params.append(key, String(entry));
-      }
-    }
-    const encoded = params.toString();
-    search = encoded ? `?${encoded}` : "";
-  }
-
-  const hash = typeof value.hash === "string" ? value.hash : "";
-  return `${protocol}${slashes}${auth}${host}${pathname}${search}${hash}`;
-}
-
-export { NativeURL as URL, fileURLToPath, format, parse, pathToFileURL };
-export default { URL: NativeURL, fileURLToPath, format, parse, pathToFileURL };
-"#,
-        );
-    }
-
     if module_name == "readline" {
         return String::from(
             r#"class MiniEmitter {
@@ -6284,483 +5816,6 @@ export default { createInterface };
     // for compatibility archaeology. The active `node:stream` wrapper must
     // fall through to the runtime builtin so ESM and CommonJS share constructor
     // identity (including the Duplex used by node:net.Socket).
-    if module_name == "__legacy_embedded_stream" {
-        return String::from(
-            r#"class MiniEmitter {
-  constructor() {
-    this._listeners = new Map();
-    this._onceListeners = new Map();
-  }
-
-  on(event, listener) {
-    const listeners = this._listeners.get(event) ?? [];
-    listeners.push(listener);
-    this._listeners.set(event, listeners);
-    return this;
-  }
-
-  once(event, listener) {
-    const listeners = this._onceListeners.get(event) ?? [];
-    listeners.push(listener);
-    this._onceListeners.set(event, listeners);
-    return this;
-  }
-
-  off(event, listener) {
-    for (const map of [this._listeners, this._onceListeners]) {
-      const listeners = map.get(event) ?? [];
-      map.set(
-        event,
-        listeners.filter((candidate) => candidate !== listener),
-      );
-    }
-    return this;
-  }
-
-  removeListener(event, listener) {
-    return this.off(event, listener);
-  }
-
-  emit(event, ...args) {
-    const persistent = [...(this._listeners.get(event) ?? [])];
-    const once = [...(this._onceListeners.get(event) ?? [])];
-    this._onceListeners.delete(event);
-    for (const listener of persistent) {
-      listener(...args);
-    }
-    for (const listener of once) {
-      listener(...args);
-    }
-    return persistent.length + once.length > 0;
-  }
-}
-
-function getCallback(encodingOrCallback, callback) {
-  if (typeof encodingOrCallback === "function") return encodingOrCallback;
-  if (typeof callback === "function") return callback;
-  return null;
-}
-
-function queueResult(callback, error = null) {
-  if (typeof callback !== "function") return;
-  queueMicrotask(() => callback(error));
-}
-
-function createReadableAsyncIterator(stream) {
-  const queuedChunks = [];
-  let pendingResolve = null;
-  let pendingReject = null;
-  let done = stream?.readableEnded === true;
-  let error = stream?.errored ?? null;
-
-  const cleanup = () => {
-    stream?.off?.("data", onData);
-    stream?.off?.("end", onEnd);
-    stream?.off?.("close", onEnd);
-    stream?.off?.("error", onError);
-  };
-
-  const settlePending = (result) => {
-    if (pendingResolve) {
-      const resolve = pendingResolve;
-      pendingResolve = null;
-      pendingReject = null;
-      resolve(result);
-    }
-  };
-
-  const rejectPending = (reason) => {
-    if (pendingReject) {
-      const reject = pendingReject;
-      pendingResolve = null;
-      pendingReject = null;
-      reject(reason);
-    }
-  };
-
-  const onData = (chunk) => {
-    if (pendingResolve) {
-      settlePending({ done: false, value: chunk });
-      return;
-    }
-    queuedChunks.push(chunk);
-  };
-
-  const onEnd = () => {
-    if (done) return;
-    done = true;
-    cleanup();
-    settlePending({ done: true, value: void 0 });
-  };
-
-  const onError = (reason) => {
-    error = reason;
-    done = true;
-    cleanup();
-    rejectPending(reason);
-  };
-
-  const pull = () => {
-    if (done || typeof stream?._read !== "function") {
-      return;
-    }
-    try {
-      stream._read();
-    } catch (reason) {
-      stream.errored = reason;
-      onError(reason);
-    }
-  };
-
-  stream?.on?.("data", onData);
-  stream?.on?.("end", onEnd);
-  stream?.on?.("close", onEnd);
-  stream?.on?.("error", onError);
-
-  return {
-    next() {
-      if (error) {
-        return Promise.reject(error);
-      }
-      if (queuedChunks.length > 0) {
-        return Promise.resolve({ done: false, value: queuedChunks.shift() });
-      }
-      if (done) {
-        return Promise.resolve({ done: true, value: void 0 });
-      }
-      pull();
-      if (queuedChunks.length > 0) {
-        return Promise.resolve({ done: false, value: queuedChunks.shift() });
-      }
-      if (done) {
-        return Promise.resolve({ done: true, value: void 0 });
-      }
-      return new Promise((resolve, reject) => {
-        pendingResolve = resolve;
-        pendingReject = reject;
-      });
-    },
-    return() {
-      done = true;
-      cleanup();
-      stream?.destroy?.();
-      return Promise.resolve({ done: true, value: void 0 });
-    },
-    [Symbol.asyncIterator]() {
-      return this;
-    },
-  };
-}
-
-class Stream extends MiniEmitter {
-  pipe(destination) {
-    this.on("data", (chunk) => destination.write(chunk));
-    this.once("end", () => destination.end());
-    return destination;
-  }
-
-  destroy(error) {
-    if (this.destroyed) return this;
-    this.destroyed = true;
-    if (error) {
-      this.errored = error;
-      queueMicrotask(() => this.emit("error", error));
-    }
-    queueMicrotask(() => this.emit("close"));
-    return this;
-  }
-}
-
-class Readable extends Stream {
-  constructor() {
-    super();
-    this.readable = true;
-    this.readableEnded = false;
-    this.destroyed = false;
-  }
-
-  push(chunk) {
-    if (chunk === null) {
-      if (!this.readableEnded) {
-        this.readableEnded = true;
-        queueMicrotask(() => {
-          this.emit("end");
-          this.emit("close");
-        });
-      }
-      return false;
-    }
-    this.emit("data", Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk ?? []));
-    return true;
-  }
-
-  static fromWeb(stream) {
-    if (!stream || typeof stream.getReader !== "function") {
-      throw new TypeError("Readable.fromWeb expects a WHATWG ReadableStream");
-    }
-    return {
-      async *[Symbol.asyncIterator]() {
-        const reader = stream.getReader();
-        try {
-          while (true) {
-            const { value, done } = await reader.read();
-            if (done) break;
-            yield Buffer.from(value ?? []);
-          }
-        } finally {
-          reader.releaseLock?.();
-        }
-      },
-    };
-  }
-
-  [Symbol.asyncIterator]() {
-    return createReadableAsyncIterator(this);
-  }
-}
-
-class Writable extends Stream {
-  constructor(options = undefined) {
-    super();
-    this.writable = true;
-    this.writableEnded = false;
-    this.destroyed = false;
-    this._writeOption =
-      options && typeof options.write === "function" ? options.write : null;
-    this._destroyOption =
-      options && typeof options.destroy === "function" ? options.destroy : null;
-  }
-
-  write(chunk, encodingOrCallback, callback) {
-    if (this.writableEnded) {
-      const error = new Error("write after end");
-      queueResult(getCallback(encodingOrCallback, callback), error);
-      this.emit("error", error);
-      return false;
-    }
-    const done = getCallback(encodingOrCallback, callback);
-    this._write(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk ?? []), done);
-    return true;
-  }
-
-  _write(_chunk, callback) {
-    if (!this._writeOption) {
-      queueResult(callback);
-      return;
-    }
-    try {
-      this._writeOption.call(this, _chunk, "buffer", callback);
-    } catch (error) {
-      queueResult(callback, error);
-    }
-  }
-
-  _destroy(error, callback) {
-    if (!this._destroyOption) {
-      queueResult(callback, error);
-      return;
-    }
-    try {
-      this._destroyOption.call(this, error ?? null, callback);
-    } catch (destroyError) {
-      queueResult(callback, destroyError);
-    }
-  }
-
-  destroy(error) {
-    if (this.destroyed) return this;
-    this.destroyed = true;
-    this._destroy(error ?? null, (destroyError) => {
-      const finalError = destroyError ?? error;
-      if (finalError) {
-        this.errored = finalError;
-        this.emit("error", finalError);
-      }
-      this.emit("close");
-    });
-    return this;
-  }
-
-  end(chunk, encodingOrCallback, callback) {
-    if (chunk !== undefined && chunk !== null) {
-      this.write(chunk, encodingOrCallback);
-    }
-    if (this.writableEnded) {
-      queueResult(getCallback(encodingOrCallback, callback));
-      return this;
-    }
-    this.writableEnded = true;
-    const done = getCallback(encodingOrCallback, callback);
-    queueMicrotask(() => {
-      queueResult(done);
-      this.emit("finish");
-      this.destroy();
-    });
-    return this;
-  }
-}
-
-class Duplex extends Readable {
-  constructor() {
-    super();
-    this.writable = true;
-    this.writableEnded = false;
-  }
-
-  write(chunk, encodingOrCallback, callback) {
-    return Writable.prototype.write.call(this, chunk, encodingOrCallback, callback);
-  }
-
-  _write(chunk, callback) {
-    queueResult(callback);
-  }
-
-  end(chunk, encodingOrCallback, callback) {
-    return Writable.prototype.end.call(this, chunk, encodingOrCallback, callback);
-  }
-}
-
-class Transform extends Duplex {
-  _write(chunk, callback) {
-    try {
-      this._transform(chunk, "buffer", (error, output) => {
-        if (!error && output !== undefined && output !== null) {
-          this.push(output);
-        }
-        queueResult(callback, error ?? null);
-      });
-    } catch (error) {
-      queueResult(callback, error);
-      this.emit("error", error);
-    }
-  }
-
-  _transform(chunk, _encoding, callback) {
-    callback(null, chunk);
-  }
-
-  end(chunk, encodingOrCallback, callback) {
-    Writable.prototype.end.call(this, chunk, encodingOrCallback, callback);
-    this.push(null);
-    return this;
-  }
-}
-
-class PassThrough extends Transform {}
-
-function finished(stream, callback) {
-  const done = (error = null) => {
-    cleanup();
-    if (typeof callback === "function") callback(error);
-  };
-  const onFinish = () => done();
-  const onEnd = () => done();
-  const onClose = () => done();
-  const onError = (error) => done(error);
-  const cleanup = () => {
-    stream?.off?.("finish", onFinish);
-    stream?.off?.("end", onEnd);
-    stream?.off?.("close", onClose);
-    stream?.off?.("error", onError);
-  };
-  stream?.once?.("finish", onFinish);
-  stream?.once?.("end", onEnd);
-  stream?.once?.("close", onClose);
-  stream?.once?.("error", onError);
-  return cleanup;
-}
-
-function pipeline(...streams) {
-  const callback =
-    streams.length > 0 && typeof streams[streams.length - 1] === "function"
-      ? streams.pop()
-      : null;
-  if (streams.length < 2) {
-    const error = new TypeError("pipeline requires at least two streams");
-    callback?.(error);
-    throw error;
-  }
-  for (let index = 0; index < streams.length - 1; index += 1) {
-    streams[index].pipe(streams[index + 1]);
-  }
-  if (callback) {
-    finished(streams[streams.length - 1], callback);
-  }
-  return streams[streams.length - 1];
-}
-
-function compose(...streams) {
-  return pipeline(...streams);
-}
-
-function addAbortSignal(signal, stream) {
-  if (signal?.aborted) {
-    stream?.destroy?.(signal.reason);
-    return stream;
-  }
-  signal?.addEventListener?.("abort", () => stream?.destroy?.(signal.reason), {
-    once: true,
-  });
-  return stream;
-}
-
-function isReadable(stream) {
-  return Boolean(stream && stream.readable && !stream.destroyed);
-}
-
-function isWritable(stream) {
-  return Boolean(stream && stream.writable && !stream.destroyed);
-}
-
-function isErrored(stream) {
-  return Boolean(stream && stream.errored);
-}
-
-function isDisturbed(stream) {
-  return Boolean(
-    stream && (stream.disturbed === true || stream.locked || stream.readableDidRead === true),
-  );
-}
-
-const streamModule = Stream;
-Object.assign(streamModule, {
-  Duplex,
-  PassThrough,
-  Readable,
-  Stream,
-  Transform,
-  Writable,
-  addAbortSignal,
-  compose,
-  finished,
-  isDisturbed,
-  isErrored,
-  isReadable,
-  isWritable,
-  pipeline,
-});
-
-export {
-  Duplex,
-  PassThrough,
-  Readable,
-  Stream,
-  Transform,
-  Writable,
-  addAbortSignal,
-  compose,
-  finished,
-  isDisturbed,
-  isErrored,
-  isReadable,
-  isWritable,
-  pipeline,
-};
-export default streamModule;
-"#,
-        );
-    }
-
     if module_name == "stream/promises" {
         return String::from(
             r#"const _m = globalThis._requireFrom("node:stream/promises", "/");
@@ -7019,40 +6074,6 @@ export { createInterface };
         );
     }
 
-    if module_name == "string_decoder" {
-        return String::from(
-            r#"class StringDecoder {
-  constructor(encoding = "utf8") {
-    this.encoding = encoding;
-    this.decoder = new TextDecoder(encoding, { fatal: false });
-  }
-
-  write(input) {
-    const buffer =
-      typeof input === "string"
-        ? Buffer.from(input, this.encoding)
-        : Buffer.isBuffer(input)
-          ? input
-          : Buffer.from(input ?? []);
-    return this.decoder.decode(buffer, { stream: true });
-  }
-
-  end(input) {
-    let output = "";
-    if (input !== undefined) {
-      output += this.write(input);
-    }
-    output += this.decoder.decode();
-    return output;
-  }
-}
-
-export { StringDecoder };
-export default { StringDecoder };
-"#,
-        );
-    }
-
     if module_name == "v8" {
         return String::from(
             r#"function serialize(value) {
@@ -7489,6 +6510,10 @@ export default {
         );
     }
 
+    build_delegating_builtin_module_wrapper(module_name)
+}
+
+fn build_delegating_builtin_module_wrapper(module_name: &str) -> String {
     let default_target = format!(
         "globalThis._requireFrom({}, \"/\")",
         serde_json::to_string(&format!("node:{module_name}"))
@@ -7510,6 +6535,29 @@ export default {
 
 fn builtin_named_exports(module_name: &str) -> &'static [&'static str] {
     match module_name {
+        "assert" | "assert/strict" => &[
+            "AssertionError",
+            "CallTracker",
+            "deepEqual",
+            "deepStrictEqual",
+            "doesNotMatch",
+            "doesNotReject",
+            "doesNotThrow",
+            "equal",
+            "fail",
+            "ifError",
+            "match",
+            "notDeepEqual",
+            "notDeepStrictEqual",
+            "notEqual",
+            "notStrictEqual",
+            "ok",
+            "partialDeepStrictEqual",
+            "rejects",
+            "strict",
+            "strictEqual",
+            "throws",
+        ],
         "async_hooks" => &[
             "AsyncLocalStorage",
             "AsyncResource",
@@ -7525,6 +6573,7 @@ fn builtin_named_exports(module_name: &str) -> &'static [&'static str] {
             "SlowBuffer",
             "isAscii",
             "isUtf8",
+            "resolveObjectURL",
         ],
         "child_process" => &[
             "ChildProcess",
@@ -8039,8 +7088,22 @@ fn builtin_named_exports(module_name: &str) -> &'static [&'static str] {
             "rootCertificates",
         ],
         "stream/promises" => &["finished", "pipeline"],
+        "string_decoder" => &["StringDecoder"],
         "timers/promises" => &["scheduler", "setImmediate", "setInterval", "setTimeout"],
-        "url" => &["URL", "fileURLToPath", "format", "parse", "pathToFileURL"],
+        "url" => &[
+            "URL",
+            "URLSearchParams",
+            "Url",
+            "domainToASCII",
+            "domainToUnicode",
+            "fileURLToPath",
+            "format",
+            "parse",
+            "pathToFileURL",
+            "resolve",
+            "resolveObject",
+            "urlToHttpOptions",
+        ],
         "util" => &[
             "MIMEType",
             "MIMEParams",
diff --git a/crates/native-sidecar/src/execution/javascript/http.rs b/crates/native-sidecar/src/execution/javascript/http.rs
index 6ceb178b43..291303eca5 100644
--- a/crates/native-sidecar/src/execution/javascript/http.rs
+++ b/crates/native-sidecar/src/execution/javascript/http.rs
@@ -4,6 +4,7 @@ use crate::state::DeferredRpcError;
 const HTTP_LOOPBACK_REQUEST_TIMEOUT: Duration = Duration::from_secs(30);
 const VM_FETCH_STREAM_CHUNK_MAX_BYTES: usize = 64 * 1024;
 const VM_FETCH_STREAM_COUNT_LIMIT: usize = 256;
+type VmFetchResponseHead = (u16, String, Vec<(String, String)>, VmFetchBodyMode);
 
 fn http_loopback_request_timeout() -> Duration {
     std::env::var(HTTP_LOOPBACK_REQUEST_TIMEOUT_MS_ENV)
@@ -272,7 +273,7 @@ fn parse_stream_response_head(
     bytes: &[u8],
     request_method: &str,
     max_response_bytes: usize,
-) -> Result<(u16, String, Vec<(String, String)>, VmFetchBodyMode), SidecarError> {
+) -> Result<VmFetchResponseHead, SidecarError> {
     let text = std::str::from_utf8(bytes).map_err(|error| {
         SidecarError::Execution(format!(
             "ERR_AGENTOS_VM_FETCH_INVALID_RESPONSE: response headers were not UTF-8: {error}"
diff --git a/crates/native-sidecar/tests/builtin_conformance.rs b/crates/native-sidecar/tests/builtin_conformance.rs
index 48bc702cda..aea2370d7a 100644
--- a/crates/native-sidecar/tests/builtin_conformance.rs
+++ b/crates/native-sidecar/tests/builtin_conformance.rs
@@ -71,6 +71,8 @@ const BUILTIN_CONFORMANCE_CASES: &[&str] = &[
     "buffer",
     "url",
     "stdlib_polyfill",
+    "web_streams",
+    "regexp",
     "extended_builtin_polyfills",
 ];
 
@@ -3338,16 +3340,23 @@ import { createRequire } from "node:module";
 const require = createRequire(import.meta.url);
 const events = require("events");
 const nodeEvents = require("node:events");
+const util = require("node:util");
 
 const emitter = new EventEmitter();
 class DerivedEmitter extends require("events") {}
 const derived = new DerivedEmitter();
 const constructed = new (require("events"))();
+function LegacyEmitter() {
+  events.call(this);
+}
+util.inherits(LegacyEmitter, events);
+const legacy = new LegacyEmitter();
 const seen = [];
 const metaNew = [];
 const metaRemove = [];
 const constructedSeen = [];
 const derivedSeen = [];
+const legacySeen = [];
 const warningEvents = [];
 
 function persistent(value) {
@@ -3422,6 +3431,11 @@ derived.on("tick", (value) => {
 });
 const derivedEmitHandled = derived.emit("tick", "delta");
 
+legacy.on("tick", (value) => {
+  legacySeen.push(`legacy:${value}`);
+});
+const legacyEmitHandled = legacy.emit("tick", "epsilon");
+
 process.on("warning", (warning) => {
   warningEvents.push({
     name: warning.name,
@@ -3445,21 +3459,181 @@ for (let index = 0; index < 12; index += 1) {
   zeroMaxListenersEmitter.on("disabled-warning-check", () => {});
 }
 
+const domTarget = new EventTarget();
+events.setMaxListeners(23, domTarget);
+const domMaxListeners = events.getMaxListeners(domTarget);
+const domSeen = [];
+const coercedType = { toString: () => "coerced" };
+domTarget.addEventListener(coercedType, () => domSeen.push("coerced"));
+domTarget.dispatchEvent(new Event("coerced"));
+domTarget.addEventListener("propagation", (event) => {
+  domSeen.push("stop");
+  event.stopPropagation();
+});
+domTarget.addEventListener("propagation", () => domSeen.push("after-stop"));
+domTarget.dispatchEvent(new Event("propagation"));
+domTarget.addEventListener("immediate", (event) => {
+  domSeen.push("immediate");
+  event.stopImmediatePropagation();
+});
+domTarget.addEventListener("immediate", () => domSeen.push("after-immediate"));
+domTarget.dispatchEvent(new Event("immediate"));
+const onceReentrant = () => {
+  domSeen.push("once");
+  domTarget.dispatchEvent(new Event("reentrant"));
+};
+domTarget.addEventListener("reentrant", onceReentrant, { once: true });
+domTarget.dispatchEvent(new Event("reentrant"));
+const objectListener = {
+  handleEvent() {
+    domSeen.push(this === objectListener ? "object-this" : "object-wrong-this");
+  },
+};
+domTarget.addEventListener("object", objectListener);
+domTarget.dispatchEvent(new Event("object"));
+const passiveEvent = new Event("passive", { cancelable: true });
+domTarget.addEventListener("passive", (event) => event.preventDefault(), {
+  passive: true,
+});
+const passiveDispatchResult = domTarget.dispatchEvent(passiveEvent);
+const canceledEvent = new Event("cancel", { cancelable: true });
+domTarget.addEventListener("cancel", (event) => event.preventDefault());
+const canceledDispatchResult = domTarget.dispatchEvent(canceledEvent);
+const signalController = new AbortController();
+domTarget.addEventListener("signaled", () => domSeen.push("signaled"), {
+  signal: signalController.signal,
+});
+signalController.abort();
+domTarget.dispatchEvent(new Event("signaled"));
+let eventSymbolErrorName = null;
+try {
+  new Event(Symbol("event"));
+} catch (error) {
+  eventSymbolErrorName = error?.name ?? null;
+}
+let listenerSymbolErrorName = null;
+try {
+  domTarget.addEventListener(Symbol("event"), () => {});
+} catch (error) {
+  listenerSymbolErrorName = error?.name ?? null;
+}
+let eventTypeReadonly = false;
+const readonlyEvent = new Event("readonly");
+try {
+  readonlyEvent.type = "changed";
+} catch (error) {
+  eventTypeReadonly = error instanceof TypeError;
+}
+
+const defaultAbortController = new AbortController();
+let defaultAbortEvents = 0;
+defaultAbortController.signal.addEventListener("abort", () => {
+  defaultAbortEvents += 1;
+});
+defaultAbortController.abort();
+defaultAbortController.abort(new Error("ignored"));
+
+const onabortController = new AbortController();
+let onabortCount = 0;
+onabortController.signal.onabort = () => {
+  onabortCount += 1;
+};
+onabortController.signal.onabort = () => {
+  onabortCount += 10;
+};
+onabortController.abort();
+
+const primitiveAbortController = new AbortController();
+primitiveAbortController.abort(17);
+let primitiveThrowExact = false;
+try {
+  primitiveAbortController.signal.throwIfAborted();
+} catch (error) {
+  primitiveThrowExact = error === 17;
+}
+
+const timeoutSignal = AbortSignal.timeout(0);
+await new Promise((resolve) => {
+  const keepAlive = setTimeout(resolve, 50);
+  timeoutSignal.addEventListener("abort", () => {
+    clearTimeout(keepAlive);
+    resolve();
+  }, { once: true });
+});
+
+const anyFirst = new AbortController();
+const anySecond = new AbortController();
+const anySignal = AbortSignal.any([anyFirst.signal, anySecond.signal]);
+anySecond.abort("second-reason");
+let invalidAnyRejected = false;
+try {
+  AbortSignal.any([anyFirst.signal, {
+    aborted: false,
+    addEventListener() {},
+    removeEventListener() {},
+  }]);
+} catch (error) {
+  invalidAnyRejected = error instanceof TypeError;
+}
+const emptyAnySignal = AbortSignal.any([]);
+let illegalAbortSignalCode = null;
+try {
+  new AbortSignal();
+} catch (error) {
+  illegalAbortSignalCode = error?.code ?? null;
+}
+let abortStateReadonly = false;
+try {
+  defaultAbortController.signal.aborted = false;
+} catch (error) {
+  abortStateReadonly = error instanceof TypeError;
+}
+let fractionalTimeoutCode = null;
+try {
+  AbortSignal.timeout(1.5);
+} catch (error) {
+  fractionalTimeoutCode = error?.code ?? null;
+}
+
 await new Promise((resolve) => setTimeout(resolve, 0));
 
 console.log(JSON.stringify({
+  abortStateReadonly,
+  anyReason: anySignal.reason,
+  defaultAbortEvents,
+  defaultAbortReasonName: defaultAbortController.signal.reason.name,
+  emptyAnyAborted: emptyAnySignal.aborted,
+  eventSymbolErrorName,
+  eventTypeReadonly,
+  fractionalTimeoutCode,
+  illegalAbortSignalCode,
+  invalidAnyRejected,
+  listenerSymbolErrorName,
+  onabortCount,
+  primitiveThrowExact,
+  staticAbortReasonName: AbortSignal.abort().reason.name,
+  timeoutReasonName: timeoutSignal.reason.name,
   bareEqualsNode: events === nodeEvents,
   cjsEqualsEventEmitter: events === EventEmitter,
   bareType: typeof events,
   nodeType: typeof nodeEvents,
   eventEmitterPropEqualsSelf: events.EventEmitter === events,
   nodeEventEmitterPropEqualsSelf: nodeEvents.EventEmitter === nodeEvents,
+  canceledDefaultPrevented: canceledEvent.defaultPrevented,
+  canceledDispatchResult,
   constructedInstanceWorks: constructed instanceof EventEmitter,
   constructedEmitHandled,
   constructedSeen,
   derivedInstanceWorks: derived instanceof EventEmitter,
   derivedEmitHandled,
   derivedSeen,
+  domMaxListeners,
+  legacyInstanceWorks: legacy instanceof EventEmitter,
+  legacyEmitHandled,
+  legacySeen,
+  domSeen,
+  passiveDefaultPrevented: passiveEvent.defaultPrevented,
+  passiveDispatchResult,
   visibleListenersIsArray: Array.isArray(visibleListeners),
   visibleRawListenersIsArray: Array.isArray(visibleRawListeners),
   listenersUnwrapOnce: visibleListeners?.[0] === onceVisible,
@@ -3731,6 +3905,29 @@ const setSemantics = new URLSearchParamsCtor("a=1&b=2&a=3&a=4&c=5");
 setSemantics.set("a", "z");
 
 const parsed = urlModule.parse("https://example.com/a/b?x=1&y=two#frag", true);
+const describeFileUrlError = (callback) => {
+  try {
+    callback();
+    return null;
+  } catch (error) {
+    return { name: error.name, code: error.code ?? null };
+  }
+};
+const encodedFileUrl = urlModule.pathToFileURL("/tmp/a #?%/ü/");
+const decodedFilePath = urlModule.fileURLToPath(encodedFileUrl);
+const localhostFilePath = urlModule.fileURLToPath("file://localhost/tmp/a%20b");
+const windowsFilePath = urlModule.fileURLToPath(
+  "file:///C:/Users/a%20b",
+  { windows: true },
+);
+const windowsUncPath = urlModule.fileURLToPath(
+  "file://server/share/a",
+  { windows: true },
+);
+const windowsFileUrl = urlModule.pathToFileURL(
+  "C:\\Users\\a #?b",
+  { windows: true },
+);
 
 console.log(JSON.stringify({
   href: url.href,
@@ -3744,6 +3941,30 @@ console.log(JSON.stringify({
   setSearchParamsSize: setSemantics.size,
   fileRelativeHref: fileRelative.href,
   fileRelativeNoBaseHref: fileRelativeNoBase.href,
+  encodedFileUrl: encodedFileUrl.href,
+  decodedFilePath,
+  localhostFilePath,
+  windowsFilePath,
+  windowsFileUrl: windowsFileUrl.href,
+  windowsUncPath,
+  encodedSlashError: describeFileUrlError(() =>
+    urlModule.fileURLToPath("file:///tmp/a%2Fb")
+  ),
+  invalidFileUrlHostError: describeFileUrlError(() =>
+    urlModule.fileURLToPath("file://example.com/tmp/a")
+  ),
+  invalidFileUrlTypeError: describeFileUrlError(() =>
+    urlModule.fileURLToPath({})
+  ),
+  invalidUrlError: describeFileUrlError(() =>
+    urlModule.fileURLToPath("not a url")
+  ),
+  invalidSchemeError: describeFileUrlError(() =>
+    urlModule.fileURLToPath("https://example.com/a")
+  ),
+  malformedPercentError: describeFileUrlError(() =>
+    urlModule.fileURLToPath("file:///tmp/%")
+  ),
   dataUrlHref: dataUrl.href,
   dataUrlProtocol: dataUrl.protocol,
   dataUrlPathname: dataUrl.pathname,
@@ -3769,6 +3990,16 @@ fn stdlib_polyfill_conformance_matches_host_node() {
         "stdlib-polyfills",
         r#"
 import { createRequire } from "node:module";
+import assertDefault, * as assertModule from "node:assert";
+import strictAssertDefault from "node:assert/strict";
+import pathDefault, * as pathModule from "node:path";
+import pathPosixDefault from "node:path/posix";
+import pathWin32Default from "node:path/win32";
+import stringDecoderDefault, { StringDecoder } from "node:string_decoder";
+import urlDefault, {
+  URL as ImportedURL,
+  URLSearchParams as ImportedURLSearchParams,
+} from "node:url";
 
 const require = createRequire(import.meta.url);
 const assert = require("node:assert");
@@ -3781,6 +4012,22 @@ const util = require("node:util");
 const utilTypes = require("node:util/types");
 const zlib = require("node:zlib");
 
+assert.strictEqual(assertDefault, assert);
+assert.strictEqual(assertModule.default, assert);
+assert.strictEqual(strictAssertDefault, require("node:assert/strict"));
+assert.strictEqual(pathDefault, path);
+assert.strictEqual(pathModule.default, path);
+assert.strictEqual(pathPosixDefault, require("node:path/posix"));
+assert.strictEqual(pathWin32Default, require("node:path/win32"));
+assert.strictEqual(stringDecoderDefault, stringDecoder);
+assert.strictEqual(StringDecoder, stringDecoder.StringDecoder);
+assert.strictEqual(urlDefault, require("node:url"));
+assert.strictEqual(ImportedURL, require("node:url").URL);
+assert.strictEqual(
+  ImportedURLSearchParams,
+  require("node:url").URLSearchParams,
+);
+
 assert.deepStrictEqual(path.normalize?.("/alpha/../beta"), "/beta");
 assert.notStrictEqual(1, 2);
 assert.strictEqual(typeof assert.fail, "function");
@@ -3817,6 +4064,59 @@ const formatted = util.format("value:%s count:%d json:%j", "alpha", 7, { ok: tru
 const promisified = await util.promisify((value, callback) => callback(null, value.toUpperCase()))("beta");
 const encodedLength = new util.TextEncoder().encode("Grüße").length;
 const decodedText = new util.TextDecoder().decode(textBytes);
+const malformedSurrogateBytes = Array.from(new TextEncoder().encode("\ud800A"));
+const encodeIntoDestination = new Uint8Array(4);
+const encodeIntoResult = new TextEncoder().encodeInto(
+  "A\u{1f600}",
+  encodeIntoDestination,
+);
+const streamingDecoder = new TextDecoder();
+const streamingDecoded =
+  streamingDecoder.decode(new Uint8Array([0xe2, 0x82]), { stream: true }) +
+  streamingDecoder.decode(new Uint8Array([0xac]));
+const maximalSubpartDecoded = new TextDecoder().decode(
+  new Uint8Array([0xe1, 0x80, 0x41]),
+);
+const utf16BeDecoded = new TextDecoder("utf-16be").decode(
+  new Uint8Array([0xfe, 0xff, 0x00, 0x41]),
+);
+const utf16LeStreamDecoder = new TextDecoder("utf-16le");
+const utf16LeStreamDecoded =
+  utf16LeStreamDecoder.decode(new Uint8Array([0x3d, 0xd8, 0x00]), {
+    stream: true,
+  }) +
+  utf16LeStreamDecoder.decode(new Uint8Array([0xde]));
+let fatalDecodeCode = null;
+try {
+  new TextDecoder("utf-8", { fatal: true }).decode(
+    new Uint8Array([0xc0]),
+  );
+} catch (error) {
+  fatalDecodeCode = error?.code ?? null;
+}
+let unsupportedEncodingCode = null;
+try {
+  new TextDecoder("not-an-encoding");
+} catch (error) {
+  unsupportedEncodingCode = error?.code ?? null;
+}
+let symbolEncodingErrorName = null;
+try {
+  new TextDecoder(Symbol("utf-8"));
+} catch (error) {
+  symbolEncodingErrorName = error?.name ?? null;
+}
+const streamGetterError = new TypeError("stream getter");
+let streamGetterPreserved = false;
+try {
+  new TextDecoder("utf-8", { fatal: true }).decode(new Uint8Array(), {
+    get stream() {
+      throw streamGetterError;
+    },
+  });
+} catch (error) {
+  streamGetterPreserved = error === streamGetterError;
+}
 
 const deflated = zlib.deflateSync(Buffer.from("secure-exec", "utf8"));
 const inflated = zlib.inflateSync(deflated).toString("utf8");
@@ -3830,20 +4130,335 @@ console.log(JSON.stringify({
   decoded,
   decodedText,
   deflatedBase64: deflated.toString("base64"),
+  encodeIntoBytes: Array.from(encodeIntoDestination),
+  encodeIntoResult,
   encodedLength,
+  fatalDecodeCode,
   formatted,
   inflated,
   isArrayBufferView: util.types.isArrayBufferView(textBytes),
   isDateViaUtilTypes: utilTypes.isDate(new Date("2024-01-01T00:00:00Z")),
   isMapViaUtilTypes: utilTypes.isMap(new Map([["alpha", 1]])),
+  isTextDecoderShared: util.TextDecoder === TextDecoder,
+  isTextEncoderShared: util.TextEncoder === TextEncoder,
   isUint8ArrayViaUtilTypes: utilTypes.isUint8Array(textBytes),
+  malformedSurrogateBytes,
+  maximalSubpartDecoded,
   promisified,
   punycodeAscii: punycode.toASCII("mañana.com"),
   punycodeUnicode: punycode.toUnicode("xn--maana-pta.com"),
   querystringParsed: querystring.parse("a=1&b=x&b=y"),
   querystringStringified: querystring.stringify({ a: 1, b: ["x", "y"] }),
   rejectsCode,
+  streamingDecoded,
+  streamGetterPreserved,
+  symbolEncodingErrorName,
   throwsCode,
+  unsupportedEncodingCode,
+  utf16BeDecoded,
+  utf16LeStreamDecoded,
+}));
+"#,
+    );
+}
+
+fn web_streams_conformance_matches_host_node() {
+    assert_conformance(
+        "web-streams",
+        r#"
+import {
+  ReadableStream as ImportedReadableStream,
+  TextDecoderStream as ImportedTextDecoderStream,
+  TextEncoderStream as ImportedTextEncoderStream,
+  WritableStream as ImportedWritableStream,
+  TransformStream as ImportedTransformStream,
+} from "node:stream/web";
+import {
+  Blob as BufferBlob,
+  File as BufferFile,
+  resolveObjectURL,
+} from "node:buffer";
+
+const readAll = async (stream) => {
+  const values = [];
+  for await (const value of stream) values.push(value);
+  return values;
+};
+
+let byobPullCount = 0;
+const byteStream = new ReadableStream({
+  type: "bytes",
+  pull(controller) {
+    byobPullCount += 1;
+    const view = controller.byobRequest.view;
+    view[0] = 0x41;
+    view[1] = 0x42;
+    controller.byobRequest.respond(2);
+    controller.close();
+  },
+});
+const byobReader = byteStream.getReader({ mode: "byob" });
+const byobResult = await byobReader.read(new Uint8Array(4));
+byobReader.releaseLock();
+
+const pipedValues = [];
+await new ReadableStream({
+  start(controller) {
+    controller.enqueue(2);
+    controller.enqueue(3);
+    controller.close();
+  },
+})
+  .pipeThrough(new TransformStream({
+    transform(value, controller) {
+      controller.enqueue(value * 10);
+    },
+  }))
+  .pipeTo(new WritableStream({
+    write(value) {
+      pipedValues.push(value);
+    },
+  }));
+
+const [teeLeft, teeRight] = new ReadableStream({
+  start(controller) {
+    controller.enqueue("alpha");
+    controller.enqueue("beta");
+    controller.close();
+  },
+}).tee();
+const [teeLeftValues, teeRightValues] = await Promise.all([
+  readAll(teeLeft),
+  readAll(teeRight),
+]);
+
+let cancellationReason = null;
+const cancellable = new ReadableStream({
+  cancel(reason) {
+    cancellationReason = reason;
+  },
+});
+await cancellable.cancel("stop");
+
+let releaseWrite;
+const pendingWrite = new Promise((resolve) => {
+  releaseWrite = resolve;
+});
+const backpressureStream = new WritableStream({
+  write() {
+    return pendingWrite;
+  },
+}, { highWaterMark: 1 });
+const writer = backpressureStream.getWriter();
+const initialDesiredSize = writer.desiredSize;
+const writePromise = writer.write("chunk");
+const queuedDesiredSize = writer.desiredSize;
+releaseWrite();
+await writePromise;
+const drainedDesiredSize = writer.desiredSize;
+writer.releaseLock();
+
+let pipeError = null;
+try {
+  await new ReadableStream({
+    start(controller) {
+      controller.error(new Error("stream-failure"));
+    },
+  }).pipeTo(new WritableStream());
+} catch (error) {
+  pipeError = error.message;
+}
+
+const lockStream = new ReadableStream();
+const lockReader = lockStream.getReader();
+const lockedWithReader = lockStream.locked;
+lockReader.releaseLock();
+
+const encoderStream = new TextEncoderStream();
+const encodedChunksPromise = readAll(encoderStream.readable);
+const encoderWriter = encoderStream.writable.getWriter();
+await encoderWriter.write("\ud83d");
+await encoderWriter.write("\ude00");
+await encoderWriter.close();
+const encodedStreamBytes = Array.from(
+  (await encodedChunksPromise).flatMap((chunk) => Array.from(chunk)),
+);
+
+const decoderStream = new TextDecoderStream();
+const decodedChunksPromise = readAll(decoderStream.readable);
+const decoderWriter = decoderStream.writable.getWriter();
+await decoderWriter.write(new Uint8Array([0xe2, 0x82]));
+await decoderWriter.write(new Uint8Array([0xac]));
+await decoderWriter.close();
+const decodedStreamText = (await decodedChunksPromise).join("");
+
+const richBlob = new Blob(
+  ["A", new Uint8Array([0, 255]), "\u{1f600}"],
+  { type: "IMAGE/PNG" },
+);
+const richBlobStreamChunks = await readAll(richBlob.stream());
+const richBlobSlice = richBlob.slice(0, 2, "IMAGE/PNG");
+const richFile = new File(
+  [richBlob],
+  "pixel-\u{1f600}.png",
+  { type: "image/png", lastModified: 1700000000123 },
+);
+const responseBlob = await new Response(richBlob).blob();
+const responseSliceBlob = await new Response(richBlobSlice).blob();
+const richFormData = new FormData();
+richFormData.append("caption", "pixel");
+richFormData.append("asset", richFile);
+richFormData.append("slice", richBlobSlice);
+const formDataFile = richFormData.get("asset");
+const multipartRequest = new Request("https://example.com/upload", {
+  method: "POST",
+  body: richFormData,
+});
+const multipartContentType = multipartRequest.headers.get("content-type");
+const multipartText = await multipartRequest.text();
+const blobUrl = URL.createObjectURL(richBlob);
+const resolvedBlob = resolveObjectURL(blobUrl);
+const fetchedBlobUrlResponse = await fetch(blobUrl);
+const fetchedBlobUrlBytes = Array.from(
+  new Uint8Array(await fetchedBlobUrlResponse.arrayBuffer()),
+);
+const rangedBlobUrlResponse = await fetch(blobUrl, {
+  headers: { Range: "bytes=1-3" },
+});
+const rangedBlobUrlText = await rangedBlobUrlResponse.text();
+const resolvedBlobFromUrl = resolveObjectURL(new URL(blobUrl));
+let blobHeadRejected = false;
+try {
+  await fetch(blobUrl, { method: "HEAD" });
+} catch {
+  blobHeadRejected = true;
+}
+const abortedBlobFetchController = new AbortController();
+abortedBlobFetchController.abort();
+let abortedBlobFetchRejected = false;
+try {
+  await fetch(blobUrl, { signal: abortedBlobFetchController.signal });
+} catch {
+  abortedBlobFetchRejected = true;
+}
+const coercionBlobUrl = URL.createObjectURL(richBlob);
+URL.revokeObjectURL(new URL(coercionBlobUrl));
+URL.revokeObjectURL(blobUrl);
+let revokedBlobUrlRejected = false;
+try {
+  await fetch(blobUrl);
+} catch {
+  revokedBlobUrlRejected = true;
+}
+
+console.log(JSON.stringify({
+  bufferBlobShared: BufferBlob === Blob,
+  bufferFileShared: BufferFile === File,
+  byobBytes: Array.from(byobResult.value),
+  byobDone: byobResult.done,
+  byobPullCount,
+  cancellationReason,
+  abortedBlobFetchRejected,
+  blobHeadRejected,
+  constructorsShared:
+    ImportedReadableStream === ReadableStream &&
+    ImportedWritableStream === WritableStream &&
+    ImportedTransformStream === TransformStream &&
+    ImportedTextEncoderStream === TextEncoderStream &&
+    ImportedTextDecoderStream === TextDecoderStream,
+  decodedStreamText,
+  drainedDesiredSize,
+  initialDesiredSize,
+  lockedAfterRelease: lockStream.locked,
+  lockedWithReader,
+  pipeError,
+  pipedValues,
+  queuedDesiredSize,
+  richBlobBytes: Array.from(new Uint8Array(await richBlob.arrayBuffer())),
+  richBlobSize: richBlob.size,
+  richBlobSliceText: await richBlob.slice(1, 3).text(),
+  richBlobSliceShared: richBlobSlice instanceof Blob,
+  richBlobSliceType: richBlobSlice.type,
+  richBlobStreamBytes: richBlobStreamChunks.flatMap((chunk) => Array.from(chunk)),
+  richBlobStreamShared: richBlob.stream() instanceof ReadableStream,
+  richBlobType: richBlob.type,
+  richFileLastModified: richFile.lastModified,
+  richFileName: richFile.name,
+  richFileSize: richFile.size,
+  richFileType: richFile.type,
+  resolvedBlobBytes: Array.from(new Uint8Array(await resolvedBlob.arrayBuffer())),
+  resolvedBlobFromUrl:
+    resolvedBlobFromUrl?.size === richBlob.size &&
+    resolvedBlobFromUrl?.type === richBlob.type,
+  revokedCoercionBlobUrl:
+    resolveObjectURL(coercionBlobUrl) === undefined,
+  resolvedBlobType: resolvedBlob.type,
+  revokedBlobUrlRejected,
+  revokedBlobUrlResolvesUndefined: resolveObjectURL(blobUrl) === undefined,
+  fetchedBlobUrlBytes,
+  fetchedBlobUrlContentType:
+    fetchedBlobUrlResponse.headers.get("content-type"),
+  fetchedBlobUrlLength:
+    fetchedBlobUrlResponse.headers.get("content-length"),
+  fetchedBlobUrlStatusText: fetchedBlobUrlResponse.statusText,
+  fetchedBlobUrlType: fetchedBlobUrlResponse.type,
+  fetchedBlobUrlUrlMatches: fetchedBlobUrlResponse.url === blobUrl,
+  rangedBlobUrlContentRange:
+    rangedBlobUrlResponse.headers.get("content-range"),
+  rangedBlobUrlStatus: rangedBlobUrlResponse.status,
+  rangedBlobUrlText,
+  responseBodyShared: new Response("ok").body instanceof ReadableStream,
+  responseBlobBytes: Array.from(new Uint8Array(await responseBlob.arrayBuffer())),
+  responseBlobInstance: responseBlob instanceof Blob,
+  responseBlobType: responseBlob.type,
+  responseSliceBlobType: responseSliceBlob.type,
+  encodedStreamBytes,
+  formDataEntries: Array.from(richFormData, ([name, value]) => [
+    name,
+    typeof value === "string" ? value : value.name,
+  ]),
+  formDataFileShared: formDataFile instanceof File,
+  multipartHasCaption: multipartText.includes('name="caption"') &&
+    multipartText.includes("pixel"),
+  multipartHasFile: multipartText.includes('name="asset"') &&
+    multipartText.includes('filename="pixel-😀.png"') &&
+    multipartText.includes("Content-Type: image/png"),
+  multipartHeaderHasBoundary:
+    multipartContentType.startsWith("multipart/form-data; boundary="),
+  teeLeftValues,
+  teeRightValues,
+}));
+"#,
+    );
+}
+
+fn regexp_conformance_matches_host_node() {
+    assert_conformance(
+        "regexp",
+        r#"
+const rgiEmoji = new RegExp("^\\p{RGI_Emoji}$", "v");
+class DerivedRegExp extends RegExp {}
+const derived = new DerivedRegExp("^[a-z]$", "v");
+const asciiLetter = new RegExp("^[\\p{ASCII}&&\\p{Letter}]+$", "v");
+
+console.log(JSON.stringify({
+  asciiLetterMatches: asciiLetter.test("AgentOS"),
+  asciiLetterRejectsDigit: !asciiLetter.test("Agent0S"),
+  constructorLength: RegExp.length,
+  constructorName: RegExp.name,
+  derivedMatches: derived.test("a"),
+  derivedPrototype: Object.getPrototypeOf(derived) === DerivedRegExp.prototype,
+  hasCompatibilityWrapper: "__secureExecRgiEmojiCompat" in RegExp,
+  malformedZwjRejected: !rgiEmoji.test("👨‍"),
+  plainTextRejected: !rgiEmoji.test("hello"),
+  rgiCases: [
+    "⚽",
+    "👨🏾‍⚕️",
+    "🇧🇪",
+    "1️⃣",
+    "🏴\u{e0067}\u{e0062}\u{e0065}\u{e006e}\u{e0067}\u{e007f}",
+  ].map((value) => rgiEmoji.test(value)),
+  standaloneModifierRejected: !rgiEmoji.test("🏾"),
 }));
 "#,
     );
@@ -4261,6 +4876,8 @@ fn run_named_case(case_name: &str) {
         "buffer" => buffer_conformance_matches_host_node(),
         "url" => url_conformance_matches_host_node(),
         "stdlib_polyfill" => stdlib_polyfill_conformance_matches_host_node(),
+        "web_streams" => web_streams_conformance_matches_host_node(),
+        "regexp" => regexp_conformance_matches_host_node(),
         "extended_builtin_polyfills" => extended_builtin_polyfills_work_in_guest_v8(),
         other => panic!("unknown builtin conformance case: {other}"),
     }
diff --git a/crates/v8-runtime/tests/event_loop.rs b/crates/v8-runtime/tests/event_loop.rs
index f8afd0fd51..ab1f67eba6 100644
--- a/crates/v8-runtime/tests/event_loop.rs
+++ b/crates/v8-runtime/tests/event_loop.rs
@@ -84,6 +84,35 @@ fn assert_event_loop_watchdog_did_not_fire(status: &EventLoopStatus) {
     );
 }
 
+fn fresh_isolate_supports_rgi_emoji_unicode_sets() {
+    isolate::init_v8_platform();
+
+    let mut isolate = isolate::create_isolate(None);
+    let context = isolate::create_context(&mut isolate);
+    let scope = &mut v8::HandleScope::new(&mut isolate);
+    let context = v8::Local::new(scope, &context);
+    let scope = &mut v8::ContextScope::new(scope, context);
+    let source = v8::String::new(
+        scope,
+        r#"(() => {
+          const rgi = new RegExp("^\\p{RGI_Emoji}$", "v");
+          const ascii = new RegExp("^[\\p{ASCII}&&\\p{Letter}]+$", "v");
+          return rgi.test("👨🏾‍⚕️") &&
+            rgi.test("🇧🇪") &&
+            !rgi.test("hello") &&
+            ascii.test("AgentOS") &&
+            !ascii.test("Agent0S");
+        })()"#,
+    )
+    .unwrap();
+    let script = v8::Script::compile(scope, source, None).unwrap();
+    let result = script.run(scope).unwrap();
+    assert!(
+        result.boolean_value(scope),
+        "fresh V8 isolate must support RGI_Emoji and Unicode set expressions"
+    );
+}
+
 fn event_loop_pumps_v8_platform_tasks_for_native_wasm_promises() {
     isolate::init_v8_platform();
 
@@ -374,6 +403,7 @@ fn event_loop_handles_native_async_wasm_paths_without_hanging() {
     // Keep the async WASM event-loop coverage inside one top-level libtest case.
     // Splitting these into separate tests in the same binary still trips the
     // V8 init/teardown SIGSEGV boundary that affects other consolidated suites.
+    fresh_isolate_supports_rgi_emoji_unicode_sets();
     event_loop_pumps_v8_platform_tasks_for_native_wasm_promises();
     event_loop_completes_native_async_wasm_instantiate_promises();
     event_loop_surfaces_native_async_wasm_compile_errors_without_hanging();
diff --git a/packages/build-tools/bridge-src/builtins/builtin-modules.ts b/packages/build-tools/bridge-src/builtins/builtin-modules.ts
index 58e6f649dc..8cc9034e3b 100644
--- a/packages/build-tools/bridge-src/builtins/builtin-modules.ts
+++ b/packages/build-tools/bridge-src/builtins/builtin-modules.ts
@@ -1,3 +1,4 @@
+import upstreamUrlHelpersModule from "agentos-node-url-polyfill";
 import { exposeCustomGlobal } from "../global-exposure.js";
 import { TextDecoder } from "../polyfills/index.js";
 import {
@@ -32,14 +33,14 @@ import {
 	createAccessDeniedBuiltinError,
 } from "./misc-stubs.js";
 import { builtinPerfHooksModule } from "./perf.js";
-import { fileURLToPath2, pathToFileURL2, process_default } from "./process.js";
+import { process_default } from "./process.js";
 import {
 	builtinAsyncHooksModule,
 	builtinTimersPromisesModule,
 } from "./timers.js";
 import { builtinV8Module } from "./v8.js";
 import { builtinVmModule } from "./vm.js";
-import { URL2, URLSearchParams } from "./whatwg-url.js";
+import { resolveObjectURL, URL2, URLSearchParams } from "./whatwg-url.js";
 
 // biome-ignore lint/complexity/noStaticOnlyClass: generated bridge consumers rely on this registry shape.
 class BuiltinModuleRegistry {
@@ -186,9 +187,9 @@ function bufferIsUtf8(input) {
 			continue;
 		}
 
-		let continuationCount;
-		let minimumCodePoint;
-		let codePoint;
+		let continuationCount = 0;
+		let minimumCodePoint = 0;
+		let codePoint = 0;
 		if (first >= 0xc2 && first <= 0xdf) {
 			continuationCount = 1;
 			minimumCodePoint = 0x80;
@@ -251,8 +252,17 @@ defineMissingModuleProperty(
 );
 defineMissingModuleProperty(builtinBufferStdlibModule, "Blob", globalThis.Blob);
 defineMissingModuleProperty(builtinBufferStdlibModule, "File", globalThis.File);
-defineMissingModuleProperty(builtinBufferStdlibModule, "isAscii", bufferIsAscii);
+defineMissingModuleProperty(
+	builtinBufferStdlibModule,
+	"isAscii",
+	bufferIsAscii,
+);
 defineMissingModuleProperty(builtinBufferStdlibModule, "isUtf8", bufferIsUtf8);
+defineMissingModuleProperty(
+	builtinBufferStdlibModule,
+	"resolveObjectURL",
+	resolveObjectURL,
+);
 var builtinConstantsStdlibModule = cloneStdlibModule(constantsStdlibModuleNs);
 var builtinEventsStdlibModule = cloneStdlibModule(eventsStdlibModuleNs);
 var builtinEventsConstructor = null;
@@ -266,24 +276,11 @@ function ensureBuiltinEventsStdlibModule() {
 		typeof builtinEventsStdlibModule === "function"
 			? builtinEventsStdlibModule
 			: builtinEventsStdlibModule?.EventEmitter;
-	if (typeof builtinEventsConstructor === "function") {
-		Object.assign(
-			builtinEventsConstructor.prototype,
-			eventsModule.EventEmitter.prototype,
-		);
-		Object.assign(
-			eventsModule.EventEmitter,
-			builtinEventsStdlibModule,
-			eventsModule,
-		);
-		builtinEventsStdlibModule = eventsModule.EventEmitter;
-		builtinEventsStdlibModule.EventEmitter = builtinEventsStdlibModule;
-	} else {
-		builtinEventsStdlibModule = {
-			...builtinEventsStdlibModule,
-			...eventsModule,
-		};
-	}
+	builtinEventsStdlibModule =
+		typeof builtinEventsConstructor === "function"
+			? Object.assign(builtinEventsConstructor, eventsModule)
+			: eventsModule;
+	builtinEventsStdlibModule.EventEmitter = builtinEventsStdlibModule;
 	return builtinEventsStdlibModule;
 }
 var builtinPathStdlibModule = cloneStdlibModule(pathStdlibModuleNs);
@@ -537,6 +534,115 @@ defineMissingModuleProperty(
 var builtinStringDecoderStdlibModule = cloneStdlibModule(
 	stringDecoderStdlibModuleNs,
 );
+const upstreamUrlStdlibModule = unwrapStdlibModule(upstreamUrlHelpersModule);
+
+function withNodeErrorCode(error, code) {
+	error.code = code;
+	return error;
+}
+
+function pathToFileURL2(filePath, options) {
+	if (typeof filePath !== "string") {
+		throw withNodeErrorCode(
+			new TypeError('The "path" argument must be of type string.'),
+			"ERR_INVALID_ARG_TYPE",
+		);
+	}
+	if (options?.windows) {
+		const windowsPath = filePath.replace(/\//g, "\\");
+		let result = new URL2("file:///");
+		if (windowsPath.startsWith("\\\\")) {
+			const [host, ...segments] = windowsPath.slice(2).split("\\");
+			result = new URL2("file:///");
+			result.hostname = host;
+			result.pathname = `/${segments.join("/")}`;
+		} else if (/^[A-Za-z]:\\/.test(windowsPath)) {
+			result = new URL2("file:///");
+			result.pathname = `/${windowsPath.replace(/\\/g, "/")}`;
+		} else {
+			const relative = windowsPath.replace(/\\/g, "/");
+			const trailingSlash = filePath.endsWith("\\") || filePath.endsWith("/");
+			let resolved = builtinPathStdlibModule.posix.resolve(
+				process_default.cwd(),
+				relative,
+			);
+			if (trailingSlash && !resolved.endsWith("/")) resolved += "/";
+			return upstreamUrlStdlibModule.pathToFileURL(resolved);
+		}
+		return result;
+	}
+	let resolved = builtinPathStdlibModule.posix.resolve(
+		process_default.cwd(),
+		filePath,
+	);
+	if (filePath.endsWith("/") && !resolved.endsWith("/")) {
+		resolved += "/";
+	}
+	return upstreamUrlStdlibModule.pathToFileURL(resolved);
+}
+
+function fileURLToPath2(input, options) {
+	if (!(input instanceof URL2) && typeof input !== "string") {
+		throw withNodeErrorCode(
+			new TypeError(
+				'The "path" argument must be of type string or an instance of URL.',
+			),
+			"ERR_INVALID_ARG_TYPE",
+		);
+	}
+	try {
+		if (options?.windows) {
+			const parsed = input instanceof URL2 ? input : new URL2(input);
+			if (parsed.protocol !== "file:") {
+				throw withNodeErrorCode(
+					new TypeError("The URL must be of scheme file"),
+					"ERR_INVALID_URL_SCHEME",
+				);
+			}
+			if (/%2f|%5c/i.test(parsed.pathname)) {
+				throw withNodeErrorCode(
+					new TypeError(
+						"File URL path must not include encoded / or \\ characters",
+					),
+					"ERR_INVALID_FILE_URL_PATH",
+				);
+			}
+			const pathname = decodeURIComponent(parsed.pathname);
+			if (parsed.hostname) {
+				return `\\\\${parsed.hostname}${pathname.replace(/\//g, "\\")}`;
+			}
+			if (!/^\/[A-Za-z]:/.test(pathname)) {
+				throw withNodeErrorCode(
+					new TypeError("File URL path must be absolute"),
+					"ERR_INVALID_FILE_URL_PATH",
+				);
+			}
+			return pathname.slice(1).replace(/\//g, "\\");
+		}
+		return upstreamUrlStdlibModule.fileURLToPath(input);
+	} catch (error) {
+		if (error?.code) throw error;
+		const message = String(error?.message ?? error);
+		if (message.includes("scheme file")) {
+			throw withNodeErrorCode(error, "ERR_INVALID_URL_SCHEME");
+		}
+		if (message.includes("host must be") || message.includes("File URL host")) {
+			throw withNodeErrorCode(error, "ERR_INVALID_FILE_URL_HOST");
+		}
+		if (
+			message.includes("encoded /") ||
+			message.includes("encoded \\") ||
+			message.includes("must not include encoded")
+		) {
+			throw withNodeErrorCode(error, "ERR_INVALID_FILE_URL_PATH");
+		}
+		if (message.includes("Invalid URL")) {
+			throw withNodeErrorCode(error, "ERR_INVALID_URL");
+		}
+		throw error;
+	}
+}
+
 var builtinUrlStdlibModule = cloneStdlibModule(urlStdlibModuleNs);
 var builtinUrlStdlibModuleInitialized = false;
 function ensureBuiltinUrlStdlibModule() {
@@ -593,8 +699,12 @@ function loadBuiltinModule(request) {
 	const normalized = rejectRestrictedBuiltinRequest(request);
 	switch (normalized) {
 		case "assert":
-		case "assert/strict":
 			return globalThis.__secureExecBuiltinAssertModule;
+		case "assert/strict":
+			return (
+				globalThis.__secureExecBuiltinAssertModule?.strict ??
+				globalThis.__secureExecBuiltinAssertModule
+			);
 		case "async_hooks":
 			return builtinAsyncHooksModule;
 		case "buffer":
@@ -920,7 +1030,11 @@ function loadBuiltinModule(request) {
 // Node 20.16+ exposes the same permission-gated builtin resolver on process.
 // Install it on the shared process object so ESM dependencies can use it before
 // an entrypoint-specific CommonJS `require` has been created.
-defineMissingModuleProperty(process_default, "getBuiltinModule", loadBuiltinModule);
+defineMissingModuleProperty(
+	process_default,
+	"getBuiltinModule",
+	loadBuiltinModule,
+);
 
 export {
 	__jsRuntimeBuiltinAllowlist,
diff --git a/packages/build-tools/bridge-src/builtins/events.ts b/packages/build-tools/bridge-src/builtins/events.ts
index 11c0c1b2c0..1baffefc10 100644
--- a/packages/build-tools/bridge-src/builtins/events.ts
+++ b/packages/build-tools/bridge-src/builtins/events.ts
@@ -1,410 +1,256 @@
-import { process2, routeAsyncCallbackError } from "./process.js";
+import eventsStdlibModule, * as eventsStdlibModuleNs from "node:events";
 import { exposeCustomGlobal } from "../global-exposure.js";
 import { Event } from "../polyfills/index.js";
+import { process2 } from "./process.js";
 
-var eventsErrorMonitor = Symbol("events.errorMonitor");
-var eventsDefaultMaxListeners = 10;
-function emitEventEmitterMeta(emitter, metaEvent, args) {
-  if (metaEvent === "newListener" && args[0] === "newListener") {
-    return false;
-  }
-  if (metaEvent === "removeListener" && args[0] === "removeListener") {
-    return false;
-  }
-  return emitEventRecords(emitter, metaEvent, args);
-}
-function cloneEventListeners(emitter, event) {
-  ensureEventEmitterInitialized(emitter);
-  const listeners = emitter._events[event];
-  return Array.isArray(listeners) ? listeners.slice() : [];
-}
-function removeEventListenerRecord(emitter, event, listener, onceOnly = false) {
-  ensureEventEmitterInitialized(emitter);
-  const listeners = emitter._events[event];
-  if (!Array.isArray(listeners) || listeners.length === 0) {
-    return emitter;
-  }
-  let removedRecord = null;
-  const next = listeners.slice();
-  for (let index = next.length - 1; index >= 0; index -= 1) {
-    const record = next[index];
-    if (record.listener !== listener && record.rawListener !== listener) {
-      continue;
-    }
-    if (onceOnly && !record.once) {
-      continue;
-    }
-    removedRecord = record;
-    next.splice(index, 1);
-    break;
-  }
-  if (removedRecord === null) {
-    return emitter;
-  }
-  if (next.length === 0) {
-    delete emitter._events[event];
-  } else {
-    emitter._events[event] = next;
-  }
-  emitEventEmitterMeta(emitter, "removeListener", [event, removedRecord.listener]);
-  return emitter;
-}
-function removeAllEventListenerRecords(emitter, event) {
-  const key = String(event);
-  const listeners = cloneEventListeners(emitter, key);
-  for (let index = listeners.length - 1; index >= 0; index -= 1) {
-    removeEventListenerRecord(emitter, key, listeners[index].listener);
-  }
-  return emitter;
-}
-function emitEventRecords(emitter, event, args) {
-  const listeners = cloneEventListeners(emitter, event);
-  if (listeners.length === 0) {
-    return false;
-  }
-  for (const record of listeners) {
-    if (record.once) {
-      removeEventListenerRecord(emitter, event, record.listener, true);
-    }
-    try {
-      record.listener.apply(emitter, args);
-    } catch (error) {
-      const outcome = routeAsyncCallbackError(error);
-      if (!outcome.handled && outcome.rethrow !== null) {
-        throw outcome.rethrow;
-      }
-      return true;
-    }
-  }
-  return true;
+const EventEmitter =
+	eventsStdlibModuleNs.EventEmitter ??
+	eventsStdlibModule?.EventEmitter ??
+	eventsStdlibModule;
+
+if (typeof EventEmitter !== "function") {
+	throw new TypeError(
+		"The upstream events module does not export EventEmitter",
+	);
 }
-function topLevelEventListenerCount(emitter, event) {
-  return cloneEventListeners(emitter, event).length;
+
+const eventsErrorMonitor =
+	eventsStdlibModuleNs.errorMonitor ?? Symbol("events.errorMonitor");
+
+// events@3 routes listener-leak warnings to console.warn because browsers do not
+// expose process.emitWarning. Keep its warning construction and threshold logic,
+// but deliver the warning through the agentOS process object.
+function routeMaxListenersWarning(method) {
+	return function routedEventEmitterListener(...args) {
+		const originalWarn = globalThis.console?.warn;
+		if (typeof originalWarn !== "function") {
+			return Reflect.apply(method, this, args);
+		}
+		globalThis.console.warn = (warning, ...warningArgs) => {
+			if (
+				warning?.name === "MaxListenersExceededWarning" &&
+				typeof process2?.emitWarning === "function"
+			) {
+				const emitterName =
+					warning.emitter?.constructor === EventEmitter
+						? "EventEmitter"
+						: warning.emitter?.constructor?.name || "EventEmitter";
+				const maxListeners =
+					typeof warning.emitter?.getMaxListeners === "function"
+						? warning.emitter.getMaxListeners()
+						: EventEmitter.defaultMaxListeners;
+				warning.message =
+					`Possible EventEmitter memory leak detected. ${warning.count} ` +
+					`${String(warning.type)} listeners added to [${emitterName}]. ` +
+					`MaxListeners is ${maxListeners}. Use emitter.setMaxListeners() ` +
+					"to increase limit";
+				process2.emitWarning(warning);
+				return;
+			}
+			Reflect.apply(originalWarn, globalThis.console, [
+				warning,
+				...warningArgs,
+			]);
+		};
+		try {
+			return Reflect.apply(method, this, args);
+		} finally {
+			globalThis.console.warn = originalWarn;
+		}
+	};
 }
-function topLevelGetEventListeners(emitter, event) {
-  return cloneEventListeners(emitter, event).map((record) => record.listener);
+
+if (!EventEmitter.__agentOSEventsWarningPatched) {
+	const addListener = routeMaxListenersWarning(
+		EventEmitter.prototype.addListener,
+	);
+	const prependListener = routeMaxListenersWarning(
+		EventEmitter.prototype.prependListener,
+	);
+	EventEmitter.prototype.addListener = addListener;
+	EventEmitter.prototype.on = addListener;
+	EventEmitter.prototype.prependListener = prependListener;
+	Object.defineProperty(EventEmitter, "__agentOSEventsWarningPatched", {
+		value: true,
+	});
 }
-function topLevelGetRawEventListeners(emitter, event) {
-  return cloneEventListeners(emitter, event).map((record) => record.rawListener ?? record.listener);
+
+const once = eventsStdlibModuleNs.once ?? EventEmitter.once;
+const eventTargetMaxListeners = new WeakMap();
+
+function isEventTargetLike(emitter) {
+	return (
+		emitter !== null &&
+		(typeof emitter === "object" || typeof emitter === "function") &&
+		typeof emitter.addEventListener === "function" &&
+		typeof emitter.removeEventListener === "function" &&
+		typeof emitter.dispatchEvent === "function"
+	);
 }
-function createOnceRawListener(emitter, event, listener) {
-  function onceRawListener(...args) {
-    removeEventListenerRecord(emitter, event, onceRawListener, true);
-    return listener.apply(emitter, args);
-  }
-  Object.defineProperty(onceRawListener, "listener", {
-    value: listener,
-    configurable: true,
-    enumerable: false,
-    writable: false
-  });
-  return onceRawListener;
+
+function getEventListeners(emitter, eventName) {
+	if (typeof emitter?.listeners === "function") {
+		return emitter.listeners(eventName);
+	}
+	throw new TypeError("The emitter argument must expose listeners()");
 }
-function topLevelGetMaxListeners(emitter) {
-  if (emitter && typeof emitter.getMaxListeners === "function") {
-    return emitter.getMaxListeners();
-  }
-  return eventsDefaultMaxListeners;
+
+function getMaxListeners(emitter) {
+	if (typeof emitter?.getMaxListeners === "function") {
+		return emitter.getMaxListeners();
+	}
+	if (isEventTargetLike(emitter)) {
+		return (
+			eventTargetMaxListeners.get(emitter) ?? EventEmitter.defaultMaxListeners
+		);
+	}
+	throw new TypeError("The emitter argument must expose getMaxListeners()");
 }
-function topLevelSetMaxListeners(n, ...emitters) {
-  for (const emitter of emitters) {
-    if (emitter && typeof emitter.setMaxListeners === "function") {
-      emitter.setMaxListeners(n);
-    }
-  }
+
+function setMaxListeners(count, ...emitters) {
+	if (emitters.length === 0) {
+		EventEmitter.defaultMaxListeners = count;
+		return;
+	}
+	const validationEmitter = new EventEmitter();
+	validationEmitter.setMaxListeners(count);
+	for (const emitter of emitters) {
+		if (typeof emitter?.setMaxListeners === "function") {
+			emitter.setMaxListeners(count);
+		} else if (isEventTargetLike(emitter)) {
+			eventTargetMaxListeners.set(emitter, count);
+		} else {
+			throw new TypeError(
+				'The "eventTargets" argument must be an instance of EventEmitter or EventTarget.',
+			);
+		}
+	}
 }
+
 function addAbortListener(signal, listener) {
-  if (!signal || typeof signal.addEventListener !== "function") {
-    throw new TypeError("AbortSignal is required");
-  }
-  const wrapped = () => listener();
-  if (signal.aborted) {
-    queueMicrotask(wrapped);
-    return { dispose() {
-    } };
-  }
-  signal.addEventListener("abort", wrapped, { once: true });
-  return {
-    dispose() {
-      signal.removeEventListener("abort", wrapped);
-    }
-  };
-}
-function once(emitter, eventName) {
-  return new Promise((resolve, reject) => {
-    const onEvent = (...args) => {
-      if (typeof emitter.removeListener === "function") {
-        emitter.removeListener("error", onError);
-      }
-      resolve(args);
-    };
-    const onError = (error) => {
-      if (typeof emitter.removeListener === "function") {
-        emitter.removeListener(eventName, onEvent);
-      }
-      reject(error);
-    };
-    emitter.once(eventName, onEvent);
-    if (eventName !== "error" && typeof emitter.once === "function") {
-      emitter.once("error", onError);
-    }
-  });
-}
-function initializeEventEmitter(target) {
-  target._events = Object.create(null);
-  target._maxListeners = eventsDefaultMaxListeners;
-  target._maxListenersWarned = /* @__PURE__ */ new Set();
-}
-function ensureEventEmitterInitialized(target) {
-  if (!target || (typeof target !== "object" && typeof target !== "function")) {
-    return;
-  }
-  if (typeof target._events === "undefined") {
-    initializeEventEmitter(target);
-    return;
-  }
-  if (!(target._maxListenersWarned instanceof Set)) {
-    target._maxListenersWarned = /* @__PURE__ */ new Set();
-  }
-  // An emitter can acquire `_events` without going through our constructor (e.g.
-  // a subclass that sets up its own event storage). If `_maxListeners` was never
-  // initialized, `maybeWarnEventEmitterListeners` would treat `total <= undefined`
-  // as false and fire a spurious MaxListenersExceededWarning on the *first*
-  // listener (reported count "1"). Default it to the standard limit so the
-  // threshold check is meaningful.
-  if (typeof target._maxListeners !== "number") {
-    target._maxListeners = eventsDefaultMaxListeners;
-  }
+	if (!signal || typeof signal.addEventListener !== "function") {
+		throw new TypeError("AbortSignal is required");
+	}
+	if (typeof listener !== "function") {
+		throw new TypeError("listener must be a function");
+	}
+	const wrapped = () =>
+		listener(
+			typeof Event === "function" ? new Event("abort") : { type: "abort" },
+		);
+	if (signal.aborted) {
+		queueMicrotask(wrapped);
+	} else {
+		signal.addEventListener("abort", wrapped, { once: true });
+	}
+	const dispose = () => signal.removeEventListener("abort", wrapped);
+	return {
+		dispose,
+		[Symbol.dispose]: dispose,
+	};
 }
-function createMaxListenersExceededWarning(emitter, event, total) {
-  const maxListeners = Number.isFinite(emitter._maxListeners) ? emitter._maxListeners : eventsDefaultMaxListeners;
-  const warning = new Error(
-    `Possible EventEmitter memory leak detected. ${total} ${event} listeners added to [EventEmitter]. MaxListeners is ${maxListeners}. Use emitter.setMaxListeners() to increase limit`
-  );
-  warning.name = "MaxListenersExceededWarning";
-  warning.emitter = emitter;
-  warning.type = event;
-  warning.count = total;
-  return warning;
-}
-function maybeWarnEventEmitterListeners(emitter, event, total) {
-  ensureEventEmitterInitialized(emitter);
-  if (!(emitter._maxListenersWarned instanceof Set)) {
-    emitter._maxListenersWarned = /* @__PURE__ */ new Set();
-  }
-  if (emitter._maxListeners <= 0 || emitter._maxListenersWarned.has(event) || total <= emitter._maxListeners) {
-    return;
-  }
-  emitter._maxListenersWarned.add(event);
-  const warning = createMaxListenersExceededWarning(emitter, event, total);
-  if (process2 && typeof process2.emitWarning === "function") {
-    process2.emitWarning(warning);
-    return;
-  }
-  if (typeof _error !== "undefined") {
-    _error.applySync(void 0, [`${warning.name}: ${warning.message}`]);
-  }
-}
-function addEventListenerRecord(emitter, event, record, prepend = false) {
-  ensureEventEmitterInitialized(emitter);
-  const listeners = emitter._events[event] ?? [];
-  if (prepend) {
-    listeners.unshift(record);
-  } else {
-    listeners.push(record);
-  }
-  emitter._events[event] = listeners;
-  maybeWarnEventEmitterListeners(emitter, event, listeners.length);
-}
-function EventEmitter() {
-  if (!this || (typeof this !== "object" && typeof this !== "function")) {
-    return new EventEmitter();
-  }
-  initializeEventEmitter(this);
+
+// events@3 predates the async-iterator helper added to Node. This is adapter
+// surface only; listener storage and dispatch remain owned by upstream events.
+function on(emitter, eventName, options) {
+	const signal = options?.signal;
+	if (signal?.aborted) {
+		throw signal.reason ?? new Error("The operation was aborted");
+	}
+	const queue = [];
+	const pending = [];
+	let error = null;
+	let finished = false;
+	const removeListener = (name, listener) =>
+		(emitter.off ?? emitter.removeListener).call(emitter, name, listener);
+	const cleanup = () => {
+		removeListener(eventName, handleEvent);
+		removeListener("error", handleError);
+		signal?.removeEventListener?.("abort", handleAbort);
+	};
+	const iterator = {
+		next() {
+			if (queue.length > 0) {
+				return Promise.resolve({ value: queue.shift(), done: false });
+			}
+			if (error !== null) {
+				const currentError = error;
+				error = null;
+				cleanup();
+				return Promise.reject(currentError);
+			}
+			if (finished) {
+				return Promise.resolve({ value: undefined, done: true });
+			}
+			return new Promise((resolve, reject) => {
+				pending.push({ resolve, reject });
+			});
+		},
+		return() {
+			finished = true;
+			cleanup();
+			for (const waiter of pending.splice(0)) {
+				waiter.resolve({ value: undefined, done: true });
+			}
+			return Promise.resolve({ value: undefined, done: true });
+		},
+		throw(thrownError) {
+			error = thrownError;
+			cleanup();
+			return Promise.reject(thrownError);
+		},
+		[Symbol.asyncIterator]() {
+			return this;
+		},
+	};
+	function handleEvent(...args) {
+		const waiter = pending.shift();
+		if (waiter) {
+			waiter.resolve({ value: args, done: false });
+		} else {
+			queue.push(args);
+		}
+	}
+	function handleError(thrownError) {
+		const waiter = pending.shift();
+		if (waiter) {
+			cleanup();
+			waiter.reject(thrownError);
+		} else {
+			error = thrownError;
+		}
+	}
+	function handleAbort() {
+		void iterator.return();
+	}
+	emitter.on(eventName, handleEvent);
+	emitter.on("error", handleError);
+	signal?.addEventListener?.("abort", handleAbort, { once: true });
+	return iterator;
 }
-EventEmitter.prototype.addListener = function(event, listener) {
-  return this.on(event, listener);
-};
-EventEmitter.prototype.on = function(event, listener) {
-  if (typeof listener !== "function") {
-    throw new TypeError("listener must be a function");
-  }
-  const key = String(event);
-  emitEventEmitterMeta(this, "newListener", [key, listener]);
-  addEventListenerRecord(this, key, { listener, once: false });
-  return this;
-};
-EventEmitter.prototype.once = function(event, listener) {
-  if (typeof listener !== "function") {
-    throw new TypeError("listener must be a function");
-  }
-  const key = String(event);
-  emitEventEmitterMeta(this, "newListener", [key, listener]);
-  addEventListenerRecord(this, key, {
-    listener,
-    rawListener: createOnceRawListener(this, key, listener),
-    once: true
-  });
-  return this;
-};
-EventEmitter.prototype.prependListener = function(event, listener) {
-  if (typeof listener !== "function") {
-    throw new TypeError("listener must be a function");
-  }
-  const key = String(event);
-  emitEventEmitterMeta(this, "newListener", [key, listener]);
-  addEventListenerRecord(this, key, { listener, once: false }, true);
-  return this;
-};
-EventEmitter.prototype.prependOnceListener = function(event, listener) {
-  if (typeof listener !== "function") {
-    throw new TypeError("listener must be a function");
-  }
-  const key = String(event);
-  emitEventEmitterMeta(this, "newListener", [key, listener]);
-  addEventListenerRecord(this, key, {
-    listener,
-    rawListener: createOnceRawListener(this, key, listener),
-    once: true
-  }, true);
-  return this;
-};
-EventEmitter.prototype.removeListener = function(event, listener) {
-  return removeEventListenerRecord(this, String(event), listener);
-};
-EventEmitter.prototype.off = function(event, listener) {
-  return removeEventListenerRecord(this, String(event), listener);
-};
-EventEmitter.prototype.removeAllListeners = function(event) {
-  ensureEventEmitterInitialized(this);
-  if (typeof event === "undefined") {
-    for (const key of Object.keys(this._events)) {
-      if (key === "removeListener") {
-        continue;
-      }
-      removeAllEventListenerRecords(this, key);
-    }
-    delete this._events.removeListener;
-  } else {
-    removeAllEventListenerRecords(this, String(event));
-  }
-  return this;
-};
-EventEmitter.prototype.emit = function(event, ...args) {
-  const key = String(event);
-  if (key === "error" && topLevelEventListenerCount(this, key) === 0) {
-    throw args[0] instanceof Error ? args[0] : new Error(String(args[0] ?? "Unhandled error event"));
-  }
-  let handled = emitEventRecords(this, key, args);
-  if (key === "error") {
-    handled = emitEventRecords(this, String(eventsErrorMonitor), args) || handled;
-  }
-  return handled;
-};
-EventEmitter.prototype.listeners = function(event) {
-  return topLevelGetEventListeners(this, String(event));
-};
-EventEmitter.prototype.rawListeners = function(event) {
-  return topLevelGetRawEventListeners(this, String(event));
-};
-EventEmitter.prototype.listenerCount = function(event) {
-  return topLevelEventListenerCount(this, String(event));
-};
-EventEmitter.prototype.eventNames = function() {
-  ensureEventEmitterInitialized(this);
-  return Object.keys(this._events);
-};
-EventEmitter.prototype.setMaxListeners = function(n) {
-  ensureEventEmitterInitialized(this);
-  this._maxListeners = Number(n);
-  return this;
-};
-EventEmitter.prototype.getMaxListeners = function() {
-  ensureEventEmitterInitialized(this);
-  return Number.isFinite(this._maxListeners) ? this._maxListeners : eventsDefaultMaxListeners;
-};
-EventEmitter.once = once;
-// Node 12.16+ async-iterator helper: `for await (const [a] of events.on(emitter, "data")) {}`.
-EventEmitter.on = function on(emitter, eventName, options) {
-  const signal = options && options.signal;
-  if (signal && signal.aborted) throw signal.reason ?? new Error("The operation was aborted");
-  const removeL = (ev, fn) => (emitter.off ?? emitter.removeListener).call(emitter, ev, fn);
-  const queue = [];
-  const unconsumed = [];
-  let error = null;
-  let finished = false;
-  const cleanup = () => {
-    removeL(eventName, onEvent);
-    removeL("error", onError);
-    if (signal && signal.removeEventListener) signal.removeEventListener("abort", onAbort);
-  };
-  const iterator = {
-    next() {
-      const value = queue.shift();
-      if (value !== undefined) return Promise.resolve({ value, done: false });
-      if (error) { const e = error; error = null; cleanup(); return Promise.reject(e); }
-      if (finished) return Promise.resolve({ value: undefined, done: true });
-      return new Promise((resolve, reject) => unconsumed.push({ resolve, reject }));
-    },
-    return() {
-      finished = true;
-      cleanup();
-      for (const c of unconsumed) c.resolve({ value: undefined, done: true });
-      unconsumed.length = 0;
-      return Promise.resolve({ value: undefined, done: true });
-    },
-    throw(err) { error = err; cleanup(); return Promise.reject(err); },
-    [Symbol.asyncIterator]() { return this; },
-  };
-  function onEvent(...args) {
-    const c = unconsumed.shift();
-    if (c) c.resolve({ value: args, done: false });
-    else queue.push(args);
-  }
-  function onError(err) {
-    const c = unconsumed.shift();
-    if (c) { cleanup(); c.reject(err); }
-    else error = err;
-  }
-  function onAbort() { iterator.return(); }
-  emitter.on(eventName, onEvent);
-  emitter.on("error", onError);
-  if (signal && signal.addEventListener) signal.addEventListener("abort", onAbort, { once: true });
-  return iterator;
-};
-EventEmitter.addAbortListener = function addAbortListener(signal, listener) {
-  if (signal && signal.aborted) {
-    queueMicrotask(() => listener(typeof Event === "function" ? new Event("abort") : { type: "abort" }));
-  } else if (signal && signal.addEventListener) {
-    signal.addEventListener("abort", listener, { once: true });
-  }
-  return {
-    [Symbol.dispose]() {
-      if (signal && signal.removeEventListener) signal.removeEventListener("abort", listener);
-    },
-  };
-};
-EventEmitter.getEventListeners = topLevelGetEventListeners;
-EventEmitter.getMaxListeners = topLevelGetMaxListeners;
-EventEmitter.setMaxListeners = topLevelSetMaxListeners;
-Object.defineProperty(EventEmitter, "defaultMaxListeners", {
-  get() {
-    return eventsDefaultMaxListeners;
-  },
-  set(value) {
-    eventsDefaultMaxListeners = Number(value);
-  }
+
+Object.assign(EventEmitter, {
+	EventEmitter,
+	addAbortListener,
+	errorMonitor: eventsErrorMonitor,
+	getEventListeners,
+	getMaxListeners,
+	on,
+	once,
+	setMaxListeners,
 });
-var eventsModule = {
-  addAbortListener,
-  defaultMaxListeners: eventsDefaultMaxListeners,
-  errorMonitor: eventsErrorMonitor,
-  EventEmitter,
-  getEventListeners: topLevelGetEventListeners,
-  getMaxListeners: topLevelGetMaxListeners,
-  listenerCount: topLevelEventListenerCount,
-  once,
-  setMaxListeners: topLevelSetMaxListeners
-};
+
+const eventsModule = EventEmitter;
 exposeCustomGlobal("_eventsModule", eventsModule);
-export { eventsErrorMonitor, eventsDefaultMaxListeners, emitEventEmitterMeta, cloneEventListeners, removeEventListenerRecord, removeAllEventListenerRecords, emitEventRecords, topLevelEventListenerCount, topLevelGetEventListeners, topLevelGetRawEventListeners, createOnceRawListener, topLevelGetMaxListeners, topLevelSetMaxListeners, addAbortListener, once, initializeEventEmitter, ensureEventEmitterInitialized, createMaxListenersExceededWarning, maybeWarnEventEmitterListeners, addEventListenerRecord, EventEmitter, eventsModule };
+
+export {
+	addAbortListener,
+	EventEmitter,
+	eventsErrorMonitor,
+	eventsModule,
+	getEventListeners,
+	getMaxListeners,
+	on,
+	once,
+	setMaxListeners,
+};
diff --git a/packages/build-tools/bridge-src/builtins/fetch.ts b/packages/build-tools/bridge-src/builtins/fetch.ts
index d7da68482c..dbb66e4198 100644
--- a/packages/build-tools/bridge-src/builtins/fetch.ts
+++ b/packages/build-tools/bridge-src/builtins/fetch.ts
@@ -1,7 +1,8 @@
 import { getSecureExecUndiciDispatcher, undiciFetch } from "./undici.js";
 import { exposeCustomGlobal, exposeInstallCompatibleHardenedGlobal } from "../global-exposure.js";
-import { undiciHeadersModule, undiciRequestModule, undiciResponseModule } from "../prelude.js";
+import { undiciFormDataModule, undiciHeadersModule, undiciRequestModule, undiciResponseModule } from "../prelude.js";
 import { isFlatHeaderList, onUpgradeSocketEnd } from "./http.js";
+import { resolveObjectURL } from "./whatwg-url.js";
 
 // npm 11 requests full registry metadata while resolving manifests. Large,
 // long-lived packages such as drizzle-orm can exceed 50 MiB even though their
@@ -21,6 +22,64 @@ var UndiciRequest = undiciRequestModule?.Request ?? undiciRequestModule?.default
 
 var UndiciResponse = undiciResponseModule?.Response ?? undiciResponseModule?.default ?? undiciResponseModule;
 
+var UndiciFormData = undiciFormDataModule?.FormData ?? undiciFormDataModule?.default ?? undiciFormDataModule;
+
+var MAX_FORM_DATA_ENTRIES = 1024;
+var MAX_FORM_DATA_VALUE_BYTES = 64 * 1024 * 1024;
+var kBoundedFormData = Symbol.for("agentOS.boundedFormData");
+
+function formDataEntryCount(formData) {
+  let count = 0;
+  for (const _entry of formData) {
+    count += 1;
+    if (count > MAX_FORM_DATA_ENTRIES) break;
+  }
+  return count;
+}
+
+function assertFormDataValueBound(value) {
+  const bytes = typeof Blob === "function" && value instanceof Blob
+    ? value.size
+    : new TextEncoder().encode(`${value}`).byteLength;
+  if (bytes > MAX_FORM_DATA_VALUE_BYTES) {
+    const error = new RangeError(`FormData value byte limit ${MAX_FORM_DATA_VALUE_BYTES} exceeded; this runtime limit cannot be raised by guest code`);
+    error.code = "ERR_FORM_DATA_VALUE_SIZE_LIMIT";
+    throw error;
+  }
+}
+
+function installBoundedFormData(FormDataCtor) {
+  if (typeof FormDataCtor !== "function" || FormDataCtor.prototype[kBoundedFormData]) return;
+  const originalAppend = FormDataCtor.prototype.append;
+  const originalSet = FormDataCtor.prototype.set;
+  const originalHas = FormDataCtor.prototype.has;
+  FormDataCtor.prototype.append = function append(name, value, filename) {
+    if (formDataEntryCount(this) >= MAX_FORM_DATA_ENTRIES) {
+      const error = new RangeError(`FormData entry limit ${MAX_FORM_DATA_ENTRIES} exceeded; this runtime limit cannot be raised by guest code`);
+      error.code = "ERR_FORM_DATA_ENTRIES_LIMIT";
+      throw error;
+    }
+    assertFormDataValueBound(value);
+    return arguments.length >= 3
+      ? originalAppend.call(this, name, value, filename)
+      : originalAppend.call(this, name, value);
+  };
+  FormDataCtor.prototype.set = function set(name, value, filename) {
+    if (!originalHas.call(this, name) && formDataEntryCount(this) >= MAX_FORM_DATA_ENTRIES) {
+      const error = new RangeError(`FormData entry limit ${MAX_FORM_DATA_ENTRIES} exceeded; this runtime limit cannot be raised by guest code`);
+      error.code = "ERR_FORM_DATA_ENTRIES_LIMIT";
+      throw error;
+    }
+    assertFormDataValueBound(value);
+    return arguments.length >= 3
+      ? originalSet.call(this, name, value, filename)
+      : originalSet.call(this, name, value);
+  };
+  Object.defineProperty(FormDataCtor.prototype, kBoundedFormData, { value: true });
+}
+
+installBoundedFormData(UndiciFormData);
+
 function serializeFetchHeaders(headers) {
   if (!headers) {
     return {};
@@ -88,6 +147,45 @@ function ensureFetchAcceptEncoding(options) {
   return { ...(options || {}), headers };
 }
 
+function blobUrlResponse(url, options) {
+  const parsed = new URL(url);
+  if (parsed.search) throw new TypeError("fetch failed");
+  parsed.hash = "";
+  const method = String(options.method ?? "GET").toUpperCase();
+  const blob = resolveObjectURL(parsed.href);
+  if (method !== "GET" || !(blob instanceof Blob)) throw new TypeError("fetch failed");
+  if (options.signal?.aborted) throw options.signal.reason;
+
+  const headers = serializeFetchHeaders(options.headers);
+  const rangeEntry = Object.entries(headers).find(([name]) => name.toLowerCase() === "range");
+  let body = blob;
+  let status = 200;
+  let statusText = "OK";
+  const responseHeaders = {
+    "content-length": String(blob.size),
+    ...(blob.type ? { "content-type": blob.type } : {})
+  };
+  if (rangeEntry) {
+    const match = /^bytes=(\d+)-(\d*)$/.exec(String(rangeEntry[1]).trim());
+    if (!match) throw new TypeError("fetch failed");
+    const start = Number(match[1]);
+    const requestedEnd = match[2] ? Number(match[2]) : blob.size - 1;
+    if (start >= blob.size || requestedEnd < start) throw new TypeError("fetch failed");
+    const end = Math.min(requestedEnd, blob.size - 1);
+    body = blob.slice(start, end + 1, blob.type);
+    status = 206;
+    statusText = "Partial Content";
+    responseHeaders["content-length"] = String(end - start + 1);
+    responseHeaders["content-range"] = `bytes ${start}-${end}/${blob.size}`;
+  }
+  const response = new UndiciResponse(body, { status, statusText, headers: responseHeaders });
+  Object.defineProperties(response, {
+    url: { configurable: true, value: parsed.href },
+    type: { configurable: true, value: "basic" }
+  });
+  return response;
+}
+
 async function fetch(input, options = {}) {
   if (typeof undiciFetch !== "function") {
     throw new Error("fetch requires undici to be configured");
@@ -100,12 +198,16 @@ async function fetch(input, options = {}) {
       method: input.method,
       headers: serializeFetchHeaders(input.headers),
       body: input.body,
+      signal: input.signal,
       ...options
     };
   }
   normalizedOptions = normalizeFetchRequestInit(normalizedOptions);
   normalizedOptions = ensureFetchAcceptEncoding(normalizedOptions);
   const requestLabel = typeof resolvedInput === "string" ? resolvedInput : resolvedInput?.url ? String(resolvedInput.url) : String(resolvedInput);
+  if (requestLabel.startsWith("blob:nodedata:")) {
+    return blobUrlResponse(requestLabel, normalizedOptions);
+  }
   const handleId = typeof _registerHandle === "function" ? `fetch:${++_fetchHandleCounter}` : null;
   if (handleId) {
     _registerHandle?.(handleId, `fetch ${requestLabel}`);
@@ -275,58 +377,11 @@ exposeInstallCompatibleHardenedGlobal("Request", UndiciRequest);
 exposeInstallCompatibleHardenedGlobal("Response", UndiciResponse);
 
 var Blob = globalThis.Blob;
-
-if (typeof Blob === "undefined") {
-  Blob = class BlobStub {
-  };
-}
 exposeInstallCompatibleHardenedGlobal("Blob", Blob);
 
 var File = globalThis.File;
-
-if (typeof File === "undefined") {
-  File = class FileStub extends Blob {
-    name;
-    lastModified;
-    webkitRelativePath;
-    constructor(parts = [], name = "", options = {}) {
-      super(parts, options);
-      this.name = String(name);
-      this.lastModified = typeof options.lastModified === "number" ? options.lastModified : Date.now();
-      this.webkitRelativePath = "";
-    }
-  };
-}
 exposeInstallCompatibleHardenedGlobal("File", File);
 
-var FormData = globalThis.FormData;
-
-if (typeof FormData === "undefined") {
-  FormData = class FormDataStub {
-    _entries = [];
-    append(name, value) {
-      this._entries.push([name, value]);
-    }
-    get(name) {
-      const entry = this._entries.find(([k]) => k === name);
-      return entry ? entry[1] : null;
-    }
-    getAll(name) {
-      return this._entries.filter(([k]) => k === name).map(([, v]) => v);
-    }
-    has(name) {
-      return this._entries.some(([k]) => k === name);
-    }
-    delete(name) {
-      this._entries = this._entries.filter(([k]) => k !== name);
-    }
-    entries() {
-      return this._entries[Symbol.iterator]();
-    }
-    [Symbol.iterator]() {
-      return this.entries();
-    }
-  };
-}
+var FormData = UndiciFormData;
 exposeInstallCompatibleHardenedGlobal("FormData", FormData);
-export { Blob, File, Headers, MAX_HTTP_BODY_BYTES, MAX_HTTP_REQUEST_HEADERS, MAX_HTTP_REQUEST_HEADER_BYTES, Request, Response, UndiciHeaders, UndiciRequest, UndiciResponse, _fetchHandleCounter, createFetchHeaders, ensureFetchAcceptEncoding, fetch, normalizeFetchRequestInit, serializeFetchHeaders };
+export { Blob, File, FormData, Headers, MAX_FORM_DATA_ENTRIES, MAX_FORM_DATA_VALUE_BYTES, MAX_HTTP_BODY_BYTES, MAX_HTTP_REQUEST_HEADERS, MAX_HTTP_REQUEST_HEADER_BYTES, Request, Response, UndiciFormData, UndiciHeaders, UndiciRequest, UndiciResponse, _fetchHandleCounter, blobUrlResponse, createFetchHeaders, ensureFetchAcceptEncoding, fetch, formDataEntryCount, installBoundedFormData, normalizeFetchRequestInit, serializeFetchHeaders };
diff --git a/packages/build-tools/bridge-src/builtins/process.ts b/packages/build-tools/bridge-src/builtins/process.ts
index 32270b46a9..726e7f66ce 100644
--- a/packages/build-tools/bridge-src/builtins/process.ts
+++ b/packages/build-tools/bridge-src/builtins/process.ts
@@ -1011,34 +1011,6 @@ Object.defineProperty(process2, Symbol.toStringTag, {
 
 var process_default = process2;
 
-function encodeFilePathSegment(value) {
-  return encodeURI(String(value)).replace(/#/g, "%23").replace(/\?/g, "%3F");
-}
-
-function pathToFileURL2(filePath) {
-  const normalized = builtinPathStdlibModule.posix.resolve(String(filePath || "/"));
-  const pathname = encodeFilePathSegment(normalized);
-  return new URL2(`file://${pathname.startsWith("/") ? pathname : `/${pathname}`}`);
-}
-
-function fileURLToPath2(input) {
-  const href = input instanceof URL2 ? input.href : String(input ?? "");
-  if (!href.startsWith("file:")) {
-    throw new TypeError("The URL must be of scheme file");
-  }
-  let pathname = href.slice("file:".length);
-  if (pathname.startsWith("//")) {
-    const authorityMatch = /^\/\/[^/]*(.*)$/.exec(pathname);
-    pathname = authorityMatch?.[1] || "/";
-  }
-  pathname = pathname.split(/[?#]/, 1)[0] || "/";
-  pathname = decodeURIComponent(pathname);
-  if (!pathname.startsWith("/")) {
-    pathname = `/${pathname}`;
-  }
-  return pathname;
-}
-
 class NodeGlobalWebSocket {
   static CONNECTING = 0;
   static OPEN = 1;
@@ -1245,4 +1217,4 @@ function setupGlobals() {
   }
   installSafeIntlFormatters(g);
 }
-export { ProcessExitError, _addListener, _createProcessKillError, _cwd, _deliverProcessSignal, _emit, _exitCode, _exited, _getStdinIsTTY, _ignoredSelfSignals, _isTrackedProcessSignalEventName, _listenerCountForEvent, _processKillErrnoByCode, _processListeners, _processMaxListeners, _processMaxListenersWarned, _processOnceListeners, _processStartTime, _processVersionsCache, _removeListener, _resolveSignal, _signalNamesByNumber, _signalNumbers, _syncAllGuestProcessSignalStates, _syncGuestProcessSignalState, _trackedProcessSignalEvents, _umask, applyProcessConfig, config2, defaultProcessMemoryUsage, defaultProcessResourceUsage, dispatchCustomEmitterListeners, encodeFilePathSegment, fileURLToPath2, getNowMs, hrtime, installProcessIpcBridge, isProcessExitError, normalizeAsyncError, pathToFileURL2, process2, processClockNow, process_default, readLiveProcessCpuUsage, readLiveProcessMemoryUsage, readLiveProcessResourceUsage, readLiveProcessVersions, readProcessConfig, routeAsyncCallbackError, scheduleAsyncRethrow, setupGlobals, signalDispatch };
+export { ProcessExitError, _addListener, _createProcessKillError, _cwd, _deliverProcessSignal, _emit, _exitCode, _exited, _getStdinIsTTY, _ignoredSelfSignals, _isTrackedProcessSignalEventName, _listenerCountForEvent, _processKillErrnoByCode, _processListeners, _processMaxListeners, _processMaxListenersWarned, _processOnceListeners, _processStartTime, _processVersionsCache, _removeListener, _resolveSignal, _signalNamesByNumber, _signalNumbers, _syncAllGuestProcessSignalStates, _syncGuestProcessSignalState, _trackedProcessSignalEvents, _umask, applyProcessConfig, config2, defaultProcessMemoryUsage, defaultProcessResourceUsage, dispatchCustomEmitterListeners, getNowMs, hrtime, installProcessIpcBridge, isProcessExitError, normalizeAsyncError, process2, processClockNow, process_default, readLiveProcessCpuUsage, readLiveProcessMemoryUsage, readLiveProcessResourceUsage, readLiveProcessVersions, readProcessConfig, routeAsyncCallbackError, scheduleAsyncRethrow, setupGlobals, signalDispatch };
diff --git a/packages/build-tools/bridge-src/builtins/url-resolution.ts b/packages/build-tools/bridge-src/builtins/url-resolution.ts
deleted file mode 100644
index 8638af1e21..0000000000
--- a/packages/build-tools/bridge-src/builtins/url-resolution.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-export function resolveRelativeNonFileUrl(raw, baseUrl, posixPath) {
-	const basePathname = baseUrl.pathname || "/";
-	const origin = `${baseUrl.protocol}//${baseUrl.host}`;
-	if (raw.startsWith("//")) {
-		return `${baseUrl.protocol}${raw}`;
-	}
-	if (raw.startsWith("#")) {
-		return `${origin}${basePathname}${baseUrl.search || ""}${raw}`;
-	}
-	if (raw.startsWith("?")) {
-		return `${origin}${basePathname}${raw}`;
-	}
-	if (raw === "") {
-		return `${origin}${basePathname}${baseUrl.search || ""}`;
-	}
-	const queryIndex = raw.indexOf("?");
-	const hashIndex = raw.indexOf("#");
-	const searchStart = queryIndex === -1 ? raw.length : queryIndex;
-	const hashStart = hashIndex === -1 ? raw.length : hashIndex;
-	const pathEnd = Math.min(searchStart, hashStart);
-	const relativePath = raw.slice(0, pathEnd);
-	const suffix = raw.slice(pathEnd);
-	const baseDirectory = basePathname.endsWith("/")
-		? basePathname
-		: posixPath.dirname(basePathname);
-	let resolvedPath = relativePath.startsWith("/")
-		? posixPath.resolve("/", relativePath)
-		: posixPath.resolve(baseDirectory, relativePath);
-	if (
-		(relativePath.endsWith("/") || /(^|\/)\.\.?$/.test(relativePath)) &&
-		!resolvedPath.endsWith("/")
-	) {
-		resolvedPath += "/";
-	}
-	return `${origin}${resolvedPath}${suffix}`;
-}
diff --git a/packages/build-tools/bridge-src/builtins/whatwg-url.ts b/packages/build-tools/bridge-src/builtins/whatwg-url.ts
index f422b3c8cd..e3ab2c22da 100644
--- a/packages/build-tools/bridge-src/builtins/whatwg-url.ts
+++ b/packages/build-tools/bridge-src/builtins/whatwg-url.ts
@@ -1,1227 +1,42 @@
-import { builtinPathStdlibModule } from "./builtin-modules.js";
-import { Blob } from "./network.js";
-import { TextDecoder } from "../polyfills/index.js";
-import { urlStdlibModuleNs } from "../prelude.js";
-import { resolveRelativeNonFileUrl } from "./url-resolution.js";
+const kBlobUrlStore = /* @__PURE__ */ Symbol.for("secureExec.blobUrlStore");
+const kBlobUrlCounter = /* @__PURE__ */ Symbol.for("secureExec.blobUrlCounter");
 
-var inspectCustomSymbol = /* @__PURE__ */ Symbol.for(
-	"nodejs.util.inspect.custom",
-);
-var toStringTagSymbol = Symbol.toStringTag;
-var ERR_INVALID_THIS = "ERR_INVALID_THIS";
-var ERR_MISSING_ARGS = "ERR_MISSING_ARGS";
-var ERR_INVALID_URL = "ERR_INVALID_URL";
-var ERR_ARG_NOT_ITERABLE = "ERR_ARG_NOT_ITERABLE";
-var ERR_INVALID_TUPLE = "ERR_INVALID_TUPLE";
-var URL_SEARCH_PARAMS_TYPE = "URLSearchParams";
-var kLinkedSearchParams = /* @__PURE__ */ Symbol(
-	"secureExecLinkedURLSearchParams",
-);
-var kBlobUrlStore = /* @__PURE__ */ Symbol.for("secureExec.blobUrlStore");
-var kBlobUrlCounter = /* @__PURE__ */ Symbol.for("secureExec.blobUrlCounter");
-var SEARCH_PARAM_METHOD_NAMES = ["append", "delete", "get", "getAll", "has"];
-var SEARCH_PARAM_PAIR_METHOD_NAMES = ["append", "set"];
-var SEARCH_PARAM_SYNC_METHOD_NAMES = ["append", "delete", "set", "sort"];
-var URL_SCHEME_TYPES = {
-	"http:": 0,
-	"https:": 2,
-	"ws:": 4,
-	"wss:": 5,
-	"file:": 6,
-	"ftp:": 8,
-};
-var searchParamsBrand = /* @__PURE__ */ new WeakSet();
-var searchParamsState = /* @__PURE__ */ new WeakMap();
-var searchParamsIteratorBrand = /* @__PURE__ */ new WeakSet();
-var searchParamsIteratorState = /* @__PURE__ */ new WeakMap();
 function createNodeTypeError(message, code) {
 	const error = new TypeError(message);
 	error.code = code;
 	return error;
 }
-function createInvalidUrlError() {
-	const error = new TypeError("Invalid URL");
-	error.code = ERR_INVALID_URL;
-	return error;
-}
-function createUrlReceiverTypeError() {
-	return new TypeError("Receiver must be an instance of class URL");
-}
+
 function createMissingArgsError(message) {
-	return createNodeTypeError(message, ERR_MISSING_ARGS);
-}
-function createIterableTypeError() {
-	return createNodeTypeError(
-		"Query pairs must be iterable",
-		ERR_ARG_NOT_ITERABLE,
-	);
-}
-function createTupleTypeError() {
-	return createNodeTypeError(
-		"Each query pair must be an iterable [name, value] tuple",
-		ERR_INVALID_TUPLE,
-	);
-}
-function createSymbolStringError() {
-	return new TypeError("Cannot convert a Symbol value to a string");
-}
-function toNodeString(value) {
-	if (typeof value === "symbol") {
-		throw createSymbolStringError();
-	}
-	return String(value);
-}
-function toWellFormedString(value) {
-	let result = "";
-	for (let index = 0; index < value.length; index += 1) {
-		const codeUnit = value.charCodeAt(index);
-		if (codeUnit >= 55296 && codeUnit <= 56319) {
-			const nextIndex = index + 1;
-			if (nextIndex < value.length) {
-				const nextCodeUnit = value.charCodeAt(nextIndex);
-				if (nextCodeUnit >= 56320 && nextCodeUnit <= 57343) {
-					result += value[index] + value[nextIndex];
-					index = nextIndex;
-					continue;
-				}
-			}
-			result += "\uFFFD";
-			continue;
-		}
-		if (codeUnit >= 56320 && codeUnit <= 57343) {
-			result += "\uFFFD";
-			continue;
-		}
-		result += value[index];
-	}
-	return result;
-}
-function toNodeUSVString(value) {
-	return toWellFormedString(toNodeString(value));
-}
-function assertUrlSearchParamsReceiver(receiver) {
-	if (!searchParamsBrand.has(receiver)) {
-		throw createNodeTypeError(
-			'Value of "this" must be of type URLSearchParams',
-			ERR_INVALID_THIS,
-		);
-	}
-}
-function assertUrlSearchParamsIteratorReceiver(receiver) {
-	if (!searchParamsIteratorBrand.has(receiver)) {
-		throw createNodeTypeError(
-			'Value of "this" must be of type URLSearchParamsIterator',
-			ERR_INVALID_THIS,
-		);
-	}
-}
-function getUrlSearchParamsImpl(receiver) {
-	const state = searchParamsState.get(receiver);
-	if (!state) {
-		throw createNodeTypeError(
-			'Value of "this" must be of type URLSearchParams',
-			ERR_INVALID_THIS,
-		);
-	}
-	return state.getImpl();
-}
-function countSearchParams(params) {
-	let count = 0;
-	for (const _entry of params) {
-		count++;
-	}
-	return count;
-}
-function isAsciiHexCodeUnit(codeUnit) {
-	return (
-		(codeUnit >= 48 && codeUnit <= 57) ||
-		(codeUnit >= 65 && codeUnit <= 70) ||
-		(codeUnit >= 97 && codeUnit <= 102)
-	);
-}
-function decodeAsciiHexCodeUnit(codeUnit) {
-	if (codeUnit >= 48 && codeUnit <= 57) {
-		return codeUnit - 48;
-	}
-	if (codeUnit >= 65 && codeUnit <= 70) {
-		return codeUnit - 55;
-	}
-	return codeUnit - 87;
-}
-function appendUtf8CodePoint(bytes, codePoint) {
-	if (codePoint <= 127) {
-		bytes.push(codePoint);
-		return;
-	}
-	if (codePoint <= 2047) {
-		bytes.push(192 | (codePoint >> 6), 128 | (codePoint & 63));
-		return;
-	}
-	if (codePoint <= 65535) {
-		bytes.push(
-			224 | (codePoint >> 12),
-			128 | ((codePoint >> 6) & 63),
-			128 | (codePoint & 63),
-		);
-		return;
-	}
-	bytes.push(
-		240 | (codePoint >> 18),
-		128 | ((codePoint >> 12) & 63),
-		128 | ((codePoint >> 6) & 63),
-		128 | (codePoint & 63),
-	);
-}
-function decodeFormUrlencodedComponent(value) {
-	const source = String(value).replace(/\+/g, " ");
-	let output = "";
-	for (let index = 0; index < source.length; index += 1) {
-		if (source.charCodeAt(index) === 37 && index + 2 < source.length) {
-			const bytes = [];
-			let nextIndex = index;
-			while (
-				nextIndex + 2 < source.length &&
-				source.charCodeAt(nextIndex) === 37
-			) {
-				const high = source.charCodeAt(nextIndex + 1);
-				const low = source.charCodeAt(nextIndex + 2);
-				if (!isAsciiHexCodeUnit(high) || !isAsciiHexCodeUnit(low)) {
-					break;
-				}
-				bytes.push(
-					(decodeAsciiHexCodeUnit(high) << 4) + decodeAsciiHexCodeUnit(low),
-				);
-				nextIndex += 3;
-			}
-			if (bytes.length > 0) {
-				output += new TextDecoder().decode(Uint8Array.from(bytes));
-				index = nextIndex - 1;
-				continue;
-			}
-		}
-		const codePoint = source.codePointAt(index);
-		output += String.fromCodePoint(codePoint);
-		if (codePoint > 65535) {
-			index += 1;
-		}
-	}
-	return output;
-}
-function serializeFormUrlencodedComponent(value) {
-	const input = String(value);
-	const bytes = [];
-	for (let index = 0; index < input.length; index += 1) {
-		const codePoint = input.codePointAt(index);
-		appendUtf8CodePoint(bytes, codePoint);
-		if (codePoint > 65535) {
-			index += 1;
-		}
-	}
-	let output = "";
-	for (const byte of bytes) {
-		if (byte === 32) {
-			output += "+";
-			continue;
-		}
-		const isAlphaNumeric =
-			(byte >= 48 && byte <= 57) ||
-			(byte >= 65 && byte <= 90) ||
-			(byte >= 97 && byte <= 122);
-		if (
-			isAlphaNumeric ||
-			byte === 42 ||
-			byte === 45 ||
-			byte === 46 ||
-			byte === 95
-		) {
-			output += String.fromCharCode(byte);
-			continue;
-		}
-		output += `%${byte.toString(16).toUpperCase().padStart(2, "0")}`;
-	}
-	return output;
-}
-function compareCodeUnitStrings(left, right) {
-	const minLength = Math.min(left.length, right.length);
-	for (let index = 0; index < minLength; index += 1) {
-		const diff = left.charCodeAt(index) - right.charCodeAt(index);
-		if (diff !== 0) {
-			return diff;
-		}
-	}
-	return left.length - right.length;
-}
-function normalizeSearchParamsInit(init) {
-	if (init && typeof init === "object" && kLinkedSearchParams in init) {
-		return init;
-	}
-	if (init == null) {
-		return void 0;
-	}
-	if (typeof init === "string") {
-		return toNodeUSVString(init);
-	}
-	if (typeof init === "object" || typeof init === "function") {
-		const iterator2 = init[Symbol.iterator];
-		if (iterator2 !== void 0) {
-			if (typeof iterator2 !== "function") {
-				throw createIterableTypeError();
-			}
-			const pairs2 = [];
-			for (const pair of init) {
-				if (pair == null) {
-					throw createTupleTypeError();
-				}
-				const pairIterator = pair[Symbol.iterator];
-				if (typeof pairIterator !== "function") {
-					throw createTupleTypeError();
-				}
-				const values = Array.from(pair);
-				if (values.length !== 2) {
-					throw createTupleTypeError();
-				}
-				pairs2.push([toNodeUSVString(values[0]), toNodeUSVString(values[1])]);
-			}
-			return pairs2;
-		}
-		const pairs = [];
-		for (const key of Reflect.ownKeys(init)) {
-			if (!Object.prototype.propertyIsEnumerable.call(init, key)) {
-				continue;
-			}
-			pairs.push([toNodeUSVString(key), toNodeUSVString(init[key])]);
-		}
-		return pairs;
-	}
-	return toNodeUSVString(init);
-}
-var NativeURLSearchParams =
-	typeof globalThis.URLSearchParams === "function" &&
-	globalThis.URLSearchParams.__secureExecBootstrapStub !== true
-		? globalThis.URLSearchParams
-		: class URLSearchParams {
-				constructor(init = "") {
-					this._pairs = [];
-					if (typeof init === "string") {
-						const query = init.replace(/^\?/, "");
-						if (!query) {
-							return;
-						}
-						for (const entry of query.split("&")) {
-							if (!entry) {
-								continue;
-							}
-							const [key, ...rest] = entry.split("=");
-							this._pairs.push([
-								decodeFormUrlencodedComponent(key),
-								decodeFormUrlencodedComponent(rest.join("=")),
-							]);
-						}
-						return;
-					}
-					if (Array.isArray(init)) {
-						for (const pair of init) {
-							if (pair == null || pair.length !== 2) {
-								continue;
-							}
-							this._pairs.push([String(pair[0]), String(pair[1])]);
-						}
-						return;
-					}
-					if (init && typeof init === "object") {
-						for (const [key, value] of Object.entries(init)) {
-							this._pairs.push([String(key), String(value)]);
-						}
-					}
-				}
-				append(name, value) {
-					this._pairs.push([String(name), String(value)]);
-				}
-				delete(name) {
-					const key = String(name);
-					this._pairs = this._pairs.filter(([candidate]) => candidate !== key);
-				}
-				get(name) {
-					const key = String(name);
-					const match = this._pairs.find(([candidate]) => candidate === key);
-					return match ? match[1] : null;
-				}
-				getAll(name) {
-					const key = String(name);
-					return this._pairs
-						.filter(([candidate]) => candidate === key)
-						.map(([, value]) => value);
-				}
-				has(name) {
-					const key = String(name);
-					return this._pairs.some(([candidate]) => candidate === key);
-				}
-				set(name, value) {
-					const key = String(name);
-					const stringValue = String(value);
-					const nextPairs = [];
-					let replaced = false;
-					for (const [candidate, currentValue] of this._pairs) {
-						if (candidate !== key) {
-							nextPairs.push([candidate, currentValue]);
-							continue;
-						}
-						if (!replaced) {
-							replaced = true;
-							nextPairs.push([key, stringValue]);
-						}
-					}
-					if (!replaced) {
-						nextPairs.push([key, stringValue]);
-					}
-					this._pairs = nextPairs;
-				}
-				sort() {
-					this._pairs = this._pairs
-						.map((pair, index) => ({ pair, index }))
-						.sort((left, right) => {
-							const diff = compareCodeUnitStrings(left.pair[0], right.pair[0]);
-							return diff !== 0 ? diff : left.index - right.index;
-						})
-						.map(({ pair }) => pair);
-				}
-				entries() {
-					return this._pairs[Symbol.iterator]();
-				}
-				keys() {
-					return this._pairs.map(([key]) => key)[Symbol.iterator]();
-				}
-				values() {
-					return this._pairs.map(([, value]) => value)[Symbol.iterator]();
-				}
-				[Symbol.iterator]() {
-					return this.entries();
-				}
-				toString() {
-					return this._pairs
-						.map(
-							([key, value]) =>
-								`${serializeFormUrlencodedComponent(key)}=${serializeFormUrlencodedComponent(value)}`,
-						)
-						.join("&");
-				}
-			};
-function createStandaloneSearchParams(init) {
-	if (typeof init === "string") {
-		return new NativeURLSearchParams(init);
-	}
-	return init === void 0
-		? new NativeURLSearchParams()
-		: new NativeURLSearchParams(init);
-}
-function createCollectionBody(items, options, emptyBody) {
-	if (items.length === 0) {
-		return emptyBody;
-	}
-	const oneLine = `{ ${items.join(", ")} }`;
-	const breakLength = options?.breakLength ?? Infinity;
-	if (oneLine.length <= breakLength) {
-		return oneLine;
-	}
-	return `{
-${items.join(",\n  ")} }`;
-}
-function createUrlContext(url) {
-	const href = url.href;
-	const protocolEnd = href.indexOf(":") + 1;
-	const authIndex = href.indexOf("@");
-	const pathnameStart = href.indexOf("/", protocolEnd + 2);
-	const searchStart = href.indexOf("?");
-	const hashStart = href.indexOf("#");
-	const usernameEnd =
-		url.username.length > 0
-			? href.indexOf(":", protocolEnd + 2)
-			: protocolEnd + 2;
-	const hostStart = authIndex === -1 ? protocolEnd + 2 : authIndex;
-	const hostEnd =
-		pathnameStart === -1
-			? href.length
-			: pathnameStart - (url.port.length > 0 ? url.port.length + 1 : 0);
-	const port = url.port.length > 0 ? Number(url.port) : null;
-	return {
-		href,
-		protocol_end: protocolEnd,
-		username_end: usernameEnd,
-		host_start: hostStart,
-		host_end: hostEnd,
-		pathname_start: pathnameStart === -1 ? href.length : pathnameStart,
-		search_start: searchStart === -1 ? href.length : searchStart,
-		hash_start: hashStart === -1 ? href.length : hashStart,
-		port,
-		scheme_type: URL_SCHEME_TYPES[url.protocol] ?? 1,
-		hasPort: url.port.length > 0,
-		hasSearch: url.search.length > 0,
-		hasHash: url.hash.length > 0,
-	};
-}
-function formatUrlContext(url, inspect, options) {
-	const context = createUrlContext(url);
-	const formatValue =
-		typeof inspect === "function"
-			? (value) => inspect(value, options)
-			: (value) => JSON.stringify(value);
-	const portValue = context.port === null ? "null" : String(context.port);
-	return [
-		"URLContext {",
-		`    href: ${formatValue(context.href)},`,
-		`    protocol_end: ${context.protocol_end},`,
-		`    username_end: ${context.username_end},`,
-		`    host_start: ${context.host_start},`,
-		`    host_end: ${context.host_end},`,
-		`    pathname_start: ${context.pathname_start},`,
-		`    search_start: ${context.search_start},`,
-		`    hash_start: ${context.hash_start},`,
-		`    port: ${portValue},`,
-		`    scheme_type: ${context.scheme_type},`,
-		"    [hasPort]: [Getter],",
-		"    [hasSearch]: [Getter],",
-		"    [hasHash]: [Getter]",
-		"  }",
-	].join("\n");
+	return createNodeTypeError(message, "ERR_MISSING_ARGS");
 }
+
 function getBlobUrlStore() {
-	const globalRecord = globalThis;
-	const existing = globalRecord[kBlobUrlStore];
+	const existing = globalThis[kBlobUrlStore];
 	if (existing instanceof Map) {
 		return existing;
 	}
 	const store = /* @__PURE__ */ new Map();
-	globalRecord[kBlobUrlStore] = store;
+	globalThis[kBlobUrlStore] = store;
 	return store;
 }
+
 function nextBlobUrlId() {
-	const globalRecord = globalThis;
 	const nextId =
-		typeof globalRecord[kBlobUrlCounter] === "number"
-			? globalRecord[kBlobUrlCounter]
+		typeof globalThis[kBlobUrlCounter] === "number"
+			? globalThis[kBlobUrlCounter]
 			: 1;
-	globalRecord[kBlobUrlCounter] = nextId + 1;
+	globalThis[kBlobUrlCounter] = nextId + 1;
 	return nextId;
 }
-var URLSearchParamsIterator = class _URLSearchParamsIterator {
-	constructor(values) {
-		searchParamsIteratorBrand.add(this);
-		searchParamsIteratorState.set(this, { values, index: 0 });
-	}
-	next() {
-		assertUrlSearchParamsIteratorReceiver(this);
-		const state = searchParamsIteratorState.get(this);
-		if (state.index >= state.values.length) {
-			return { value: void 0, done: true };
-		}
-		const value = state.values[state.index];
-		state.index += 1;
-		return { value, done: false };
-	}
-	[inspectCustomSymbol](depth, options, inspect) {
-		assertUrlSearchParamsIteratorReceiver(this);
-		if (depth < 0) {
-			return "[Object]";
-		}
-		const state = searchParamsIteratorState.get(this);
-		const formatValue =
-			typeof inspect === "function"
-				? (value) => inspect(value, options)
-				: (value) => JSON.stringify(value);
-		const remaining = state.values
-			.slice(state.index)
-			.map((value) => formatValue(value));
-		return `URLSearchParams Iterator ${createCollectionBody(remaining, options, "{  }")}`;
-	}
-	get [toStringTagSymbol]() {
-		if (this !== _URLSearchParamsIterator.prototype) {
-			assertUrlSearchParamsIteratorReceiver(this);
-		}
-		return "URLSearchParams Iterator";
-	}
-};
-Object.defineProperties(URLSearchParamsIterator.prototype, {
-	next: {
-		value: URLSearchParamsIterator.prototype.next,
-		writable: true,
-		configurable: true,
-		enumerable: true,
-	},
-	[Symbol.iterator]: {
-		value: function iterator() {
-			assertUrlSearchParamsIteratorReceiver(this);
-			return this;
-		},
-		writable: true,
-		configurable: true,
-		enumerable: false,
-	},
-	[inspectCustomSymbol]: {
-		value: URLSearchParamsIterator.prototype[inspectCustomSymbol],
-		writable: true,
-		configurable: true,
-		enumerable: false,
-	},
-	[toStringTagSymbol]: {
-		get: Object.getOwnPropertyDescriptor(
-			URLSearchParamsIterator.prototype,
-			toStringTagSymbol,
-		)?.get,
-		configurable: true,
-		enumerable: false,
-	},
-});
-Object.defineProperty(
-	Object.getOwnPropertyDescriptor(
-		URLSearchParamsIterator.prototype,
-		Symbol.iterator,
-	)?.value,
-	"name",
-	{
-		value: "entries",
-		configurable: true,
-	},
-);
-var URLSearchParams = class _URLSearchParams {
-	constructor(init) {
-		searchParamsBrand.add(this);
-		const normalized = normalizeSearchParamsInit(init);
-		if (
-			normalized &&
-			typeof normalized === "object" &&
-			kLinkedSearchParams in normalized
-		) {
-			searchParamsState.set(this, {
-				getImpl: normalized[kLinkedSearchParams],
-			});
-			return;
-		}
-		const impl = createStandaloneSearchParams(normalized);
-		searchParamsState.set(this, { getImpl: () => impl });
-	}
-	append(name, value) {
-		assertUrlSearchParamsReceiver(this);
-		if (arguments.length < 2) {
-			throw createMissingArgsError(
-				'The "name" and "value" arguments must be specified',
-			);
-		}
-		getUrlSearchParamsImpl(this).append(
-			toNodeUSVString(name),
-			toNodeUSVString(value),
-		);
-	}
-	delete(name) {
-		assertUrlSearchParamsReceiver(this);
-		if (arguments.length < 1) {
-			throw createMissingArgsError('The "name" argument must be specified');
-		}
-		getUrlSearchParamsImpl(this).delete(toNodeUSVString(name));
-	}
-	get(name) {
-		assertUrlSearchParamsReceiver(this);
-		if (arguments.length < 1) {
-			throw createMissingArgsError('The "name" argument must be specified');
-		}
-		return getUrlSearchParamsImpl(this).get(toNodeUSVString(name));
-	}
-	getAll(name) {
-		assertUrlSearchParamsReceiver(this);
-		if (arguments.length < 1) {
-			throw createMissingArgsError('The "name" argument must be specified');
-		}
-		return getUrlSearchParamsImpl(this).getAll(toNodeUSVString(name));
-	}
-	has(name) {
-		assertUrlSearchParamsReceiver(this);
-		if (arguments.length < 1) {
-			throw createMissingArgsError('The "name" argument must be specified');
-		}
-		return getUrlSearchParamsImpl(this).has(toNodeUSVString(name));
-	}
-	set(name, value) {
-		assertUrlSearchParamsReceiver(this);
-		if (arguments.length < 2) {
-			throw createMissingArgsError(
-				'The "name" and "value" arguments must be specified',
-			);
-		}
-		getUrlSearchParamsImpl(this).set(
-			toNodeUSVString(name),
-			toNodeUSVString(value),
-		);
-	}
-	sort() {
-		assertUrlSearchParamsReceiver(this);
-		getUrlSearchParamsImpl(this).sort();
-	}
-	entries() {
-		assertUrlSearchParamsReceiver(this);
-		return new URLSearchParamsIterator(
-			Array.from(getUrlSearchParamsImpl(this)),
-		);
-	}
-	keys() {
-		assertUrlSearchParamsReceiver(this);
-		return new URLSearchParamsIterator(
-			Array.from(getUrlSearchParamsImpl(this).keys()),
-		);
-	}
-	values() {
-		assertUrlSearchParamsReceiver(this);
-		return new URLSearchParamsIterator(
-			Array.from(getUrlSearchParamsImpl(this).values()),
-		);
-	}
-	forEach(callback, thisArg) {
-		assertUrlSearchParamsReceiver(this);
-		if (typeof callback !== "function") {
-			throw createNodeTypeError(
-				'The "callback" argument must be of type function. Received ' +
-					(callback === void 0 ? "undefined" : typeof callback),
-				"ERR_INVALID_ARG_TYPE",
-			);
-		}
-		for (const [key, value] of getUrlSearchParamsImpl(this)) {
-			callback.call(thisArg, value, key, this);
-		}
-	}
-	toString() {
-		assertUrlSearchParamsReceiver(this);
-		return getUrlSearchParamsImpl(this).toString();
-	}
-	get size() {
-		assertUrlSearchParamsReceiver(this);
-		return countSearchParams(getUrlSearchParamsImpl(this));
-	}
-	[inspectCustomSymbol](depth, options, inspect) {
-		assertUrlSearchParamsReceiver(this);
-		if (depth < 0) {
-			return "[Object]";
-		}
-		const formatValue =
-			typeof inspect === "function"
-				? (value) => inspect(value, options)
-				: (value) => JSON.stringify(value);
-		const items = Array.from(getUrlSearchParamsImpl(this)).map(
-			([key, value]) => `${formatValue(key)} => ${formatValue(value)}`,
-		);
-		return `URLSearchParams ${createCollectionBody(items, options, "{}")}`;
-	}
-	get [toStringTagSymbol]() {
-		if (this !== _URLSearchParams.prototype) {
-			assertUrlSearchParamsReceiver(this);
-		}
-		return URL_SEARCH_PARAMS_TYPE;
-	}
-};
-for (const name of SEARCH_PARAM_METHOD_NAMES) {
-	Object.defineProperty(URLSearchParams.prototype, name, {
-		value: URLSearchParams.prototype[name],
-		writable: true,
-		configurable: true,
-		enumerable: true,
-	});
-}
-for (const name of SEARCH_PARAM_PAIR_METHOD_NAMES) {
-	Object.defineProperty(URLSearchParams.prototype, name, {
-		value: URLSearchParams.prototype[name],
-		writable: true,
-		configurable: true,
-		enumerable: true,
-	});
-}
-for (const name of [
-	"sort",
-	"entries",
-	"forEach",
-	"keys",
-	"values",
-	"toString",
-]) {
-	Object.defineProperty(URLSearchParams.prototype, name, {
-		value: URLSearchParams.prototype[name],
-		writable: true,
-		configurable: true,
-		enumerable: true,
-	});
-}
-Object.defineProperties(URLSearchParams.prototype, {
-	size: {
-		get: Object.getOwnPropertyDescriptor(URLSearchParams.prototype, "size")
-			?.get,
-		configurable: true,
-		enumerable: true,
-	},
-	[Symbol.iterator]: {
-		value: URLSearchParams.prototype.entries,
-		writable: true,
-		configurable: true,
-		enumerable: false,
-	},
-	[inspectCustomSymbol]: {
-		value: URLSearchParams.prototype[inspectCustomSymbol],
-		writable: true,
-		configurable: true,
-		enumerable: false,
-	},
-	[toStringTagSymbol]: {
-		get: Object.getOwnPropertyDescriptor(
-			URLSearchParams.prototype,
-			toStringTagSymbol,
-		)?.get,
-		configurable: true,
-		enumerable: false,
-	},
-});
-function canUseNativeUrlImplementation(candidate) {
-	if (
-		typeof candidate !== "function" ||
-		candidate.__secureExecBootstrapStub === true
-	) {
-		return false;
-	}
-	try {
-		return (
-			String(
-				new candidate("./child.mjs", "file:///root/base/entry.mjs").href,
-			) === "file:///root/base/child.mjs"
-		);
-	} catch {
-		return false;
-	}
-}
-function ensureTrailingSlashForFilePath(pathname) {
-	return pathname.endsWith("/") ? pathname : `${pathname}/`;
-}
-function normalizeRelativeFileUrlInput(input, base) {
-	const rawInput = String(input ?? "");
-	if (!rawInput.startsWith("file:")) {
-		return { input: rawInput, base };
-	}
-	const relativeMatch = /^file:(\.\.?(?:\/[^?#]*)?)([?#].*)?$/.exec(rawInput);
-	if (!relativeMatch) {
-		return { input: rawInput, base };
-	}
-	const relativePath = relativeMatch[1];
-	const suffix = relativeMatch[2] ?? "";
-	let baseHref = typeof base === "undefined" ? "file:///" : String(base);
-	try {
-		const parsedBase = new globalThis.URL(baseHref);
-		if (parsedBase.protocol !== "file:") {
-			return { input: rawInput, base };
-		}
-		let basePathname = parsedBase.pathname || "/";
-		if (!basePathname.startsWith("/")) {
-			basePathname = `/${basePathname}`;
-		}
-		const baseDirectory = basePathname.endsWith("/")
-			? basePathname
-			: builtinPathStdlibModule.posix.dirname(basePathname);
-		const resolvedPath = builtinPathStdlibModule.posix.resolve(
-			baseDirectory,
-			relativePath,
-		);
-		const needsTrailingSlash =
-			relativePath === "." ||
-			relativePath === ".." ||
-			relativePath.endsWith("/");
-		const normalizedPath = needsTrailingSlash
-			? ensureTrailingSlashForFilePath(resolvedPath)
-			: resolvedPath;
-		return {
-			input: `file://${normalizedPath}${suffix}`,
-			base: void 0,
-		};
-	} catch {
-		return { input: rawInput, base };
-	}
-}
-var nativeUrlCandidate =
-	typeof urlStdlibModuleNs?.URL === "function"
-		? urlStdlibModuleNs.URL
-		: typeof urlStdlibModuleNs?.default?.URL === "function"
-			? urlStdlibModuleNs.default.URL
-			: globalThis.URL;
-var NativeURL = canUseNativeUrlImplementation(nativeUrlCandidate)
-	? nativeUrlCandidate
-	: class URL {
-			constructor(url, base) {
-				const raw = String(url ?? "");
-				const hasScheme = /^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(raw);
-				if (!hasScheme && typeof base === "undefined") {
-					throw new TypeError(`Invalid URL: ${raw}`);
-				}
-				let full = raw;
-				if (!hasScheme) {
-					const baseUrl = new URL(base);
-					if (baseUrl.protocol === "file:") {
-						const queryIndex2 = raw.indexOf("?");
-						const hashIndex2 = raw.indexOf("#");
-						const searchStart2 = queryIndex2 === -1 ? raw.length : queryIndex2;
-						const hashStart2 = hashIndex2 === -1 ? raw.length : hashIndex2;
-						const pathEnd2 = Math.min(searchStart2, hashStart2);
-						const relativePath = raw.slice(0, pathEnd2);
-						const suffix = raw.slice(pathEnd2);
-						let basePathname = baseUrl.pathname || "/";
-						if (!basePathname.startsWith("/")) {
-							basePathname = `/${basePathname}`;
-						}
-						const baseDirectory = basePathname.endsWith("/")
-							? basePathname
-							: builtinPathStdlibModule.posix.dirname(basePathname);
-						let resolvedPath = builtinPathStdlibModule.posix.resolve(
-							baseDirectory,
-							relativePath,
-						);
-						if (
-							(relativePath.endsWith("/") ||
-								/(^|\/)\.\.?$/.test(relativePath)) &&
-							!resolvedPath.endsWith("/")
-						) {
-							resolvedPath += "/";
-						}
-						full = `file://${resolvedPath}${suffix}`;
-					} else {
-						full = resolveRelativeNonFileUrl(
-							raw,
-							baseUrl,
-							builtinPathStdlibModule.posix,
-						);
-					}
-				}
-				const queryIndex = full.indexOf("?");
-				const hashIndex = full.indexOf("#");
-				const searchStart = queryIndex === -1 ? full.length : queryIndex;
-				const hashStart = hashIndex === -1 ? full.length : hashIndex;
-				const pathEnd = Math.min(searchStart, hashStart);
-				const searchValue =
-					queryIndex === -1 ? "" : full.slice(queryIndex, hashStart);
-				const hashValue = hashIndex === -1 ? "" : full.slice(hashIndex);
-				const bindSearchParams = (buildHref) => {
-					this.searchParams = new URLSearchParams(this.search);
-					for (const method of SEARCH_PARAM_SYNC_METHOD_NAMES) {
-						const original = this.searchParams[method]?.bind(this.searchParams);
-						if (!original) {
-							continue;
-						}
-						this.searchParams[method] = (...args) => {
-							const result = original(...args);
-							const query = this.searchParams.toString();
-							this.search = query ? `?${query}` : "";
-							this.href = buildHref();
-							return result;
-						};
-					}
-				};
-				if (full.startsWith("file:")) {
-					let pathname = full.slice(5, pathEnd);
-					if (pathname.startsWith("//")) {
-						const authorityMatch = /^\/\/[^/]*(.*)$/.exec(pathname);
-						pathname = authorityMatch?.[1] || "/";
-					}
-					if (!pathname.startsWith("/")) {
-						pathname = `/${pathname}`;
-					}
-					this.protocol = "file:";
-					this.hostname = "";
-					this.port = "";
-					this.pathname = pathname || "/";
-					this.search = searchValue;
-					this.hash = hashValue;
-					this.host = "";
-					this.href = `file://${this.pathname}${this.search}${this.hash}`;
-					this.origin = "null";
-					bindSearchParams(
-						() => `file://${this.pathname}${this.search}${this.hash}`,
-					);
-					return;
-				}
-				const opaqueSchemeMatch = full.match(
-					/^([a-zA-Z][a-zA-Z\d+\-.]*:)(?!\/\/)/,
-				);
-				if (opaqueSchemeMatch) {
-					const protocol = opaqueSchemeMatch[1];
-					this.protocol = protocol;
-					this.hostname = "";
-					this.port = "";
-					this.host = "";
-					this.pathname = full.slice(protocol.length, pathEnd);
-					this.search = searchValue;
-					this.hash = hashValue;
-					this.href = protocol + this.pathname + this.search + this.hash;
-					this.origin = "null";
-					bindSearchParams(
-						() => protocol + this.pathname + this.search + this.hash,
-					);
-					return;
-				}
-				const match = full.match(/^(\w+:)\/\/([^/:?#]+)(:\d+)?(.*)$/);
-				this.protocol = match?.[1] || "";
-				this.hostname = match?.[2] || "";
-				this.port = (match?.[3] || "").slice(1);
-				this.pathname = (match?.[4] || "/").split("?")[0].split("#")[0] || "/";
-				this.search = full.includes("?")
-					? "?" + full.split("?")[1].split("#")[0]
-					: "";
-				this.hash = full.includes("#") ? "#" + full.split("#")[1] : "";
-				this.host = this.hostname + (this.port ? ":" + this.port : "");
-				this.href =
-					this.protocol +
-					"//" +
-					this.host +
-					this.pathname +
-					this.search +
-					this.hash;
-				this.origin = this.protocol + "//" + this.host;
-				bindSearchParams(
-					() =>
-						this.protocol +
-						"//" +
-						this.host +
-						this.pathname +
-						this.search +
-						this.hash,
-				);
-			}
-			toString() {
-				return this.href;
-			}
-		};
-var URL2 = class _URL {
-	#impl;
-	#searchParams;
-	constructor(input, base) {
-		if (arguments.length < 1) {
-			throw createMissingArgsError('The "url" argument must be specified');
-		}
-		const normalizedArgs = normalizeRelativeFileUrlInput(
-			toNodeUSVString(input),
-			arguments.length >= 2 ? toNodeUSVString(base) : void 0,
-		);
-		try {
-			this.#impl =
-				normalizedArgs.base !== void 0
-					? new NativeURL(normalizedArgs.input, normalizedArgs.base)
-					: new NativeURL(normalizedArgs.input);
-		} catch {
-			throw createInvalidUrlError();
-		}
-	}
-	static canParse(input, base) {
-		if (arguments.length < 1) {
-			throw createMissingArgsError('The "url" argument must be specified');
-		}
-		try {
-			if (arguments.length >= 2) {
-				new _URL(input, base);
-			} else {
-				new _URL(input);
-			}
-			return true;
-		} catch {
-			return false;
-		}
-	}
-	static createObjectURL(obj) {
-		if (typeof Blob === "undefined" || !(obj instanceof Blob)) {
-			throw createNodeTypeError(
-				'The "obj" argument must be an instance of Blob. Received ' +
-					(obj === null ? "null" : typeof obj),
-				"ERR_INVALID_ARG_TYPE",
-			);
-		}
-		const id = `blob:nodedata:${nextBlobUrlId()}`;
-		getBlobUrlStore().set(id, obj);
-		return id;
-	}
-	static revokeObjectURL(url) {
-		if (arguments.length < 1) {
-			throw createMissingArgsError('The "url" argument must be specified');
-		}
-		if (typeof url !== "string") {
-			return;
-		}
-		getBlobUrlStore().delete(url);
-	}
-	get href() {
-		if (!(this instanceof _URL)) {
-			throw createUrlReceiverTypeError();
-		}
-		return this.#impl.href;
-	}
-	set href(value) {
-		this.#impl.href = toNodeUSVString(value);
-	}
-	get origin() {
-		return this.#impl.origin;
-	}
-	get protocol() {
-		return this.#impl.protocol;
-	}
-	set protocol(value) {
-		this.#impl.protocol = toNodeUSVString(value);
-	}
-	get username() {
-		return this.#impl.username;
-	}
-	set username(value) {
-		this.#impl.username = toNodeUSVString(value);
-	}
-	get password() {
-		return this.#impl.password;
-	}
-	set password(value) {
-		this.#impl.password = toNodeUSVString(value);
-	}
-	get host() {
-		return this.#impl.host;
-	}
-	set host(value) {
-		this.#impl.host = toNodeUSVString(value);
-	}
-	get hostname() {
-		return this.#impl.hostname;
-	}
-	set hostname(value) {
-		this.#impl.hostname = toNodeUSVString(value);
-	}
-	get port() {
-		return this.#impl.port;
-	}
-	set port(value) {
-		this.#impl.port = toNodeUSVString(value);
-	}
-	get pathname() {
-		return this.#impl.pathname;
-	}
-	set pathname(value) {
-		this.#impl.pathname = toNodeUSVString(value);
-	}
-	get search() {
-		if (!(this instanceof _URL)) {
-			throw createUrlReceiverTypeError();
-		}
-		return this.#impl.search;
-	}
-	set search(value) {
-		this.#impl.search = toNodeUSVString(value);
-	}
-	get searchParams() {
-		if (!this.#searchParams) {
-			this.#searchParams = new URLSearchParams({
-				[kLinkedSearchParams]: () => this.#impl.searchParams,
-			});
-		}
-		return this.#searchParams;
-	}
-	get hash() {
-		return this.#impl.hash;
-	}
-	set hash(value) {
-		this.#impl.hash = toNodeUSVString(value);
-	}
-	toString() {
-		if (!(this instanceof _URL)) {
-			throw createUrlReceiverTypeError();
-		}
-		return this.#impl.href;
-	}
-	toJSON() {
-		if (!(this instanceof _URL)) {
-			throw createUrlReceiverTypeError();
-		}
-		return this.#impl.href;
-	}
-	[inspectCustomSymbol](depth, options, inspect) {
-		const inspectName =
-			this.constructor === _URL ? "URL" : this.constructor.name;
-		if (depth < 0) {
-			return `${inspectName} {}`;
-		}
-		const formatValue =
-			typeof inspect === "function"
-				? (value) => inspect(value, options)
-				: (value) => JSON.stringify(value);
-		const lines = [
-			`${inspectName} {`,
-			`  href: ${formatValue(this.href)},`,
-			`  origin: ${formatValue(this.origin)},`,
-			`  protocol: ${formatValue(this.protocol)},`,
-			`  username: ${formatValue(this.username)},`,
-			`  password: ${formatValue(this.password)},`,
-			`  host: ${formatValue(this.host)},`,
-			`  hostname: ${formatValue(this.hostname)},`,
-			`  port: ${formatValue(this.port)},`,
-			`  pathname: ${formatValue(this.pathname)},`,
-			`  search: ${formatValue(this.search)},`,
-			`  searchParams: ${this.searchParams[inspectCustomSymbol](depth - 1, void 0, inspect)},`,
-			`  hash: ${formatValue(this.hash)}`,
-		];
-		if (options?.showHidden) {
-			lines[lines.length - 1] += ",";
-			lines.push(
-				`  [Symbol(context)]: ${formatUrlContext(this, inspect, options)}`,
-			);
-		}
-		lines.push("}");
-		return lines.join("\n");
-	}
-	get [toStringTagSymbol]() {
-		return "URL";
-	}
-};
-for (const name of ["toString", "toJSON"]) {
-	Object.defineProperty(URL2.prototype, name, {
-		value: URL2.prototype[name],
-		writable: true,
-		configurable: true,
-		enumerable: true,
-	});
-}
-for (const name of [
-	"href",
-	"protocol",
-	"username",
-	"password",
-	"host",
-	"hostname",
-	"port",
-	"pathname",
-	"search",
-	"hash",
-	"origin",
-	"searchParams",
-]) {
-	const descriptor = Object.getOwnPropertyDescriptor(URL2.prototype, name);
-	if (!descriptor) {
-		continue;
-	}
-	descriptor.enumerable = true;
-	Object.defineProperty(URL2.prototype, name, descriptor);
-}
-Object.defineProperties(URL2.prototype, {
-	[inspectCustomSymbol]: {
-		value: URL2.prototype[inspectCustomSymbol],
-		writable: true,
-		configurable: true,
-		enumerable: false,
-	},
-	[toStringTagSymbol]: {
-		get: Object.getOwnPropertyDescriptor(URL2.prototype, toStringTagSymbol)
-			?.get,
-		configurable: true,
-		enumerable: false,
-	},
-});
-for (const name of ["canParse", "createObjectURL", "revokeObjectURL"]) {
-	Object.defineProperty(URL2, name, {
-		value: URL2[name],
-		writable: true,
-		configurable: true,
-		enumerable: true,
-	});
+
+function resolveObjectURL(url) {
+	return getBlobUrlStore().get(typeof url === "string" ? url : `${url}`);
 }
+
+const URL2 = globalThis.URL;
+const URLSearchParams = globalThis.URLSearchParams;
+
 function installWhatwgUrlGlobals(target = globalThis) {
 	Object.defineProperty(target, "URL", {
 		value: URL2,
@@ -1236,60 +51,16 @@ function installWhatwgUrlGlobals(target = globalThis) {
 		enumerable: false,
 	});
 }
+
 export {
-	inspectCustomSymbol,
-	toStringTagSymbol,
-	ERR_INVALID_THIS,
-	ERR_MISSING_ARGS,
-	ERR_INVALID_URL,
-	ERR_ARG_NOT_ITERABLE,
-	ERR_INVALID_TUPLE,
-	URL_SEARCH_PARAMS_TYPE,
-	kLinkedSearchParams,
-	kBlobUrlStore,
-	kBlobUrlCounter,
-	SEARCH_PARAM_METHOD_NAMES,
-	SEARCH_PARAM_PAIR_METHOD_NAMES,
-	URL_SCHEME_TYPES,
-	searchParamsBrand,
-	searchParamsState,
-	searchParamsIteratorBrand,
-	searchParamsIteratorState,
-	createNodeTypeError,
-	createInvalidUrlError,
-	createUrlReceiverTypeError,
 	createMissingArgsError,
-	createIterableTypeError,
-	createTupleTypeError,
-	createSymbolStringError,
-	toNodeString,
-	toWellFormedString,
-	toNodeUSVString,
-	assertUrlSearchParamsReceiver,
-	assertUrlSearchParamsIteratorReceiver,
-	getUrlSearchParamsImpl,
-	countSearchParams,
-	isAsciiHexCodeUnit,
-	decodeAsciiHexCodeUnit,
-	appendUtf8CodePoint,
-	decodeFormUrlencodedComponent,
-	serializeFormUrlencodedComponent,
-	compareCodeUnitStrings,
-	normalizeSearchParamsInit,
-	NativeURLSearchParams,
-	createStandaloneSearchParams,
-	createCollectionBody,
-	createUrlContext,
-	formatUrlContext,
+	createNodeTypeError,
 	getBlobUrlStore,
+	installWhatwgUrlGlobals,
+	kBlobUrlCounter,
+	kBlobUrlStore,
 	nextBlobUrlId,
-	URLSearchParamsIterator,
-	URLSearchParams,
-	canUseNativeUrlImplementation,
-	ensureTrailingSlashForFilePath,
-	normalizeRelativeFileUrlInput,
-	nativeUrlCandidate,
-	NativeURL,
+	resolveObjectURL,
 	URL2,
-	installWhatwgUrlGlobals,
+	URLSearchParams,
 };
diff --git a/packages/build-tools/bridge-src/polyfills/abort.ts b/packages/build-tools/bridge-src/polyfills/abort.ts
index a6cb83b7fc..f213b69de6 100644
--- a/packages/build-tools/bridge-src/polyfills/abort.ts
+++ b/packages/build-tools/bridge-src/polyfills/abort.ts
@@ -1,150 +1,251 @@
-import { NativeAbortControllerGlobal, NativeAbortSignalGlobal } from "../prelude.js";
 import { Event, EventTarget } from "./dom-events.js";
 
-var AbortSignal = typeof NativeAbortSignalGlobal === "function" ? NativeAbortSignalGlobal : class extends EventTarget {
-  constructor() {
-    super();
-    this.aborted = false;
-    this.reason = void 0;
-  }
-  throwIfAborted() {
-    if (this.aborted) {
-      throw this.reason instanceof Error ? this.reason : new Error(String(this.reason ?? "AbortError"));
-    }
-  }
-};
-var AbortController = typeof NativeAbortControllerGlobal === "function" ? NativeAbortControllerGlobal : class {
-  constructor() {
-    this.signal = new AbortSignal();
-  }
-  abort(reason) {
-    if (this.signal.aborted) {
-      return;
-    }
-    this.signal.aborted = true;
-    this.signal.reason = reason;
-    this.signal.dispatchEvent(new Event("abort"));
-  }
-};
+const NativeAbortControllerGlobal = globalThis.AbortController;
+const NativeAbortSignalGlobal = globalThis.AbortSignal;
+const hasNativeAbortGlobals =
+	typeof NativeAbortSignalGlobal === "function" &&
+	NativeAbortSignalGlobal.name === "AbortSignal" &&
+	typeof NativeAbortControllerGlobal === "function" &&
+	NativeAbortControllerGlobal.name === "AbortController";
+const MAX_ABORT_SIGNAL_ANY_INPUTS = 1024;
+const abortSignalToken = {};
+const abortSignalState = new WeakMap();
+const abortControllerState = new WeakMap();
+
+function withCode(error, code) {
+	error.code = code;
+	return error;
+}
+
+class FallbackAbortSignal extends EventTarget {
+	constructor(token) {
+		super();
+		if (token !== abortSignalToken) {
+			throw withCode(
+				new TypeError("Illegal constructor"),
+				"ERR_ILLEGAL_CONSTRUCTOR",
+			);
+		}
+		abortSignalState.set(this, {
+			aborted: false,
+			reason: void 0,
+			onabort: null,
+		});
+	}
+
+	get aborted() {
+		return abortSignalState.get(this).aborted;
+	}
+
+	get reason() {
+		return abortSignalState.get(this).reason;
+	}
+
+	get onabort() {
+		return abortSignalState.get(this).onabort;
+	}
+
+	set onabort(listener) {
+		const state = abortSignalState.get(this);
+		if (state.onabort) this.removeEventListener("abort", state.onabort);
+		state.onabort = typeof listener === "function" ? listener : null;
+		if (state.onabort) this.addEventListener("abort", state.onabort);
+	}
+
+	throwIfAborted() {
+		const state = abortSignalState.get(this);
+		if (state.aborted) throw state.reason;
+	}
+}
+
+class FallbackAbortController {
+	constructor() {
+		abortControllerState.set(this, new FallbackAbortSignal(abortSignalToken));
+	}
+
+	get signal() {
+		return abortControllerState.get(this);
+	}
+
+	abort(reason) {
+		const signal = abortControllerState.get(this);
+		const state = abortSignalState.get(signal);
+		if (state.aborted) return;
+		state.aborted = true;
+		state.reason = createAbortSignalReason(reason);
+		signal.dispatchEvent(new Event("abort"));
+	}
+}
+
+var AbortSignal = hasNativeAbortGlobals
+	? NativeAbortSignalGlobal
+	: FallbackAbortSignal;
+var AbortController = hasNativeAbortGlobals
+	? NativeAbortControllerGlobal
+	: FallbackAbortController;
+
 function ensureNamedConstructor(ctor, expectedName) {
-  if (typeof ctor !== "function") {
-    return;
-  }
-  try {
-    if (ctor.name !== expectedName) {
-      Object.defineProperty(ctor, "name", {
-        configurable: true,
-        value: expectedName
-      });
-    }
-  } catch {
-  }
+	if (typeof ctor !== "function") return;
+	try {
+		if (ctor.name !== expectedName) {
+			Object.defineProperty(ctor, "name", {
+				configurable: true,
+				value: expectedName,
+			});
+		}
+	} catch {}
 }
+
 ensureNamedConstructor(AbortSignal, "AbortSignal");
 ensureNamedConstructor(AbortController, "AbortController");
 try {
-  const signalCtor = Object.getPrototypeOf(new AbortController().signal)?.constructor;
-  ensureNamedConstructor(signalCtor, "AbortSignal");
-} catch {
-}
+	const signalCtor = Object.getPrototypeOf(
+		new AbortController().signal,
+	)?.constructor;
+	ensureNamedConstructor(signalCtor, "AbortSignal");
+} catch {}
 try {
-  globalThis.AbortSignal = AbortSignal;
-} catch {
-}
+	globalThis.AbortSignal = AbortSignal;
+} catch {}
 try {
-  globalThis.AbortController = AbortController;
-} catch {
-}
+	globalThis.AbortController = AbortController;
+} catch {}
+
 function createAbortSignalReason(reason) {
-  if (reason !== void 0) {
-    return reason;
-  }
-  if (typeof globalThis.DOMException === "function") {
-    return new globalThis.DOMException("This operation was aborted", "AbortError");
-  }
-  const error = new Error("This operation was aborted");
-  error.name = "AbortError";
-  return error;
+	if (reason !== void 0) return reason;
+	if (typeof globalThis.DOMException === "function") {
+		return new globalThis.DOMException(
+			"This operation was aborted",
+			"AbortError",
+		);
+	}
+	const error = new Error("This operation was aborted");
+	error.name = "AbortError";
+	return error;
 }
+
+function createAbortSignalTimeoutReason() {
+	if (typeof globalThis.DOMException === "function") {
+		return new globalThis.DOMException(
+			"The operation was aborted due to timeout",
+			"TimeoutError",
+		);
+	}
+	const error = new Error("The operation was aborted due to timeout");
+	error.name = "TimeoutError";
+	return error;
+}
+
 function createAbortedSignal(reason) {
-  const controller = new AbortController();
-  controller.abort(createAbortSignalReason(reason));
-  return controller.signal;
+	const controller = new AbortController();
+	controller.abort(reason);
+	return controller.signal;
 }
+
 function normalizeAbortSignalTimeout(delay) {
-  if (typeof delay !== "number") {
-    throw new TypeError(`The "delay" argument must be of type number. Received ${typeof delay}`);
-  }
-  if (!Number.isFinite(delay) || delay < 0) {
-    throw new RangeError(`The value of "delay" is out of range. It must be >= 0. Received ${String(delay)}`);
-  }
-  return Math.trunc(delay);
+	if (typeof delay !== "number") {
+		throw withCode(
+			new TypeError(
+				`The "delay" argument must be of type number. Received ${typeof delay}`,
+			),
+			"ERR_INVALID_ARG_TYPE",
+		);
+	}
+	if (!Number.isInteger(delay) || delay < 0 || delay > 4294967295) {
+		throw withCode(
+			new RangeError(
+				`The value of "delay" is out of range. It must be an integer >= 0 and <= 4294967295. Received ${String(delay)}`,
+			),
+			"ERR_OUT_OF_RANGE",
+		);
+	}
+	return delay;
 }
+
 if (typeof AbortSignal.abort !== "function") {
-  Object.defineProperty(AbortSignal, "abort", {
-    configurable: true,
-    writable: true,
-    value(reason = void 0) {
-      return createAbortedSignal(reason);
-    }
-  });
+	Object.defineProperty(AbortSignal, "abort", {
+		configurable: true,
+		writable: true,
+		value(reason = void 0) {
+			return createAbortedSignal(reason);
+		},
+	});
 }
+
 if (typeof AbortSignal.timeout !== "function") {
-  Object.defineProperty(AbortSignal, "timeout", {
-    configurable: true,
-    writable: true,
-    value(delay) {
-      const timeout = normalizeAbortSignalTimeout(delay);
-      const controller = new AbortController();
-      const timer = setTimeout(() => {
-        controller.abort(createAbortSignalReason());
-      }, timeout);
-      if (typeof timer?.unref === "function") {
-        timer.unref();
-      }
-      controller.signal.addEventListener("abort", () => {
-        clearTimeout(timer);
-      }, { once: true });
-      return controller.signal;
-    }
-  });
+	Object.defineProperty(AbortSignal, "timeout", {
+		configurable: true,
+		writable: true,
+		value(delay) {
+			const timeout = normalizeAbortSignalTimeout(delay);
+			const controller = new AbortController();
+			const timer = setTimeout(() => {
+				controller.abort(createAbortSignalTimeoutReason());
+			}, timeout);
+			if (typeof timer?.unref === "function") timer.unref();
+			controller.signal.addEventListener("abort", () => clearTimeout(timer), {
+				once: true,
+			});
+			return controller.signal;
+		},
+	});
 }
+
 if (typeof AbortSignal.any !== "function") {
-  Object.defineProperty(AbortSignal, "any", {
-    configurable: true,
-    writable: true,
-    value(signals) {
-      if (!signals || typeof signals[Symbol.iterator] !== "function") {
-        throw new TypeError("The \"signals\" argument must be an iterable");
-      }
-      const inputs = Array.from(signals);
-      const controller = new AbortController();
-      if (inputs.length === 0) {
-        return controller.signal;
-      }
-      const listeners = [];
-      const abortFromSignal = (signal) => {
-        while (listeners.length > 0) {
-          const [candidate, listener] = listeners.pop();
-          candidate.removeEventListener?.("abort", listener);
-        }
-        controller.abort(signal.reason);
-      };
-      for (const signal of inputs) {
-        if (!signal || typeof signal.aborted !== "boolean" || typeof signal.addEventListener !== "function") {
-          throw new TypeError("The \"signals\" argument must contain AbortSignal instances");
-        }
-        if (signal.aborted) {
-          abortFromSignal(signal);
-          return controller.signal;
-        }
-        const onAbort = () => abortFromSignal(signal);
-        listeners.push([signal, onAbort]);
-        signal.addEventListener("abort", onAbort, { once: true });
-      }
-      return controller.signal;
-    }
-  });
+	Object.defineProperty(AbortSignal, "any", {
+		configurable: true,
+		writable: true,
+		value(signals) {
+			if (!signals || typeof signals[Symbol.iterator] !== "function") {
+				throw new TypeError('The "signals" argument must be an iterable');
+			}
+			const inputs = [];
+			for (const signal of signals) {
+				if (inputs.length >= MAX_ABORT_SIGNAL_ANY_INPUTS) {
+					throw withCode(
+						new RangeError(
+							`AbortSignal.any input limit ${MAX_ABORT_SIGNAL_ANY_INPUTS} exceeded; this runtime limit cannot be raised by guest code`,
+						),
+						"ERR_ABORT_SIGNAL_LIMIT",
+					);
+				}
+				if (!(signal instanceof AbortSignal)) {
+					throw new TypeError(
+						'The "signals" argument must contain AbortSignal instances',
+					);
+				}
+				inputs.push(signal);
+			}
+			const controller = new AbortController();
+			const listeners = [];
+			const abortFromSignal = (signal) => {
+				while (listeners.length > 0) {
+					const [candidate, listener] = listeners.pop();
+					candidate.removeEventListener("abort", listener);
+				}
+				controller.abort(signal.reason);
+			};
+			for (const signal of inputs) {
+				if (signal.aborted) {
+					abortFromSignal(signal);
+					return controller.signal;
+				}
+				const onAbort = () => abortFromSignal(signal);
+				listeners.push([signal, onAbort]);
+				signal.addEventListener("abort", onAbort, { once: true });
+			}
+			return controller.signal;
+		},
+	});
 }
 
-export { AbortSignal, AbortController, ensureNamedConstructor, createAbortSignalReason, createAbortedSignal, normalizeAbortSignalTimeout };
+export {
+	AbortController,
+	AbortSignal,
+	createAbortedSignal,
+	createAbortSignalReason,
+	createAbortSignalTimeoutReason,
+	ensureNamedConstructor,
+	MAX_ABORT_SIGNAL_ANY_INPUTS,
+	normalizeAbortSignalTimeout,
+};
diff --git a/packages/build-tools/bridge-src/polyfills/blob-file.ts b/packages/build-tools/bridge-src/polyfills/blob-file.ts
new file mode 100644
index 0000000000..4bdfe4ae3a
--- /dev/null
+++ b/packages/build-tools/bridge-src/polyfills/blob-file.ts
@@ -0,0 +1,79 @@
+import { Blob as UpstreamBlob } from "fetch-blob";
+import { File as UpstreamFile } from "fetch-blob/file.js";
+
+const MAX_BLOB_PARTS = 1024;
+const MAX_BLOB_BYTES = 64 * 1024 * 1024;
+
+function blobPartSize(part) {
+	if (part instanceof UpstreamBlob) return part.size;
+	if (ArrayBuffer.isView(part)) return part.byteLength;
+	if (part instanceof ArrayBuffer) return part.byteLength;
+	return new TextEncoder().encode(`${part}`).byteLength;
+}
+
+function normalizeBlobParts(parts) {
+	if (parts === void 0) return [];
+	if (parts == null || typeof parts[Symbol.iterator] !== "function") {
+		throw new TypeError("Blob parts must be an iterable");
+	}
+	const normalized = [];
+	let totalBytes = 0;
+	for (const part of parts) {
+		if (normalized.length >= MAX_BLOB_PARTS) {
+			const error = new RangeError(
+				`Blob part limit ${MAX_BLOB_PARTS} exceeded; this runtime limit cannot be raised by guest code`,
+			);
+			error.code = "ERR_BLOB_PARTS_LIMIT";
+			throw error;
+		}
+		totalBytes += blobPartSize(part);
+		if (!Number.isSafeInteger(totalBytes) || totalBytes > MAX_BLOB_BYTES) {
+			const error = new RangeError(
+				`Blob byte limit ${MAX_BLOB_BYTES} exceeded; this runtime limit cannot be raised by guest code`,
+			);
+			error.code = "ERR_BLOB_SIZE_LIMIT";
+			throw error;
+		}
+		normalized.push(part);
+	}
+	return normalized;
+}
+
+function normalizeBlobOptions(options) {
+	if (options == null || options.type === void 0) {
+		return options;
+	}
+	const type = String(options.type);
+	return {
+		...Object(options),
+		type: /^[\x20-\x7e]*$/.test(type) ? type.toLowerCase() : "",
+	};
+}
+
+class Blob extends UpstreamBlob {
+	constructor(parts, options) {
+		super(normalizeBlobParts(parts), normalizeBlobOptions(options));
+	}
+
+	slice(start, end, type) {
+		const sliced = super.slice(start, end, type);
+		return new Blob([sliced], { type: sliced.type });
+	}
+}
+
+Object.setPrototypeOf(UpstreamFile.prototype, Blob.prototype);
+
+class File extends UpstreamFile {
+	constructor(parts, name, options) {
+		super(normalizeBlobParts(parts), name, normalizeBlobOptions(options));
+	}
+}
+
+export {
+	Blob,
+	File,
+	MAX_BLOB_BYTES,
+	MAX_BLOB_PARTS,
+	normalizeBlobOptions,
+	normalizeBlobParts,
+};
diff --git a/packages/build-tools/bridge-src/polyfills/dom-events.ts b/packages/build-tools/bridge-src/polyfills/dom-events.ts
index 8448d8f975..a3425d977b 100644
--- a/packages/build-tools/bridge-src/polyfills/dom-events.ts
+++ b/packages/build-tools/bridge-src/polyfills/dom-events.ts
@@ -1,219 +1,350 @@
+const MAX_EVENT_TYPES = 256;
+const MAX_EVENT_LISTENERS = 1024;
+const eventState = new WeakMap();
+const customEventDetail = new WeakMap();
+const targetState = new WeakMap();
+
+function toDomString(value) {
+	return `${value}`;
+}
+
+function withCode(error, code) {
+	error.code = code;
+	return error;
+}
+
 function normalizeAddEventListenerOptions(options) {
-  if (typeof options === "boolean") {
-    return {
-      capture: options,
-      once: false,
-      passive: false
-    };
-  }
-  if (options == null) {
-    return {
-      capture: false,
-      once: false,
-      passive: false
-    };
-  }
-  const normalized = Object(options);
-  return {
-    capture: Boolean(normalized.capture),
-    once: Boolean(normalized.once),
-    passive: Boolean(normalized.passive),
-    signal: normalized.signal
-  };
+	if (typeof options === "boolean") {
+		return { capture: options, once: false, passive: false };
+	}
+	if (options == null) {
+		return { capture: false, once: false, passive: false };
+	}
+	const normalized = Object(options);
+	return {
+		capture: Boolean(normalized.capture),
+		once: Boolean(normalized.once),
+		passive: Boolean(normalized.passive),
+		signal: normalized.signal,
+	};
 }
+
 function normalizeRemoveEventListenerOptions(options) {
-  if (typeof options === "boolean") {
-    return options;
-  }
-  if (options == null) {
-    return false;
-  }
-  return Boolean(Object(options).capture);
+	if (typeof options === "boolean") return options;
+	if (options == null) return false;
+	return Boolean(Object(options).capture);
 }
+
 function isAbortSignalLike(value) {
-  return typeof value === "object" && value !== null && "aborted" in value && typeof value.addEventListener === "function" && typeof value.removeEventListener === "function";
+	return (
+		typeof value === "object" &&
+		value !== null &&
+		"aborted" in value &&
+		typeof value.addEventListener === "function" &&
+		typeof value.removeEventListener === "function"
+	);
 }
-var PatchedEvent = class {
-  static NONE = 0;
-  static CAPTURING_PHASE = 1;
-  static AT_TARGET = 2;
-  static BUBBLING_PHASE = 3;
-  type;
-  bubbles;
-  cancelable;
-  composed;
-  detail = null;
-  defaultPrevented = false;
-  target = null;
-  currentTarget = null;
-  eventPhase = 0;
-  returnValue = true;
-  cancelBubble = false;
-  timeStamp = Date.now();
-  isTrusted = false;
-  srcElement = null;
-  inPassiveListener = false;
-  propagationStopped = false;
-  immediatePropagationStopped = false;
-  constructor(type, init) {
-    if (arguments.length === 0) {
-      throw new TypeError("The event type must be provided");
-    }
-    const normalizedInit = init == null ? {} : Object(init);
-    this.type = String(type);
-    this.bubbles = Boolean(normalizedInit.bubbles);
-    this.cancelable = Boolean(normalizedInit.cancelable);
-    this.composed = Boolean(normalizedInit.composed);
-  }
-  get [Symbol.toStringTag]() {
-    return "Event";
-  }
-  preventDefault() {
-    if (this.cancelable && !this.inPassiveListener) {
-      this.defaultPrevented = true;
-      this.returnValue = false;
-    }
-  }
-  stopPropagation() {
-    this.propagationStopped = true;
-    this.cancelBubble = true;
-  }
-  stopImmediatePropagation() {
-    this.propagationStopped = true;
-    this.immediatePropagationStopped = true;
-    this.cancelBubble = true;
-  }
-  composedPath() {
-    return this.target ? [this.target] : [];
-  }
-  _setPassive(value) {
-    this.inPassiveListener = value;
-  }
-  _isPropagationStopped() {
-    return this.propagationStopped;
-  }
-  _isImmediatePropagationStopped() {
-    return this.immediatePropagationStopped;
-  }
-};
-var PatchedCustomEvent = class extends PatchedEvent {
-  constructor(type, init) {
-    super(type, init);
-    const normalizedInit = init == null ? null : Object(init);
-    this.detail = normalizedInit && "detail" in normalizedInit ? normalizedInit.detail : null;
-  }
-  get [Symbol.toStringTag]() {
-    return "CustomEvent";
-  }
-};
-var PatchedEventTarget = class {
-  listeners = /* @__PURE__ */ new Map();
-  addEventListener(type, listener, options) {
-    const normalized = normalizeAddEventListenerOptions(options);
-    if (normalized.signal !== void 0 && !isAbortSignalLike(normalized.signal)) {
-      throw new TypeError(
-        'The "signal" option must be an instance of AbortSignal.'
-      );
-    }
-    if (listener == null) {
-      return void 0;
-    }
-    if (typeof listener !== "function" && (typeof listener !== "object" || listener === null)) {
-      return void 0;
-    }
-    if (normalized.signal?.aborted) {
-      return void 0;
-    }
-    const records = this.listeners.get(type) ?? [];
-    const existing = records.find(
-      (record2) => record2.listener === listener && record2.capture === normalized.capture
-    );
-    if (existing) {
-      return void 0;
-    }
-    const record = {
-      listener,
-      capture: normalized.capture,
-      once: normalized.once,
-      passive: normalized.passive,
-      kind: typeof listener === "function" ? "function" : "object",
-      signal: normalized.signal
-    };
-    if (normalized.signal) {
-      record.abortListener = () => {
-        this.removeEventListener(type, listener, normalized.capture);
-      };
-      normalized.signal.addEventListener("abort", record.abortListener, {
-        once: true
-      });
-    }
-    records.push(record);
-    this.listeners.set(type, records);
-    return void 0;
-  }
-  removeEventListener(type, listener, options) {
-    if (listener == null) {
-      return;
-    }
-    const capture = normalizeRemoveEventListenerOptions(options);
-    const records = this.listeners.get(type);
-    if (!records) {
-      return;
-    }
-    const nextRecords = records.filter((record) => {
-      const match = record.listener === listener && record.capture === capture;
-      if (match && record.signal && record.abortListener) {
-        record.signal.removeEventListener("abort", record.abortListener);
-      }
-      return !match;
-    });
-    if (nextRecords.length === 0) {
-      this.listeners.delete(type);
-      return;
-    }
-    this.listeners.set(type, nextRecords);
-  }
-  dispatchEvent(event) {
-    if (typeof event !== "object" || event === null || typeof event.type !== "string") {
-      throw new TypeError("Argument 1 must be an Event");
-    }
-    const patchedEvent = event;
-    const records = (this.listeners.get(patchedEvent.type) ?? []).slice();
-    patchedEvent.target = this;
-    patchedEvent.currentTarget = this;
-    patchedEvent.eventPhase = 2;
-    for (const record of records) {
-      const active = this.listeners.get(patchedEvent.type)?.includes(record);
-      if (!active) {
-        continue;
-      }
-      if (record.once) {
-        this.removeEventListener(patchedEvent.type, record.listener, record.capture);
-      }
-      patchedEvent._setPassive(record.passive);
-      if (record.kind === "function") {
-        record.listener.call(this, patchedEvent);
-      } else {
-        const handleEvent = record.listener.handleEvent;
-        if (typeof handleEvent === "function") {
-          handleEvent.call(record.listener, patchedEvent);
-        }
-      }
-      patchedEvent._setPassive(false);
-      if (patchedEvent._isImmediatePropagationStopped()) {
-        break;
-      }
-      if (patchedEvent._isPropagationStopped()) {
-        break;
-      }
-    }
-    patchedEvent.currentTarget = null;
-    patchedEvent.eventPhase = 0;
-    return !patchedEvent.defaultPrevented;
-  }
-};
+
+function reportListenerError(error) {
+	queueMicrotask(() => {
+		throw error;
+	});
+}
+
+class PatchedEvent {
+	static NONE = 0;
+	static CAPTURING_PHASE = 1;
+	static AT_TARGET = 2;
+	static BUBBLING_PHASE = 3;
+
+	constructor(type, init) {
+		if (arguments.length === 0) {
+			throw new TypeError("The event type must be provided");
+		}
+		const normalizedInit = init == null ? {} : Object(init);
+		eventState.set(this, {
+			type: toDomString(type),
+			bubbles: Boolean(normalizedInit.bubbles),
+			cancelable: Boolean(normalizedInit.cancelable),
+			composed: Boolean(normalizedInit.composed),
+			defaultPrevented: false,
+			target: null,
+			currentTarget: null,
+			eventPhase: 0,
+			timeStamp: Date.now(),
+			inPassiveListener: false,
+			propagationStopped: false,
+			immediatePropagationStopped: false,
+			dispatching: false,
+		});
+	}
+
+	get NONE() {
+		return 0;
+	}
+	get CAPTURING_PHASE() {
+		return 1;
+	}
+	get AT_TARGET() {
+		return 2;
+	}
+	get BUBBLING_PHASE() {
+		return 3;
+	}
+	get type() {
+		return eventState.get(this).type;
+	}
+	get bubbles() {
+		return eventState.get(this).bubbles;
+	}
+	get cancelable() {
+		return eventState.get(this).cancelable;
+	}
+	get composed() {
+		return eventState.get(this).composed;
+	}
+	get defaultPrevented() {
+		return eventState.get(this).defaultPrevented;
+	}
+	get target() {
+		return eventState.get(this).target;
+	}
+	get currentTarget() {
+		return eventState.get(this).currentTarget;
+	}
+	get eventPhase() {
+		return eventState.get(this).eventPhase;
+	}
+	get timeStamp() {
+		return eventState.get(this).timeStamp;
+	}
+	get isTrusted() {
+		return false;
+	}
+	get srcElement() {
+		return eventState.get(this).target;
+	}
+	get returnValue() {
+		return !eventState.get(this).defaultPrevented;
+	}
+	set returnValue(value) {
+		if (!value) this.preventDefault();
+	}
+	get cancelBubble() {
+		return eventState.get(this).propagationStopped;
+	}
+	set cancelBubble(value) {
+		if (value) this.stopPropagation();
+	}
+
+	get [Symbol.toStringTag]() {
+		return "Event";
+	}
+
+	preventDefault() {
+		const state = eventState.get(this);
+		if (state.cancelable && !state.inPassiveListener) {
+			state.defaultPrevented = true;
+		}
+	}
+
+	stopPropagation() {
+		eventState.get(this).propagationStopped = true;
+	}
+
+	stopImmediatePropagation() {
+		const state = eventState.get(this);
+		state.propagationStopped = true;
+		state.immediatePropagationStopped = true;
+	}
+
+	composedPath() {
+		const target = eventState.get(this).target;
+		return target ? [target] : [];
+	}
+}
+
+class PatchedCustomEvent extends PatchedEvent {
+	constructor(type, init) {
+		super(type, init);
+		const normalizedInit = init == null ? null : Object(init);
+		customEventDetail.set(
+			this,
+			normalizedInit && "detail" in normalizedInit
+				? normalizedInit.detail
+				: null,
+		);
+	}
+
+	get detail() {
+		return customEventDetail.get(this);
+	}
+
+	get [Symbol.toStringTag]() {
+		return "CustomEvent";
+	}
+}
+
+class PatchedEventTarget {
+	constructor() {
+		targetState.set(this, { listeners: new Map(), listenerCount: 0 });
+	}
+
+	addEventListener(type, listener, options) {
+		const eventType = toDomString(type);
+		const normalized = normalizeAddEventListenerOptions(options);
+		if (normalized.signal !== void 0 && !isAbortSignalLike(normalized.signal)) {
+			throw new TypeError(
+				'The "signal" option must be an instance of AbortSignal.',
+			);
+		}
+		if (listener == null) return;
+		if (
+			typeof listener !== "function" &&
+			(typeof listener !== "object" || listener === null)
+		) {
+			return;
+		}
+		if (normalized.signal?.aborted) return;
+
+		const state = targetState.get(this);
+		const records = state.listeners.get(eventType) ?? [];
+		if (
+			records.some(
+				(record) =>
+					record.listener === listener && record.capture === normalized.capture,
+			)
+		) {
+			return;
+		}
+		if (
+			!state.listeners.has(eventType) &&
+			state.listeners.size >= MAX_EVENT_TYPES
+		) {
+			throw withCode(
+				new RangeError(
+					`EventTarget event type limit ${MAX_EVENT_TYPES} exceeded; this runtime limit cannot be raised by guest code`,
+				),
+				"ERR_EVENT_TYPE_LIMIT",
+			);
+		}
+		if (state.listenerCount >= MAX_EVENT_LISTENERS) {
+			throw withCode(
+				new RangeError(
+					`EventTarget listener limit ${MAX_EVENT_LISTENERS} exceeded; this runtime limit cannot be raised by guest code`,
+				),
+				"ERR_EVENT_LISTENER_LIMIT",
+			);
+		}
+
+		const record = {
+			listener,
+			capture: normalized.capture,
+			once: normalized.once,
+			passive: normalized.passive,
+			kind: typeof listener === "function" ? "function" : "object",
+			signal: normalized.signal,
+		};
+		if (normalized.signal) {
+			record.abortListener = () => {
+				this.removeEventListener(eventType, listener, normalized.capture);
+			};
+			normalized.signal.addEventListener("abort", record.abortListener, {
+				once: true,
+			});
+		}
+		records.push(record);
+		state.listeners.set(eventType, records);
+		state.listenerCount += 1;
+	}
+
+	removeEventListener(type, listener, options) {
+		const eventType = toDomString(type);
+		if (listener == null) return;
+		const capture = normalizeRemoveEventListenerOptions(options);
+		const state = targetState.get(this);
+		const records = state.listeners.get(eventType);
+		if (!records) return;
+		const nextRecords = [];
+		for (const record of records) {
+			const match = record.listener === listener && record.capture === capture;
+			if (match) {
+				state.listenerCount -= 1;
+				if (record.signal && record.abortListener) {
+					record.signal.removeEventListener("abort", record.abortListener);
+				}
+			} else {
+				nextRecords.push(record);
+			}
+		}
+		if (nextRecords.length === 0) state.listeners.delete(eventType);
+		else state.listeners.set(eventType, nextRecords);
+	}
+
+	dispatchEvent(event) {
+		if (!(event instanceof PatchedEvent)) {
+			throw new TypeError("Argument 1 must be an Event");
+		}
+		const state = eventState.get(event);
+		if (state.dispatching) {
+			throw new DOMException(
+				"The event is already being dispatched",
+				"InvalidStateError",
+			);
+		}
+		const listeners = targetState.get(this).listeners;
+		const records = (listeners.get(state.type) ?? []).slice();
+		state.target = this;
+		state.currentTarget = this;
+		state.eventPhase = PatchedEvent.AT_TARGET;
+		state.dispatching = true;
+		try {
+			for (const record of records) {
+				if (!listeners.get(state.type)?.includes(record)) continue;
+				if (record.once) {
+					this.removeEventListener(state.type, record.listener, record.capture);
+				}
+				state.inPassiveListener = record.passive;
+				try {
+					if (record.kind === "function") {
+						record.listener.call(this, event);
+					} else {
+						const handleEvent = record.listener.handleEvent;
+						if (typeof handleEvent === "function") {
+							handleEvent.call(record.listener, event);
+						}
+					}
+				} catch (error) {
+					reportListenerError(error);
+				} finally {
+					state.inPassiveListener = false;
+				}
+				if (state.immediatePropagationStopped) break;
+			}
+		} finally {
+			state.currentTarget = null;
+			state.eventPhase = PatchedEvent.NONE;
+			state.dispatching = false;
+		}
+		return !state.defaultPrevented;
+	}
+}
+
 var Event = PatchedEvent;
 var CustomEvent = PatchedCustomEvent;
 var EventTarget = PatchedEventTarget;
 
-export { normalizeAddEventListenerOptions, normalizeRemoveEventListenerOptions, isAbortSignalLike, PatchedEvent, PatchedCustomEvent, PatchedEventTarget, Event, CustomEvent, EventTarget };
+export {
+	CustomEvent,
+	Event,
+	EventTarget,
+	isAbortSignalLike,
+	MAX_EVENT_LISTENERS,
+	MAX_EVENT_TYPES,
+	normalizeAddEventListenerOptions,
+	normalizeRemoveEventListenerOptions,
+	PatchedCustomEvent,
+	PatchedEvent,
+	PatchedEventTarget,
+	toDomString,
+};
diff --git a/packages/build-tools/bridge-src/polyfills/index.ts b/packages/build-tools/bridge-src/polyfills/index.ts
index 0b5eadb0e2..885a6d6ed5 100644
--- a/packages/build-tools/bridge-src/polyfills/index.ts
+++ b/packages/build-tools/bridge-src/polyfills/index.ts
@@ -1,52 +1,18 @@
 import { WebReadableStream, WebTextDecoderStream, WebTextEncoderStream, WebTransformStream, WebWritableStream, sandboxStructuredClone, undiciWebidlModule } from "../prelude.js";
-import { CustomEvent, Event, EventTarget } from "./dom-events.js";
-import { AbortController, AbortSignal } from "./abort.js";
-import { FallbackReadableStream, FallbackWritableStream } from "./web-streams-fallback.js";
 import { TextDecoder, TextEncoder2 } from "./text-encoding.js";
 
+const Event = globalThis.Event;
+const CustomEvent = globalThis.CustomEvent;
+const EventTarget = globalThis.EventTarget;
+const AbortSignal = globalThis.AbortSignal;
+const AbortController = globalThis.AbortController;
+
 function defineGlobal(name, value) {
   globalThis[name] = value;
 }
 if (typeof globalThis.global === "undefined") {
   defineGlobal("global", globalThis);
 }
-if (typeof globalThis.RegExp === "function" && !("__secureExecRgiEmojiCompat" in globalThis.RegExp)) {
-  const NativeRegExp = globalThis.RegExp;
-  const rgiEmojiPattern = "^\\p{RGI_Emoji}$";
-  const rgiEmojiBaseClass = "[\\u{00A9}\\u{00AE}\\u{203C}\\u{2049}\\u{2122}\\u{2139}\\u{2194}-\\u{21AA}\\u{231A}-\\u{23FF}\\u{24C2}\\u{25AA}-\\u{27BF}\\u{2934}-\\u{2935}\\u{2B05}-\\u{2B55}\\u{3030}\\u{303D}\\u{3297}\\u{3299}\\u{1F000}-\\u{1FAFF}]";
-  const rgiEmojiKeycap = "[#*0-9]\\uFE0F?\\u20E3";
-  const rgiEmojiFallbackSource = "^(?:" + rgiEmojiKeycap + "|\\p{Regional_Indicator}{2}|" + rgiEmojiBaseClass + "(?:\\uFE0F|\\u200D(?:" + rgiEmojiKeycap + "|" + rgiEmojiBaseClass + ")|[\\u{1F3FB}-\\u{1F3FF}])*)$";
-  try {
-    new NativeRegExp(rgiEmojiPattern, "v");
-  } catch (error) {
-    if (String(error?.message ?? error).includes("RGI_Emoji")) {
-      const CompatRegExp = function CompatRegExp2(pattern, flags) {
-        const normalizedPattern = pattern instanceof NativeRegExp && flags === void 0 ? pattern.source : String(pattern);
-        const normalizedFlags = flags === void 0 ? pattern instanceof NativeRegExp ? pattern.flags : "" : String(flags);
-        try {
-          return new NativeRegExp(pattern, flags);
-        } catch (innerError) {
-          if (normalizedPattern === rgiEmojiPattern && normalizedFlags === "v") {
-            return new NativeRegExp(rgiEmojiFallbackSource, "u");
-          }
-          throw innerError;
-        }
-      };
-      Object.setPrototypeOf(CompatRegExp, NativeRegExp);
-      CompatRegExp.prototype = NativeRegExp.prototype;
-      Object.defineProperty(CompatRegExp.prototype, "constructor", {
-        value: CompatRegExp,
-        writable: true,
-        configurable: true
-      });
-      defineGlobal(
-        "RegExp",
-        Object.assign(CompatRegExp, { __secureExecRgiEmojiCompat: true })
-      );
-    }
-  }
-}
-
 defineGlobal("TextEncoder", TextEncoder2);
 defineGlobal("TextDecoder", TextDecoder);
 defineGlobal("Event", Event);
@@ -68,11 +34,9 @@ if (
     return globalThis.WebAssembly.instantiate(bytes, imports);
   };
 }
-defineGlobal("ReadableStream", typeof WebReadableStream === "function" ? WebReadableStream : FallbackReadableStream);
-defineGlobal("WritableStream", typeof WebWritableStream === "function" ? WebWritableStream : FallbackWritableStream);
-if (typeof WebTransformStream === "function") {
-  defineGlobal("TransformStream", WebTransformStream);
-}
+defineGlobal("ReadableStream", WebReadableStream);
+defineGlobal("WritableStream", WebWritableStream);
+defineGlobal("TransformStream", WebTransformStream);
 if (typeof WebTextEncoderStream === "function") {
   defineGlobal("TextEncoderStream", WebTextEncoderStream);
 }
@@ -80,35 +44,6 @@ if (typeof WebTextDecoderStream === "function") {
   defineGlobal("TextDecoderStream", WebTextDecoderStream);
 }
 const undiciWebidl = undiciWebidlModule?.webidl ?? undiciWebidlModule;
-if (undiciWebidl?.is) {
-  undiciWebidl.is.ReadableStream = (value) =>
-    value != null &&
-    (value instanceof globalThis.ReadableStream ||
-      typeof value.getReader === "function");
-  undiciWebidl.is.AbortSignal = (value) =>
-    value != null &&
-    (value instanceof globalThis.AbortSignal ||
-      (typeof value.aborted === "boolean" &&
-        typeof value.addEventListener === "function"));
-}
-if (undiciWebidl?.converters?.AbortSignal) {
-  undiciWebidl.converters.AbortSignal = (value, ...args) => {
-    if (
-      value != null &&
-      (value instanceof globalThis.AbortSignal ||
-        (typeof value.aborted === "boolean" &&
-          typeof value.addEventListener === "function"))
-    ) {
-      return value;
-    }
-    return undiciWebidl.interfaceConverter(
-      undiciWebidl.is.AbortSignal,
-      "AbortSignal"
-    )(value, ...args);
-  };
-}
 
-export { defineGlobal, TextEncoder2, TextDecoder, Event, CustomEvent, EventTarget, AbortSignal, AbortController, FallbackWritableStream, FallbackReadableStream, undiciWebidl };
-export { withCode, createEncodingNotSupportedError, createEncodingInvalidDataError, createInvalidDecodeInputError, trimAsciiWhitespace, normalizeEncodingLabel, toUint8Array, encodeUtf8ScalarValue, encodeUtf8, appendCodePoint, isContinuationByte, decodeUtf8, decodeUtf16, PatchedTextEncoder, PatchedTextDecoder } from "./text-encoding.js";
-export { normalizeAddEventListenerOptions, normalizeRemoveEventListenerOptions, isAbortSignalLike, PatchedEvent, PatchedCustomEvent, PatchedEventTarget } from "./dom-events.js";
-export { ensureNamedConstructor, createAbortSignalReason, createAbortedSignal, normalizeAbortSignalTimeout } from "./abort.js";
+export { defineGlobal, TextEncoder2, TextDecoder, Event, CustomEvent, EventTarget, AbortSignal, AbortController, undiciWebidl };
+export { withCode, createEncodingNotSupportedError, createEncodingInvalidDataError, createInvalidDecodeInputError, trimAsciiWhitespace, normalizeEncodingLabel, toUint8Array, PatchedTextEncoder, PatchedTextDecoder } from "./text-encoding.js";
diff --git a/packages/build-tools/bridge-src/polyfills/text-encoding.ts b/packages/build-tools/bridge-src/polyfills/text-encoding.ts
index cbd5dfb055..84779ebb6e 100644
--- a/packages/build-tools/bridge-src/polyfills/text-encoding.ts
+++ b/packages/build-tools/bridge-src/polyfills/text-encoding.ts
@@ -1,409 +1,161 @@
+import {
+	TextDecoder as UpstreamTextDecoder,
+	TextEncoder as UpstreamTextEncoder,
+	TextEncoderStream as UpstreamTextEncoderStream,
+} from "@exodus/bytes/encoding-lite.js";
+
 function withCode(error, code) {
-  error.code = code;
-  return error;
+	error.code = code;
+	return error;
 }
+
 function createEncodingNotSupportedError(label) {
-  return withCode(
-    new RangeError(`The "${label}" encoding is not supported`),
-    "ERR_ENCODING_NOT_SUPPORTED"
-  );
+	return withCode(
+		new RangeError(`The "${label}" encoding is not supported`),
+		"ERR_ENCODING_NOT_SUPPORTED",
+	);
 }
+
 function createEncodingInvalidDataError(encoding) {
-  return withCode(
-    new TypeError(`The encoded data was not valid for encoding ${encoding}`),
-    "ERR_ENCODING_INVALID_ENCODED_DATA"
-  );
+	return withCode(
+		new TypeError(`The encoded data was not valid for encoding ${encoding}`),
+		"ERR_ENCODING_INVALID_ENCODED_DATA",
+	);
 }
+
 function createInvalidDecodeInputError() {
-  return withCode(
-    new TypeError(
-      'The "input" argument must be an instance of ArrayBuffer, SharedArrayBuffer, or ArrayBufferView.'
-    ),
-    "ERR_INVALID_ARG_TYPE"
-  );
+	return withCode(
+		new TypeError(
+			'The "input" argument must be an instance of ArrayBuffer, SharedArrayBuffer, or ArrayBufferView.',
+		),
+		"ERR_INVALID_ARG_TYPE",
+	);
 }
+
 function trimAsciiWhitespace(value) {
-  return value.replace(/^[\t\n\f\r ]+|[\t\n\f\r ]+$/g, "");
+	return value.replace(/^[\t\n\f\r ]+|[\t\n\f\r ]+$/g, "");
 }
+
 function normalizeEncodingLabel(label) {
-  const normalized = trimAsciiWhitespace(
-    label === void 0 ? "utf-8" : String(label)
-  ).toLowerCase();
-  switch (normalized) {
-    case "utf-8":
-    case "utf8":
-    case "unicode-1-1-utf-8":
-    case "unicode11utf8":
-    case "unicode20utf8":
-    case "x-unicode20utf8":
-      return "utf-8";
-    case "utf-16":
-    case "utf-16le":
-    case "ucs-2":
-    case "ucs2":
-    case "csunicode":
-    case "iso-10646-ucs-2":
-    case "unicode":
-    case "unicodefeff":
-      return "utf-16le";
-    case "utf-16be":
-    case "unicodefffe":
-      return "utf-16be";
-    default:
-      throw createEncodingNotSupportedError(normalized);
-  }
+	const normalized = trimAsciiWhitespace(
+		label === void 0 ? "utf-8" : `${label}`,
+	).toLowerCase();
+	switch (normalized) {
+		case "utf-8":
+		case "utf8":
+		case "unicode-1-1-utf-8":
+		case "unicode11utf8":
+		case "unicode20utf8":
+		case "x-unicode20utf8":
+			return "utf-8";
+		case "utf-16":
+		case "utf-16le":
+		case "ucs-2":
+		case "ucs2":
+		case "csunicode":
+		case "iso-10646-ucs-2":
+		case "unicode":
+		case "unicodefeff":
+			return "utf-16le";
+		case "utf-16be":
+		case "unicodefffe":
+			return "utf-16be";
+		default:
+			throw createEncodingNotSupportedError(normalized);
+	}
 }
+
 function toUint8Array(input) {
-  if (input === void 0) {
-    return new Uint8Array(0);
-  }
-  if (ArrayBuffer.isView(input)) {
-    return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
-  }
-  if (input instanceof ArrayBuffer) {
-    return new Uint8Array(input);
-  }
-  if (typeof SharedArrayBuffer !== "undefined" && input instanceof SharedArrayBuffer) {
-    return new Uint8Array(input);
-  }
-  throw createInvalidDecodeInputError();
-}
-function encodeUtf8ScalarValue(codePoint, bytes) {
-  if (codePoint <= 127) {
-    bytes.push(codePoint);
-    return;
-  }
-  if (codePoint <= 2047) {
-    bytes.push(192 | codePoint >> 6, 128 | codePoint & 63);
-    return;
-  }
-  if (codePoint <= 65535) {
-    bytes.push(
-      224 | codePoint >> 12,
-      128 | codePoint >> 6 & 63,
-      128 | codePoint & 63
-    );
-    return;
-  }
-  bytes.push(
-    240 | codePoint >> 18,
-    128 | codePoint >> 12 & 63,
-    128 | codePoint >> 6 & 63,
-    128 | codePoint & 63
-  );
-}
-function encodeUtf8(input = "") {
-  const value = String(input);
-  const bytes = [];
-  for (let index = 0; index < value.length; index += 1) {
-    const codeUnit = value.charCodeAt(index);
-    if (codeUnit >= 55296 && codeUnit <= 56319) {
-      const nextIndex = index + 1;
-      if (nextIndex < value.length) {
-        const nextCodeUnit = value.charCodeAt(nextIndex);
-        if (nextCodeUnit >= 56320 && nextCodeUnit <= 57343) {
-          const codePoint = 65536 + (codeUnit - 55296 << 10) + (nextCodeUnit - 56320);
-          encodeUtf8ScalarValue(codePoint, bytes);
-          index = nextIndex;
-          continue;
-        }
-      }
-      encodeUtf8ScalarValue(65533, bytes);
-      continue;
-    }
-    if (codeUnit >= 56320 && codeUnit <= 57343) {
-      encodeUtf8ScalarValue(65533, bytes);
-      continue;
-    }
-    encodeUtf8ScalarValue(codeUnit, bytes);
-  }
-  return new Uint8Array(bytes);
-}
-function appendCodePoint(output, codePoint) {
-  if (codePoint <= 65535) {
-    output.push(String.fromCharCode(codePoint));
-    return;
-  }
-  const adjusted = codePoint - 65536;
-  output.push(
-    String.fromCharCode(55296 + (adjusted >> 10)),
-    String.fromCharCode(56320 + (adjusted & 1023))
-  );
+	if (input === void 0) {
+		return new Uint8Array(0);
+	}
+	if (ArrayBuffer.isView(input)) {
+		return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+	}
+	if (input instanceof ArrayBuffer) {
+		return new Uint8Array(input);
+	}
+	if (
+		typeof SharedArrayBuffer !== "undefined" &&
+		input instanceof SharedArrayBuffer
+	) {
+		return new Uint8Array(input);
+	}
+	throw createInvalidDecodeInputError();
 }
-function isContinuationByte(value) {
-  return value >= 128 && value <= 191;
-}
-function decodeUtf8(bytes, fatal, stream, encoding) {
-  const output = [];
-  for (let index = 0; index < bytes.length; ) {
-    const first = bytes[index];
-    if (first <= 127) {
-      output.push(String.fromCharCode(first));
-      index += 1;
-      continue;
-    }
-    let needed = 0;
-    let codePoint = 0;
-    if (first >= 194 && first <= 223) {
-      needed = 1;
-      codePoint = first & 31;
-    } else if (first >= 224 && first <= 239) {
-      needed = 2;
-      codePoint = first & 15;
-    } else if (first >= 240 && first <= 244) {
-      needed = 3;
-      codePoint = first & 7;
-    } else {
-      if (fatal) {
-        throw createEncodingInvalidDataError(encoding);
-      }
-      output.push("\uFFFD");
-      index += 1;
-      continue;
-    }
-    if (index + needed >= bytes.length) {
-      if (stream) {
-        return {
-          text: output.join(""),
-          pending: Array.from(bytes.slice(index))
-        };
-      }
-      if (fatal) {
-        throw createEncodingInvalidDataError(encoding);
-      }
-      output.push("\uFFFD");
-      break;
-    }
-    const second = bytes[index + 1];
-    if (!isContinuationByte(second)) {
-      if (fatal) {
-        throw createEncodingInvalidDataError(encoding);
-      }
-      output.push("\uFFFD");
-      index += 1;
-      continue;
-    }
-    if (first === 224 && second < 160 || first === 237 && second > 159 || first === 240 && second < 144 || first === 244 && second > 143) {
-      if (fatal) {
-        throw createEncodingInvalidDataError(encoding);
-      }
-      output.push("\uFFFD");
-      index += 1;
-      continue;
-    }
-    codePoint = codePoint << 6 | second & 63;
-    if (needed >= 2) {
-      const third = bytes[index + 2];
-      if (!isContinuationByte(third)) {
-        if (fatal) {
-          throw createEncodingInvalidDataError(encoding);
-        }
-        output.push("\uFFFD");
-        index += 1;
-        continue;
-      }
-      codePoint = codePoint << 6 | third & 63;
-    }
-    if (needed === 3) {
-      const fourth = bytes[index + 3];
-      if (!isContinuationByte(fourth)) {
-        if (fatal) {
-          throw createEncodingInvalidDataError(encoding);
-        }
-        output.push("\uFFFD");
-        index += 1;
-        continue;
-      }
-      codePoint = codePoint << 6 | fourth & 63;
-    }
-    if (codePoint >= 55296 && codePoint <= 57343) {
-      if (fatal) {
-        throw createEncodingInvalidDataError(encoding);
-      }
-      output.push("\uFFFD");
-      index += needed + 1;
-      continue;
-    }
-    appendCodePoint(output, codePoint);
-    index += needed + 1;
-  }
-  return { text: output.join(""), pending: [] };
+
+class PatchedTextEncoder extends UpstreamTextEncoder {}
+
+class PatchedTextDecoder extends UpstreamTextDecoder {
+	constructor(label, options) {
+		super(
+			normalizeEncodingLabel(label),
+			options == null ? {} : Object(options),
+		);
+	}
+
+	decode(input, options) {
+		const source = toUint8Array(input);
+		const decodeOptions = options == null ? {} : Object(options);
+		const stream = Boolean(decodeOptions.stream);
+		try {
+			return super.decode(source, { stream });
+		} catch (error) {
+			if (this.fatal && error instanceof TypeError) {
+				throw createEncodingInvalidDataError(this.encoding);
+			}
+			throw error;
+		}
+	}
 }
-function decodeUtf16(bytes, encoding, fatal, stream, bomSeen) {
-  const output = [];
-  let endian = encoding === "utf-16be" ? "be" : "le";
-  if (!bomSeen && encoding === "utf-16le" && bytes.length >= 2) {
-    if (bytes[0] === 254 && bytes[1] === 255) {
-      endian = "be";
-    }
-  }
-  for (let index = 0; index < bytes.length; ) {
-    if (index + 1 >= bytes.length) {
-      if (stream) {
-        return {
-          text: output.join(""),
-          pending: Array.from(bytes.slice(index))
-        };
-      }
-      if (fatal) {
-        throw createEncodingInvalidDataError(encoding);
-      }
-      output.push("\uFFFD");
-      break;
-    }
-    const first = bytes[index];
-    const second = bytes[index + 1];
-    const codeUnit = endian === "le" ? first | second << 8 : first << 8 | second;
-    index += 2;
-    if (codeUnit >= 55296 && codeUnit <= 56319) {
-      if (index + 1 >= bytes.length) {
-        if (stream) {
-          return {
-            text: output.join(""),
-            pending: Array.from(bytes.slice(index - 2))
-          };
-        }
-        if (fatal) {
-          throw createEncodingInvalidDataError(encoding);
-        }
-        output.push("\uFFFD");
-        continue;
-      }
-      const nextFirst = bytes[index];
-      const nextSecond = bytes[index + 1];
-      const nextCodeUnit = endian === "le" ? nextFirst | nextSecond << 8 : nextFirst << 8 | nextSecond;
-      if (nextCodeUnit >= 56320 && nextCodeUnit <= 57343) {
-        const codePoint = 65536 + (codeUnit - 55296 << 10) + (nextCodeUnit - 56320);
-        appendCodePoint(output, codePoint);
-        index += 2;
-        continue;
-      }
-      if (fatal) {
-        throw createEncodingInvalidDataError(encoding);
-      }
-      output.push("\uFFFD");
-      continue;
-    }
-    if (codeUnit >= 56320 && codeUnit <= 57343) {
-      if (fatal) {
-        throw createEncodingInvalidDataError(encoding);
-      }
-      output.push("\uFFFD");
-      continue;
-    }
-    output.push(String.fromCharCode(codeUnit));
-  }
-  return { text: output.join(""), pending: [] };
+
+class PatchedTextDecoderStream {
+	constructor(label, options) {
+		const decoder = new PatchedTextDecoder(label, options);
+		const transform = new TransformStream({
+			transform(chunk, controller) {
+				const output = decoder.decode(chunk, { stream: true });
+				if (output) controller.enqueue(output);
+			},
+			flush(controller) {
+				const output = decoder.decode();
+				if (output) controller.enqueue(output);
+			},
+		});
+		this.readable = transform.readable;
+		this.writable = transform.writable;
+		this.encoding = decoder.encoding;
+		this.fatal = decoder.fatal;
+		this.ignoreBOM = decoder.ignoreBOM;
+	}
 }
-var PatchedTextEncoder = class {
-  encode(input = "") {
-    return encodeUtf8(input);
-  }
-  encodeInto(input, destination) {
-    const value = String(input);
-    let read = 0;
-    let written = 0;
-    for (let index = 0; index < value.length; index += 1) {
-      const codeUnit = value.charCodeAt(index);
-      let chunk = "";
-      if (codeUnit >= 55296 && codeUnit <= 56319 && index + 1 < value.length) {
-        const nextCodeUnit = value.charCodeAt(index + 1);
-        if (nextCodeUnit >= 56320 && nextCodeUnit <= 57343) {
-          chunk = value.slice(index, index + 2);
-        }
-      }
-      if (chunk === "") {
-        chunk = value[index] ?? "";
-      }
-      const encoded = encodeUtf8(chunk);
-      if (written + encoded.length > destination.length) {
-        break;
-      }
-      destination.set(encoded, written);
-      written += encoded.length;
-      read += chunk.length;
-      if (chunk.length === 2) {
-        index += 1;
-      }
-    }
-    return { read, written };
-  }
-  get encoding() {
-    return "utf-8";
-  }
-  get [Symbol.toStringTag]() {
-    return "TextEncoder";
-  }
-};
-var PatchedTextDecoder = class {
-  normalizedEncoding;
-  fatalFlag;
-  ignoreBOMFlag;
-  pendingBytes = [];
-  bomSeen = false;
-  constructor(label, options) {
-    const normalizedOptions = options == null ? {} : Object(options);
-    this.normalizedEncoding = normalizeEncodingLabel(label);
-    this.fatalFlag = Boolean(
-      normalizedOptions.fatal
-    );
-    this.ignoreBOMFlag = Boolean(
-      normalizedOptions.ignoreBOM
-    );
-  }
-  get encoding() {
-    return this.normalizedEncoding;
-  }
-  get fatal() {
-    return this.fatalFlag;
-  }
-  get ignoreBOM() {
-    return this.ignoreBOMFlag;
-  }
-  get [Symbol.toStringTag]() {
-    return "TextDecoder";
-  }
-  decode(input, options) {
-    const normalizedOptions = options == null ? {} : Object(options);
-    const stream = Boolean(
-      normalizedOptions.stream
-    );
-    const incoming = toUint8Array(input);
-    const merged = new Uint8Array(this.pendingBytes.length + incoming.length);
-    merged.set(this.pendingBytes, 0);
-    merged.set(incoming, this.pendingBytes.length);
-    const decoded = this.normalizedEncoding === "utf-8" ? decodeUtf8(
-      merged,
-      this.fatalFlag,
-      stream,
-      this.normalizedEncoding
-    ) : decodeUtf16(
-      merged,
-      this.normalizedEncoding,
-      this.fatalFlag,
-      stream,
-      this.bomSeen
-    );
-    this.pendingBytes = decoded.pending;
-    let text = decoded.text;
-    if (!this.bomSeen && text.length > 0) {
-      if (!this.ignoreBOMFlag && text.charCodeAt(0) === 65279) {
-        text = text.slice(1);
-      }
-      this.bomSeen = true;
-    }
-    if (!stream && this.pendingBytes.length > 0) {
-      const pending = this.pendingBytes;
-      this.pendingBytes = [];
-      if (this.fatalFlag) {
-        throw createEncodingInvalidDataError(this.normalizedEncoding);
-      }
-      return text + "\uFFFD".repeat(Math.ceil(pending.length / 2));
-    }
-    return text;
-  }
-};
+
+Object.defineProperty(PatchedTextEncoder, "name", {
+	configurable: true,
+	value: "TextEncoder",
+});
+Object.defineProperty(PatchedTextDecoder, "name", {
+	configurable: true,
+	value: "TextDecoder",
+});
+
 var TextEncoder2 = PatchedTextEncoder;
 var TextDecoder = PatchedTextDecoder;
+var TextEncoderStream = UpstreamTextEncoderStream;
+var TextDecoderStream = PatchedTextDecoderStream;
 
-export { withCode, createEncodingNotSupportedError, createEncodingInvalidDataError, createInvalidDecodeInputError, trimAsciiWhitespace, normalizeEncodingLabel, toUint8Array, encodeUtf8ScalarValue, encodeUtf8, appendCodePoint, isContinuationByte, decodeUtf8, decodeUtf16, PatchedTextEncoder, PatchedTextDecoder, TextEncoder2, TextDecoder };
+export {
+	createEncodingInvalidDataError,
+	createEncodingNotSupportedError,
+	createInvalidDecodeInputError,
+	normalizeEncodingLabel,
+	PatchedTextDecoder,
+	PatchedTextEncoder,
+	TextDecoder,
+	TextDecoderStream,
+	TextEncoder2,
+	TextEncoderStream,
+	toUint8Array,
+	trimAsciiWhitespace,
+	withCode,
+};
diff --git a/packages/build-tools/bridge-src/polyfills/web-streams-fallback.ts b/packages/build-tools/bridge-src/polyfills/web-streams-fallback.ts
deleted file mode 100644
index b4e9dc6f58..0000000000
--- a/packages/build-tools/bridge-src/polyfills/web-streams-fallback.ts
+++ /dev/null
@@ -1,87 +0,0 @@
-var FallbackWritableStream = class {
-  constructor(sink = {}) {
-    this._sink = sink;
-  }
-  getWriter() {
-    const sink = this._sink;
-    return {
-      write(chunk) {
-        return Promise.resolve(typeof sink.write === "function" ? sink.write(chunk) : void 0);
-      },
-      close() {
-        return Promise.resolve(typeof sink.close === "function" ? sink.close() : void 0);
-      },
-      releaseLock() {
-      }
-    };
-  }
-};
-var FallbackReadableStream = class {
-  constructor(source = {}) {
-    this._queue = [];
-    this._pending = [];
-    this._closed = false;
-    this._error = null;
-    const flushPending = () => {
-      while (this._pending.length > 0) {
-        const waiter = this._pending.shift();
-        if (this._error) {
-          waiter.reject(this._error);
-          continue;
-        }
-        if (this._queue.length > 0) {
-          waiter.resolve({ value: this._queue.shift(), done: false });
-          continue;
-        }
-        if (this._closed) {
-          waiter.resolve({ value: void 0, done: true });
-          continue;
-        }
-        this._pending.unshift(waiter);
-        break;
-      }
-    };
-    const controller = {
-      enqueue: (value) => {
-        if (this._closed || this._error) return;
-        this._queue.push(value);
-        flushPending();
-      },
-      close: () => {
-        if (this._closed || this._error) return;
-        this._closed = true;
-        flushPending();
-      },
-      error: (error) => {
-        if (this._closed || this._error) return;
-        this._error = error instanceof Error ? error : new Error(String(error));
-        flushPending();
-      }
-    };
-    if (typeof source.start === "function") {
-      Promise.resolve().then(() => source.start(controller)).catch((error) => controller.error(error));
-    }
-  }
-  getReader() {
-    return {
-      read: () => {
-        if (this._error) {
-          return Promise.reject(this._error);
-        }
-        if (this._queue.length > 0) {
-          return Promise.resolve({ value: this._queue.shift(), done: false });
-        }
-        if (this._closed) {
-          return Promise.resolve({ value: void 0, done: true });
-        }
-        return new Promise((resolve, reject) => {
-          this._pending.push({ resolve, reject });
-        });
-      },
-      releaseLock() {
-      }
-    };
-  }
-};
-
-export { FallbackWritableStream, FallbackReadableStream };
diff --git a/packages/build-tools/bridge-src/polyfills/whatwg-url.ts b/packages/build-tools/bridge-src/polyfills/whatwg-url.ts
new file mode 100644
index 0000000000..9cc257f5bf
--- /dev/null
+++ b/packages/build-tools/bridge-src/polyfills/whatwg-url.ts
@@ -0,0 +1,116 @@
+import {
+	URL as UpstreamURL,
+	URLSearchParams as UpstreamURLSearchParams,
+} from "whatwg-url";
+
+const kBlobUrlStore = /* @__PURE__ */ Symbol.for("secureExec.blobUrlStore");
+const kBlobUrlCounter = /* @__PURE__ */ Symbol.for("secureExec.blobUrlCounter");
+const MAX_BLOB_URLS = 1024;
+
+function createNodeTypeError(message, code) {
+	const error = new TypeError(message);
+	error.code = code;
+	return error;
+}
+
+function createMissingArgsError(message) {
+	return createNodeTypeError(message, "ERR_MISSING_ARGS");
+}
+
+function getBlobUrlStore() {
+	const globalRecord = globalThis;
+	const existing = globalRecord[kBlobUrlStore];
+	if (existing instanceof Map) {
+		return existing;
+	}
+	const store = /* @__PURE__ */ new Map();
+	globalRecord[kBlobUrlStore] = store;
+	return store;
+}
+
+function nextBlobUrlId() {
+	const globalRecord = globalThis;
+	const nextId =
+		typeof globalRecord[kBlobUrlCounter] === "number"
+			? globalRecord[kBlobUrlCounter]
+			: 1;
+	globalRecord[kBlobUrlCounter] = nextId + 1;
+	return nextId;
+}
+
+function resolveObjectURL(url) {
+	return getBlobUrlStore().get(typeof url === "string" ? url : `${url}`);
+}
+
+const URL2 = UpstreamURL;
+const URLSearchParams = UpstreamURLSearchParams;
+
+Object.defineProperties(URL2, {
+	createObjectURL: {
+		value(obj) {
+			const Blob = globalThis.Blob;
+			if (typeof Blob !== "function" || !(obj instanceof Blob)) {
+				throw createNodeTypeError(
+					'The "obj" argument must be an instance of Blob. Received ' +
+						(obj === null ? "null" : typeof obj),
+					"ERR_INVALID_ARG_TYPE",
+				);
+			}
+			const store = getBlobUrlStore();
+			if (store.size >= MAX_BLOB_URLS) {
+				const error = new Error(
+					`Blob URL limit of ${MAX_BLOB_URLS} reached. Revoke unused object URLs or increase MAX_BLOB_URLS in the runtime build.`,
+				);
+				error.code = "ERR_BLOB_URL_STORE_LIMIT";
+				throw error;
+			}
+			const id = `blob:nodedata:${nextBlobUrlId()}`;
+			store.set(id, obj);
+			return id;
+		},
+		writable: true,
+		configurable: true,
+		enumerable: true,
+	},
+	revokeObjectURL: {
+		value(...args) {
+			if (args.length < 1) {
+				throw createMissingArgsError('The "url" argument must be specified');
+			}
+			const [url] = args;
+			getBlobUrlStore().delete(typeof url === "string" ? url : `${url}`);
+		},
+		writable: true,
+		configurable: true,
+		enumerable: true,
+	},
+});
+
+function installWhatwgUrlGlobals(target = globalThis) {
+	Object.defineProperty(target, "URL", {
+		value: URL2,
+		writable: true,
+		configurable: true,
+		enumerable: false,
+	});
+	Object.defineProperty(target, "URLSearchParams", {
+		value: URLSearchParams,
+		writable: true,
+		configurable: true,
+		enumerable: false,
+	});
+}
+
+export {
+	createMissingArgsError,
+	createNodeTypeError,
+	getBlobUrlStore,
+	installWhatwgUrlGlobals,
+	kBlobUrlCounter,
+	kBlobUrlStore,
+	MAX_BLOB_URLS,
+	nextBlobUrlId,
+	resolveObjectURL,
+	URL2,
+	URLSearchParams,
+};
diff --git a/packages/build-tools/bridge-src/prelude.ts b/packages/build-tools/bridge-src/prelude.ts
index fc83983397..1a33e627fd 100644
--- a/packages/build-tools/bridge-src/prelude.ts
+++ b/packages/build-tools/bridge-src/prelude.ts
@@ -19,6 +19,7 @@ import undiciApiModule from "undici/lib/api/index.js";
 import undiciAgentModule from "undici/lib/dispatcher/agent.js";
 import undiciClientModule from "undici/lib/dispatcher/client.js";
 import undiciFetchModule from "undici/lib/web/fetch/index.js";
+import undiciFormDataModule from "undici/lib/web/fetch/formdata.js";
 import undiciGlobalModule from "undici/lib/global.js";
 import undiciHeadersModule from "undici/lib/web/fetch/headers.js";
 import undiciRequestModule from "undici/lib/web/fetch/request.js";
@@ -26,9 +27,6 @@ import undiciResponseModule from "undici/lib/web/fetch/response.js";
 import undiciWebidlModule from "undici/lib/web/webidl/index.js";
 import loadWebSocketModule from "./undici-shims/websocket-lazy.js";
 
-const NativeAbortControllerGlobal = globalThis.AbortController;
-const NativeAbortSignalGlobal = globalThis.AbortSignal;
-
 const EarlyBufferGlobal =
   bufferStdlibModuleNs.Buffer ??
   bufferStdlibModuleNs.default?.Buffer ??
@@ -219,8 +217,6 @@ if (EarlyUtilTypes && typeof EarlyUtilTypes.isProxy !== "function") {
 export {
   EarlyBufferGlobal,
   EarlyUtilTypes,
-  NativeAbortControllerGlobal,
-  NativeAbortSignalGlobal,
   StructuredCloneTypedArrayCtors,
   WebReadableStream,
   WebTextDecoderStream,
@@ -246,6 +242,7 @@ export {
   undiciApiModule,
   undiciClientModule,
   undiciFetchModule,
+  undiciFormDataModule,
   undiciGlobalModule,
   undiciHeadersModule,
   undiciRequestModule,
diff --git a/packages/build-tools/package.json b/packages/build-tools/package.json
index 08b1590e5f..d2729ebc8b 100644
--- a/packages/build-tools/package.json
+++ b/packages/build-tools/package.json
@@ -11,24 +11,28 @@
 	"scripts": {
 		"build:base-filesystem": "node ./scripts/build-base-filesystem.mjs",
 		"build:browser-buffer-polyfill": "node ./scripts/build-browser-buffer-polyfill.mjs",
+		"build:browser-node-polyfills": "node ./scripts/build-browser-node-polyfills.mjs",
 		"build:browser-path-polyfill": "node ./scripts/build-browser-path-polyfill.mjs",
 		"build:browser-util-polyfill": "node ./scripts/build-browser-util-polyfill.mjs",
 		"build:protocol": "node ./scripts/compile-sidecar-protocol.mjs",
 		"build:v8-bridge": "node ./scripts/build-v8-bridge.mjs",
 		"snapshot:alpine-defaults": "node ./scripts/snapshot-alpine-defaults.mjs",
 		"check:generated": "node ../../scripts/check-generated-artifacts.mjs",
-		"check-types": "node --check ./scripts/build-base-filesystem.mjs && node --check ./scripts/build-browser-buffer-polyfill.mjs && node --check ./scripts/build-browser-path-polyfill.mjs && node --check ./scripts/build-browser-util-polyfill.mjs && node --check ./scripts/build-v8-bridge.mjs && node --check ./scripts/compile-sidecar-protocol.mjs",
+		"check-types": "node --check ./scripts/build-base-filesystem.mjs && node --check ./scripts/build-browser-buffer-polyfill.mjs && node --check ./scripts/build-browser-node-polyfills.mjs && node --check ./scripts/build-browser-path-polyfill.mjs && node --check ./scripts/build-browser-util-polyfill.mjs && node --check ./scripts/build-v8-bridge.mjs && node --check ./scripts/compile-sidecar-protocol.mjs",
 		"build": "pnpm run check-types",
-		"test": "pnpm run check-types && node --test ./scripts/tty-config.test.mjs",
+		"test": "pnpm run check-types && node --test ./scripts/browser-node-polyfills.test.mjs ./scripts/tty-config.test.mjs",
 		"build:package-format": "node ./scripts/compile-package-format.mjs"
 	},
 	"dependencies": {
 		"@bare-ts/tools": "0.15.0",
+		"@exodus/bytes": "1.15.1",
 		"esbuild": "^0.27.4",
+		"fetch-blob": "4.0.0",
 		"node-stdlib-browser": "^1.3.1",
 		"readable-stream": "4.7.0",
-		"undici": "^7.24.6",
-		"web-streams-polyfill": "^3.3.3",
+		"undici": "7.24.6",
+		"web-streams-polyfill": "4.3.0",
+		"whatwg-url": "15.1.0",
 		"ws": "8.21.0"
 	}
 }
diff --git a/packages/build-tools/scripts/browser-node-polyfills.test.mjs b/packages/build-tools/scripts/browser-node-polyfills.test.mjs
new file mode 100644
index 0000000000..040e9d8eb2
--- /dev/null
+++ b/packages/build-tools/scripts/browser-node-polyfills.test.mjs
@@ -0,0 +1,88 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { test } from "node:test";
+import { fileURLToPath } from "node:url";
+
+const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+const generatedPath = path.resolve(
+	scriptDir,
+	"..",
+	"..",
+	"runtime-browser",
+	"src",
+	"generated",
+	"node-polyfills.ts",
+);
+
+async function loadGeneratedPolyfill(name) {
+	const source = await readFile(generatedPath, "utf8");
+	const prefix = `export const BROWSER_${name}_POLYFILL_CODE = `;
+	const line = source.split("\n").find((candidate) => candidate.startsWith(prefix));
+	assert.ok(line, `missing generated ${name} polyfill`);
+	const code = JSON.parse(line.slice(prefix.length, -1));
+	const module = { exports: {} };
+	new Function("module", "exports", code)(module, module.exports);
+	return module.exports;
+}
+
+test("generated browser Node polyfills use upstream behavior", async () => {
+	const [
+		assertModule,
+		events,
+		querystring,
+		stream,
+		stringDecoder,
+		url,
+	] = await Promise.all([
+		loadGeneratedPolyfill("ASSERT"),
+		loadGeneratedPolyfill("EVENTS"),
+		loadGeneratedPolyfill("QUERYSTRING"),
+		loadGeneratedPolyfill("STREAM"),
+		loadGeneratedPolyfill("STRING_DECODER"),
+		loadGeneratedPolyfill("URL"),
+	]);
+
+	assertModule.deepStrictEqual(
+		{ nested: new Set(["alpha"]) },
+		{ nested: new Set(["alpha"]) },
+	);
+
+	const emitter = new events();
+	const seen = [];
+	emitter.once("value", (value) => seen.push(value));
+	emitter.emit("value", "first");
+	emitter.emit("value", "second");
+	assert.deepEqual(seen, ["first"]);
+
+	assert.deepEqual({ ...querystring.parse("a=hello+world&a=again") }, {
+		a: ["hello world", "again"],
+	});
+
+	const passThrough = new stream.PassThrough();
+	const chunks = [];
+	passThrough.on("data", (chunk) => chunks.push(chunk.toString()));
+	passThrough.end("streamed");
+	assert.deepEqual(chunks, ["streamed"]);
+	assert.equal(typeof stream.promises.pipeline, "function");
+	assert.ok(stream.Readable.toWeb(new stream.PassThrough()) instanceof ReadableStream);
+
+	const decoder = new stringDecoder.StringDecoder("utf8");
+	const encoded = Buffer.from("Grüße");
+	assert.equal(
+		decoder.write(encoded.subarray(0, 4)) + decoder.end(encoded.subarray(4)),
+		"Grüße",
+	);
+
+	for (const input of [
+		"data:image/png;base64,SGVsbG8=",
+		"mailto:user@example.com",
+	]) {
+		assert.equal(new url.URL(input).href, input);
+	}
+	assert.equal(url.resolve("https://example.com/a/", "../b"), "https://example.com/b");
+	assert.equal(url.parse("https://example.com/a?b=c").pathname, "/a");
+	assert.equal(url.fileURLToPath("file:///tmp/a%20b"), "/tmp/a b");
+	assert.equal(url.pathToFileURL("/tmp/a b").href, "file:///tmp/a%20b");
+	assert.equal(url.domainToASCII("mañana.com"), "xn--maana-pta.com");
+});
diff --git a/packages/build-tools/scripts/build-browser-node-polyfills.mjs b/packages/build-tools/scripts/build-browser-node-polyfills.mjs
new file mode 100644
index 0000000000..084a75323a
--- /dev/null
+++ b/packages/build-tools/scripts/build-browser-node-polyfills.mjs
@@ -0,0 +1,128 @@
+import { build } from "esbuild";
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import stdLibBrowser from "node-stdlib-browser";
+
+const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+const packageRoot = path.resolve(scriptDir, "..");
+const workspaceRoot = path.resolve(packageRoot, "..", "..");
+const outputPath = path.join(
+	workspaceRoot,
+	"packages",
+	"runtime-browser",
+	"src",
+	"generated",
+	"node-polyfills.ts",
+);
+
+const moduleEntries = {
+	assert: "assert",
+	events: "events",
+	querystring: "querystring",
+	stream: "readable-stream",
+	stringDecoder: "string_decoder",
+	url: "url",
+};
+
+const aliases = {};
+for (const [name, modulePath] of Object.entries(stdLibBrowser)) {
+	if (typeof modulePath !== "string") {
+		continue;
+	}
+	aliases[name] = modulePath;
+	aliases[`node:${name}`] = modulePath;
+}
+aliases["readable-stream"] = path.dirname(
+	fileURLToPath(import.meta.resolve("readable-stream/package.json")),
+);
+
+const generated = {};
+for (const [exportName, request] of Object.entries(moduleEntries)) {
+	const augmentation =
+		exportName === "url"
+			? [
+					'const path = require("path");',
+					'const punycode = require("punycode");',
+					"resolved.URL = globalThis.URL;",
+					"resolved.URLSearchParams = globalThis.URLSearchParams;",
+					"resolved.domainToASCII = punycode.toASCII;",
+					"resolved.domainToUnicode = punycode.toUnicode;",
+					"resolved.fileURLToPath = (input) => {",
+					"  const url = input instanceof globalThis.URL ? input : new globalThis.URL(input);",
+					'  if (url.protocol !== "file:") throw new TypeError("The URL must be of scheme file");',
+					'  if (url.host && url.host !== "localhost") throw new TypeError("File URL host must be empty or localhost");',
+					'  if (/%2f/i.test(url.pathname)) throw new TypeError("File URL path must not include encoded / characters");',
+					"  return decodeURIComponent(url.pathname);",
+					"};",
+					"resolved.pathToFileURL = (input) => {",
+					'  const absolute = path.posix.resolve(String(input || "/"));',
+					'  const encoded = encodeURI(absolute).replaceAll("#", "%23").replaceAll("?", "%3F");',
+					'  return new globalThis.URL(`file://${encoded.startsWith("/") ? encoded : `/${encoded}`}`);',
+					"};",
+				].join("\n")
+			: exportName === "stream"
+				? [
+						"resolved.Readable.toWeb = (stream) => new ReadableStream({",
+						'  start(controller) { stream.on("data", (chunk) => controller.enqueue(chunk)); stream.once("end", () => controller.close()); stream.once("error", (error) => controller.error(error)); stream.resume?.(); },',
+						"  cancel(reason) { stream.destroy?.(reason instanceof Error ? reason : undefined); },",
+						"});",
+						"resolved.Writable.toWeb = (stream) => new WritableStream({",
+						'  start(controller) { stream.on("error", (error) => controller.error(error)); },',
+						"  write(chunk) { return new Promise((resolve, reject) => stream.write(chunk, undefined, (error) => error ? reject(error) : resolve())); },",
+						"  close() { return new Promise((resolve, reject) => stream.end((error) => error ? reject(error) : resolve())); },",
+						"  abort(reason) { stream.destroy?.(reason instanceof Error ? reason : new Error(String(reason))); },",
+						"});",
+						"resolved.Duplex.toWeb = (stream) => ({",
+						"  readable: resolved.Readable.toWeb(stream),",
+						"  writable: resolved.Writable.toWeb(stream),",
+						"});",
+					].join("\n")
+				: "";
+	const result = await build({
+		stdin: {
+			contents: [
+				`const imported = require(${JSON.stringify(request)});`,
+				"const resolved = imported.default ?? imported;",
+				augmentation,
+				"module.exports = resolved;",
+			].join("\n"),
+			resolveDir: workspaceRoot,
+			loader: "js",
+		},
+		bundle: true,
+		write: false,
+		format: "cjs",
+		platform: "browser",
+		alias: aliases,
+		banner: {
+			js: [
+				"var process = globalThis.process || {",
+				"  env: {},",
+				"  cwd: () => '/',",
+				"  nextTick: (fn, ...args) => queueMicrotask(() => fn(...args)),",
+				"};",
+			].join("\n"),
+		},
+		target: "es2020",
+	});
+	let bundle = result.outputFiles[0].text;
+	bundle +=
+		"\nif (module.exports && module.exports.default == null) module.exports.default = module.exports;\n";
+	generated[exportName] = bundle;
+}
+
+await mkdir(path.dirname(outputPath), { recursive: true });
+await writeFile(
+	outputPath,
+	[
+		"// @generated - run node packages/build-tools/scripts/build-browser-node-polyfills.mjs",
+		...Object.entries(generated).map(
+			([name, code]) =>
+				`export const BROWSER_${name.replace(/([A-Z])/g, "_$1").toUpperCase()}_POLYFILL_CODE = ${JSON.stringify(code)};`,
+		),
+		"",
+	].join("\n"),
+);
+
+console.log("Built packages/runtime-browser/src/generated/node-polyfills.ts");
diff --git a/packages/build-tools/scripts/build-v8-bridge.mjs b/packages/build-tools/scripts/build-v8-bridge.mjs
index 5aa1338a4a..79b5ab6b89 100644
--- a/packages/build-tools/scripts/build-v8-bridge.mjs
+++ b/packages/build-tools/scripts/build-v8-bridge.mjs
@@ -80,12 +80,57 @@ const undiciRuntimeFeaturesPath = require.resolve(
 );
 const nodeStdlibUrlPackageEntry = createRequire(stdLibBrowser.url).resolve("url/");
 const wsNodeEntry = require.resolve("ws");
+const exodusBytesRoot = path.dirname(
+	require.resolve("@exodus/bytes/encoding-lite.js"),
+);
+const fetchBlobEntry = require.resolve("fetch-blob");
+const fetchBlobFileEntry = require.resolve("fetch-blob/file.js");
 
 const alias = {};
 const customAlias = {
+	"@exodus/bytes/encoding-lite.js": require.resolve(
+		"@exodus/bytes/encoding-lite.js",
+	),
+	"fetch-blob": fetchBlobEntry,
+	"fetch-blob/file.js": fetchBlobFileEntry,
+	crypto: path.join(undiciShimDir, "crypto.cjs"),
+	"node:crypto": path.join(undiciShimDir, "crypto.cjs"),
+	"agentos-legacy-crypto-polyfill": stdLibBrowser.crypto,
 	url: path.join(undiciShimDir, "url.js"),
 	"node:url": path.join(undiciShimDir, "url.js"),
 	"agentos-legacy-url-polyfill": nodeStdlibUrlPackageEntry,
+	"agentos-node-url-polyfill": stdLibBrowser.url,
+	"agentos-text-encoding-polyfill": path.join(
+		packageRoot,
+		"bridge-src",
+		"polyfills",
+		"text-encoding.ts",
+	),
+	"agentos-blob-file-polyfill": path.join(
+		packageRoot,
+		"bridge-src",
+		"polyfills",
+		"blob-file.ts",
+	),
+	"agentos-whatwg-url-polyfill": path.join(
+		packageRoot,
+		"bridge-src",
+		"polyfills",
+		"whatwg-url.ts",
+	),
+	"agentos-dom-events-polyfill": path.join(
+		packageRoot,
+		"bridge-src",
+		"polyfills",
+		"dom-events.ts",
+	),
+	"agentos-abort-polyfill": path.join(
+		packageRoot,
+		"bridge-src",
+		"polyfills",
+		"abort.ts",
+	),
+	"whatwg-url": require.resolve("whatwg-url"),
 	stream: path.join(undiciShimDir, "stream.js"),
 	"node:stream": path.join(undiciShimDir, "stream.js"),
 	"secure-exec-stream-stdlib": require.resolve("readable-stream"),
@@ -398,7 +443,15 @@ async function buildWebStreamsPrelude() {
 				'  ReadableStream,',
 				'  WritableStream,',
 				'  TransformStream,',
-				'} from "web-streams-polyfill/ponyfill/es2018";',
+				'} from "web-streams-polyfill";',
+				'import { TextDecoder as AgentOSTextDecoder, TextDecoderStream as AgentOSTextDecoderStream, TextEncoder2 as AgentOSTextEncoder, TextEncoderStream as AgentOSTextEncoderStream } from "agentos-text-encoding-polyfill";',
+				'import { Blob as AgentOSBlob, File as AgentOSFile } from "agentos-blob-file-polyfill";',
+				'if (typeof globalThis.TextEncoder === "undefined") {',
+				"  globalThis.TextEncoder = AgentOSTextEncoder;",
+				"}",
+				'if (typeof globalThis.TextDecoder === "undefined") {',
+				"  globalThis.TextDecoder = AgentOSTextDecoder;",
+				"}",
 				'if (typeof globalThis.ReadableStream === "undefined") {',
 				"  globalThis.ReadableStream = ReadableStream;",
 				"}",
@@ -408,199 +461,10 @@ async function buildWebStreamsPrelude() {
 				'if (typeof globalThis.TransformStream === "undefined") {',
 				"  globalThis.TransformStream = TransformStream;",
 				"}",
-				'if (typeof globalThis.URLSearchParams === "undefined") {',
-				"  globalThis.URLSearchParams = class URLSearchParamsStub {",
-				"    _entries = [];",
-				"    constructor(init = undefined) {",
-				'      if (typeof init === "string") {',
-				'        const source = init.startsWith("?") ? init.slice(1) : init;',
-				'        if (source.length > 0) {',
-				'          for (const pair of source.split("&")) {',
-				'            if (!pair) continue;',
-				'            const [rawKey, rawValue = ""] = pair.split("=");',
-				"            this.append(decodeURIComponent(rawKey), decodeURIComponent(rawValue));",
-				"          }",
-				"        }",
-				"      } else if (Array.isArray(init)) {",
-				"        for (const [key, value] of init) {",
-				"          this.append(key, value);",
-				"        }",
-				'      } else if (init && typeof init === "object") {',
-				"        for (const [key, value] of Object.entries(init)) {",
-				"          this.append(key, value);",
-				"        }",
-				"      }",
-				"    }",
-				"    append(name, value) {",
-				"      this._entries.push([String(name), String(value)]);",
-				"    }",
-				"    delete(name) {",
-				"      const key = String(name);",
-				"      this._entries = this._entries.filter(([entryKey]) => entryKey !== key);",
-				"    }",
-				"    get(name) {",
-				"      const key = String(name);",
-				"      const entry = this._entries.find(([entryKey]) => entryKey === key);",
-				"      return entry ? entry[1] : null;",
-				"    }",
-				"    getAll(name) {",
-				"      const key = String(name);",
-				"      return this._entries.filter(([entryKey]) => entryKey === key).map(([, value]) => value);",
-				"    }",
-				"    has(name) {",
-				"      const key = String(name);",
-				"      return this._entries.some(([entryKey]) => entryKey === key);",
-				"    }",
-				"    set(name, value) {",
-				"      this.delete(name);",
-				"      this.append(name, value);",
-				"    }",
-				"    entries() {",
-				"      return this._entries[Symbol.iterator]();",
-				"    }",
-				"    keys() {",
-				"      return this._entries.map(([key]) => key)[Symbol.iterator]();",
-				"    }",
-				"    values() {",
-				"      return this._entries.map(([, value]) => value)[Symbol.iterator]();",
-				"    }",
-				"    forEach(callback, thisArg = undefined) {",
-				"      for (const [key, value] of this._entries) {",
-				"        callback.call(thisArg, value, key, this);",
-				"      }",
-				"    }",
-				"    toString() {",
-				'      return this._entries.map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`).join("&");',
-				"    }",
-				"    [Symbol.iterator]() {",
-				"      return this.entries();",
-				"    }",
-				"  };",
-				"  globalThis.URLSearchParams.__secureExecBootstrapStub = true;",
-				"}",
-				'if (typeof globalThis.URL === "undefined") {',
-				"  globalThis.URL = class URLStub {",
-				"    constructor(url, base = undefined) {",
-				"      const raw = String(url ?? \"\");",
-				"      const hasScheme = /^[a-zA-Z][a-zA-Z\\d+\\-.]*:/.test(raw);",
-				"      const baseHref = hasScheme || typeof base === \"undefined\"",
-				"        ? \"\"",
-				"        : String(new globalThis.URL(base).href);",
-				"      const resolved = hasScheme",
-				"        ? raw",
-				"        : baseHref.replace(/\\/[^/]*$/, \"/\") + raw;",
-				"      const match = resolved.match(/^(\\w+:)\\/\\/([^/:?#]+)(:\\d+)?(.*)$/);",
-				"      if (!match) {",
-				"        throw new TypeError(`Invalid URL: ${raw}`);",
-				"      }",
-				"      this.protocol = match[1];",
-				"      this.hostname = match[2];",
-				"      this.port = (match[3] || \"\").slice(1);",
-				"      const remainder = match[4] || \"/\";",
-				"      const searchIndex = remainder.indexOf(\"?\");",
-				"      const hashIndex = remainder.indexOf(\"#\");",
-				"      const pathEnd = [searchIndex, hashIndex].filter((index) => index >= 0).sort((a, b) => a - b)[0] ?? remainder.length;",
-				"      this.pathname = remainder.slice(0, pathEnd) || \"/\";",
-				"      this.search = searchIndex >= 0",
-				"        ? remainder.slice(searchIndex, hashIndex >= 0 && hashIndex > searchIndex ? hashIndex : remainder.length)",
-				"        : \"\";",
-				"      this.hash = hashIndex >= 0 ? remainder.slice(hashIndex) : \"\";",
-				"      this.host = this.hostname + (this.port ? `:${this.port}` : \"\");",
-				"      this.origin = `${this.protocol}//${this.host}`;",
-				"      this.href = `${this.origin}${this.pathname}${this.search}${this.hash}`;",
-				"      this.searchParams = new globalThis.URLSearchParams(this.search);",
-				"    }",
-				"    toString() {",
-				"      return this.href;",
-				"    }",
-				"    toJSON() {",
-				"      return this.href;",
-				"    }",
-				"  };",
-				"  globalThis.URL.__secureExecBootstrapStub = true;",
-				"}",
-				'if (typeof globalThis.Blob === "undefined") {',
-				"  globalThis.Blob = class BlobStub {};",
-				"}",
-				'if (typeof globalThis.AbortSignal === "undefined") {',
-				"  globalThis.AbortSignal = class AbortSignalStub {",
-				"    aborted = false;",
-				"    reason = undefined;",
-				"    _listeners = new Set();",
-				"    addEventListener(type, listener) {",
-				'      if (type !== "abort" || typeof listener !== "function") return;',
-				"      this._listeners.add(listener);",
-				"    }",
-				"    removeEventListener(type, listener) {",
-				'      if (type !== "abort") return;',
-				"      this._listeners.delete(listener);",
-				"    }",
-				"    dispatchEvent(event) {",
-				"      for (const listener of this._listeners) {",
-				"        listener.call(this, event);",
-				"      }",
-				"      return true;",
-				"    }",
-				"    throwIfAborted() {",
-				"      if (this.aborted) {",
-				'        throw this.reason instanceof Error ? this.reason : new Error(String(this.reason ?? "AbortError"));',
-				"      }",
-				"    }",
-				"  };",
-				"}",
-				'if (typeof globalThis.AbortController === "undefined") {',
-				"  globalThis.AbortController = class AbortControllerStub {",
-				"    constructor() {",
-				"      this.signal = new globalThis.AbortSignal();",
-				"    }",
-				"    abort(reason = undefined) {",
-				"      if (this.signal.aborted) return;",
-				"      this.signal.aborted = true;",
-				"      this.signal.reason = reason;",
-				'      this.signal.dispatchEvent({ type: "abort" });',
-				"    }",
-				"  };",
-				"}",
-				'if (typeof globalThis.File === "undefined") {',
-				"  globalThis.File = class FileStub extends Blob {",
-				"    name;",
-				"    lastModified;",
-				"    webkitRelativePath;",
-				'    constructor(parts = [], name = "", options = {}) {',
-				"      super(parts, options);",
-				"      this.name = String(name);",
-				'      this.lastModified = typeof options.lastModified === "number" ? options.lastModified : Date.now();',
-				'      this.webkitRelativePath = "";',
-				"    }",
-				"  };",
-				"}",
-				'if (typeof globalThis.FormData === "undefined") {',
-				"  globalThis.FormData = class FormDataStub {",
-				"    _entries = [];",
-				"    append(name, value) {",
-				"      this._entries.push([name, value]);",
-				"    }",
-				"    get(name) {",
-				"      const entry = this._entries.find(([key]) => key === name);",
-				"      return entry ? entry[1] : null;",
-				"    }",
-				"    getAll(name) {",
-				"      return this._entries.filter(([key]) => key === name).map(([, value]) => value);",
-				"    }",
-				"    has(name) {",
-				"      return this._entries.some(([key]) => key === name);",
-				"    }",
-				"    delete(name) {",
-				"      this._entries = this._entries.filter(([key]) => key !== name);",
-				"    }",
-				"    entries() {",
-				"      return this._entries[Symbol.iterator]();",
-				"    }",
-				"    [Symbol.iterator]() {",
-				"      return this.entries();",
-				"    }",
-				"  };",
-				"}",
+				"globalThis.TextEncoderStream = AgentOSTextEncoderStream;",
+				"globalThis.TextDecoderStream = AgentOSTextDecoderStream;",
+				"globalThis.Blob = AgentOSBlob;",
+				"globalThis.File = AgentOSFile;",
 				'if (typeof globalThis.MessagePort === "undefined") {',
 				"  globalThis.MessagePort = class MessagePortStub {",
 				"    onmessage = null;",
@@ -654,6 +518,7 @@ async function buildWebStreamsPrelude() {
 			js: [
 				'if(typeof globalThis.global==="undefined"){globalThis.global=globalThis;}',
 				'if(typeof globalThis.process==="undefined"){globalThis.process={env:{},argv:["node"],browser:false,version:"v22.0.0",versions:{node:"22.0.0"},nextTick(callback,...args){return Promise.resolve().then(()=>callback(...args));}};}',
+				'if(typeof globalThis.SharedArrayBuffer==="undefined"){class SharedArrayBufferBootstrapStub{}Object.defineProperties(SharedArrayBufferBootstrapStub.prototype,{byteLength:{configurable:true,get(){if(!(this instanceof SharedArrayBufferBootstrapStub))throw new TypeError("incompatible receiver");return 0;}},growable:{configurable:true,get(){if(!(this instanceof SharedArrayBufferBootstrapStub))throw new TypeError("incompatible receiver");return false;}}});SharedArrayBufferBootstrapStub.__agentOSBootstrapStub=true;globalThis.SharedArrayBuffer=SharedArrayBufferBootstrapStub;}',
 			].join(""),
 		},
 	});
@@ -663,6 +528,78 @@ async function buildWebStreamsPrelude() {
 	return `${preludeResult.outputFiles[0].text}\n`;
 }
 
+async function buildUrlPrelude() {
+	const urlPreludeResult = await build({
+		stdin: {
+			contents: [
+				'import { installWhatwgUrlGlobals } from "agentos-whatwg-url-polyfill";',
+				"installWhatwgUrlGlobals(globalThis);",
+				'if (globalThis.SharedArrayBuffer?.__agentOSBootstrapStub === true) {',
+				"  delete globalThis.SharedArrayBuffer;",
+				"}",
+			].join("\n"),
+			resolveDir: bridgeAssetsDir,
+			sourcefile: "v8-bridge-url.entry.js",
+			loader: "js",
+		},
+		bundle: true,
+		write: false,
+		format: "iife",
+		platform: "browser",
+		target: "es2020",
+		minify: true,
+		alias,
+		plugins: createUndiciBuildPlugins(),
+		define: {
+			"process.env.NODE_ENV": '"production"',
+			global: "globalThis",
+		},
+	});
+	if (urlPreludeResult.errors.length > 0) {
+		throw new Error(
+			`Failed to build URL prelude: ${urlPreludeResult.errors[0].text}`,
+		);
+	}
+	return `${urlPreludeResult.outputFiles[0].text}\n`;
+}
+
+async function buildEventAbortPrelude() {
+	const eventAbortPreludeResult = await build({
+		stdin: {
+			contents: [
+				'import { Event, CustomEvent, EventTarget } from "agentos-dom-events-polyfill";',
+				'import { AbortController, AbortSignal } from "agentos-abort-polyfill";',
+				"globalThis.Event = Event;",
+				"globalThis.CustomEvent = CustomEvent;",
+				"globalThis.EventTarget = EventTarget;",
+				"globalThis.AbortSignal = AbortSignal;",
+				"globalThis.AbortController = AbortController;",
+			].join("\n"),
+			resolveDir: bridgeAssetsDir,
+			sourcefile: "v8-bridge-event-abort.entry.js",
+			loader: "js",
+		},
+		bundle: true,
+		write: false,
+		format: "iife",
+		platform: "browser",
+		target: "es2020",
+		minify: true,
+		alias,
+		plugins: createUndiciBuildPlugins(),
+		define: {
+			"process.env.NODE_ENV": '"production"',
+			global: "globalThis",
+		},
+	});
+	if (eventAbortPreludeResult.errors.length > 0) {
+		throw new Error(
+			`Failed to build event/abort prelude: ${eventAbortPreludeResult.errors[0].text}`,
+		);
+	}
+	return `${eventAbortPreludeResult.outputFiles[0].text}\n`;
+}
+
 async function prependBundlePrelude(bundlePath, preludeSource) {
 	const bundleText = await readFile(bundlePath, "utf8");
 	if (bundleText.startsWith(preludeSource)) {
@@ -673,6 +610,85 @@ async function prependBundlePrelude(bundlePath, preludeSource) {
 
 function createUndiciBuildPlugins() {
 	return [
+		{
+			name: "agentos-exodus-bytes-pure-js",
+			setup(build) {
+				build.onLoad(
+					{
+						filter:
+							/[\\/]@exodus[\\/]bytes[\\/]fallback[\\/]platform\.browser\.js$/,
+					},
+					async () => ({
+						contents: await readFile(
+							path.join(
+								exodusBytesRoot,
+								"fallback",
+								"platform.native.js",
+							),
+							"utf8",
+						),
+						loader: "js",
+						resolveDir: path.join(exodusBytesRoot, "fallback"),
+					}),
+				);
+				build.onLoad(
+					{
+						filter:
+							/[\\/]@exodus[\\/]bytes[\\/]fallback[\\/]utf8\.auto\.browser\.js$/,
+					},
+					async () => ({
+						contents: await readFile(
+							path.join(
+								exodusBytesRoot,
+								"fallback",
+								"utf8.auto.js",
+							),
+							"utf8",
+						),
+						loader: "js",
+						resolveDir: path.join(exodusBytesRoot, "fallback"),
+					}),
+				);
+				build.onLoad(
+					{ filter: /[\\/]@exodus[\\/]bytes[\\/]utf16\.browser\.js$/ },
+					async () => ({
+						contents: await readFile(
+							path.join(exodusBytesRoot, "utf16.native.js"),
+							"utf8",
+						),
+						loader: "js",
+						resolveDir: exodusBytesRoot,
+					}),
+				);
+			},
+		},
+		{
+			name: "agentos-fetch-blob-preinstalled-streams",
+			setup(build) {
+				build.onLoad(
+					{ filter: /[\\/]fetch-blob[\\/]index\.js$/ },
+					async (args) => {
+						const source = await readFile(args.path, "utf8");
+						const bootstrapStart = source.indexOf(
+							"if (!globalThis.ReadableStream)",
+						);
+						const implementationStart = source.indexOf("// 64 KiB");
+						if (bootstrapStart < 0 || implementationStart < bootstrapStart) {
+							throw new Error(
+								`fetch-blob bootstrap shape changed in ${args.path}`,
+							);
+						}
+						return {
+							contents:
+								source.slice(0, bootstrapStart) +
+								source.slice(implementationStart),
+							loader: "js",
+							resolveDir: path.dirname(args.path),
+						};
+					},
+				);
+			},
+		},
 		{
 			name: "secure-exec-undici-runtime-features-shim",
 			setup(build) {
@@ -684,8 +700,7 @@ function createUndiciBuildPlugins() {
 				}));
 				build.onResolve(
 					{
-						filter:
-							/^(undici\/lib\/.+|web-streams-polyfill\/ponyfill\/es2018)$/,
+						filter: /^(undici\/lib\/.+|web-streams-polyfill)$/,
 					},
 					(args) => {
 						const resolvedPath = require.resolve(args.path, {
@@ -823,7 +838,12 @@ for (const [name, buildResult] of [
 }
 
 const webStreamsPrelude = await buildWebStreamsPrelude();
-await prependBundlePrelude(bridgeTempOutput, webStreamsPrelude);
+const urlPrelude = await buildUrlPrelude();
+const eventAbortPrelude = await buildEventAbortPrelude();
+await prependBundlePrelude(
+	bridgeTempOutput,
+	`${webStreamsPrelude}${urlPrelude}${eventAbortPrelude}`,
+);
 await rewriteUndiciRuntimeFeaturesBundle(bridgeTempOutput, { required: true });
 await rewriteUnsupportedUtilTypesBundle(bridgeTempOutput, { required: true });
 await rewriteUndiciRuntimeFeaturesBundle(zlibBridgeTempOutput);
diff --git a/packages/build-tools/scripts/whatwg-url.test.mjs b/packages/build-tools/scripts/whatwg-url.test.mjs
deleted file mode 100644
index cadeff014a..0000000000
--- a/packages/build-tools/scripts/whatwg-url.test.mjs
+++ /dev/null
@@ -1,22 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import path from "node:path";
-import { resolveRelativeNonFileUrl } from "../bridge-src/builtins/url-resolution.ts";
-
-test("fallback URL resolution follows HTTP base URL semantics", () => {
-	const base = {
-		protocol: "http:",
-		host: "example.test:8080",
-		pathname: "/parent/entry",
-		search: "?old=1",
-	};
-	const resolve = (input) => resolveRelativeNonFileUrl(input, base, path.posix);
-
-	assert.equal(resolve("/hello?q=1"), "http://example.test:8080/hello?q=1");
-	assert.equal(resolve("child"), "http://example.test:8080/parent/child");
-	assert.equal(resolve("../child/"), "http://example.test:8080/child/");
-	assert.equal(resolve("?next=1"), "http://example.test:8080/parent/entry?next=1");
-	assert.equal(resolve("#result"), "http://example.test:8080/parent/entry?old=1#result");
-	assert.equal(resolve(""), "http://example.test:8080/parent/entry?old=1");
-	assert.equal(resolve("//cdn.test/file.js"), "http://cdn.test/file.js");
-});
diff --git a/packages/runtime-browser/src/generated/node-polyfills.ts b/packages/runtime-browser/src/generated/node-polyfills.ts
new file mode 100644
index 0000000000..b0555f8d8b
--- /dev/null
+++ b/packages/runtime-browser/src/generated/node-polyfills.ts
@@ -0,0 +1,7 @@
+// @generated - run node packages/build-tools/scripts/build-browser-node-polyfills.mjs
+export const BROWSER_ASSERT_POLYFILL_CODE = "var process = globalThis.process || {\n  env: {},\n  cwd: () => '/',\n  nextTick: (fn, ...args) => queueMicrotask(() => fn(...args)),\n};\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __commonJS = (cb, mod) => function __require() {\n  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;\n};\n\n// ../../node_modules/.pnpm/has-symbols@1.1.0/node_modules/has-symbols/shams.js\nvar require_shams = __commonJS({\n  \"../../node_modules/.pnpm/has-symbols@1.1.0/node_modules/has-symbols/shams.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = function hasSymbols() {\n      if (typeof Symbol !== \"function\" || typeof Object.getOwnPropertySymbols !== \"function\") {\n        return false;\n      }\n      if (typeof Symbol.iterator === \"symbol\") {\n        return true;\n      }\n      var obj = {};\n      var sym = /* @__PURE__ */ Symbol(\"test\");\n      var symObj = Object(sym);\n      if (typeof sym === \"string\") {\n        return false;\n      }\n      if (Object.prototype.toString.call(sym) !== \"[object Symbol]\") {\n        return false;\n      }\n      if (Object.prototype.toString.call(symObj) !== \"[object Symbol]\") {\n        return false;\n      }\n      var symVal = 42;\n      obj[sym] = symVal;\n      for (var _ in obj) {\n        return false;\n      }\n      if (typeof Object.keys === \"function\" && Object.keys(obj).length !== 0) {\n        return false;\n      }\n      if (typeof Object.getOwnPropertyNames === \"function\" && Object.getOwnPropertyNames(obj).length !== 0) {\n        return false;\n      }\n      var syms = Object.getOwnPropertySymbols(obj);\n      if (syms.length !== 1 || syms[0] !== sym) {\n        return false;\n      }\n      if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) {\n        return false;\n      }\n      if (typeof Object.getOwnPropertyDescriptor === \"function\") {\n        var descriptor = (\n          /** @type {PropertyDescriptor} */\n          Object.getOwnPropertyDescriptor(obj, sym)\n        );\n        if (descriptor.value !== symVal || descriptor.enumerable !== true) {\n          return false;\n        }\n      }\n      return true;\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/has-tostringtag@1.0.2/node_modules/has-tostringtag/shams.js\nvar require_shams2 = __commonJS({\n  \"../../node_modules/.pnpm/has-tostringtag@1.0.2/node_modules/has-tostringtag/shams.js\"(exports2, module2) {\n    \"use strict\";\n    var hasSymbols = require_shams();\n    module2.exports = function hasToStringTagShams() {\n      return hasSymbols() && !!Symbol.toStringTag;\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/es-object-atoms@1.1.1/node_modules/es-object-atoms/index.js\nvar require_es_object_atoms = __commonJS({\n  \"../../node_modules/.pnpm/es-object-atoms@1.1.1/node_modules/es-object-atoms/index.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = Object;\n  }\n});\n\n// ../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/index.js\nvar require_es_errors = __commonJS({\n  \"../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/index.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = Error;\n  }\n});\n\n// ../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/eval.js\nvar require_eval = __commonJS({\n  \"../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/eval.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = EvalError;\n  }\n});\n\n// ../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/range.js\nvar require_range = __commonJS({\n  \"../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/range.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = RangeError;\n  }\n});\n\n// ../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/ref.js\nvar require_ref = __commonJS({\n  \"../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/ref.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = ReferenceError;\n  }\n});\n\n// ../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/syntax.js\nvar require_syntax = __commonJS({\n  \"../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/syntax.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = SyntaxError;\n  }\n});\n\n// ../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/type.js\nvar require_type = __commonJS({\n  \"../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/type.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = TypeError;\n  }\n});\n\n// ../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/uri.js\nvar require_uri = __commonJS({\n  \"../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/uri.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = URIError;\n  }\n});\n\n// ../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/abs.js\nvar require_abs = __commonJS({\n  \"../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/abs.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = Math.abs;\n  }\n});\n\n// ../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/floor.js\nvar require_floor = __commonJS({\n  \"../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/floor.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = Math.floor;\n  }\n});\n\n// ../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/max.js\nvar require_max = __commonJS({\n  \"../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/max.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = Math.max;\n  }\n});\n\n// ../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/min.js\nvar require_min = __commonJS({\n  \"../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/min.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = Math.min;\n  }\n});\n\n// ../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/pow.js\nvar require_pow = __commonJS({\n  \"../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/pow.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = Math.pow;\n  }\n});\n\n// ../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/round.js\nvar require_round = __commonJS({\n  \"../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/round.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = Math.round;\n  }\n});\n\n// ../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/isNaN.js\nvar require_isNaN = __commonJS({\n  \"../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/isNaN.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = Number.isNaN || function isNaN2(a) {\n      return a !== a;\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/sign.js\nvar require_sign = __commonJS({\n  \"../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/sign.js\"(exports2, module2) {\n    \"use strict\";\n    var $isNaN = require_isNaN();\n    module2.exports = function sign(number) {\n      if ($isNaN(number) || number === 0) {\n        return number;\n      }\n      return number < 0 ? -1 : 1;\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/gOPD.js\nvar require_gOPD = __commonJS({\n  \"../../node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/gOPD.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = Object.getOwnPropertyDescriptor;\n  }\n});\n\n// ../../node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/index.js\nvar require_gopd = __commonJS({\n  \"../../node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/index.js\"(exports2, module2) {\n    \"use strict\";\n    var $gOPD = require_gOPD();\n    if ($gOPD) {\n      try {\n        $gOPD([], \"length\");\n      } catch (e) {\n        $gOPD = null;\n      }\n    }\n    module2.exports = $gOPD;\n  }\n});\n\n// ../../node_modules/.pnpm/es-define-property@1.0.1/node_modules/es-define-property/index.js\nvar require_es_define_property = __commonJS({\n  \"../../node_modules/.pnpm/es-define-property@1.0.1/node_modules/es-define-property/index.js\"(exports2, module2) {\n    \"use strict\";\n    var $defineProperty = Object.defineProperty || false;\n    if ($defineProperty) {\n      try {\n        $defineProperty({}, \"a\", { value: 1 });\n      } catch (e) {\n        $defineProperty = false;\n      }\n    }\n    module2.exports = $defineProperty;\n  }\n});\n\n// ../../node_modules/.pnpm/has-symbols@1.1.0/node_modules/has-symbols/index.js\nvar require_has_symbols = __commonJS({\n  \"../../node_modules/.pnpm/has-symbols@1.1.0/node_modules/has-symbols/index.js\"(exports2, module2) {\n    \"use strict\";\n    var origSymbol = typeof Symbol !== \"undefined\" && Symbol;\n    var hasSymbolSham = require_shams();\n    module2.exports = function hasNativeSymbols() {\n      if (typeof origSymbol !== \"function\") {\n        return false;\n      }\n      if (typeof Symbol !== \"function\") {\n        return false;\n      }\n      if (typeof origSymbol(\"foo\") !== \"symbol\") {\n        return false;\n      }\n      if (typeof /* @__PURE__ */ Symbol(\"bar\") !== \"symbol\") {\n        return false;\n      }\n      return hasSymbolSham();\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/Reflect.getPrototypeOf.js\nvar require_Reflect_getPrototypeOf = __commonJS({\n  \"../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/Reflect.getPrototypeOf.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = typeof Reflect !== \"undefined\" && Reflect.getPrototypeOf || null;\n  }\n});\n\n// ../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/Object.getPrototypeOf.js\nvar require_Object_getPrototypeOf = __commonJS({\n  \"../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/Object.getPrototypeOf.js\"(exports2, module2) {\n    \"use strict\";\n    var $Object = require_es_object_atoms();\n    module2.exports = $Object.getPrototypeOf || null;\n  }\n});\n\n// ../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/implementation.js\nvar require_implementation = __commonJS({\n  \"../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/implementation.js\"(exports2, module2) {\n    \"use strict\";\n    var ERROR_MESSAGE = \"Function.prototype.bind called on incompatible \";\n    var toStr = Object.prototype.toString;\n    var max = Math.max;\n    var funcType = \"[object Function]\";\n    var concatty = function concatty2(a, b) {\n      var arr = [];\n      for (var i = 0; i < a.length; i += 1) {\n        arr[i] = a[i];\n      }\n      for (var j = 0; j < b.length; j += 1) {\n        arr[j + a.length] = b[j];\n      }\n      return arr;\n    };\n    var slicy = function slicy2(arrLike, offset) {\n      var arr = [];\n      for (var i = offset || 0, j = 0; i < arrLike.length; i += 1, j += 1) {\n        arr[j] = arrLike[i];\n      }\n      return arr;\n    };\n    var joiny = function(arr, joiner) {\n      var str = \"\";\n      for (var i = 0; i < arr.length; i += 1) {\n        str += arr[i];\n        if (i + 1 < arr.length) {\n          str += joiner;\n        }\n      }\n      return str;\n    };\n    module2.exports = function bind(that) {\n      var target = this;\n      if (typeof target !== \"function\" || toStr.apply(target) !== funcType) {\n        throw new TypeError(ERROR_MESSAGE + target);\n      }\n      var args = slicy(arguments, 1);\n      var bound;\n      var binder = function() {\n        if (this instanceof bound) {\n          var result = target.apply(\n            this,\n            concatty(args, arguments)\n          );\n          if (Object(result) === result) {\n            return result;\n          }\n          return this;\n        }\n        return target.apply(\n          that,\n          concatty(args, arguments)\n        );\n      };\n      var boundLength = max(0, target.length - args.length);\n      var boundArgs = [];\n      for (var i = 0; i < boundLength; i++) {\n        boundArgs[i] = \"$\" + i;\n      }\n      bound = Function(\"binder\", \"return function (\" + joiny(boundArgs, \",\") + \"){ return binder.apply(this,arguments); }\")(binder);\n      if (target.prototype) {\n        var Empty = function Empty2() {\n        };\n        Empty.prototype = target.prototype;\n        bound.prototype = new Empty();\n        Empty.prototype = null;\n      }\n      return bound;\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/index.js\nvar require_function_bind = __commonJS({\n  \"../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/index.js\"(exports2, module2) {\n    \"use strict\";\n    var implementation = require_implementation();\n    module2.exports = Function.prototype.bind || implementation;\n  }\n});\n\n// ../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionCall.js\nvar require_functionCall = __commonJS({\n  \"../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionCall.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = Function.prototype.call;\n  }\n});\n\n// ../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionApply.js\nvar require_functionApply = __commonJS({\n  \"../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionApply.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = Function.prototype.apply;\n  }\n});\n\n// ../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/reflectApply.js\nvar require_reflectApply = __commonJS({\n  \"../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/reflectApply.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = typeof Reflect !== \"undefined\" && Reflect && Reflect.apply;\n  }\n});\n\n// ../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/actualApply.js\nvar require_actualApply = __commonJS({\n  \"../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/actualApply.js\"(exports2, module2) {\n    \"use strict\";\n    var bind = require_function_bind();\n    var $apply = require_functionApply();\n    var $call = require_functionCall();\n    var $reflectApply = require_reflectApply();\n    module2.exports = $reflectApply || bind.call($call, $apply);\n  }\n});\n\n// ../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/index.js\nvar require_call_bind_apply_helpers = __commonJS({\n  \"../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/index.js\"(exports2, module2) {\n    \"use strict\";\n    var bind = require_function_bind();\n    var $TypeError = require_type();\n    var $call = require_functionCall();\n    var $actualApply = require_actualApply();\n    module2.exports = function callBindBasic(args) {\n      if (args.length < 1 || typeof args[0] !== \"function\") {\n        throw new $TypeError(\"a function is required\");\n      }\n      return $actualApply(bind, $call, args);\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/dunder-proto@1.0.1/node_modules/dunder-proto/get.js\nvar require_get = __commonJS({\n  \"../../node_modules/.pnpm/dunder-proto@1.0.1/node_modules/dunder-proto/get.js\"(exports2, module2) {\n    \"use strict\";\n    var callBind = require_call_bind_apply_helpers();\n    var gOPD = require_gopd();\n    var hasProtoAccessor;\n    try {\n      hasProtoAccessor = /** @type {{ __proto__?: typeof Array.prototype }} */\n      [].__proto__ === Array.prototype;\n    } catch (e) {\n      if (!e || typeof e !== \"object\" || !(\"code\" in e) || e.code !== \"ERR_PROTO_ACCESS\") {\n        throw e;\n      }\n    }\n    var desc = !!hasProtoAccessor && gOPD && gOPD(\n      Object.prototype,\n      /** @type {keyof typeof Object.prototype} */\n      \"__proto__\"\n    );\n    var $Object = Object;\n    var $getPrototypeOf = $Object.getPrototypeOf;\n    module2.exports = desc && typeof desc.get === \"function\" ? callBind([desc.get]) : typeof $getPrototypeOf === \"function\" ? (\n      /** @type {import('./get')} */\n      function getDunder(value) {\n        return $getPrototypeOf(value == null ? value : $Object(value));\n      }\n    ) : false;\n  }\n});\n\n// ../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/index.js\nvar require_get_proto = __commonJS({\n  \"../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/index.js\"(exports2, module2) {\n    \"use strict\";\n    var reflectGetProto = require_Reflect_getPrototypeOf();\n    var originalGetProto = require_Object_getPrototypeOf();\n    var getDunderProto = require_get();\n    module2.exports = reflectGetProto ? function getProto(O) {\n      return reflectGetProto(O);\n    } : originalGetProto ? function getProto(O) {\n      if (!O || typeof O !== \"object\" && typeof O !== \"function\") {\n        throw new TypeError(\"getProto: not an object\");\n      }\n      return originalGetProto(O);\n    } : getDunderProto ? function getProto(O) {\n      return getDunderProto(O);\n    } : null;\n  }\n});\n\n// ../../node_modules/.pnpm/hasown@2.0.2/node_modules/hasown/index.js\nvar require_hasown = __commonJS({\n  \"../../node_modules/.pnpm/hasown@2.0.2/node_modules/hasown/index.js\"(exports2, module2) {\n    \"use strict\";\n    var call = Function.prototype.call;\n    var $hasOwn = Object.prototype.hasOwnProperty;\n    var bind = require_function_bind();\n    module2.exports = bind.call(call, $hasOwn);\n  }\n});\n\n// ../../node_modules/.pnpm/get-intrinsic@1.3.0/node_modules/get-intrinsic/index.js\nvar require_get_intrinsic = __commonJS({\n  \"../../node_modules/.pnpm/get-intrinsic@1.3.0/node_modules/get-intrinsic/index.js\"(exports2, module2) {\n    \"use strict\";\n    var undefined2;\n    var $Object = require_es_object_atoms();\n    var $Error = require_es_errors();\n    var $EvalError = require_eval();\n    var $RangeError = require_range();\n    var $ReferenceError = require_ref();\n    var $SyntaxError = require_syntax();\n    var $TypeError = require_type();\n    var $URIError = require_uri();\n    var abs = require_abs();\n    var floor = require_floor();\n    var max = require_max();\n    var min = require_min();\n    var pow = require_pow();\n    var round = require_round();\n    var sign = require_sign();\n    var $Function = Function;\n    var getEvalledConstructor = function(expressionSyntax) {\n      try {\n        return $Function('\"use strict\"; return (' + expressionSyntax + \").constructor;\")();\n      } catch (e) {\n      }\n    };\n    var $gOPD = require_gopd();\n    var $defineProperty = require_es_define_property();\n    var throwTypeError = function() {\n      throw new $TypeError();\n    };\n    var ThrowTypeError = $gOPD ? (function() {\n      try {\n        arguments.callee;\n        return throwTypeError;\n      } catch (calleeThrows) {\n        try {\n          return $gOPD(arguments, \"callee\").get;\n        } catch (gOPDthrows) {\n          return throwTypeError;\n        }\n      }\n    })() : throwTypeError;\n    var hasSymbols = require_has_symbols()();\n    var getProto = require_get_proto();\n    var $ObjectGPO = require_Object_getPrototypeOf();\n    var $ReflectGPO = require_Reflect_getPrototypeOf();\n    var $apply = require_functionApply();\n    var $call = require_functionCall();\n    var needsEval = {};\n    var TypedArray = typeof Uint8Array === \"undefined\" || !getProto ? undefined2 : getProto(Uint8Array);\n    var INTRINSICS = {\n      __proto__: null,\n      \"%AggregateError%\": typeof AggregateError === \"undefined\" ? undefined2 : AggregateError,\n      \"%Array%\": Array,\n      \"%ArrayBuffer%\": typeof ArrayBuffer === \"undefined\" ? undefined2 : ArrayBuffer,\n      \"%ArrayIteratorPrototype%\": hasSymbols && getProto ? getProto([][Symbol.iterator]()) : undefined2,\n      \"%AsyncFromSyncIteratorPrototype%\": undefined2,\n      \"%AsyncFunction%\": needsEval,\n      \"%AsyncGenerator%\": needsEval,\n      \"%AsyncGeneratorFunction%\": needsEval,\n      \"%AsyncIteratorPrototype%\": needsEval,\n      \"%Atomics%\": typeof Atomics === \"undefined\" ? undefined2 : Atomics,\n      \"%BigInt%\": typeof BigInt === \"undefined\" ? undefined2 : BigInt,\n      \"%BigInt64Array%\": typeof BigInt64Array === \"undefined\" ? undefined2 : BigInt64Array,\n      \"%BigUint64Array%\": typeof BigUint64Array === \"undefined\" ? undefined2 : BigUint64Array,\n      \"%Boolean%\": Boolean,\n      \"%DataView%\": typeof DataView === \"undefined\" ? undefined2 : DataView,\n      \"%Date%\": Date,\n      \"%decodeURI%\": decodeURI,\n      \"%decodeURIComponent%\": decodeURIComponent,\n      \"%encodeURI%\": encodeURI,\n      \"%encodeURIComponent%\": encodeURIComponent,\n      \"%Error%\": $Error,\n      \"%eval%\": eval,\n      // eslint-disable-line no-eval\n      \"%EvalError%\": $EvalError,\n      \"%Float16Array%\": typeof Float16Array === \"undefined\" ? undefined2 : Float16Array,\n      \"%Float32Array%\": typeof Float32Array === \"undefined\" ? undefined2 : Float32Array,\n      \"%Float64Array%\": typeof Float64Array === \"undefined\" ? undefined2 : Float64Array,\n      \"%FinalizationRegistry%\": typeof FinalizationRegistry === \"undefined\" ? undefined2 : FinalizationRegistry,\n      \"%Function%\": $Function,\n      \"%GeneratorFunction%\": needsEval,\n      \"%Int8Array%\": typeof Int8Array === \"undefined\" ? undefined2 : Int8Array,\n      \"%Int16Array%\": typeof Int16Array === \"undefined\" ? undefined2 : Int16Array,\n      \"%Int32Array%\": typeof Int32Array === \"undefined\" ? undefined2 : Int32Array,\n      \"%isFinite%\": isFinite,\n      \"%isNaN%\": isNaN,\n      \"%IteratorPrototype%\": hasSymbols && getProto ? getProto(getProto([][Symbol.iterator]())) : undefined2,\n      \"%JSON%\": typeof JSON === \"object\" ? JSON : undefined2,\n      \"%Map%\": typeof Map === \"undefined\" ? undefined2 : Map,\n      \"%MapIteratorPrototype%\": typeof Map === \"undefined\" || !hasSymbols || !getProto ? undefined2 : getProto((/* @__PURE__ */ new Map())[Symbol.iterator]()),\n      \"%Math%\": Math,\n      \"%Number%\": Number,\n      \"%Object%\": $Object,\n      \"%Object.getOwnPropertyDescriptor%\": $gOPD,\n      \"%parseFloat%\": parseFloat,\n      \"%parseInt%\": parseInt,\n      \"%Promise%\": typeof Promise === \"undefined\" ? undefined2 : Promise,\n      \"%Proxy%\": typeof Proxy === \"undefined\" ? undefined2 : Proxy,\n      \"%RangeError%\": $RangeError,\n      \"%ReferenceError%\": $ReferenceError,\n      \"%Reflect%\": typeof Reflect === \"undefined\" ? undefined2 : Reflect,\n      \"%RegExp%\": RegExp,\n      \"%Set%\": typeof Set === \"undefined\" ? undefined2 : Set,\n      \"%SetIteratorPrototype%\": typeof Set === \"undefined\" || !hasSymbols || !getProto ? undefined2 : getProto((/* @__PURE__ */ new Set())[Symbol.iterator]()),\n      \"%SharedArrayBuffer%\": typeof SharedArrayBuffer === \"undefined\" ? undefined2 : SharedArrayBuffer,\n      \"%String%\": String,\n      \"%StringIteratorPrototype%\": hasSymbols && getProto ? getProto(\"\"[Symbol.iterator]()) : undefined2,\n      \"%Symbol%\": hasSymbols ? Symbol : undefined2,\n      \"%SyntaxError%\": $SyntaxError,\n      \"%ThrowTypeError%\": ThrowTypeError,\n      \"%TypedArray%\": TypedArray,\n      \"%TypeError%\": $TypeError,\n      \"%Uint8Array%\": typeof Uint8Array === \"undefined\" ? undefined2 : Uint8Array,\n      \"%Uint8ClampedArray%\": typeof Uint8ClampedArray === \"undefined\" ? undefined2 : Uint8ClampedArray,\n      \"%Uint16Array%\": typeof Uint16Array === \"undefined\" ? undefined2 : Uint16Array,\n      \"%Uint32Array%\": typeof Uint32Array === \"undefined\" ? undefined2 : Uint32Array,\n      \"%URIError%\": $URIError,\n      \"%WeakMap%\": typeof WeakMap === \"undefined\" ? undefined2 : WeakMap,\n      \"%WeakRef%\": typeof WeakRef === \"undefined\" ? undefined2 : WeakRef,\n      \"%WeakSet%\": typeof WeakSet === \"undefined\" ? undefined2 : WeakSet,\n      \"%Function.prototype.call%\": $call,\n      \"%Function.prototype.apply%\": $apply,\n      \"%Object.defineProperty%\": $defineProperty,\n      \"%Object.getPrototypeOf%\": $ObjectGPO,\n      \"%Math.abs%\": abs,\n      \"%Math.floor%\": floor,\n      \"%Math.max%\": max,\n      \"%Math.min%\": min,\n      \"%Math.pow%\": pow,\n      \"%Math.round%\": round,\n      \"%Math.sign%\": sign,\n      \"%Reflect.getPrototypeOf%\": $ReflectGPO\n    };\n    if (getProto) {\n      try {\n        null.error;\n      } catch (e) {\n        errorProto = getProto(getProto(e));\n        INTRINSICS[\"%Error.prototype%\"] = errorProto;\n      }\n    }\n    var errorProto;\n    var doEval = function doEval2(name) {\n      var value;\n      if (name === \"%AsyncFunction%\") {\n        value = getEvalledConstructor(\"async function () {}\");\n      } else if (name === \"%GeneratorFunction%\") {\n        value = getEvalledConstructor(\"function* () {}\");\n      } else if (name === \"%AsyncGeneratorFunction%\") {\n        value = getEvalledConstructor(\"async function* () {}\");\n      } else if (name === \"%AsyncGenerator%\") {\n        var fn = doEval2(\"%AsyncGeneratorFunction%\");\n        if (fn) {\n          value = fn.prototype;\n        }\n      } else if (name === \"%AsyncIteratorPrototype%\") {\n        var gen = doEval2(\"%AsyncGenerator%\");\n        if (gen && getProto) {\n          value = getProto(gen.prototype);\n        }\n      }\n      INTRINSICS[name] = value;\n      return value;\n    };\n    var LEGACY_ALIASES = {\n      __proto__: null,\n      \"%ArrayBufferPrototype%\": [\"ArrayBuffer\", \"prototype\"],\n      \"%ArrayPrototype%\": [\"Array\", \"prototype\"],\n      \"%ArrayProto_entries%\": [\"Array\", \"prototype\", \"entries\"],\n      \"%ArrayProto_forEach%\": [\"Array\", \"prototype\", \"forEach\"],\n      \"%ArrayProto_keys%\": [\"Array\", \"prototype\", \"keys\"],\n      \"%ArrayProto_values%\": [\"Array\", \"prototype\", \"values\"],\n      \"%AsyncFunctionPrototype%\": [\"AsyncFunction\", \"prototype\"],\n      \"%AsyncGenerator%\": [\"AsyncGeneratorFunction\", \"prototype\"],\n      \"%AsyncGeneratorPrototype%\": [\"AsyncGeneratorFunction\", \"prototype\", \"prototype\"],\n      \"%BooleanPrototype%\": [\"Boolean\", \"prototype\"],\n      \"%DataViewPrototype%\": [\"DataView\", \"prototype\"],\n      \"%DatePrototype%\": [\"Date\", \"prototype\"],\n      \"%ErrorPrototype%\": [\"Error\", \"prototype\"],\n      \"%EvalErrorPrototype%\": [\"EvalError\", \"prototype\"],\n      \"%Float32ArrayPrototype%\": [\"Float32Array\", \"prototype\"],\n      \"%Float64ArrayPrototype%\": [\"Float64Array\", \"prototype\"],\n      \"%FunctionPrototype%\": [\"Function\", \"prototype\"],\n      \"%Generator%\": [\"GeneratorFunction\", \"prototype\"],\n      \"%GeneratorPrototype%\": [\"GeneratorFunction\", \"prototype\", \"prototype\"],\n      \"%Int8ArrayPrototype%\": [\"Int8Array\", \"prototype\"],\n      \"%Int16ArrayPrototype%\": [\"Int16Array\", \"prototype\"],\n      \"%Int32ArrayPrototype%\": [\"Int32Array\", \"prototype\"],\n      \"%JSONParse%\": [\"JSON\", \"parse\"],\n      \"%JSONStringify%\": [\"JSON\", \"stringify\"],\n      \"%MapPrototype%\": [\"Map\", \"prototype\"],\n      \"%NumberPrototype%\": [\"Number\", \"prototype\"],\n      \"%ObjectPrototype%\": [\"Object\", \"prototype\"],\n      \"%ObjProto_toString%\": [\"Object\", \"prototype\", \"toString\"],\n      \"%ObjProto_valueOf%\": [\"Object\", \"prototype\", \"valueOf\"],\n      \"%PromisePrototype%\": [\"Promise\", \"prototype\"],\n      \"%PromiseProto_then%\": [\"Promise\", \"prototype\", \"then\"],\n      \"%Promise_all%\": [\"Promise\", \"all\"],\n      \"%Promise_reject%\": [\"Promise\", \"reject\"],\n      \"%Promise_resolve%\": [\"Promise\", \"resolve\"],\n      \"%RangeErrorPrototype%\": [\"RangeError\", \"prototype\"],\n      \"%ReferenceErrorPrototype%\": [\"ReferenceError\", \"prototype\"],\n      \"%RegExpPrototype%\": [\"RegExp\", \"prototype\"],\n      \"%SetPrototype%\": [\"Set\", \"prototype\"],\n      \"%SharedArrayBufferPrototype%\": [\"SharedArrayBuffer\", \"prototype\"],\n      \"%StringPrototype%\": [\"String\", \"prototype\"],\n      \"%SymbolPrototype%\": [\"Symbol\", \"prototype\"],\n      \"%SyntaxErrorPrototype%\": [\"SyntaxError\", \"prototype\"],\n      \"%TypedArrayPrototype%\": [\"TypedArray\", \"prototype\"],\n      \"%TypeErrorPrototype%\": [\"TypeError\", \"prototype\"],\n      \"%Uint8ArrayPrototype%\": [\"Uint8Array\", \"prototype\"],\n      \"%Uint8ClampedArrayPrototype%\": [\"Uint8ClampedArray\", \"prototype\"],\n      \"%Uint16ArrayPrototype%\": [\"Uint16Array\", \"prototype\"],\n      \"%Uint32ArrayPrototype%\": [\"Uint32Array\", \"prototype\"],\n      \"%URIErrorPrototype%\": [\"URIError\", \"prototype\"],\n      \"%WeakMapPrototype%\": [\"WeakMap\", \"prototype\"],\n      \"%WeakSetPrototype%\": [\"WeakSet\", \"prototype\"]\n    };\n    var bind = require_function_bind();\n    var hasOwn = require_hasown();\n    var $concat = bind.call($call, Array.prototype.concat);\n    var $spliceApply = bind.call($apply, Array.prototype.splice);\n    var $replace = bind.call($call, String.prototype.replace);\n    var $strSlice = bind.call($call, String.prototype.slice);\n    var $exec = bind.call($call, RegExp.prototype.exec);\n    var rePropName = /[^%.[\\]]+|\\[(?:(-?\\d+(?:\\.\\d+)?)|([\"'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2)\\]|(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|%$))/g;\n    var reEscapeChar = /\\\\(\\\\)?/g;\n    var stringToPath = function stringToPath2(string) {\n      var first = $strSlice(string, 0, 1);\n      var last = $strSlice(string, -1);\n      if (first === \"%\" && last !== \"%\") {\n        throw new $SyntaxError(\"invalid intrinsic syntax, expected closing `%`\");\n      } else if (last === \"%\" && first !== \"%\") {\n        throw new $SyntaxError(\"invalid intrinsic syntax, expected opening `%`\");\n      }\n      var result = [];\n      $replace(string, rePropName, function(match, number, quote, subString) {\n        result[result.length] = quote ? $replace(subString, reEscapeChar, \"$1\") : number || match;\n      });\n      return result;\n    };\n    var getBaseIntrinsic = function getBaseIntrinsic2(name, allowMissing) {\n      var intrinsicName = name;\n      var alias;\n      if (hasOwn(LEGACY_ALIASES, intrinsicName)) {\n        alias = LEGACY_ALIASES[intrinsicName];\n        intrinsicName = \"%\" + alias[0] + \"%\";\n      }\n      if (hasOwn(INTRINSICS, intrinsicName)) {\n        var value = INTRINSICS[intrinsicName];\n        if (value === needsEval) {\n          value = doEval(intrinsicName);\n        }\n        if (typeof value === \"undefined\" && !allowMissing) {\n          throw new $TypeError(\"intrinsic \" + name + \" exists, but is not available. Please file an issue!\");\n        }\n        return {\n          alias,\n          name: intrinsicName,\n          value\n        };\n      }\n      throw new $SyntaxError(\"intrinsic \" + name + \" does not exist!\");\n    };\n    module2.exports = function GetIntrinsic(name, allowMissing) {\n      if (typeof name !== \"string\" || name.length === 0) {\n        throw new $TypeError(\"intrinsic name must be a non-empty string\");\n      }\n      if (arguments.length > 1 && typeof allowMissing !== \"boolean\") {\n        throw new $TypeError('\"allowMissing\" argument must be a boolean');\n      }\n      if ($exec(/^%?[^%]*%?$/, name) === null) {\n        throw new $SyntaxError(\"`%` may not be present anywhere but at the beginning and end of the intrinsic name\");\n      }\n      var parts = stringToPath(name);\n      var intrinsicBaseName = parts.length > 0 ? parts[0] : \"\";\n      var intrinsic = getBaseIntrinsic(\"%\" + intrinsicBaseName + \"%\", allowMissing);\n      var intrinsicRealName = intrinsic.name;\n      var value = intrinsic.value;\n      var skipFurtherCaching = false;\n      var alias = intrinsic.alias;\n      if (alias) {\n        intrinsicBaseName = alias[0];\n        $spliceApply(parts, $concat([0, 1], alias));\n      }\n      for (var i = 1, isOwn = true; i < parts.length; i += 1) {\n        var part = parts[i];\n        var first = $strSlice(part, 0, 1);\n        var last = $strSlice(part, -1);\n        if ((first === '\"' || first === \"'\" || first === \"`\" || (last === '\"' || last === \"'\" || last === \"`\")) && first !== last) {\n          throw new $SyntaxError(\"property names with quotes must have matching quotes\");\n        }\n        if (part === \"constructor\" || !isOwn) {\n          skipFurtherCaching = true;\n        }\n        intrinsicBaseName += \".\" + part;\n        intrinsicRealName = \"%\" + intrinsicBaseName + \"%\";\n        if (hasOwn(INTRINSICS, intrinsicRealName)) {\n          value = INTRINSICS[intrinsicRealName];\n        } else if (value != null) {\n          if (!(part in value)) {\n            if (!allowMissing) {\n              throw new $TypeError(\"base intrinsic for \" + name + \" exists, but the property is not available.\");\n            }\n            return void undefined2;\n          }\n          if ($gOPD && i + 1 >= parts.length) {\n            var desc = $gOPD(value, part);\n            isOwn = !!desc;\n            if (isOwn && \"get\" in desc && !(\"originalValue\" in desc.get)) {\n              value = desc.get;\n            } else {\n              value = value[part];\n            }\n          } else {\n            isOwn = hasOwn(value, part);\n            value = value[part];\n          }\n          if (isOwn && !skipFurtherCaching) {\n            INTRINSICS[intrinsicRealName] = value;\n          }\n        }\n      }\n      return value;\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/call-bound@1.0.4/node_modules/call-bound/index.js\nvar require_call_bound = __commonJS({\n  \"../../node_modules/.pnpm/call-bound@1.0.4/node_modules/call-bound/index.js\"(exports2, module2) {\n    \"use strict\";\n    var GetIntrinsic = require_get_intrinsic();\n    var callBindBasic = require_call_bind_apply_helpers();\n    var $indexOf = callBindBasic([GetIntrinsic(\"%String.prototype.indexOf%\")]);\n    module2.exports = function callBoundIntrinsic(name, allowMissing) {\n      var intrinsic = (\n        /** @type {(this: unknown, ...args: unknown[]) => unknown} */\n        GetIntrinsic(name, !!allowMissing)\n      );\n      if (typeof intrinsic === \"function\" && $indexOf(name, \".prototype.\") > -1) {\n        return callBindBasic(\n          /** @type {const} */\n          [intrinsic]\n        );\n      }\n      return intrinsic;\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/is-arguments@1.2.0/node_modules/is-arguments/index.js\nvar require_is_arguments = __commonJS({\n  \"../../node_modules/.pnpm/is-arguments@1.2.0/node_modules/is-arguments/index.js\"(exports2, module2) {\n    \"use strict\";\n    var hasToStringTag = require_shams2()();\n    var callBound = require_call_bound();\n    var $toString = callBound(\"Object.prototype.toString\");\n    var isStandardArguments = function isArguments(value) {\n      if (hasToStringTag && value && typeof value === \"object\" && Symbol.toStringTag in value) {\n        return false;\n      }\n      return $toString(value) === \"[object Arguments]\";\n    };\n    var isLegacyArguments = function isArguments(value) {\n      if (isStandardArguments(value)) {\n        return true;\n      }\n      return value !== null && typeof value === \"object\" && \"length\" in value && typeof value.length === \"number\" && value.length >= 0 && $toString(value) !== \"[object Array]\" && \"callee\" in value && $toString(value.callee) === \"[object Function]\";\n    };\n    var supportsStandardArguments = (function() {\n      return isStandardArguments(arguments);\n    })();\n    isStandardArguments.isLegacyArguments = isLegacyArguments;\n    module2.exports = supportsStandardArguments ? isStandardArguments : isLegacyArguments;\n  }\n});\n\n// ../../node_modules/.pnpm/is-regex@1.2.1/node_modules/is-regex/index.js\nvar require_is_regex = __commonJS({\n  \"../../node_modules/.pnpm/is-regex@1.2.1/node_modules/is-regex/index.js\"(exports2, module2) {\n    \"use strict\";\n    var callBound = require_call_bound();\n    var hasToStringTag = require_shams2()();\n    var hasOwn = require_hasown();\n    var gOPD = require_gopd();\n    var fn;\n    if (hasToStringTag) {\n      $exec = callBound(\"RegExp.prototype.exec\");\n      isRegexMarker = {};\n      throwRegexMarker = function() {\n        throw isRegexMarker;\n      };\n      badStringifier = {\n        toString: throwRegexMarker,\n        valueOf: throwRegexMarker\n      };\n      if (typeof Symbol.toPrimitive === \"symbol\") {\n        badStringifier[Symbol.toPrimitive] = throwRegexMarker;\n      }\n      fn = function isRegex(value) {\n        if (!value || typeof value !== \"object\") {\n          return false;\n        }\n        var descriptor = (\n          /** @type {NonNullable<typeof gOPD>} */\n          gOPD(\n            /** @type {{ lastIndex?: unknown }} */\n            value,\n            \"lastIndex\"\n          )\n        );\n        var hasLastIndexDataProperty = descriptor && hasOwn(descriptor, \"value\");\n        if (!hasLastIndexDataProperty) {\n          return false;\n        }\n        try {\n          $exec(\n            value,\n            /** @type {string} */\n            /** @type {unknown} */\n            badStringifier\n          );\n        } catch (e) {\n          return e === isRegexMarker;\n        }\n      };\n    } else {\n      $toString = callBound(\"Object.prototype.toString\");\n      regexClass = \"[object RegExp]\";\n      fn = function isRegex(value) {\n        if (!value || typeof value !== \"object\" && typeof value !== \"function\") {\n          return false;\n        }\n        return $toString(value) === regexClass;\n      };\n    }\n    var $exec;\n    var isRegexMarker;\n    var throwRegexMarker;\n    var badStringifier;\n    var $toString;\n    var regexClass;\n    module2.exports = fn;\n  }\n});\n\n// ../../node_modules/.pnpm/safe-regex-test@1.1.0/node_modules/safe-regex-test/index.js\nvar require_safe_regex_test = __commonJS({\n  \"../../node_modules/.pnpm/safe-regex-test@1.1.0/node_modules/safe-regex-test/index.js\"(exports2, module2) {\n    \"use strict\";\n    var callBound = require_call_bound();\n    var isRegex = require_is_regex();\n    var $exec = callBound(\"RegExp.prototype.exec\");\n    var $TypeError = require_type();\n    module2.exports = function regexTester(regex) {\n      if (!isRegex(regex)) {\n        throw new $TypeError(\"`regex` must be a RegExp\");\n      }\n      return function test(s) {\n        return $exec(regex, s) !== null;\n      };\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/generator-function@2.0.1/node_modules/generator-function/index.js\nvar require_generator_function = __commonJS({\n  \"../../node_modules/.pnpm/generator-function@2.0.1/node_modules/generator-function/index.js\"(exports2, module2) {\n    \"use strict\";\n    var cached = (\n      /** @type {GeneratorFunctionConstructor} */\n      function* () {\n      }.constructor\n    );\n    module2.exports = () => cached;\n  }\n});\n\n// ../../node_modules/.pnpm/is-generator-function@1.1.2/node_modules/is-generator-function/index.js\nvar require_is_generator_function = __commonJS({\n  \"../../node_modules/.pnpm/is-generator-function@1.1.2/node_modules/is-generator-function/index.js\"(exports2, module2) {\n    \"use strict\";\n    var callBound = require_call_bound();\n    var safeRegexTest = require_safe_regex_test();\n    var isFnRegex = safeRegexTest(/^\\s*(?:function)?\\*/);\n    var hasToStringTag = require_shams2()();\n    var getProto = require_get_proto();\n    var toStr = callBound(\"Object.prototype.toString\");\n    var fnToStr = callBound(\"Function.prototype.toString\");\n    var getGeneratorFunction = require_generator_function();\n    module2.exports = function isGeneratorFunction(fn) {\n      if (typeof fn !== \"function\") {\n        return false;\n      }\n      if (isFnRegex(fnToStr(fn))) {\n        return true;\n      }\n      if (!hasToStringTag) {\n        var str = toStr(fn);\n        return str === \"[object GeneratorFunction]\";\n      }\n      if (!getProto) {\n        return false;\n      }\n      var GeneratorFunction = getGeneratorFunction();\n      return GeneratorFunction && getProto(fn) === GeneratorFunction.prototype;\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/is-callable@1.2.7/node_modules/is-callable/index.js\nvar require_is_callable = __commonJS({\n  \"../../node_modules/.pnpm/is-callable@1.2.7/node_modules/is-callable/index.js\"(exports2, module2) {\n    \"use strict\";\n    var fnToStr = Function.prototype.toString;\n    var reflectApply = typeof Reflect === \"object\" && Reflect !== null && Reflect.apply;\n    var badArrayLike;\n    var isCallableMarker;\n    if (typeof reflectApply === \"function\" && typeof Object.defineProperty === \"function\") {\n      try {\n        badArrayLike = Object.defineProperty({}, \"length\", {\n          get: function() {\n            throw isCallableMarker;\n          }\n        });\n        isCallableMarker = {};\n        reflectApply(function() {\n          throw 42;\n        }, null, badArrayLike);\n      } catch (_) {\n        if (_ !== isCallableMarker) {\n          reflectApply = null;\n        }\n      }\n    } else {\n      reflectApply = null;\n    }\n    var constructorRegex = /^\\s*class\\b/;\n    var isES6ClassFn = function isES6ClassFunction(value) {\n      try {\n        var fnStr = fnToStr.call(value);\n        return constructorRegex.test(fnStr);\n      } catch (e) {\n        return false;\n      }\n    };\n    var tryFunctionObject = function tryFunctionToStr(value) {\n      try {\n        if (isES6ClassFn(value)) {\n          return false;\n        }\n        fnToStr.call(value);\n        return true;\n      } catch (e) {\n        return false;\n      }\n    };\n    var toStr = Object.prototype.toString;\n    var objectClass = \"[object Object]\";\n    var fnClass = \"[object Function]\";\n    var genClass = \"[object GeneratorFunction]\";\n    var ddaClass = \"[object HTMLAllCollection]\";\n    var ddaClass2 = \"[object HTML document.all class]\";\n    var ddaClass3 = \"[object HTMLCollection]\";\n    var hasToStringTag = typeof Symbol === \"function\" && !!Symbol.toStringTag;\n    var isIE68 = !(0 in [,]);\n    var isDDA = function isDocumentDotAll() {\n      return false;\n    };\n    if (typeof document === \"object\") {\n      all = document.all;\n      if (toStr.call(all) === toStr.call(document.all)) {\n        isDDA = function isDocumentDotAll(value) {\n          if ((isIE68 || !value) && (typeof value === \"undefined\" || typeof value === \"object\")) {\n            try {\n              var str = toStr.call(value);\n              return (str === ddaClass || str === ddaClass2 || str === ddaClass3 || str === objectClass) && value(\"\") == null;\n            } catch (e) {\n            }\n          }\n          return false;\n        };\n      }\n    }\n    var all;\n    module2.exports = reflectApply ? function isCallable(value) {\n      if (isDDA(value)) {\n        return true;\n      }\n      if (!value) {\n        return false;\n      }\n      if (typeof value !== \"function\" && typeof value !== \"object\") {\n        return false;\n      }\n      try {\n        reflectApply(value, null, badArrayLike);\n      } catch (e) {\n        if (e !== isCallableMarker) {\n          return false;\n        }\n      }\n      return !isES6ClassFn(value) && tryFunctionObject(value);\n    } : function isCallable(value) {\n      if (isDDA(value)) {\n        return true;\n      }\n      if (!value) {\n        return false;\n      }\n      if (typeof value !== \"function\" && typeof value !== \"object\") {\n        return false;\n      }\n      if (hasToStringTag) {\n        return tryFunctionObject(value);\n      }\n      if (isES6ClassFn(value)) {\n        return false;\n      }\n      var strClass = toStr.call(value);\n      if (strClass !== fnClass && strClass !== genClass && !/^\\[object HTML/.test(strClass)) {\n        return false;\n      }\n      return tryFunctionObject(value);\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/for-each@0.3.5/node_modules/for-each/index.js\nvar require_for_each = __commonJS({\n  \"../../node_modules/.pnpm/for-each@0.3.5/node_modules/for-each/index.js\"(exports2, module2) {\n    \"use strict\";\n    var isCallable = require_is_callable();\n    var toStr = Object.prototype.toString;\n    var hasOwnProperty = Object.prototype.hasOwnProperty;\n    var forEachArray = function forEachArray2(array, iterator, receiver) {\n      for (var i = 0, len = array.length; i < len; i++) {\n        if (hasOwnProperty.call(array, i)) {\n          if (receiver == null) {\n            iterator(array[i], i, array);\n          } else {\n            iterator.call(receiver, array[i], i, array);\n          }\n        }\n      }\n    };\n    var forEachString = function forEachString2(string, iterator, receiver) {\n      for (var i = 0, len = string.length; i < len; i++) {\n        if (receiver == null) {\n          iterator(string.charAt(i), i, string);\n        } else {\n          iterator.call(receiver, string.charAt(i), i, string);\n        }\n      }\n    };\n    var forEachObject = function forEachObject2(object, iterator, receiver) {\n      for (var k in object) {\n        if (hasOwnProperty.call(object, k)) {\n          if (receiver == null) {\n            iterator(object[k], k, object);\n          } else {\n            iterator.call(receiver, object[k], k, object);\n          }\n        }\n      }\n    };\n    function isArray(x) {\n      return toStr.call(x) === \"[object Array]\";\n    }\n    module2.exports = function forEach(list, iterator, thisArg) {\n      if (!isCallable(iterator)) {\n        throw new TypeError(\"iterator must be a function\");\n      }\n      var receiver;\n      if (arguments.length >= 3) {\n        receiver = thisArg;\n      }\n      if (isArray(list)) {\n        forEachArray(list, iterator, receiver);\n      } else if (typeof list === \"string\") {\n        forEachString(list, iterator, receiver);\n      } else {\n        forEachObject(list, iterator, receiver);\n      }\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/possible-typed-array-names@1.1.0/node_modules/possible-typed-array-names/index.js\nvar require_possible_typed_array_names = __commonJS({\n  \"../../node_modules/.pnpm/possible-typed-array-names@1.1.0/node_modules/possible-typed-array-names/index.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = [\n      \"Float16Array\",\n      \"Float32Array\",\n      \"Float64Array\",\n      \"Int8Array\",\n      \"Int16Array\",\n      \"Int32Array\",\n      \"Uint8Array\",\n      \"Uint8ClampedArray\",\n      \"Uint16Array\",\n      \"Uint32Array\",\n      \"BigInt64Array\",\n      \"BigUint64Array\"\n    ];\n  }\n});\n\n// ../../node_modules/.pnpm/available-typed-arrays@1.0.7/node_modules/available-typed-arrays/index.js\nvar require_available_typed_arrays = __commonJS({\n  \"../../node_modules/.pnpm/available-typed-arrays@1.0.7/node_modules/available-typed-arrays/index.js\"(exports2, module2) {\n    \"use strict\";\n    var possibleNames = require_possible_typed_array_names();\n    var g = typeof globalThis === \"undefined\" ? global : globalThis;\n    module2.exports = function availableTypedArrays() {\n      var out = [];\n      for (var i = 0; i < possibleNames.length; i++) {\n        if (typeof g[possibleNames[i]] === \"function\") {\n          out[out.length] = possibleNames[i];\n        }\n      }\n      return out;\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/define-data-property@1.1.4/node_modules/define-data-property/index.js\nvar require_define_data_property = __commonJS({\n  \"../../node_modules/.pnpm/define-data-property@1.1.4/node_modules/define-data-property/index.js\"(exports2, module2) {\n    \"use strict\";\n    var $defineProperty = require_es_define_property();\n    var $SyntaxError = require_syntax();\n    var $TypeError = require_type();\n    var gopd = require_gopd();\n    module2.exports = function defineDataProperty(obj, property, value) {\n      if (!obj || typeof obj !== \"object\" && typeof obj !== \"function\") {\n        throw new $TypeError(\"`obj` must be an object or a function`\");\n      }\n      if (typeof property !== \"string\" && typeof property !== \"symbol\") {\n        throw new $TypeError(\"`property` must be a string or a symbol`\");\n      }\n      if (arguments.length > 3 && typeof arguments[3] !== \"boolean\" && arguments[3] !== null) {\n        throw new $TypeError(\"`nonEnumerable`, if provided, must be a boolean or null\");\n      }\n      if (arguments.length > 4 && typeof arguments[4] !== \"boolean\" && arguments[4] !== null) {\n        throw new $TypeError(\"`nonWritable`, if provided, must be a boolean or null\");\n      }\n      if (arguments.length > 5 && typeof arguments[5] !== \"boolean\" && arguments[5] !== null) {\n        throw new $TypeError(\"`nonConfigurable`, if provided, must be a boolean or null\");\n      }\n      if (arguments.length > 6 && typeof arguments[6] !== \"boolean\") {\n        throw new $TypeError(\"`loose`, if provided, must be a boolean\");\n      }\n      var nonEnumerable = arguments.length > 3 ? arguments[3] : null;\n      var nonWritable = arguments.length > 4 ? arguments[4] : null;\n      var nonConfigurable = arguments.length > 5 ? arguments[5] : null;\n      var loose = arguments.length > 6 ? arguments[6] : false;\n      var desc = !!gopd && gopd(obj, property);\n      if ($defineProperty) {\n        $defineProperty(obj, property, {\n          configurable: nonConfigurable === null && desc ? desc.configurable : !nonConfigurable,\n          enumerable: nonEnumerable === null && desc ? desc.enumerable : !nonEnumerable,\n          value,\n          writable: nonWritable === null && desc ? desc.writable : !nonWritable\n        });\n      } else if (loose || !nonEnumerable && !nonWritable && !nonConfigurable) {\n        obj[property] = value;\n      } else {\n        throw new $SyntaxError(\"This environment does not support defining a property as non-configurable, non-writable, or non-enumerable.\");\n      }\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/has-property-descriptors@1.0.2/node_modules/has-property-descriptors/index.js\nvar require_has_property_descriptors = __commonJS({\n  \"../../node_modules/.pnpm/has-property-descriptors@1.0.2/node_modules/has-property-descriptors/index.js\"(exports2, module2) {\n    \"use strict\";\n    var $defineProperty = require_es_define_property();\n    var hasPropertyDescriptors = function hasPropertyDescriptors2() {\n      return !!$defineProperty;\n    };\n    hasPropertyDescriptors.hasArrayLengthDefineBug = function hasArrayLengthDefineBug() {\n      if (!$defineProperty) {\n        return null;\n      }\n      try {\n        return $defineProperty([], \"length\", { value: 1 }).length !== 1;\n      } catch (e) {\n        return true;\n      }\n    };\n    module2.exports = hasPropertyDescriptors;\n  }\n});\n\n// ../../node_modules/.pnpm/set-function-length@1.2.2/node_modules/set-function-length/index.js\nvar require_set_function_length = __commonJS({\n  \"../../node_modules/.pnpm/set-function-length@1.2.2/node_modules/set-function-length/index.js\"(exports2, module2) {\n    \"use strict\";\n    var GetIntrinsic = require_get_intrinsic();\n    var define = require_define_data_property();\n    var hasDescriptors = require_has_property_descriptors()();\n    var gOPD = require_gopd();\n    var $TypeError = require_type();\n    var $floor = GetIntrinsic(\"%Math.floor%\");\n    module2.exports = function setFunctionLength(fn, length) {\n      if (typeof fn !== \"function\") {\n        throw new $TypeError(\"`fn` is not a function\");\n      }\n      if (typeof length !== \"number\" || length < 0 || length > 4294967295 || $floor(length) !== length) {\n        throw new $TypeError(\"`length` must be a positive 32-bit integer\");\n      }\n      var loose = arguments.length > 2 && !!arguments[2];\n      var functionLengthIsConfigurable = true;\n      var functionLengthIsWritable = true;\n      if (\"length\" in fn && gOPD) {\n        var desc = gOPD(fn, \"length\");\n        if (desc && !desc.configurable) {\n          functionLengthIsConfigurable = false;\n        }\n        if (desc && !desc.writable) {\n          functionLengthIsWritable = false;\n        }\n      }\n      if (functionLengthIsConfigurable || functionLengthIsWritable || !loose) {\n        if (hasDescriptors) {\n          define(\n            /** @type {Parameters<define>[0]} */\n            fn,\n            \"length\",\n            length,\n            true,\n            true\n          );\n        } else {\n          define(\n            /** @type {Parameters<define>[0]} */\n            fn,\n            \"length\",\n            length\n          );\n        }\n      }\n      return fn;\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/applyBind.js\nvar require_applyBind = __commonJS({\n  \"../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/applyBind.js\"(exports2, module2) {\n    \"use strict\";\n    var bind = require_function_bind();\n    var $apply = require_functionApply();\n    var actualApply = require_actualApply();\n    module2.exports = function applyBind() {\n      return actualApply(bind, $apply, arguments);\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/call-bind@1.0.9/node_modules/call-bind/index.js\nvar require_call_bind = __commonJS({\n  \"../../node_modules/.pnpm/call-bind@1.0.9/node_modules/call-bind/index.js\"(exports2, module2) {\n    \"use strict\";\n    var setFunctionLength = require_set_function_length();\n    var $defineProperty = require_es_define_property();\n    var callBindBasic = require_call_bind_apply_helpers();\n    var applyBind = require_applyBind();\n    module2.exports = function callBind(originalFunction) {\n      var func = callBindBasic(arguments);\n      var adjustedLength = 1 + originalFunction.length - (arguments.length - 1);\n      return setFunctionLength(\n        func,\n        adjustedLength > 0 ? adjustedLength : 0,\n        true\n      );\n    };\n    if ($defineProperty) {\n      $defineProperty(module2.exports, \"apply\", { value: applyBind });\n    } else {\n      module2.exports.apply = applyBind;\n    }\n  }\n});\n\n// ../../node_modules/.pnpm/which-typed-array@1.1.22/node_modules/which-typed-array/index.js\nvar require_which_typed_array = __commonJS({\n  \"../../node_modules/.pnpm/which-typed-array@1.1.22/node_modules/which-typed-array/index.js\"(exports2, module2) {\n    \"use strict\";\n    var forEach = require_for_each();\n    var availableTypedArrays = require_available_typed_arrays();\n    var callBind = require_call_bind();\n    var callBound = require_call_bound();\n    var gOPD = require_gopd();\n    var getProto = require_get_proto();\n    var $toString = callBound(\"Object.prototype.toString\");\n    var hasToStringTag = require_shams2()();\n    var g = typeof globalThis === \"undefined\" ? global : globalThis;\n    var typedArrays = availableTypedArrays();\n    var $slice = callBound(\"String.prototype.slice\");\n    var $indexOf = callBound(\"Array.prototype.indexOf\", true) || function indexOf(array, value) {\n      for (var i = 0; i < array.length; i += 1) {\n        if (array[i] === value) {\n          return i;\n        }\n      }\n      return -1;\n    };\n    var cache = { __proto__: null };\n    if (hasToStringTag && gOPD && getProto) {\n      forEach(typedArrays, function(typedArray) {\n        var arr = new g[typedArray]();\n        if (Symbol.toStringTag in arr && getProto) {\n          var proto = getProto(arr);\n          var descriptor = gOPD(proto, Symbol.toStringTag);\n          if (!descriptor && proto) {\n            var superProto = getProto(proto);\n            descriptor = gOPD(superProto, Symbol.toStringTag);\n          }\n          if (descriptor && descriptor.get) {\n            var bound = callBind(descriptor.get);\n            cache[\n              /** @type {`$${TypedArrayName}`} */\n              \"$\" + typedArray\n            ] = bound;\n          }\n        }\n      });\n    } else {\n      forEach(typedArrays, function(typedArray) {\n        var arr = new g[typedArray]();\n        var fn = arr.slice || arr.set;\n        if (fn) {\n          var bound = (\n            /** @type {BoundSlice | BoundSet} */\n            // @ts-expect-error TODO FIXME\n            callBind(fn)\n          );\n          cache[\n            /** @type {`$${TypedArrayName}`} */\n            \"$\" + typedArray\n          ] = bound;\n        }\n      });\n    }\n    function tryTypedArrays(value) {\n      var found = false;\n      forEach(\n        /** @type {Record<`$${TypedArrayName}`, Getter>} */\n        cache,\n        /** @param {Getter} getter @param {`$${TypedArrayName}`} typedArray */\n        function(getter, typedArray) {\n          if (!found) {\n            try {\n              if (\"$\" + getter(value) === typedArray) {\n                found = /** @type {TypedArrayName} */\n                $slice(typedArray, 1);\n              }\n            } catch (e) {\n            }\n          }\n        }\n      );\n      return found;\n    }\n    function trySlices(value) {\n      var found = false;\n      forEach(\n        /** @type {Record<`$${TypedArrayName}`, Getter>} */\n        cache,\n        /** @param {Getter} getter @param {`$${TypedArrayName}`} name */\n        function(getter, name) {\n          if (!found) {\n            try {\n              getter(value);\n              found = /** @type {TypedArrayName} */\n              $slice(name, 1);\n            } catch (e) {\n            }\n          }\n        }\n      );\n      return found;\n    }\n    function isTATag(tag) {\n      return $indexOf(typedArrays, tag) > -1;\n    }\n    module2.exports = function whichTypedArray(value) {\n      if (!value || typeof value !== \"object\") {\n        return false;\n      }\n      if (!hasToStringTag) {\n        var tag = $slice($toString(value), 8, -1);\n        if (isTATag(tag)) {\n          return tag;\n        }\n        if (tag !== \"Object\") {\n          return false;\n        }\n        return trySlices(value);\n      }\n      if (!gOPD) {\n        return null;\n      }\n      return tryTypedArrays(value);\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/is-typed-array@1.1.15/node_modules/is-typed-array/index.js\nvar require_is_typed_array = __commonJS({\n  \"../../node_modules/.pnpm/is-typed-array@1.1.15/node_modules/is-typed-array/index.js\"(exports2, module2) {\n    \"use strict\";\n    var whichTypedArray = require_which_typed_array();\n    module2.exports = function isTypedArray(value) {\n      return !!whichTypedArray(value);\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/util@0.12.5/node_modules/util/support/types.js\nvar require_types = __commonJS({\n  \"../../node_modules/.pnpm/util@0.12.5/node_modules/util/support/types.js\"(exports2) {\n    \"use strict\";\n    var isArgumentsObject = require_is_arguments();\n    var isGeneratorFunction = require_is_generator_function();\n    var whichTypedArray = require_which_typed_array();\n    var isTypedArray = require_is_typed_array();\n    function uncurryThis(f) {\n      return f.call.bind(f);\n    }\n    var BigIntSupported = typeof BigInt !== \"undefined\";\n    var SymbolSupported = typeof Symbol !== \"undefined\";\n    var ObjectToString = uncurryThis(Object.prototype.toString);\n    var numberValue = uncurryThis(Number.prototype.valueOf);\n    var stringValue = uncurryThis(String.prototype.valueOf);\n    var booleanValue = uncurryThis(Boolean.prototype.valueOf);\n    if (BigIntSupported) {\n      bigIntValue = uncurryThis(BigInt.prototype.valueOf);\n    }\n    var bigIntValue;\n    if (SymbolSupported) {\n      symbolValue = uncurryThis(Symbol.prototype.valueOf);\n    }\n    var symbolValue;\n    function checkBoxedPrimitive(value, prototypeValueOf) {\n      if (typeof value !== \"object\") {\n        return false;\n      }\n      try {\n        prototypeValueOf(value);\n        return true;\n      } catch (e) {\n        return false;\n      }\n    }\n    exports2.isArgumentsObject = isArgumentsObject;\n    exports2.isGeneratorFunction = isGeneratorFunction;\n    exports2.isTypedArray = isTypedArray;\n    function isPromise(input) {\n      return typeof Promise !== \"undefined\" && input instanceof Promise || input !== null && typeof input === \"object\" && typeof input.then === \"function\" && typeof input.catch === \"function\";\n    }\n    exports2.isPromise = isPromise;\n    function isArrayBufferView(value) {\n      if (typeof ArrayBuffer !== \"undefined\" && ArrayBuffer.isView) {\n        return ArrayBuffer.isView(value);\n      }\n      return isTypedArray(value) || isDataView(value);\n    }\n    exports2.isArrayBufferView = isArrayBufferView;\n    function isUint8Array(value) {\n      return whichTypedArray(value) === \"Uint8Array\";\n    }\n    exports2.isUint8Array = isUint8Array;\n    function isUint8ClampedArray(value) {\n      return whichTypedArray(value) === \"Uint8ClampedArray\";\n    }\n    exports2.isUint8ClampedArray = isUint8ClampedArray;\n    function isUint16Array(value) {\n      return whichTypedArray(value) === \"Uint16Array\";\n    }\n    exports2.isUint16Array = isUint16Array;\n    function isUint32Array(value) {\n      return whichTypedArray(value) === \"Uint32Array\";\n    }\n    exports2.isUint32Array = isUint32Array;\n    function isInt8Array(value) {\n      return whichTypedArray(value) === \"Int8Array\";\n    }\n    exports2.isInt8Array = isInt8Array;\n    function isInt16Array(value) {\n      return whichTypedArray(value) === \"Int16Array\";\n    }\n    exports2.isInt16Array = isInt16Array;\n    function isInt32Array(value) {\n      return whichTypedArray(value) === \"Int32Array\";\n    }\n    exports2.isInt32Array = isInt32Array;\n    function isFloat32Array(value) {\n      return whichTypedArray(value) === \"Float32Array\";\n    }\n    exports2.isFloat32Array = isFloat32Array;\n    function isFloat64Array(value) {\n      return whichTypedArray(value) === \"Float64Array\";\n    }\n    exports2.isFloat64Array = isFloat64Array;\n    function isBigInt64Array(value) {\n      return whichTypedArray(value) === \"BigInt64Array\";\n    }\n    exports2.isBigInt64Array = isBigInt64Array;\n    function isBigUint64Array(value) {\n      return whichTypedArray(value) === \"BigUint64Array\";\n    }\n    exports2.isBigUint64Array = isBigUint64Array;\n    function isMapToString(value) {\n      return ObjectToString(value) === \"[object Map]\";\n    }\n    isMapToString.working = typeof Map !== \"undefined\" && isMapToString(/* @__PURE__ */ new Map());\n    function isMap(value) {\n      if (typeof Map === \"undefined\") {\n        return false;\n      }\n      return isMapToString.working ? isMapToString(value) : value instanceof Map;\n    }\n    exports2.isMap = isMap;\n    function isSetToString(value) {\n      return ObjectToString(value) === \"[object Set]\";\n    }\n    isSetToString.working = typeof Set !== \"undefined\" && isSetToString(/* @__PURE__ */ new Set());\n    function isSet(value) {\n      if (typeof Set === \"undefined\") {\n        return false;\n      }\n      return isSetToString.working ? isSetToString(value) : value instanceof Set;\n    }\n    exports2.isSet = isSet;\n    function isWeakMapToString(value) {\n      return ObjectToString(value) === \"[object WeakMap]\";\n    }\n    isWeakMapToString.working = typeof WeakMap !== \"undefined\" && isWeakMapToString(/* @__PURE__ */ new WeakMap());\n    function isWeakMap(value) {\n      if (typeof WeakMap === \"undefined\") {\n        return false;\n      }\n      return isWeakMapToString.working ? isWeakMapToString(value) : value instanceof WeakMap;\n    }\n    exports2.isWeakMap = isWeakMap;\n    function isWeakSetToString(value) {\n      return ObjectToString(value) === \"[object WeakSet]\";\n    }\n    isWeakSetToString.working = typeof WeakSet !== \"undefined\" && isWeakSetToString(/* @__PURE__ */ new WeakSet());\n    function isWeakSet(value) {\n      return isWeakSetToString(value);\n    }\n    exports2.isWeakSet = isWeakSet;\n    function isArrayBufferToString(value) {\n      return ObjectToString(value) === \"[object ArrayBuffer]\";\n    }\n    isArrayBufferToString.working = typeof ArrayBuffer !== \"undefined\" && isArrayBufferToString(new ArrayBuffer());\n    function isArrayBuffer(value) {\n      if (typeof ArrayBuffer === \"undefined\") {\n        return false;\n      }\n      return isArrayBufferToString.working ? isArrayBufferToString(value) : value instanceof ArrayBuffer;\n    }\n    exports2.isArrayBuffer = isArrayBuffer;\n    function isDataViewToString(value) {\n      return ObjectToString(value) === \"[object DataView]\";\n    }\n    isDataViewToString.working = typeof ArrayBuffer !== \"undefined\" && typeof DataView !== \"undefined\" && isDataViewToString(new DataView(new ArrayBuffer(1), 0, 1));\n    function isDataView(value) {\n      if (typeof DataView === \"undefined\") {\n        return false;\n      }\n      return isDataViewToString.working ? isDataViewToString(value) : value instanceof DataView;\n    }\n    exports2.isDataView = isDataView;\n    var SharedArrayBufferCopy = typeof SharedArrayBuffer !== \"undefined\" ? SharedArrayBuffer : void 0;\n    function isSharedArrayBufferToString(value) {\n      return ObjectToString(value) === \"[object SharedArrayBuffer]\";\n    }\n    function isSharedArrayBuffer(value) {\n      if (typeof SharedArrayBufferCopy === \"undefined\") {\n        return false;\n      }\n      if (typeof isSharedArrayBufferToString.working === \"undefined\") {\n        isSharedArrayBufferToString.working = isSharedArrayBufferToString(new SharedArrayBufferCopy());\n      }\n      return isSharedArrayBufferToString.working ? isSharedArrayBufferToString(value) : value instanceof SharedArrayBufferCopy;\n    }\n    exports2.isSharedArrayBuffer = isSharedArrayBuffer;\n    function isAsyncFunction(value) {\n      return ObjectToString(value) === \"[object AsyncFunction]\";\n    }\n    exports2.isAsyncFunction = isAsyncFunction;\n    function isMapIterator(value) {\n      return ObjectToString(value) === \"[object Map Iterator]\";\n    }\n    exports2.isMapIterator = isMapIterator;\n    function isSetIterator(value) {\n      return ObjectToString(value) === \"[object Set Iterator]\";\n    }\n    exports2.isSetIterator = isSetIterator;\n    function isGeneratorObject(value) {\n      return ObjectToString(value) === \"[object Generator]\";\n    }\n    exports2.isGeneratorObject = isGeneratorObject;\n    function isWebAssemblyCompiledModule(value) {\n      return ObjectToString(value) === \"[object WebAssembly.Module]\";\n    }\n    exports2.isWebAssemblyCompiledModule = isWebAssemblyCompiledModule;\n    function isNumberObject(value) {\n      return checkBoxedPrimitive(value, numberValue);\n    }\n    exports2.isNumberObject = isNumberObject;\n    function isStringObject(value) {\n      return checkBoxedPrimitive(value, stringValue);\n    }\n    exports2.isStringObject = isStringObject;\n    function isBooleanObject(value) {\n      return checkBoxedPrimitive(value, booleanValue);\n    }\n    exports2.isBooleanObject = isBooleanObject;\n    function isBigIntObject(value) {\n      return BigIntSupported && checkBoxedPrimitive(value, bigIntValue);\n    }\n    exports2.isBigIntObject = isBigIntObject;\n    function isSymbolObject(value) {\n      return SymbolSupported && checkBoxedPrimitive(value, symbolValue);\n    }\n    exports2.isSymbolObject = isSymbolObject;\n    function isBoxedPrimitive(value) {\n      return isNumberObject(value) || isStringObject(value) || isBooleanObject(value) || isBigIntObject(value) || isSymbolObject(value);\n    }\n    exports2.isBoxedPrimitive = isBoxedPrimitive;\n    function isAnyArrayBuffer(value) {\n      return typeof Uint8Array !== \"undefined\" && (isArrayBuffer(value) || isSharedArrayBuffer(value));\n    }\n    exports2.isAnyArrayBuffer = isAnyArrayBuffer;\n    [\"isProxy\", \"isExternal\", \"isModuleNamespaceObject\"].forEach(function(method) {\n      Object.defineProperty(exports2, method, {\n        enumerable: false,\n        value: function() {\n          throw new Error(method + \" is not supported in userland\");\n        }\n      });\n    });\n  }\n});\n\n// ../../node_modules/.pnpm/util@0.12.5/node_modules/util/support/isBufferBrowser.js\nvar require_isBufferBrowser = __commonJS({\n  \"../../node_modules/.pnpm/util@0.12.5/node_modules/util/support/isBufferBrowser.js\"(exports2, module2) {\n    module2.exports = function isBuffer(arg) {\n      return arg && typeof arg === \"object\" && typeof arg.copy === \"function\" && typeof arg.fill === \"function\" && typeof arg.readUInt8 === \"function\";\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits_browser.js\nvar require_inherits_browser = __commonJS({\n  \"../../node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits_browser.js\"(exports2, module2) {\n    if (typeof Object.create === \"function\") {\n      module2.exports = function inherits(ctor, superCtor) {\n        if (superCtor) {\n          ctor.super_ = superCtor;\n          ctor.prototype = Object.create(superCtor.prototype, {\n            constructor: {\n              value: ctor,\n              enumerable: false,\n              writable: true,\n              configurable: true\n            }\n          });\n        }\n      };\n    } else {\n      module2.exports = function inherits(ctor, superCtor) {\n        if (superCtor) {\n          ctor.super_ = superCtor;\n          var TempCtor = function() {\n          };\n          TempCtor.prototype = superCtor.prototype;\n          ctor.prototype = new TempCtor();\n          ctor.prototype.constructor = ctor;\n        }\n      };\n    }\n  }\n});\n\n// ../../node_modules/.pnpm/util@0.12.5/node_modules/util/util.js\nvar require_util = __commonJS({\n  \"../../node_modules/.pnpm/util@0.12.5/node_modules/util/util.js\"(exports2) {\n    var getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors || function getOwnPropertyDescriptors2(obj) {\n      var keys = Object.keys(obj);\n      var descriptors = {};\n      for (var i = 0; i < keys.length; i++) {\n        descriptors[keys[i]] = Object.getOwnPropertyDescriptor(obj, keys[i]);\n      }\n      return descriptors;\n    };\n    var formatRegExp = /%[sdj%]/g;\n    exports2.format = function(f) {\n      if (!isString(f)) {\n        var objects = [];\n        for (var i = 0; i < arguments.length; i++) {\n          objects.push(inspect(arguments[i]));\n        }\n        return objects.join(\" \");\n      }\n      var i = 1;\n      var args = arguments;\n      var len = args.length;\n      var str = String(f).replace(formatRegExp, function(x2) {\n        if (x2 === \"%%\") return \"%\";\n        if (i >= len) return x2;\n        switch (x2) {\n          case \"%s\":\n            return String(args[i++]);\n          case \"%d\":\n            return Number(args[i++]);\n          case \"%j\":\n            try {\n              return JSON.stringify(args[i++]);\n            } catch (_) {\n              return \"[Circular]\";\n            }\n          default:\n            return x2;\n        }\n      });\n      for (var x = args[i]; i < len; x = args[++i]) {\n        if (isNull(x) || !isObject(x)) {\n          str += \" \" + x;\n        } else {\n          str += \" \" + inspect(x);\n        }\n      }\n      return str;\n    };\n    exports2.deprecate = function(fn, msg) {\n      if (typeof process !== \"undefined\" && process.noDeprecation === true) {\n        return fn;\n      }\n      if (typeof process === \"undefined\") {\n        return function() {\n          return exports2.deprecate(fn, msg).apply(this, arguments);\n        };\n      }\n      var warned = false;\n      function deprecated() {\n        if (!warned) {\n          if (process.throwDeprecation) {\n            throw new Error(msg);\n          } else if (process.traceDeprecation) {\n            console.trace(msg);\n          } else {\n            console.error(msg);\n          }\n          warned = true;\n        }\n        return fn.apply(this, arguments);\n      }\n      return deprecated;\n    };\n    var debugs = {};\n    var debugEnvRegex = /^$/;\n    if (process.env.NODE_DEBUG) {\n      debugEnv = process.env.NODE_DEBUG;\n      debugEnv = debugEnv.replace(/[|\\\\{}()[\\]^$+?.]/g, \"\\\\$&\").replace(/\\*/g, \".*\").replace(/,/g, \"$|^\").toUpperCase();\n      debugEnvRegex = new RegExp(\"^\" + debugEnv + \"$\", \"i\");\n    }\n    var debugEnv;\n    exports2.debuglog = function(set) {\n      set = set.toUpperCase();\n      if (!debugs[set]) {\n        if (debugEnvRegex.test(set)) {\n          var pid = process.pid;\n          debugs[set] = function() {\n            var msg = exports2.format.apply(exports2, arguments);\n            console.error(\"%s %d: %s\", set, pid, msg);\n          };\n        } else {\n          debugs[set] = function() {\n          };\n        }\n      }\n      return debugs[set];\n    };\n    function inspect(obj, opts) {\n      var ctx = {\n        seen: [],\n        stylize: stylizeNoColor\n      };\n      if (arguments.length >= 3) ctx.depth = arguments[2];\n      if (arguments.length >= 4) ctx.colors = arguments[3];\n      if (isBoolean(opts)) {\n        ctx.showHidden = opts;\n      } else if (opts) {\n        exports2._extend(ctx, opts);\n      }\n      if (isUndefined(ctx.showHidden)) ctx.showHidden = false;\n      if (isUndefined(ctx.depth)) ctx.depth = 2;\n      if (isUndefined(ctx.colors)) ctx.colors = false;\n      if (isUndefined(ctx.customInspect)) ctx.customInspect = true;\n      if (ctx.colors) ctx.stylize = stylizeWithColor;\n      return formatValue(ctx, obj, ctx.depth);\n    }\n    exports2.inspect = inspect;\n    inspect.colors = {\n      \"bold\": [1, 22],\n      \"italic\": [3, 23],\n      \"underline\": [4, 24],\n      \"inverse\": [7, 27],\n      \"white\": [37, 39],\n      \"grey\": [90, 39],\n      \"black\": [30, 39],\n      \"blue\": [34, 39],\n      \"cyan\": [36, 39],\n      \"green\": [32, 39],\n      \"magenta\": [35, 39],\n      \"red\": [31, 39],\n      \"yellow\": [33, 39]\n    };\n    inspect.styles = {\n      \"special\": \"cyan\",\n      \"number\": \"yellow\",\n      \"boolean\": \"yellow\",\n      \"undefined\": \"grey\",\n      \"null\": \"bold\",\n      \"string\": \"green\",\n      \"date\": \"magenta\",\n      // \"name\": intentionally not styling\n      \"regexp\": \"red\"\n    };\n    function stylizeWithColor(str, styleType) {\n      var style = inspect.styles[styleType];\n      if (style) {\n        return \"\\x1B[\" + inspect.colors[style][0] + \"m\" + str + \"\\x1B[\" + inspect.colors[style][1] + \"m\";\n      } else {\n        return str;\n      }\n    }\n    function stylizeNoColor(str, styleType) {\n      return str;\n    }\n    function arrayToHash(array) {\n      var hash = {};\n      array.forEach(function(val, idx) {\n        hash[val] = true;\n      });\n      return hash;\n    }\n    function formatValue(ctx, value, recurseTimes) {\n      if (ctx.customInspect && value && isFunction(value.inspect) && // Filter out the util module, it's inspect function is special\n      value.inspect !== exports2.inspect && // Also filter out any prototype objects using the circular check.\n      !(value.constructor && value.constructor.prototype === value)) {\n        var ret = value.inspect(recurseTimes, ctx);\n        if (!isString(ret)) {\n          ret = formatValue(ctx, ret, recurseTimes);\n        }\n        return ret;\n      }\n      var primitive = formatPrimitive(ctx, value);\n      if (primitive) {\n        return primitive;\n      }\n      var keys = Object.keys(value);\n      var visibleKeys = arrayToHash(keys);\n      if (ctx.showHidden) {\n        keys = Object.getOwnPropertyNames(value);\n      }\n      if (isError(value) && (keys.indexOf(\"message\") >= 0 || keys.indexOf(\"description\") >= 0)) {\n        return formatError(value);\n      }\n      if (keys.length === 0) {\n        if (isFunction(value)) {\n          var name = value.name ? \": \" + value.name : \"\";\n          return ctx.stylize(\"[Function\" + name + \"]\", \"special\");\n        }\n        if (isRegExp(value)) {\n          return ctx.stylize(RegExp.prototype.toString.call(value), \"regexp\");\n        }\n        if (isDate(value)) {\n          return ctx.stylize(Date.prototype.toString.call(value), \"date\");\n        }\n        if (isError(value)) {\n          return formatError(value);\n        }\n      }\n      var base = \"\", array = false, braces = [\"{\", \"}\"];\n      if (isArray(value)) {\n        array = true;\n        braces = [\"[\", \"]\"];\n      }\n      if (isFunction(value)) {\n        var n = value.name ? \": \" + value.name : \"\";\n        base = \" [Function\" + n + \"]\";\n      }\n      if (isRegExp(value)) {\n        base = \" \" + RegExp.prototype.toString.call(value);\n      }\n      if (isDate(value)) {\n        base = \" \" + Date.prototype.toUTCString.call(value);\n      }\n      if (isError(value)) {\n        base = \" \" + formatError(value);\n      }\n      if (keys.length === 0 && (!array || value.length == 0)) {\n        return braces[0] + base + braces[1];\n      }\n      if (recurseTimes < 0) {\n        if (isRegExp(value)) {\n          return ctx.stylize(RegExp.prototype.toString.call(value), \"regexp\");\n        } else {\n          return ctx.stylize(\"[Object]\", \"special\");\n        }\n      }\n      ctx.seen.push(value);\n      var output;\n      if (array) {\n        output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);\n      } else {\n        output = keys.map(function(key) {\n          return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);\n        });\n      }\n      ctx.seen.pop();\n      return reduceToSingleString(output, base, braces);\n    }\n    function formatPrimitive(ctx, value) {\n      if (isUndefined(value))\n        return ctx.stylize(\"undefined\", \"undefined\");\n      if (isString(value)) {\n        var simple = \"'\" + JSON.stringify(value).replace(/^\"|\"$/g, \"\").replace(/'/g, \"\\\\'\").replace(/\\\\\"/g, '\"') + \"'\";\n        return ctx.stylize(simple, \"string\");\n      }\n      if (isNumber(value))\n        return ctx.stylize(\"\" + value, \"number\");\n      if (isBoolean(value))\n        return ctx.stylize(\"\" + value, \"boolean\");\n      if (isNull(value))\n        return ctx.stylize(\"null\", \"null\");\n    }\n    function formatError(value) {\n      return \"[\" + Error.prototype.toString.call(value) + \"]\";\n    }\n    function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {\n      var output = [];\n      for (var i = 0, l = value.length; i < l; ++i) {\n        if (hasOwnProperty(value, String(i))) {\n          output.push(formatProperty(\n            ctx,\n            value,\n            recurseTimes,\n            visibleKeys,\n            String(i),\n            true\n          ));\n        } else {\n          output.push(\"\");\n        }\n      }\n      keys.forEach(function(key) {\n        if (!key.match(/^\\d+$/)) {\n          output.push(formatProperty(\n            ctx,\n            value,\n            recurseTimes,\n            visibleKeys,\n            key,\n            true\n          ));\n        }\n      });\n      return output;\n    }\n    function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {\n      var name, str, desc;\n      desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };\n      if (desc.get) {\n        if (desc.set) {\n          str = ctx.stylize(\"[Getter/Setter]\", \"special\");\n        } else {\n          str = ctx.stylize(\"[Getter]\", \"special\");\n        }\n      } else {\n        if (desc.set) {\n          str = ctx.stylize(\"[Setter]\", \"special\");\n        }\n      }\n      if (!hasOwnProperty(visibleKeys, key)) {\n        name = \"[\" + key + \"]\";\n      }\n      if (!str) {\n        if (ctx.seen.indexOf(desc.value) < 0) {\n          if (isNull(recurseTimes)) {\n            str = formatValue(ctx, desc.value, null);\n          } else {\n            str = formatValue(ctx, desc.value, recurseTimes - 1);\n          }\n          if (str.indexOf(\"\\n\") > -1) {\n            if (array) {\n              str = str.split(\"\\n\").map(function(line) {\n                return \"  \" + line;\n              }).join(\"\\n\").slice(2);\n            } else {\n              str = \"\\n\" + str.split(\"\\n\").map(function(line) {\n                return \"   \" + line;\n              }).join(\"\\n\");\n            }\n          }\n        } else {\n          str = ctx.stylize(\"[Circular]\", \"special\");\n        }\n      }\n      if (isUndefined(name)) {\n        if (array && key.match(/^\\d+$/)) {\n          return str;\n        }\n        name = JSON.stringify(\"\" + key);\n        if (name.match(/^\"([a-zA-Z_][a-zA-Z_0-9]*)\"$/)) {\n          name = name.slice(1, -1);\n          name = ctx.stylize(name, \"name\");\n        } else {\n          name = name.replace(/'/g, \"\\\\'\").replace(/\\\\\"/g, '\"').replace(/(^\"|\"$)/g, \"'\");\n          name = ctx.stylize(name, \"string\");\n        }\n      }\n      return name + \": \" + str;\n    }\n    function reduceToSingleString(output, base, braces) {\n      var numLinesEst = 0;\n      var length = output.reduce(function(prev, cur) {\n        numLinesEst++;\n        if (cur.indexOf(\"\\n\") >= 0) numLinesEst++;\n        return prev + cur.replace(/\\u001b\\[\\d\\d?m/g, \"\").length + 1;\n      }, 0);\n      if (length > 60) {\n        return braces[0] + (base === \"\" ? \"\" : base + \"\\n \") + \" \" + output.join(\",\\n  \") + \" \" + braces[1];\n      }\n      return braces[0] + base + \" \" + output.join(\", \") + \" \" + braces[1];\n    }\n    exports2.types = require_types();\n    function isArray(ar) {\n      return Array.isArray(ar);\n    }\n    exports2.isArray = isArray;\n    function isBoolean(arg) {\n      return typeof arg === \"boolean\";\n    }\n    exports2.isBoolean = isBoolean;\n    function isNull(arg) {\n      return arg === null;\n    }\n    exports2.isNull = isNull;\n    function isNullOrUndefined(arg) {\n      return arg == null;\n    }\n    exports2.isNullOrUndefined = isNullOrUndefined;\n    function isNumber(arg) {\n      return typeof arg === \"number\";\n    }\n    exports2.isNumber = isNumber;\n    function isString(arg) {\n      return typeof arg === \"string\";\n    }\n    exports2.isString = isString;\n    function isSymbol(arg) {\n      return typeof arg === \"symbol\";\n    }\n    exports2.isSymbol = isSymbol;\n    function isUndefined(arg) {\n      return arg === void 0;\n    }\n    exports2.isUndefined = isUndefined;\n    function isRegExp(re) {\n      return isObject(re) && objectToString(re) === \"[object RegExp]\";\n    }\n    exports2.isRegExp = isRegExp;\n    exports2.types.isRegExp = isRegExp;\n    function isObject(arg) {\n      return typeof arg === \"object\" && arg !== null;\n    }\n    exports2.isObject = isObject;\n    function isDate(d) {\n      return isObject(d) && objectToString(d) === \"[object Date]\";\n    }\n    exports2.isDate = isDate;\n    exports2.types.isDate = isDate;\n    function isError(e) {\n      return isObject(e) && (objectToString(e) === \"[object Error]\" || e instanceof Error);\n    }\n    exports2.isError = isError;\n    exports2.types.isNativeError = isError;\n    function isFunction(arg) {\n      return typeof arg === \"function\";\n    }\n    exports2.isFunction = isFunction;\n    function isPrimitive(arg) {\n      return arg === null || typeof arg === \"boolean\" || typeof arg === \"number\" || typeof arg === \"string\" || typeof arg === \"symbol\" || // ES6 symbol\n      typeof arg === \"undefined\";\n    }\n    exports2.isPrimitive = isPrimitive;\n    exports2.isBuffer = require_isBufferBrowser();\n    function objectToString(o) {\n      return Object.prototype.toString.call(o);\n    }\n    function pad(n) {\n      return n < 10 ? \"0\" + n.toString(10) : n.toString(10);\n    }\n    var months = [\n      \"Jan\",\n      \"Feb\",\n      \"Mar\",\n      \"Apr\",\n      \"May\",\n      \"Jun\",\n      \"Jul\",\n      \"Aug\",\n      \"Sep\",\n      \"Oct\",\n      \"Nov\",\n      \"Dec\"\n    ];\n    function timestamp() {\n      var d = /* @__PURE__ */ new Date();\n      var time = [\n        pad(d.getHours()),\n        pad(d.getMinutes()),\n        pad(d.getSeconds())\n      ].join(\":\");\n      return [d.getDate(), months[d.getMonth()], time].join(\" \");\n    }\n    exports2.log = function() {\n      console.log(\"%s - %s\", timestamp(), exports2.format.apply(exports2, arguments));\n    };\n    exports2.inherits = require_inherits_browser();\n    exports2._extend = function(origin, add) {\n      if (!add || !isObject(add)) return origin;\n      var keys = Object.keys(add);\n      var i = keys.length;\n      while (i--) {\n        origin[keys[i]] = add[keys[i]];\n      }\n      return origin;\n    };\n    function hasOwnProperty(obj, prop) {\n      return Object.prototype.hasOwnProperty.call(obj, prop);\n    }\n    var kCustomPromisifiedSymbol = typeof Symbol !== \"undefined\" ? /* @__PURE__ */ Symbol(\"util.promisify.custom\") : void 0;\n    exports2.promisify = function promisify(original) {\n      if (typeof original !== \"function\")\n        throw new TypeError('The \"original\" argument must be of type Function');\n      if (kCustomPromisifiedSymbol && original[kCustomPromisifiedSymbol]) {\n        var fn = original[kCustomPromisifiedSymbol];\n        if (typeof fn !== \"function\") {\n          throw new TypeError('The \"util.promisify.custom\" argument must be of type Function');\n        }\n        Object.defineProperty(fn, kCustomPromisifiedSymbol, {\n          value: fn,\n          enumerable: false,\n          writable: false,\n          configurable: true\n        });\n        return fn;\n      }\n      function fn() {\n        var promiseResolve, promiseReject;\n        var promise = new Promise(function(resolve, reject) {\n          promiseResolve = resolve;\n          promiseReject = reject;\n        });\n        var args = [];\n        for (var i = 0; i < arguments.length; i++) {\n          args.push(arguments[i]);\n        }\n        args.push(function(err, value) {\n          if (err) {\n            promiseReject(err);\n          } else {\n            promiseResolve(value);\n          }\n        });\n        try {\n          original.apply(this, args);\n        } catch (err) {\n          promiseReject(err);\n        }\n        return promise;\n      }\n      Object.setPrototypeOf(fn, Object.getPrototypeOf(original));\n      if (kCustomPromisifiedSymbol) Object.defineProperty(fn, kCustomPromisifiedSymbol, {\n        value: fn,\n        enumerable: false,\n        writable: false,\n        configurable: true\n      });\n      return Object.defineProperties(\n        fn,\n        getOwnPropertyDescriptors(original)\n      );\n    };\n    exports2.promisify.custom = kCustomPromisifiedSymbol;\n    function callbackifyOnRejected(reason, cb) {\n      if (!reason) {\n        var newReason = new Error(\"Promise was rejected with a falsy value\");\n        newReason.reason = reason;\n        reason = newReason;\n      }\n      return cb(reason);\n    }\n    function callbackify(original) {\n      if (typeof original !== \"function\") {\n        throw new TypeError('The \"original\" argument must be of type Function');\n      }\n      function callbackified() {\n        var args = [];\n        for (var i = 0; i < arguments.length; i++) {\n          args.push(arguments[i]);\n        }\n        var maybeCb = args.pop();\n        if (typeof maybeCb !== \"function\") {\n          throw new TypeError(\"The last argument must be of type Function\");\n        }\n        var self = this;\n        var cb = function() {\n          return maybeCb.apply(self, arguments);\n        };\n        original.apply(this, args).then(\n          function(ret) {\n            process.nextTick(cb.bind(null, null, ret));\n          },\n          function(rej) {\n            process.nextTick(callbackifyOnRejected.bind(null, rej, cb));\n          }\n        );\n      }\n      Object.setPrototypeOf(callbackified, Object.getPrototypeOf(original));\n      Object.defineProperties(\n        callbackified,\n        getOwnPropertyDescriptors(original)\n      );\n      return callbackified;\n    }\n    exports2.callbackify = callbackify;\n  }\n});\n\n// ../../node_modules/.pnpm/assert@2.1.0/node_modules/assert/build/internal/errors.js\nvar require_errors = __commonJS({\n  \"../../node_modules/.pnpm/assert@2.1.0/node_modules/assert/build/internal/errors.js\"(exports2, module2) {\n    \"use strict\";\n    function _typeof(o) {\n      \"@babel/helpers - typeof\";\n      return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function(o2) {\n        return typeof o2;\n      } : function(o2) {\n        return o2 && \"function\" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? \"symbol\" : typeof o2;\n      }, _typeof(o);\n    }\n    function _defineProperties(target, props) {\n      for (var i = 0; i < props.length; i++) {\n        var descriptor = props[i];\n        descriptor.enumerable = descriptor.enumerable || false;\n        descriptor.configurable = true;\n        if (\"value\" in descriptor) descriptor.writable = true;\n        Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);\n      }\n    }\n    function _createClass(Constructor, protoProps, staticProps) {\n      if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n      if (staticProps) _defineProperties(Constructor, staticProps);\n      Object.defineProperty(Constructor, \"prototype\", { writable: false });\n      return Constructor;\n    }\n    function _toPropertyKey(arg) {\n      var key = _toPrimitive(arg, \"string\");\n      return _typeof(key) === \"symbol\" ? key : String(key);\n    }\n    function _toPrimitive(input, hint) {\n      if (_typeof(input) !== \"object\" || input === null) return input;\n      var prim = input[Symbol.toPrimitive];\n      if (prim !== void 0) {\n        var res = prim.call(input, hint || \"default\");\n        if (_typeof(res) !== \"object\") return res;\n        throw new TypeError(\"@@toPrimitive must return a primitive value.\");\n      }\n      return (hint === \"string\" ? String : Number)(input);\n    }\n    function _classCallCheck(instance, Constructor) {\n      if (!(instance instanceof Constructor)) {\n        throw new TypeError(\"Cannot call a class as a function\");\n      }\n    }\n    function _inherits(subClass, superClass) {\n      if (typeof superClass !== \"function\" && superClass !== null) {\n        throw new TypeError(\"Super expression must either be null or a function\");\n      }\n      subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } });\n      Object.defineProperty(subClass, \"prototype\", { writable: false });\n      if (superClass) _setPrototypeOf(subClass, superClass);\n    }\n    function _setPrototypeOf(o, p) {\n      _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf2(o2, p2) {\n        o2.__proto__ = p2;\n        return o2;\n      };\n      return _setPrototypeOf(o, p);\n    }\n    function _createSuper(Derived) {\n      var hasNativeReflectConstruct = _isNativeReflectConstruct();\n      return function _createSuperInternal() {\n        var Super = _getPrototypeOf(Derived), result;\n        if (hasNativeReflectConstruct) {\n          var NewTarget = _getPrototypeOf(this).constructor;\n          result = Reflect.construct(Super, arguments, NewTarget);\n        } else {\n          result = Super.apply(this, arguments);\n        }\n        return _possibleConstructorReturn(this, result);\n      };\n    }\n    function _possibleConstructorReturn(self, call) {\n      if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) {\n        return call;\n      } else if (call !== void 0) {\n        throw new TypeError(\"Derived constructors may only return object or undefined\");\n      }\n      return _assertThisInitialized(self);\n    }\n    function _assertThisInitialized(self) {\n      if (self === void 0) {\n        throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n      }\n      return self;\n    }\n    function _isNativeReflectConstruct() {\n      if (typeof Reflect === \"undefined\" || !Reflect.construct) return false;\n      if (Reflect.construct.sham) return false;\n      if (typeof Proxy === \"function\") return true;\n      try {\n        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {\n        }));\n        return true;\n      } catch (e) {\n        return false;\n      }\n    }\n    function _getPrototypeOf(o) {\n      _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf2(o2) {\n        return o2.__proto__ || Object.getPrototypeOf(o2);\n      };\n      return _getPrototypeOf(o);\n    }\n    var codes = {};\n    var assert;\n    var util;\n    function createErrorType(code, message, Base) {\n      if (!Base) {\n        Base = Error;\n      }\n      function getMessage(arg1, arg2, arg3) {\n        if (typeof message === \"string\") {\n          return message;\n        } else {\n          return message(arg1, arg2, arg3);\n        }\n      }\n      var NodeError = /* @__PURE__ */ (function(_Base) {\n        _inherits(NodeError2, _Base);\n        var _super = _createSuper(NodeError2);\n        function NodeError2(arg1, arg2, arg3) {\n          var _this;\n          _classCallCheck(this, NodeError2);\n          _this = _super.call(this, getMessage(arg1, arg2, arg3));\n          _this.code = code;\n          return _this;\n        }\n        return _createClass(NodeError2);\n      })(Base);\n      codes[code] = NodeError;\n    }\n    function oneOf(expected, thing) {\n      if (Array.isArray(expected)) {\n        var len = expected.length;\n        expected = expected.map(function(i) {\n          return String(i);\n        });\n        if (len > 2) {\n          return \"one of \".concat(thing, \" \").concat(expected.slice(0, len - 1).join(\", \"), \", or \") + expected[len - 1];\n        } else if (len === 2) {\n          return \"one of \".concat(thing, \" \").concat(expected[0], \" or \").concat(expected[1]);\n        } else {\n          return \"of \".concat(thing, \" \").concat(expected[0]);\n        }\n      } else {\n        return \"of \".concat(thing, \" \").concat(String(expected));\n      }\n    }\n    function startsWith(str, search, pos) {\n      return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;\n    }\n    function endsWith(str, search, this_len) {\n      if (this_len === void 0 || this_len > str.length) {\n        this_len = str.length;\n      }\n      return str.substring(this_len - search.length, this_len) === search;\n    }\n    function includes(str, search, start) {\n      if (typeof start !== \"number\") {\n        start = 0;\n      }\n      if (start + search.length > str.length) {\n        return false;\n      } else {\n        return str.indexOf(search, start) !== -1;\n      }\n    }\n    createErrorType(\"ERR_AMBIGUOUS_ARGUMENT\", 'The \"%s\" argument is ambiguous. %s', TypeError);\n    createErrorType(\"ERR_INVALID_ARG_TYPE\", function(name, expected, actual) {\n      if (assert === void 0) assert = require_assert();\n      assert(typeof name === \"string\", \"'name' must be a string\");\n      var determiner;\n      if (typeof expected === \"string\" && startsWith(expected, \"not \")) {\n        determiner = \"must not be\";\n        expected = expected.replace(/^not /, \"\");\n      } else {\n        determiner = \"must be\";\n      }\n      var msg;\n      if (endsWith(name, \" argument\")) {\n        msg = \"The \".concat(name, \" \").concat(determiner, \" \").concat(oneOf(expected, \"type\"));\n      } else {\n        var type = includes(name, \".\") ? \"property\" : \"argument\";\n        msg = 'The \"'.concat(name, '\" ').concat(type, \" \").concat(determiner, \" \").concat(oneOf(expected, \"type\"));\n      }\n      msg += \". Received type \".concat(_typeof(actual));\n      return msg;\n    }, TypeError);\n    createErrorType(\"ERR_INVALID_ARG_VALUE\", function(name, value) {\n      var reason = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : \"is invalid\";\n      if (util === void 0) util = require_util();\n      var inspected = util.inspect(value);\n      if (inspected.length > 128) {\n        inspected = \"\".concat(inspected.slice(0, 128), \"...\");\n      }\n      return \"The argument '\".concat(name, \"' \").concat(reason, \". Received \").concat(inspected);\n    }, TypeError, RangeError);\n    createErrorType(\"ERR_INVALID_RETURN_VALUE\", function(input, name, value) {\n      var type;\n      if (value && value.constructor && value.constructor.name) {\n        type = \"instance of \".concat(value.constructor.name);\n      } else {\n        type = \"type \".concat(_typeof(value));\n      }\n      return \"Expected \".concat(input, ' to be returned from the \"').concat(name, '\"') + \" function but got \".concat(type, \".\");\n    }, TypeError);\n    createErrorType(\"ERR_MISSING_ARGS\", function() {\n      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n        args[_key] = arguments[_key];\n      }\n      if (assert === void 0) assert = require_assert();\n      assert(args.length > 0, \"At least one arg needs to be specified\");\n      var msg = \"The \";\n      var len = args.length;\n      args = args.map(function(a) {\n        return '\"'.concat(a, '\"');\n      });\n      switch (len) {\n        case 1:\n          msg += \"\".concat(args[0], \" argument\");\n          break;\n        case 2:\n          msg += \"\".concat(args[0], \" and \").concat(args[1], \" arguments\");\n          break;\n        default:\n          msg += args.slice(0, len - 1).join(\", \");\n          msg += \", and \".concat(args[len - 1], \" arguments\");\n          break;\n      }\n      return \"\".concat(msg, \" must be specified\");\n    }, TypeError);\n    module2.exports.codes = codes;\n  }\n});\n\n// ../../node_modules/.pnpm/assert@2.1.0/node_modules/assert/build/internal/assert/assertion_error.js\nvar require_assertion_error = __commonJS({\n  \"../../node_modules/.pnpm/assert@2.1.0/node_modules/assert/build/internal/assert/assertion_error.js\"(exports2, module2) {\n    \"use strict\";\n    function ownKeys(e, r) {\n      var t = Object.keys(e);\n      if (Object.getOwnPropertySymbols) {\n        var o = Object.getOwnPropertySymbols(e);\n        r && (o = o.filter(function(r2) {\n          return Object.getOwnPropertyDescriptor(e, r2).enumerable;\n        })), t.push.apply(t, o);\n      }\n      return t;\n    }\n    function _objectSpread(e) {\n      for (var r = 1; r < arguments.length; r++) {\n        var t = null != arguments[r] ? arguments[r] : {};\n        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {\n          _defineProperty(e, r2, t[r2]);\n        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {\n          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));\n        });\n      }\n      return e;\n    }\n    function _defineProperty(obj, key, value) {\n      key = _toPropertyKey(key);\n      if (key in obj) {\n        Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });\n      } else {\n        obj[key] = value;\n      }\n      return obj;\n    }\n    function _classCallCheck(instance, Constructor) {\n      if (!(instance instanceof Constructor)) {\n        throw new TypeError(\"Cannot call a class as a function\");\n      }\n    }\n    function _defineProperties(target, props) {\n      for (var i = 0; i < props.length; i++) {\n        var descriptor = props[i];\n        descriptor.enumerable = descriptor.enumerable || false;\n        descriptor.configurable = true;\n        if (\"value\" in descriptor) descriptor.writable = true;\n        Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);\n      }\n    }\n    function _createClass(Constructor, protoProps, staticProps) {\n      if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n      if (staticProps) _defineProperties(Constructor, staticProps);\n      Object.defineProperty(Constructor, \"prototype\", { writable: false });\n      return Constructor;\n    }\n    function _toPropertyKey(arg) {\n      var key = _toPrimitive(arg, \"string\");\n      return _typeof(key) === \"symbol\" ? key : String(key);\n    }\n    function _toPrimitive(input, hint) {\n      if (_typeof(input) !== \"object\" || input === null) return input;\n      var prim = input[Symbol.toPrimitive];\n      if (prim !== void 0) {\n        var res = prim.call(input, hint || \"default\");\n        if (_typeof(res) !== \"object\") return res;\n        throw new TypeError(\"@@toPrimitive must return a primitive value.\");\n      }\n      return (hint === \"string\" ? String : Number)(input);\n    }\n    function _inherits(subClass, superClass) {\n      if (typeof superClass !== \"function\" && superClass !== null) {\n        throw new TypeError(\"Super expression must either be null or a function\");\n      }\n      subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } });\n      Object.defineProperty(subClass, \"prototype\", { writable: false });\n      if (superClass) _setPrototypeOf(subClass, superClass);\n    }\n    function _createSuper(Derived) {\n      var hasNativeReflectConstruct = _isNativeReflectConstruct();\n      return function _createSuperInternal() {\n        var Super = _getPrototypeOf(Derived), result;\n        if (hasNativeReflectConstruct) {\n          var NewTarget = _getPrototypeOf(this).constructor;\n          result = Reflect.construct(Super, arguments, NewTarget);\n        } else {\n          result = Super.apply(this, arguments);\n        }\n        return _possibleConstructorReturn(this, result);\n      };\n    }\n    function _possibleConstructorReturn(self, call) {\n      if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) {\n        return call;\n      } else if (call !== void 0) {\n        throw new TypeError(\"Derived constructors may only return object or undefined\");\n      }\n      return _assertThisInitialized(self);\n    }\n    function _assertThisInitialized(self) {\n      if (self === void 0) {\n        throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n      }\n      return self;\n    }\n    function _wrapNativeSuper(Class) {\n      var _cache = typeof Map === \"function\" ? /* @__PURE__ */ new Map() : void 0;\n      _wrapNativeSuper = function _wrapNativeSuper2(Class2) {\n        if (Class2 === null || !_isNativeFunction(Class2)) return Class2;\n        if (typeof Class2 !== \"function\") {\n          throw new TypeError(\"Super expression must either be null or a function\");\n        }\n        if (typeof _cache !== \"undefined\") {\n          if (_cache.has(Class2)) return _cache.get(Class2);\n          _cache.set(Class2, Wrapper);\n        }\n        function Wrapper() {\n          return _construct(Class2, arguments, _getPrototypeOf(this).constructor);\n        }\n        Wrapper.prototype = Object.create(Class2.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } });\n        return _setPrototypeOf(Wrapper, Class2);\n      };\n      return _wrapNativeSuper(Class);\n    }\n    function _construct(Parent, args, Class) {\n      if (_isNativeReflectConstruct()) {\n        _construct = Reflect.construct.bind();\n      } else {\n        _construct = function _construct2(Parent2, args2, Class2) {\n          var a = [null];\n          a.push.apply(a, args2);\n          var Constructor = Function.bind.apply(Parent2, a);\n          var instance = new Constructor();\n          if (Class2) _setPrototypeOf(instance, Class2.prototype);\n          return instance;\n        };\n      }\n      return _construct.apply(null, arguments);\n    }\n    function _isNativeReflectConstruct() {\n      if (typeof Reflect === \"undefined\" || !Reflect.construct) return false;\n      if (Reflect.construct.sham) return false;\n      if (typeof Proxy === \"function\") return true;\n      try {\n        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {\n        }));\n        return true;\n      } catch (e) {\n        return false;\n      }\n    }\n    function _isNativeFunction(fn) {\n      return Function.toString.call(fn).indexOf(\"[native code]\") !== -1;\n    }\n    function _setPrototypeOf(o, p) {\n      _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf2(o2, p2) {\n        o2.__proto__ = p2;\n        return o2;\n      };\n      return _setPrototypeOf(o, p);\n    }\n    function _getPrototypeOf(o) {\n      _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf2(o2) {\n        return o2.__proto__ || Object.getPrototypeOf(o2);\n      };\n      return _getPrototypeOf(o);\n    }\n    function _typeof(o) {\n      \"@babel/helpers - typeof\";\n      return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function(o2) {\n        return typeof o2;\n      } : function(o2) {\n        return o2 && \"function\" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? \"symbol\" : typeof o2;\n      }, _typeof(o);\n    }\n    var _require = require_util();\n    var inspect = _require.inspect;\n    var _require2 = require_errors();\n    var ERR_INVALID_ARG_TYPE = _require2.codes.ERR_INVALID_ARG_TYPE;\n    function endsWith(str, search, this_len) {\n      if (this_len === void 0 || this_len > str.length) {\n        this_len = str.length;\n      }\n      return str.substring(this_len - search.length, this_len) === search;\n    }\n    function repeat(str, count) {\n      count = Math.floor(count);\n      if (str.length == 0 || count == 0) return \"\";\n      var maxCount = str.length * count;\n      count = Math.floor(Math.log(count) / Math.log(2));\n      while (count) {\n        str += str;\n        count--;\n      }\n      str += str.substring(0, maxCount - str.length);\n      return str;\n    }\n    var blue = \"\";\n    var green = \"\";\n    var red = \"\";\n    var white = \"\";\n    var kReadableOperator = {\n      deepStrictEqual: \"Expected values to be strictly deep-equal:\",\n      strictEqual: \"Expected values to be strictly equal:\",\n      strictEqualObject: 'Expected \"actual\" to be reference-equal to \"expected\":',\n      deepEqual: \"Expected values to be loosely deep-equal:\",\n      equal: \"Expected values to be loosely equal:\",\n      notDeepStrictEqual: 'Expected \"actual\" not to be strictly deep-equal to:',\n      notStrictEqual: 'Expected \"actual\" to be strictly unequal to:',\n      notStrictEqualObject: 'Expected \"actual\" not to be reference-equal to \"expected\":',\n      notDeepEqual: 'Expected \"actual\" not to be loosely deep-equal to:',\n      notEqual: 'Expected \"actual\" to be loosely unequal to:',\n      notIdentical: \"Values identical but not reference-equal:\"\n    };\n    var kMaxShortLength = 10;\n    function copyError(source) {\n      var keys = Object.keys(source);\n      var target = Object.create(Object.getPrototypeOf(source));\n      keys.forEach(function(key) {\n        target[key] = source[key];\n      });\n      Object.defineProperty(target, \"message\", {\n        value: source.message\n      });\n      return target;\n    }\n    function inspectValue(val) {\n      return inspect(val, {\n        compact: false,\n        customInspect: false,\n        depth: 1e3,\n        maxArrayLength: Infinity,\n        // Assert compares only enumerable properties (with a few exceptions).\n        showHidden: false,\n        // Having a long line as error is better than wrapping the line for\n        // comparison for now.\n        // TODO(BridgeAR): `breakLength` should be limited as soon as soon as we\n        // have meta information about the inspected properties (i.e., know where\n        // in what line the property starts and ends).\n        breakLength: Infinity,\n        // Assert does not detect proxies currently.\n        showProxy: false,\n        sorted: true,\n        // Inspect getters as we also check them when comparing entries.\n        getters: true\n      });\n    }\n    function createErrDiff(actual, expected, operator) {\n      var other = \"\";\n      var res = \"\";\n      var lastPos = 0;\n      var end = \"\";\n      var skipped = false;\n      var actualInspected = inspectValue(actual);\n      var actualLines = actualInspected.split(\"\\n\");\n      var expectedLines = inspectValue(expected).split(\"\\n\");\n      var i = 0;\n      var indicator = \"\";\n      if (operator === \"strictEqual\" && _typeof(actual) === \"object\" && _typeof(expected) === \"object\" && actual !== null && expected !== null) {\n        operator = \"strictEqualObject\";\n      }\n      if (actualLines.length === 1 && expectedLines.length === 1 && actualLines[0] !== expectedLines[0]) {\n        var inputLength = actualLines[0].length + expectedLines[0].length;\n        if (inputLength <= kMaxShortLength) {\n          if ((_typeof(actual) !== \"object\" || actual === null) && (_typeof(expected) !== \"object\" || expected === null) && (actual !== 0 || expected !== 0)) {\n            return \"\".concat(kReadableOperator[operator], \"\\n\\n\") + \"\".concat(actualLines[0], \" !== \").concat(expectedLines[0], \"\\n\");\n          }\n        } else if (operator !== \"strictEqualObject\") {\n          var maxLength = process.stderr && process.stderr.isTTY ? process.stderr.columns : 80;\n          if (inputLength < maxLength) {\n            while (actualLines[0][i] === expectedLines[0][i]) {\n              i++;\n            }\n            if (i > 2) {\n              indicator = \"\\n  \".concat(repeat(\" \", i), \"^\");\n              i = 0;\n            }\n          }\n        }\n      }\n      var a = actualLines[actualLines.length - 1];\n      var b = expectedLines[expectedLines.length - 1];\n      while (a === b) {\n        if (i++ < 2) {\n          end = \"\\n  \".concat(a).concat(end);\n        } else {\n          other = a;\n        }\n        actualLines.pop();\n        expectedLines.pop();\n        if (actualLines.length === 0 || expectedLines.length === 0) break;\n        a = actualLines[actualLines.length - 1];\n        b = expectedLines[expectedLines.length - 1];\n      }\n      var maxLines = Math.max(actualLines.length, expectedLines.length);\n      if (maxLines === 0) {\n        var _actualLines = actualInspected.split(\"\\n\");\n        if (_actualLines.length > 30) {\n          _actualLines[26] = \"\".concat(blue, \"...\").concat(white);\n          while (_actualLines.length > 27) {\n            _actualLines.pop();\n          }\n        }\n        return \"\".concat(kReadableOperator.notIdentical, \"\\n\\n\").concat(_actualLines.join(\"\\n\"), \"\\n\");\n      }\n      if (i > 3) {\n        end = \"\\n\".concat(blue, \"...\").concat(white).concat(end);\n        skipped = true;\n      }\n      if (other !== \"\") {\n        end = \"\\n  \".concat(other).concat(end);\n        other = \"\";\n      }\n      var printedLines = 0;\n      var msg = kReadableOperator[operator] + \"\\n\".concat(green, \"+ actual\").concat(white, \" \").concat(red, \"- expected\").concat(white);\n      var skippedMsg = \" \".concat(blue, \"...\").concat(white, \" Lines skipped\");\n      for (i = 0; i < maxLines; i++) {\n        var cur = i - lastPos;\n        if (actualLines.length < i + 1) {\n          if (cur > 1 && i > 2) {\n            if (cur > 4) {\n              res += \"\\n\".concat(blue, \"...\").concat(white);\n              skipped = true;\n            } else if (cur > 3) {\n              res += \"\\n  \".concat(expectedLines[i - 2]);\n              printedLines++;\n            }\n            res += \"\\n  \".concat(expectedLines[i - 1]);\n            printedLines++;\n          }\n          lastPos = i;\n          other += \"\\n\".concat(red, \"-\").concat(white, \" \").concat(expectedLines[i]);\n          printedLines++;\n        } else if (expectedLines.length < i + 1) {\n          if (cur > 1 && i > 2) {\n            if (cur > 4) {\n              res += \"\\n\".concat(blue, \"...\").concat(white);\n              skipped = true;\n            } else if (cur > 3) {\n              res += \"\\n  \".concat(actualLines[i - 2]);\n              printedLines++;\n            }\n            res += \"\\n  \".concat(actualLines[i - 1]);\n            printedLines++;\n          }\n          lastPos = i;\n          res += \"\\n\".concat(green, \"+\").concat(white, \" \").concat(actualLines[i]);\n          printedLines++;\n        } else {\n          var expectedLine = expectedLines[i];\n          var actualLine = actualLines[i];\n          var divergingLines = actualLine !== expectedLine && (!endsWith(actualLine, \",\") || actualLine.slice(0, -1) !== expectedLine);\n          if (divergingLines && endsWith(expectedLine, \",\") && expectedLine.slice(0, -1) === actualLine) {\n            divergingLines = false;\n            actualLine += \",\";\n          }\n          if (divergingLines) {\n            if (cur > 1 && i > 2) {\n              if (cur > 4) {\n                res += \"\\n\".concat(blue, \"...\").concat(white);\n                skipped = true;\n              } else if (cur > 3) {\n                res += \"\\n  \".concat(actualLines[i - 2]);\n                printedLines++;\n              }\n              res += \"\\n  \".concat(actualLines[i - 1]);\n              printedLines++;\n            }\n            lastPos = i;\n            res += \"\\n\".concat(green, \"+\").concat(white, \" \").concat(actualLine);\n            other += \"\\n\".concat(red, \"-\").concat(white, \" \").concat(expectedLine);\n            printedLines += 2;\n          } else {\n            res += other;\n            other = \"\";\n            if (cur === 1 || i === 0) {\n              res += \"\\n  \".concat(actualLine);\n              printedLines++;\n            }\n          }\n        }\n        if (printedLines > 20 && i < maxLines - 2) {\n          return \"\".concat(msg).concat(skippedMsg, \"\\n\").concat(res, \"\\n\").concat(blue, \"...\").concat(white).concat(other, \"\\n\") + \"\".concat(blue, \"...\").concat(white);\n        }\n      }\n      return \"\".concat(msg).concat(skipped ? skippedMsg : \"\", \"\\n\").concat(res).concat(other).concat(end).concat(indicator);\n    }\n    var AssertionError = /* @__PURE__ */ (function(_Error, _inspect$custom) {\n      _inherits(AssertionError2, _Error);\n      var _super = _createSuper(AssertionError2);\n      function AssertionError2(options) {\n        var _this;\n        _classCallCheck(this, AssertionError2);\n        if (_typeof(options) !== \"object\" || options === null) {\n          throw new ERR_INVALID_ARG_TYPE(\"options\", \"Object\", options);\n        }\n        var message = options.message, operator = options.operator, stackStartFn = options.stackStartFn;\n        var actual = options.actual, expected = options.expected;\n        var limit = Error.stackTraceLimit;\n        Error.stackTraceLimit = 0;\n        if (message != null) {\n          _this = _super.call(this, String(message));\n        } else {\n          if (process.stderr && process.stderr.isTTY) {\n            if (process.stderr && process.stderr.getColorDepth && process.stderr.getColorDepth() !== 1) {\n              blue = \"\\x1B[34m\";\n              green = \"\\x1B[32m\";\n              white = \"\\x1B[39m\";\n              red = \"\\x1B[31m\";\n            } else {\n              blue = \"\";\n              green = \"\";\n              white = \"\";\n              red = \"\";\n            }\n          }\n          if (_typeof(actual) === \"object\" && actual !== null && _typeof(expected) === \"object\" && expected !== null && \"stack\" in actual && actual instanceof Error && \"stack\" in expected && expected instanceof Error) {\n            actual = copyError(actual);\n            expected = copyError(expected);\n          }\n          if (operator === \"deepStrictEqual\" || operator === \"strictEqual\") {\n            _this = _super.call(this, createErrDiff(actual, expected, operator));\n          } else if (operator === \"notDeepStrictEqual\" || operator === \"notStrictEqual\") {\n            var base = kReadableOperator[operator];\n            var res = inspectValue(actual).split(\"\\n\");\n            if (operator === \"notStrictEqual\" && _typeof(actual) === \"object\" && actual !== null) {\n              base = kReadableOperator.notStrictEqualObject;\n            }\n            if (res.length > 30) {\n              res[26] = \"\".concat(blue, \"...\").concat(white);\n              while (res.length > 27) {\n                res.pop();\n              }\n            }\n            if (res.length === 1) {\n              _this = _super.call(this, \"\".concat(base, \" \").concat(res[0]));\n            } else {\n              _this = _super.call(this, \"\".concat(base, \"\\n\\n\").concat(res.join(\"\\n\"), \"\\n\"));\n            }\n          } else {\n            var _res = inspectValue(actual);\n            var other = \"\";\n            var knownOperators = kReadableOperator[operator];\n            if (operator === \"notDeepEqual\" || operator === \"notEqual\") {\n              _res = \"\".concat(kReadableOperator[operator], \"\\n\\n\").concat(_res);\n              if (_res.length > 1024) {\n                _res = \"\".concat(_res.slice(0, 1021), \"...\");\n              }\n            } else {\n              other = \"\".concat(inspectValue(expected));\n              if (_res.length > 512) {\n                _res = \"\".concat(_res.slice(0, 509), \"...\");\n              }\n              if (other.length > 512) {\n                other = \"\".concat(other.slice(0, 509), \"...\");\n              }\n              if (operator === \"deepEqual\" || operator === \"equal\") {\n                _res = \"\".concat(knownOperators, \"\\n\\n\").concat(_res, \"\\n\\nshould equal\\n\\n\");\n              } else {\n                other = \" \".concat(operator, \" \").concat(other);\n              }\n            }\n            _this = _super.call(this, \"\".concat(_res).concat(other));\n          }\n        }\n        Error.stackTraceLimit = limit;\n        _this.generatedMessage = !message;\n        Object.defineProperty(_assertThisInitialized(_this), \"name\", {\n          value: \"AssertionError [ERR_ASSERTION]\",\n          enumerable: false,\n          writable: true,\n          configurable: true\n        });\n        _this.code = \"ERR_ASSERTION\";\n        _this.actual = actual;\n        _this.expected = expected;\n        _this.operator = operator;\n        if (Error.captureStackTrace) {\n          Error.captureStackTrace(_assertThisInitialized(_this), stackStartFn);\n        }\n        _this.stack;\n        _this.name = \"AssertionError\";\n        return _possibleConstructorReturn(_this);\n      }\n      _createClass(AssertionError2, [{\n        key: \"toString\",\n        value: function toString() {\n          return \"\".concat(this.name, \" [\").concat(this.code, \"]: \").concat(this.message);\n        }\n      }, {\n        key: _inspect$custom,\n        value: function value(recurseTimes, ctx) {\n          return inspect(this, _objectSpread(_objectSpread({}, ctx), {}, {\n            customInspect: false,\n            depth: 0\n          }));\n        }\n      }]);\n      return AssertionError2;\n    })(/* @__PURE__ */ _wrapNativeSuper(Error), inspect.custom);\n    module2.exports = AssertionError;\n  }\n});\n\n// ../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/isArguments.js\nvar require_isArguments = __commonJS({\n  \"../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/isArguments.js\"(exports2, module2) {\n    \"use strict\";\n    var toStr = Object.prototype.toString;\n    module2.exports = function isArguments(value) {\n      var str = toStr.call(value);\n      var isArgs = str === \"[object Arguments]\";\n      if (!isArgs) {\n        isArgs = str !== \"[object Array]\" && value !== null && typeof value === \"object\" && typeof value.length === \"number\" && value.length >= 0 && toStr.call(value.callee) === \"[object Function]\";\n      }\n      return isArgs;\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/implementation.js\nvar require_implementation2 = __commonJS({\n  \"../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/implementation.js\"(exports2, module2) {\n    \"use strict\";\n    var keysShim;\n    if (!Object.keys) {\n      has = Object.prototype.hasOwnProperty;\n      toStr = Object.prototype.toString;\n      isArgs = require_isArguments();\n      isEnumerable = Object.prototype.propertyIsEnumerable;\n      hasDontEnumBug = !isEnumerable.call({ toString: null }, \"toString\");\n      hasProtoEnumBug = isEnumerable.call(function() {\n      }, \"prototype\");\n      dontEnums = [\n        \"toString\",\n        \"toLocaleString\",\n        \"valueOf\",\n        \"hasOwnProperty\",\n        \"isPrototypeOf\",\n        \"propertyIsEnumerable\",\n        \"constructor\"\n      ];\n      equalsConstructorPrototype = function(o) {\n        var ctor = o.constructor;\n        return ctor && ctor.prototype === o;\n      };\n      excludedKeys = {\n        $applicationCache: true,\n        $console: true,\n        $external: true,\n        $frame: true,\n        $frameElement: true,\n        $frames: true,\n        $innerHeight: true,\n        $innerWidth: true,\n        $onmozfullscreenchange: true,\n        $onmozfullscreenerror: true,\n        $outerHeight: true,\n        $outerWidth: true,\n        $pageXOffset: true,\n        $pageYOffset: true,\n        $parent: true,\n        $scrollLeft: true,\n        $scrollTop: true,\n        $scrollX: true,\n        $scrollY: true,\n        $self: true,\n        $webkitIndexedDB: true,\n        $webkitStorageInfo: true,\n        $window: true\n      };\n      hasAutomationEqualityBug = (function() {\n        if (typeof window === \"undefined\") {\n          return false;\n        }\n        for (var k in window) {\n          try {\n            if (!excludedKeys[\"$\" + k] && has.call(window, k) && window[k] !== null && typeof window[k] === \"object\") {\n              try {\n                equalsConstructorPrototype(window[k]);\n              } catch (e) {\n                return true;\n              }\n            }\n          } catch (e) {\n            return true;\n          }\n        }\n        return false;\n      })();\n      equalsConstructorPrototypeIfNotBuggy = function(o) {\n        if (typeof window === \"undefined\" || !hasAutomationEqualityBug) {\n          return equalsConstructorPrototype(o);\n        }\n        try {\n          return equalsConstructorPrototype(o);\n        } catch (e) {\n          return false;\n        }\n      };\n      keysShim = function keys(object) {\n        var isObject = object !== null && typeof object === \"object\";\n        var isFunction = toStr.call(object) === \"[object Function]\";\n        var isArguments = isArgs(object);\n        var isString = isObject && toStr.call(object) === \"[object String]\";\n        var theKeys = [];\n        if (!isObject && !isFunction && !isArguments) {\n          throw new TypeError(\"Object.keys called on a non-object\");\n        }\n        var skipProto = hasProtoEnumBug && isFunction;\n        if (isString && object.length > 0 && !has.call(object, 0)) {\n          for (var i = 0; i < object.length; ++i) {\n            theKeys.push(String(i));\n          }\n        }\n        if (isArguments && object.length > 0) {\n          for (var j = 0; j < object.length; ++j) {\n            theKeys.push(String(j));\n          }\n        } else {\n          for (var name in object) {\n            if (!(skipProto && name === \"prototype\") && has.call(object, name)) {\n              theKeys.push(String(name));\n            }\n          }\n        }\n        if (hasDontEnumBug) {\n          var skipConstructor = equalsConstructorPrototypeIfNotBuggy(object);\n          for (var k = 0; k < dontEnums.length; ++k) {\n            if (!(skipConstructor && dontEnums[k] === \"constructor\") && has.call(object, dontEnums[k])) {\n              theKeys.push(dontEnums[k]);\n            }\n          }\n        }\n        return theKeys;\n      };\n    }\n    var has;\n    var toStr;\n    var isArgs;\n    var isEnumerable;\n    var hasDontEnumBug;\n    var hasProtoEnumBug;\n    var dontEnums;\n    var equalsConstructorPrototype;\n    var excludedKeys;\n    var hasAutomationEqualityBug;\n    var equalsConstructorPrototypeIfNotBuggy;\n    module2.exports = keysShim;\n  }\n});\n\n// ../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/index.js\nvar require_object_keys = __commonJS({\n  \"../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/index.js\"(exports2, module2) {\n    \"use strict\";\n    var slice = Array.prototype.slice;\n    var isArgs = require_isArguments();\n    var origKeys = Object.keys;\n    var keysShim = origKeys ? function keys(o) {\n      return origKeys(o);\n    } : require_implementation2();\n    var originalKeys = Object.keys;\n    keysShim.shim = function shimObjectKeys() {\n      if (Object.keys) {\n        var keysWorksWithArguments = (function() {\n          var args = Object.keys(arguments);\n          return args && args.length === arguments.length;\n        })(1, 2);\n        if (!keysWorksWithArguments) {\n          Object.keys = function keys(object) {\n            if (isArgs(object)) {\n              return originalKeys(slice.call(object));\n            }\n            return originalKeys(object);\n          };\n        }\n      } else {\n        Object.keys = keysShim;\n      }\n      return Object.keys || keysShim;\n    };\n    module2.exports = keysShim;\n  }\n});\n\n// ../../node_modules/.pnpm/object.assign@4.1.7/node_modules/object.assign/implementation.js\nvar require_implementation3 = __commonJS({\n  \"../../node_modules/.pnpm/object.assign@4.1.7/node_modules/object.assign/implementation.js\"(exports2, module2) {\n    \"use strict\";\n    var objectKeys = require_object_keys();\n    var hasSymbols = require_shams()();\n    var callBound = require_call_bound();\n    var $Object = require_es_object_atoms();\n    var $push = callBound(\"Array.prototype.push\");\n    var $propIsEnumerable = callBound(\"Object.prototype.propertyIsEnumerable\");\n    var originalGetSymbols = hasSymbols ? $Object.getOwnPropertySymbols : null;\n    module2.exports = function assign(target, source1) {\n      if (target == null) {\n        throw new TypeError(\"target must be an object\");\n      }\n      var to = $Object(target);\n      if (arguments.length === 1) {\n        return to;\n      }\n      for (var s = 1; s < arguments.length; ++s) {\n        var from = $Object(arguments[s]);\n        var keys = objectKeys(from);\n        var getSymbols = hasSymbols && ($Object.getOwnPropertySymbols || originalGetSymbols);\n        if (getSymbols) {\n          var syms = getSymbols(from);\n          for (var j = 0; j < syms.length; ++j) {\n            var key = syms[j];\n            if ($propIsEnumerable(from, key)) {\n              $push(keys, key);\n            }\n          }\n        }\n        for (var i = 0; i < keys.length; ++i) {\n          var nextKey = keys[i];\n          if ($propIsEnumerable(from, nextKey)) {\n            var propValue = from[nextKey];\n            to[nextKey] = propValue;\n          }\n        }\n      }\n      return to;\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/object.assign@4.1.7/node_modules/object.assign/polyfill.js\nvar require_polyfill = __commonJS({\n  \"../../node_modules/.pnpm/object.assign@4.1.7/node_modules/object.assign/polyfill.js\"(exports2, module2) {\n    \"use strict\";\n    var implementation = require_implementation3();\n    var lacksProperEnumerationOrder = function() {\n      if (!Object.assign) {\n        return false;\n      }\n      var str = \"abcdefghijklmnopqrst\";\n      var letters = str.split(\"\");\n      var map = {};\n      for (var i = 0; i < letters.length; ++i) {\n        map[letters[i]] = letters[i];\n      }\n      var obj = Object.assign({}, map);\n      var actual = \"\";\n      for (var k in obj) {\n        actual += k;\n      }\n      return str !== actual;\n    };\n    var assignHasPendingExceptions = function() {\n      if (!Object.assign || !Object.preventExtensions) {\n        return false;\n      }\n      var thrower = Object.preventExtensions({ 1: 2 });\n      try {\n        Object.assign(thrower, \"xy\");\n      } catch (e) {\n        return thrower[1] === \"y\";\n      }\n      return false;\n    };\n    module2.exports = function getPolyfill() {\n      if (!Object.assign) {\n        return implementation;\n      }\n      if (lacksProperEnumerationOrder()) {\n        return implementation;\n      }\n      if (assignHasPendingExceptions()) {\n        return implementation;\n      }\n      return Object.assign;\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/object-is@1.1.6/node_modules/object-is/implementation.js\nvar require_implementation4 = __commonJS({\n  \"../../node_modules/.pnpm/object-is@1.1.6/node_modules/object-is/implementation.js\"(exports2, module2) {\n    \"use strict\";\n    var numberIsNaN = function(value) {\n      return value !== value;\n    };\n    module2.exports = function is(a, b) {\n      if (a === 0 && b === 0) {\n        return 1 / a === 1 / b;\n      }\n      if (a === b) {\n        return true;\n      }\n      if (numberIsNaN(a) && numberIsNaN(b)) {\n        return true;\n      }\n      return false;\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/object-is@1.1.6/node_modules/object-is/polyfill.js\nvar require_polyfill2 = __commonJS({\n  \"../../node_modules/.pnpm/object-is@1.1.6/node_modules/object-is/polyfill.js\"(exports2, module2) {\n    \"use strict\";\n    var implementation = require_implementation4();\n    module2.exports = function getPolyfill() {\n      return typeof Object.is === \"function\" ? Object.is : implementation;\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/call-bind@1.0.9/node_modules/call-bind/callBound.js\nvar require_callBound = __commonJS({\n  \"../../node_modules/.pnpm/call-bind@1.0.9/node_modules/call-bind/callBound.js\"(exports2, module2) {\n    \"use strict\";\n    var GetIntrinsic = require_get_intrinsic();\n    var callBind = require_call_bind();\n    var $indexOf = callBind(GetIntrinsic(\"String.prototype.indexOf\"));\n    module2.exports = function callBoundIntrinsic(name, allowMissing) {\n      var intrinsic = GetIntrinsic(name, !!allowMissing);\n      if (typeof intrinsic === \"function\" && $indexOf(name, \".prototype.\") > -1) {\n        return callBind(intrinsic);\n      }\n      return intrinsic;\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/define-properties@1.2.1/node_modules/define-properties/index.js\nvar require_define_properties = __commonJS({\n  \"../../node_modules/.pnpm/define-properties@1.2.1/node_modules/define-properties/index.js\"(exports2, module2) {\n    \"use strict\";\n    var keys = require_object_keys();\n    var hasSymbols = typeof Symbol === \"function\" && typeof /* @__PURE__ */ Symbol(\"foo\") === \"symbol\";\n    var toStr = Object.prototype.toString;\n    var concat = Array.prototype.concat;\n    var defineDataProperty = require_define_data_property();\n    var isFunction = function(fn) {\n      return typeof fn === \"function\" && toStr.call(fn) === \"[object Function]\";\n    };\n    var supportsDescriptors = require_has_property_descriptors()();\n    var defineProperty = function(object, name, value, predicate) {\n      if (name in object) {\n        if (predicate === true) {\n          if (object[name] === value) {\n            return;\n          }\n        } else if (!isFunction(predicate) || !predicate()) {\n          return;\n        }\n      }\n      if (supportsDescriptors) {\n        defineDataProperty(object, name, value, true);\n      } else {\n        defineDataProperty(object, name, value);\n      }\n    };\n    var defineProperties = function(object, map) {\n      var predicates = arguments.length > 2 ? arguments[2] : {};\n      var props = keys(map);\n      if (hasSymbols) {\n        props = concat.call(props, Object.getOwnPropertySymbols(map));\n      }\n      for (var i = 0; i < props.length; i += 1) {\n        defineProperty(object, props[i], map[props[i]], predicates[props[i]]);\n      }\n    };\n    defineProperties.supportsDescriptors = !!supportsDescriptors;\n    module2.exports = defineProperties;\n  }\n});\n\n// ../../node_modules/.pnpm/object-is@1.1.6/node_modules/object-is/shim.js\nvar require_shim = __commonJS({\n  \"../../node_modules/.pnpm/object-is@1.1.6/node_modules/object-is/shim.js\"(exports2, module2) {\n    \"use strict\";\n    var getPolyfill = require_polyfill2();\n    var define = require_define_properties();\n    module2.exports = function shimObjectIs() {\n      var polyfill = getPolyfill();\n      define(Object, { is: polyfill }, {\n        is: function testObjectIs() {\n          return Object.is !== polyfill;\n        }\n      });\n      return polyfill;\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/object-is@1.1.6/node_modules/object-is/index.js\nvar require_object_is = __commonJS({\n  \"../../node_modules/.pnpm/object-is@1.1.6/node_modules/object-is/index.js\"(exports2, module2) {\n    \"use strict\";\n    var define = require_define_properties();\n    var callBind = require_call_bind();\n    var implementation = require_implementation4();\n    var getPolyfill = require_polyfill2();\n    var shim = require_shim();\n    var polyfill = callBind(getPolyfill(), Object);\n    define(polyfill, {\n      getPolyfill,\n      implementation,\n      shim\n    });\n    module2.exports = polyfill;\n  }\n});\n\n// ../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/implementation.js\nvar require_implementation5 = __commonJS({\n  \"../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/implementation.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = function isNaN2(value) {\n      return value !== value;\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/polyfill.js\nvar require_polyfill3 = __commonJS({\n  \"../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/polyfill.js\"(exports2, module2) {\n    \"use strict\";\n    var implementation = require_implementation5();\n    module2.exports = function getPolyfill() {\n      if (Number.isNaN && Number.isNaN(NaN) && !Number.isNaN(\"a\")) {\n        return Number.isNaN;\n      }\n      return implementation;\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/shim.js\nvar require_shim2 = __commonJS({\n  \"../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/shim.js\"(exports2, module2) {\n    \"use strict\";\n    var define = require_define_properties();\n    var getPolyfill = require_polyfill3();\n    module2.exports = function shimNumberIsNaN() {\n      var polyfill = getPolyfill();\n      define(Number, { isNaN: polyfill }, {\n        isNaN: function testIsNaN() {\n          return Number.isNaN !== polyfill;\n        }\n      });\n      return polyfill;\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/index.js\nvar require_is_nan = __commonJS({\n  \"../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/index.js\"(exports2, module2) {\n    \"use strict\";\n    var callBind = require_call_bind();\n    var define = require_define_properties();\n    var implementation = require_implementation5();\n    var getPolyfill = require_polyfill3();\n    var shim = require_shim2();\n    var polyfill = callBind(getPolyfill(), Number);\n    define(polyfill, {\n      getPolyfill,\n      implementation,\n      shim\n    });\n    module2.exports = polyfill;\n  }\n});\n\n// ../../node_modules/.pnpm/assert@2.1.0/node_modules/assert/build/internal/util/comparisons.js\nvar require_comparisons = __commonJS({\n  \"../../node_modules/.pnpm/assert@2.1.0/node_modules/assert/build/internal/util/comparisons.js\"(exports2, module2) {\n    \"use strict\";\n    function _slicedToArray(arr, i) {\n      return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();\n    }\n    function _nonIterableRest() {\n      throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n    }\n    function _unsupportedIterableToArray(o, minLen) {\n      if (!o) return;\n      if (typeof o === \"string\") return _arrayLikeToArray(o, minLen);\n      var n = Object.prototype.toString.call(o).slice(8, -1);\n      if (n === \"Object\" && o.constructor) n = o.constructor.name;\n      if (n === \"Map\" || n === \"Set\") return Array.from(o);\n      if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);\n    }\n    function _arrayLikeToArray(arr, len) {\n      if (len == null || len > arr.length) len = arr.length;\n      for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];\n      return arr2;\n    }\n    function _iterableToArrayLimit(r, l) {\n      var t = null == r ? null : \"undefined\" != typeof Symbol && r[Symbol.iterator] || r[\"@@iterator\"];\n      if (null != t) {\n        var e, n, i, u, a = [], f = true, o = false;\n        try {\n          if (i = (t = t.call(r)).next, 0 === l) {\n            if (Object(t) !== t) return;\n            f = false;\n          } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = true) ;\n        } catch (r2) {\n          o = true, n = r2;\n        } finally {\n          try {\n            if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;\n          } finally {\n            if (o) throw n;\n          }\n        }\n        return a;\n      }\n    }\n    function _arrayWithHoles(arr) {\n      if (Array.isArray(arr)) return arr;\n    }\n    function _typeof(o) {\n      \"@babel/helpers - typeof\";\n      return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function(o2) {\n        return typeof o2;\n      } : function(o2) {\n        return o2 && \"function\" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? \"symbol\" : typeof o2;\n      }, _typeof(o);\n    }\n    var regexFlagsSupported = /a/g.flags !== void 0;\n    var arrayFromSet = function arrayFromSet2(set) {\n      var array = [];\n      set.forEach(function(value) {\n        return array.push(value);\n      });\n      return array;\n    };\n    var arrayFromMap = function arrayFromMap2(map) {\n      var array = [];\n      map.forEach(function(value, key) {\n        return array.push([key, value]);\n      });\n      return array;\n    };\n    var objectIs = Object.is ? Object.is : require_object_is();\n    var objectGetOwnPropertySymbols = Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols : function() {\n      return [];\n    };\n    var numberIsNaN = Number.isNaN ? Number.isNaN : require_is_nan();\n    function uncurryThis(f) {\n      return f.call.bind(f);\n    }\n    var hasOwnProperty = uncurryThis(Object.prototype.hasOwnProperty);\n    var propertyIsEnumerable = uncurryThis(Object.prototype.propertyIsEnumerable);\n    var objectToString = uncurryThis(Object.prototype.toString);\n    var _require$types = require_util().types;\n    var isAnyArrayBuffer = _require$types.isAnyArrayBuffer;\n    var isArrayBufferView = _require$types.isArrayBufferView;\n    var isDate = _require$types.isDate;\n    var isMap = _require$types.isMap;\n    var isRegExp = _require$types.isRegExp;\n    var isSet = _require$types.isSet;\n    var isNativeError = _require$types.isNativeError;\n    var isBoxedPrimitive = _require$types.isBoxedPrimitive;\n    var isNumberObject = _require$types.isNumberObject;\n    var isStringObject = _require$types.isStringObject;\n    var isBooleanObject = _require$types.isBooleanObject;\n    var isBigIntObject = _require$types.isBigIntObject;\n    var isSymbolObject = _require$types.isSymbolObject;\n    var isFloat32Array = _require$types.isFloat32Array;\n    var isFloat64Array = _require$types.isFloat64Array;\n    function isNonIndex(key) {\n      if (key.length === 0 || key.length > 10) return true;\n      for (var i = 0; i < key.length; i++) {\n        var code = key.charCodeAt(i);\n        if (code < 48 || code > 57) return true;\n      }\n      return key.length === 10 && key >= Math.pow(2, 32);\n    }\n    function getOwnNonIndexProperties(value) {\n      return Object.keys(value).filter(isNonIndex).concat(objectGetOwnPropertySymbols(value).filter(Object.prototype.propertyIsEnumerable.bind(value)));\n    }\n    function compare(a, b) {\n      if (a === b) {\n        return 0;\n      }\n      var x = a.length;\n      var y = b.length;\n      for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n        if (a[i] !== b[i]) {\n          x = a[i];\n          y = b[i];\n          break;\n        }\n      }\n      if (x < y) {\n        return -1;\n      }\n      if (y < x) {\n        return 1;\n      }\n      return 0;\n    }\n    var ONLY_ENUMERABLE = void 0;\n    var kStrict = true;\n    var kLoose = false;\n    var kNoIterator = 0;\n    var kIsArray = 1;\n    var kIsSet = 2;\n    var kIsMap = 3;\n    function areSimilarRegExps(a, b) {\n      return regexFlagsSupported ? a.source === b.source && a.flags === b.flags : RegExp.prototype.toString.call(a) === RegExp.prototype.toString.call(b);\n    }\n    function areSimilarFloatArrays(a, b) {\n      if (a.byteLength !== b.byteLength) {\n        return false;\n      }\n      for (var offset = 0; offset < a.byteLength; offset++) {\n        if (a[offset] !== b[offset]) {\n          return false;\n        }\n      }\n      return true;\n    }\n    function areSimilarTypedArrays(a, b) {\n      if (a.byteLength !== b.byteLength) {\n        return false;\n      }\n      return compare(new Uint8Array(a.buffer, a.byteOffset, a.byteLength), new Uint8Array(b.buffer, b.byteOffset, b.byteLength)) === 0;\n    }\n    function areEqualArrayBuffers(buf1, buf2) {\n      return buf1.byteLength === buf2.byteLength && compare(new Uint8Array(buf1), new Uint8Array(buf2)) === 0;\n    }\n    function isEqualBoxedPrimitive(val1, val2) {\n      if (isNumberObject(val1)) {\n        return isNumberObject(val2) && objectIs(Number.prototype.valueOf.call(val1), Number.prototype.valueOf.call(val2));\n      }\n      if (isStringObject(val1)) {\n        return isStringObject(val2) && String.prototype.valueOf.call(val1) === String.prototype.valueOf.call(val2);\n      }\n      if (isBooleanObject(val1)) {\n        return isBooleanObject(val2) && Boolean.prototype.valueOf.call(val1) === Boolean.prototype.valueOf.call(val2);\n      }\n      if (isBigIntObject(val1)) {\n        return isBigIntObject(val2) && BigInt.prototype.valueOf.call(val1) === BigInt.prototype.valueOf.call(val2);\n      }\n      return isSymbolObject(val2) && Symbol.prototype.valueOf.call(val1) === Symbol.prototype.valueOf.call(val2);\n    }\n    function innerDeepEqual(val1, val2, strict, memos) {\n      if (val1 === val2) {\n        if (val1 !== 0) return true;\n        return strict ? objectIs(val1, val2) : true;\n      }\n      if (strict) {\n        if (_typeof(val1) !== \"object\") {\n          return typeof val1 === \"number\" && numberIsNaN(val1) && numberIsNaN(val2);\n        }\n        if (_typeof(val2) !== \"object\" || val1 === null || val2 === null) {\n          return false;\n        }\n        if (Object.getPrototypeOf(val1) !== Object.getPrototypeOf(val2)) {\n          return false;\n        }\n      } else {\n        if (val1 === null || _typeof(val1) !== \"object\") {\n          if (val2 === null || _typeof(val2) !== \"object\") {\n            return val1 == val2;\n          }\n          return false;\n        }\n        if (val2 === null || _typeof(val2) !== \"object\") {\n          return false;\n        }\n      }\n      var val1Tag = objectToString(val1);\n      var val2Tag = objectToString(val2);\n      if (val1Tag !== val2Tag) {\n        return false;\n      }\n      if (Array.isArray(val1)) {\n        if (val1.length !== val2.length) {\n          return false;\n        }\n        var keys1 = getOwnNonIndexProperties(val1, ONLY_ENUMERABLE);\n        var keys2 = getOwnNonIndexProperties(val2, ONLY_ENUMERABLE);\n        if (keys1.length !== keys2.length) {\n          return false;\n        }\n        return keyCheck(val1, val2, strict, memos, kIsArray, keys1);\n      }\n      if (val1Tag === \"[object Object]\") {\n        if (!isMap(val1) && isMap(val2) || !isSet(val1) && isSet(val2)) {\n          return false;\n        }\n      }\n      if (isDate(val1)) {\n        if (!isDate(val2) || Date.prototype.getTime.call(val1) !== Date.prototype.getTime.call(val2)) {\n          return false;\n        }\n      } else if (isRegExp(val1)) {\n        if (!isRegExp(val2) || !areSimilarRegExps(val1, val2)) {\n          return false;\n        }\n      } else if (isNativeError(val1) || val1 instanceof Error) {\n        if (val1.message !== val2.message || val1.name !== val2.name) {\n          return false;\n        }\n      } else if (isArrayBufferView(val1)) {\n        if (!strict && (isFloat32Array(val1) || isFloat64Array(val1))) {\n          if (!areSimilarFloatArrays(val1, val2)) {\n            return false;\n          }\n        } else if (!areSimilarTypedArrays(val1, val2)) {\n          return false;\n        }\n        var _keys = getOwnNonIndexProperties(val1, ONLY_ENUMERABLE);\n        var _keys2 = getOwnNonIndexProperties(val2, ONLY_ENUMERABLE);\n        if (_keys.length !== _keys2.length) {\n          return false;\n        }\n        return keyCheck(val1, val2, strict, memos, kNoIterator, _keys);\n      } else if (isSet(val1)) {\n        if (!isSet(val2) || val1.size !== val2.size) {\n          return false;\n        }\n        return keyCheck(val1, val2, strict, memos, kIsSet);\n      } else if (isMap(val1)) {\n        if (!isMap(val2) || val1.size !== val2.size) {\n          return false;\n        }\n        return keyCheck(val1, val2, strict, memos, kIsMap);\n      } else if (isAnyArrayBuffer(val1)) {\n        if (!areEqualArrayBuffers(val1, val2)) {\n          return false;\n        }\n      } else if (isBoxedPrimitive(val1) && !isEqualBoxedPrimitive(val1, val2)) {\n        return false;\n      }\n      return keyCheck(val1, val2, strict, memos, kNoIterator);\n    }\n    function getEnumerables(val, keys) {\n      return keys.filter(function(k) {\n        return propertyIsEnumerable(val, k);\n      });\n    }\n    function keyCheck(val1, val2, strict, memos, iterationType, aKeys) {\n      if (arguments.length === 5) {\n        aKeys = Object.keys(val1);\n        var bKeys = Object.keys(val2);\n        if (aKeys.length !== bKeys.length) {\n          return false;\n        }\n      }\n      var i = 0;\n      for (; i < aKeys.length; i++) {\n        if (!hasOwnProperty(val2, aKeys[i])) {\n          return false;\n        }\n      }\n      if (strict && arguments.length === 5) {\n        var symbolKeysA = objectGetOwnPropertySymbols(val1);\n        if (symbolKeysA.length !== 0) {\n          var count = 0;\n          for (i = 0; i < symbolKeysA.length; i++) {\n            var key = symbolKeysA[i];\n            if (propertyIsEnumerable(val1, key)) {\n              if (!propertyIsEnumerable(val2, key)) {\n                return false;\n              }\n              aKeys.push(key);\n              count++;\n            } else if (propertyIsEnumerable(val2, key)) {\n              return false;\n            }\n          }\n          var symbolKeysB = objectGetOwnPropertySymbols(val2);\n          if (symbolKeysA.length !== symbolKeysB.length && getEnumerables(val2, symbolKeysB).length !== count) {\n            return false;\n          }\n        } else {\n          var _symbolKeysB = objectGetOwnPropertySymbols(val2);\n          if (_symbolKeysB.length !== 0 && getEnumerables(val2, _symbolKeysB).length !== 0) {\n            return false;\n          }\n        }\n      }\n      if (aKeys.length === 0 && (iterationType === kNoIterator || iterationType === kIsArray && val1.length === 0 || val1.size === 0)) {\n        return true;\n      }\n      if (memos === void 0) {\n        memos = {\n          val1: /* @__PURE__ */ new Map(),\n          val2: /* @__PURE__ */ new Map(),\n          position: 0\n        };\n      } else {\n        var val2MemoA = memos.val1.get(val1);\n        if (val2MemoA !== void 0) {\n          var val2MemoB = memos.val2.get(val2);\n          if (val2MemoB !== void 0) {\n            return val2MemoA === val2MemoB;\n          }\n        }\n        memos.position++;\n      }\n      memos.val1.set(val1, memos.position);\n      memos.val2.set(val2, memos.position);\n      var areEq = objEquiv(val1, val2, strict, aKeys, memos, iterationType);\n      memos.val1.delete(val1);\n      memos.val2.delete(val2);\n      return areEq;\n    }\n    function setHasEqualElement(set, val1, strict, memo) {\n      var setValues = arrayFromSet(set);\n      for (var i = 0; i < setValues.length; i++) {\n        var val2 = setValues[i];\n        if (innerDeepEqual(val1, val2, strict, memo)) {\n          set.delete(val2);\n          return true;\n        }\n      }\n      return false;\n    }\n    function findLooseMatchingPrimitives(prim) {\n      switch (_typeof(prim)) {\n        case \"undefined\":\n          return null;\n        case \"object\":\n          return void 0;\n        case \"symbol\":\n          return false;\n        case \"string\":\n          prim = +prim;\n        // Loose equal entries exist only if the string is possible to convert to\n        // a regular number and not NaN.\n        // Fall through\n        case \"number\":\n          if (numberIsNaN(prim)) {\n            return false;\n          }\n      }\n      return true;\n    }\n    function setMightHaveLoosePrim(a, b, prim) {\n      var altValue = findLooseMatchingPrimitives(prim);\n      if (altValue != null) return altValue;\n      return b.has(altValue) && !a.has(altValue);\n    }\n    function mapMightHaveLoosePrim(a, b, prim, item, memo) {\n      var altValue = findLooseMatchingPrimitives(prim);\n      if (altValue != null) {\n        return altValue;\n      }\n      var curB = b.get(altValue);\n      if (curB === void 0 && !b.has(altValue) || !innerDeepEqual(item, curB, false, memo)) {\n        return false;\n      }\n      return !a.has(altValue) && innerDeepEqual(item, curB, false, memo);\n    }\n    function setEquiv(a, b, strict, memo) {\n      var set = null;\n      var aValues = arrayFromSet(a);\n      for (var i = 0; i < aValues.length; i++) {\n        var val = aValues[i];\n        if (_typeof(val) === \"object\" && val !== null) {\n          if (set === null) {\n            set = /* @__PURE__ */ new Set();\n          }\n          set.add(val);\n        } else if (!b.has(val)) {\n          if (strict) return false;\n          if (!setMightHaveLoosePrim(a, b, val)) {\n            return false;\n          }\n          if (set === null) {\n            set = /* @__PURE__ */ new Set();\n          }\n          set.add(val);\n        }\n      }\n      if (set !== null) {\n        var bValues = arrayFromSet(b);\n        for (var _i = 0; _i < bValues.length; _i++) {\n          var _val = bValues[_i];\n          if (_typeof(_val) === \"object\" && _val !== null) {\n            if (!setHasEqualElement(set, _val, strict, memo)) return false;\n          } else if (!strict && !a.has(_val) && !setHasEqualElement(set, _val, strict, memo)) {\n            return false;\n          }\n        }\n        return set.size === 0;\n      }\n      return true;\n    }\n    function mapHasEqualEntry(set, map, key1, item1, strict, memo) {\n      var setValues = arrayFromSet(set);\n      for (var i = 0; i < setValues.length; i++) {\n        var key2 = setValues[i];\n        if (innerDeepEqual(key1, key2, strict, memo) && innerDeepEqual(item1, map.get(key2), strict, memo)) {\n          set.delete(key2);\n          return true;\n        }\n      }\n      return false;\n    }\n    function mapEquiv(a, b, strict, memo) {\n      var set = null;\n      var aEntries = arrayFromMap(a);\n      for (var i = 0; i < aEntries.length; i++) {\n        var _aEntries$i = _slicedToArray(aEntries[i], 2), key = _aEntries$i[0], item1 = _aEntries$i[1];\n        if (_typeof(key) === \"object\" && key !== null) {\n          if (set === null) {\n            set = /* @__PURE__ */ new Set();\n          }\n          set.add(key);\n        } else {\n          var item2 = b.get(key);\n          if (item2 === void 0 && !b.has(key) || !innerDeepEqual(item1, item2, strict, memo)) {\n            if (strict) return false;\n            if (!mapMightHaveLoosePrim(a, b, key, item1, memo)) return false;\n            if (set === null) {\n              set = /* @__PURE__ */ new Set();\n            }\n            set.add(key);\n          }\n        }\n      }\n      if (set !== null) {\n        var bEntries = arrayFromMap(b);\n        for (var _i2 = 0; _i2 < bEntries.length; _i2++) {\n          var _bEntries$_i = _slicedToArray(bEntries[_i2], 2), _key = _bEntries$_i[0], item = _bEntries$_i[1];\n          if (_typeof(_key) === \"object\" && _key !== null) {\n            if (!mapHasEqualEntry(set, a, _key, item, strict, memo)) return false;\n          } else if (!strict && (!a.has(_key) || !innerDeepEqual(a.get(_key), item, false, memo)) && !mapHasEqualEntry(set, a, _key, item, false, memo)) {\n            return false;\n          }\n        }\n        return set.size === 0;\n      }\n      return true;\n    }\n    function objEquiv(a, b, strict, keys, memos, iterationType) {\n      var i = 0;\n      if (iterationType === kIsSet) {\n        if (!setEquiv(a, b, strict, memos)) {\n          return false;\n        }\n      } else if (iterationType === kIsMap) {\n        if (!mapEquiv(a, b, strict, memos)) {\n          return false;\n        }\n      } else if (iterationType === kIsArray) {\n        for (; i < a.length; i++) {\n          if (hasOwnProperty(a, i)) {\n            if (!hasOwnProperty(b, i) || !innerDeepEqual(a[i], b[i], strict, memos)) {\n              return false;\n            }\n          } else if (hasOwnProperty(b, i)) {\n            return false;\n          } else {\n            var keysA = Object.keys(a);\n            for (; i < keysA.length; i++) {\n              var key = keysA[i];\n              if (!hasOwnProperty(b, key) || !innerDeepEqual(a[key], b[key], strict, memos)) {\n                return false;\n              }\n            }\n            if (keysA.length !== Object.keys(b).length) {\n              return false;\n            }\n            return true;\n          }\n        }\n      }\n      for (i = 0; i < keys.length; i++) {\n        var _key2 = keys[i];\n        if (!innerDeepEqual(a[_key2], b[_key2], strict, memos)) {\n          return false;\n        }\n      }\n      return true;\n    }\n    function isDeepEqual(val1, val2) {\n      return innerDeepEqual(val1, val2, kLoose);\n    }\n    function isDeepStrictEqual(val1, val2) {\n      return innerDeepEqual(val1, val2, kStrict);\n    }\n    module2.exports = {\n      isDeepEqual,\n      isDeepStrictEqual\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/assert@2.1.0/node_modules/assert/build/assert.js\nvar require_assert = __commonJS({\n  \"../../node_modules/.pnpm/assert@2.1.0/node_modules/assert/build/assert.js\"(exports2, module2) {\n    \"use strict\";\n    function _typeof(o) {\n      \"@babel/helpers - typeof\";\n      return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function(o2) {\n        return typeof o2;\n      } : function(o2) {\n        return o2 && \"function\" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? \"symbol\" : typeof o2;\n      }, _typeof(o);\n    }\n    function _defineProperties(target, props) {\n      for (var i = 0; i < props.length; i++) {\n        var descriptor = props[i];\n        descriptor.enumerable = descriptor.enumerable || false;\n        descriptor.configurable = true;\n        if (\"value\" in descriptor) descriptor.writable = true;\n        Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);\n      }\n    }\n    function _createClass(Constructor, protoProps, staticProps) {\n      if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n      if (staticProps) _defineProperties(Constructor, staticProps);\n      Object.defineProperty(Constructor, \"prototype\", { writable: false });\n      return Constructor;\n    }\n    function _toPropertyKey(arg) {\n      var key = _toPrimitive(arg, \"string\");\n      return _typeof(key) === \"symbol\" ? key : String(key);\n    }\n    function _toPrimitive(input, hint) {\n      if (_typeof(input) !== \"object\" || input === null) return input;\n      var prim = input[Symbol.toPrimitive];\n      if (prim !== void 0) {\n        var res = prim.call(input, hint || \"default\");\n        if (_typeof(res) !== \"object\") return res;\n        throw new TypeError(\"@@toPrimitive must return a primitive value.\");\n      }\n      return (hint === \"string\" ? String : Number)(input);\n    }\n    function _classCallCheck(instance, Constructor) {\n      if (!(instance instanceof Constructor)) {\n        throw new TypeError(\"Cannot call a class as a function\");\n      }\n    }\n    var _require = require_errors();\n    var _require$codes = _require.codes;\n    var ERR_AMBIGUOUS_ARGUMENT = _require$codes.ERR_AMBIGUOUS_ARGUMENT;\n    var ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE;\n    var ERR_INVALID_ARG_VALUE = _require$codes.ERR_INVALID_ARG_VALUE;\n    var ERR_INVALID_RETURN_VALUE = _require$codes.ERR_INVALID_RETURN_VALUE;\n    var ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS;\n    var AssertionError = require_assertion_error();\n    var _require2 = require_util();\n    var inspect = _require2.inspect;\n    var _require$types = require_util().types;\n    var isPromise = _require$types.isPromise;\n    var isRegExp = _require$types.isRegExp;\n    var objectAssign = require_polyfill()();\n    var objectIs = require_polyfill2()();\n    var RegExpPrototypeTest = require_callBound()(\"RegExp.prototype.test\");\n    var isDeepEqual;\n    var isDeepStrictEqual;\n    function lazyLoadComparison() {\n      var comparison = require_comparisons();\n      isDeepEqual = comparison.isDeepEqual;\n      isDeepStrictEqual = comparison.isDeepStrictEqual;\n    }\n    var warned = false;\n    var assert = module2.exports = ok;\n    var NO_EXCEPTION_SENTINEL = {};\n    function innerFail(obj) {\n      if (obj.message instanceof Error) throw obj.message;\n      throw new AssertionError(obj);\n    }\n    function fail(actual, expected, message, operator, stackStartFn) {\n      var argsLen = arguments.length;\n      var internalMessage;\n      if (argsLen === 0) {\n        internalMessage = \"Failed\";\n      } else if (argsLen === 1) {\n        message = actual;\n        actual = void 0;\n      } else {\n        if (warned === false) {\n          warned = true;\n          var warn = process.emitWarning ? process.emitWarning : console.warn.bind(console);\n          warn(\"assert.fail() with more than one argument is deprecated. Please use assert.strictEqual() instead or only pass a message.\", \"DeprecationWarning\", \"DEP0094\");\n        }\n        if (argsLen === 2) operator = \"!=\";\n      }\n      if (message instanceof Error) throw message;\n      var errArgs = {\n        actual,\n        expected,\n        operator: operator === void 0 ? \"fail\" : operator,\n        stackStartFn: stackStartFn || fail\n      };\n      if (message !== void 0) {\n        errArgs.message = message;\n      }\n      var err = new AssertionError(errArgs);\n      if (internalMessage) {\n        err.message = internalMessage;\n        err.generatedMessage = true;\n      }\n      throw err;\n    }\n    assert.fail = fail;\n    assert.AssertionError = AssertionError;\n    function innerOk(fn, argLen, value, message) {\n      if (!value) {\n        var generatedMessage = false;\n        if (argLen === 0) {\n          generatedMessage = true;\n          message = \"No value argument passed to `assert.ok()`\";\n        } else if (message instanceof Error) {\n          throw message;\n        }\n        var err = new AssertionError({\n          actual: value,\n          expected: true,\n          message,\n          operator: \"==\",\n          stackStartFn: fn\n        });\n        err.generatedMessage = generatedMessage;\n        throw err;\n      }\n    }\n    function ok() {\n      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n        args[_key] = arguments[_key];\n      }\n      innerOk.apply(void 0, [ok, args.length].concat(args));\n    }\n    assert.ok = ok;\n    assert.equal = function equal(actual, expected, message) {\n      if (arguments.length < 2) {\n        throw new ERR_MISSING_ARGS(\"actual\", \"expected\");\n      }\n      if (actual != expected) {\n        innerFail({\n          actual,\n          expected,\n          message,\n          operator: \"==\",\n          stackStartFn: equal\n        });\n      }\n    };\n    assert.notEqual = function notEqual(actual, expected, message) {\n      if (arguments.length < 2) {\n        throw new ERR_MISSING_ARGS(\"actual\", \"expected\");\n      }\n      if (actual == expected) {\n        innerFail({\n          actual,\n          expected,\n          message,\n          operator: \"!=\",\n          stackStartFn: notEqual\n        });\n      }\n    };\n    assert.deepEqual = function deepEqual(actual, expected, message) {\n      if (arguments.length < 2) {\n        throw new ERR_MISSING_ARGS(\"actual\", \"expected\");\n      }\n      if (isDeepEqual === void 0) lazyLoadComparison();\n      if (!isDeepEqual(actual, expected)) {\n        innerFail({\n          actual,\n          expected,\n          message,\n          operator: \"deepEqual\",\n          stackStartFn: deepEqual\n        });\n      }\n    };\n    assert.notDeepEqual = function notDeepEqual(actual, expected, message) {\n      if (arguments.length < 2) {\n        throw new ERR_MISSING_ARGS(\"actual\", \"expected\");\n      }\n      if (isDeepEqual === void 0) lazyLoadComparison();\n      if (isDeepEqual(actual, expected)) {\n        innerFail({\n          actual,\n          expected,\n          message,\n          operator: \"notDeepEqual\",\n          stackStartFn: notDeepEqual\n        });\n      }\n    };\n    assert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {\n      if (arguments.length < 2) {\n        throw new ERR_MISSING_ARGS(\"actual\", \"expected\");\n      }\n      if (isDeepEqual === void 0) lazyLoadComparison();\n      if (!isDeepStrictEqual(actual, expected)) {\n        innerFail({\n          actual,\n          expected,\n          message,\n          operator: \"deepStrictEqual\",\n          stackStartFn: deepStrictEqual\n        });\n      }\n    };\n    assert.notDeepStrictEqual = notDeepStrictEqual;\n    function notDeepStrictEqual(actual, expected, message) {\n      if (arguments.length < 2) {\n        throw new ERR_MISSING_ARGS(\"actual\", \"expected\");\n      }\n      if (isDeepEqual === void 0) lazyLoadComparison();\n      if (isDeepStrictEqual(actual, expected)) {\n        innerFail({\n          actual,\n          expected,\n          message,\n          operator: \"notDeepStrictEqual\",\n          stackStartFn: notDeepStrictEqual\n        });\n      }\n    }\n    assert.strictEqual = function strictEqual(actual, expected, message) {\n      if (arguments.length < 2) {\n        throw new ERR_MISSING_ARGS(\"actual\", \"expected\");\n      }\n      if (!objectIs(actual, expected)) {\n        innerFail({\n          actual,\n          expected,\n          message,\n          operator: \"strictEqual\",\n          stackStartFn: strictEqual\n        });\n      }\n    };\n    assert.notStrictEqual = function notStrictEqual(actual, expected, message) {\n      if (arguments.length < 2) {\n        throw new ERR_MISSING_ARGS(\"actual\", \"expected\");\n      }\n      if (objectIs(actual, expected)) {\n        innerFail({\n          actual,\n          expected,\n          message,\n          operator: \"notStrictEqual\",\n          stackStartFn: notStrictEqual\n        });\n      }\n    };\n    var Comparison = /* @__PURE__ */ _createClass(function Comparison2(obj, keys, actual) {\n      var _this = this;\n      _classCallCheck(this, Comparison2);\n      keys.forEach(function(key) {\n        if (key in obj) {\n          if (actual !== void 0 && typeof actual[key] === \"string\" && isRegExp(obj[key]) && RegExpPrototypeTest(obj[key], actual[key])) {\n            _this[key] = actual[key];\n          } else {\n            _this[key] = obj[key];\n          }\n        }\n      });\n    });\n    function compareExceptionKey(actual, expected, key, message, keys, fn) {\n      if (!(key in actual) || !isDeepStrictEqual(actual[key], expected[key])) {\n        if (!message) {\n          var a = new Comparison(actual, keys);\n          var b = new Comparison(expected, keys, actual);\n          var err = new AssertionError({\n            actual: a,\n            expected: b,\n            operator: \"deepStrictEqual\",\n            stackStartFn: fn\n          });\n          err.actual = actual;\n          err.expected = expected;\n          err.operator = fn.name;\n          throw err;\n        }\n        innerFail({\n          actual,\n          expected,\n          message,\n          operator: fn.name,\n          stackStartFn: fn\n        });\n      }\n    }\n    function expectedException(actual, expected, msg, fn) {\n      if (typeof expected !== \"function\") {\n        if (isRegExp(expected)) return RegExpPrototypeTest(expected, actual);\n        if (arguments.length === 2) {\n          throw new ERR_INVALID_ARG_TYPE(\"expected\", [\"Function\", \"RegExp\"], expected);\n        }\n        if (_typeof(actual) !== \"object\" || actual === null) {\n          var err = new AssertionError({\n            actual,\n            expected,\n            message: msg,\n            operator: \"deepStrictEqual\",\n            stackStartFn: fn\n          });\n          err.operator = fn.name;\n          throw err;\n        }\n        var keys = Object.keys(expected);\n        if (expected instanceof Error) {\n          keys.push(\"name\", \"message\");\n        } else if (keys.length === 0) {\n          throw new ERR_INVALID_ARG_VALUE(\"error\", expected, \"may not be an empty object\");\n        }\n        if (isDeepEqual === void 0) lazyLoadComparison();\n        keys.forEach(function(key) {\n          if (typeof actual[key] === \"string\" && isRegExp(expected[key]) && RegExpPrototypeTest(expected[key], actual[key])) {\n            return;\n          }\n          compareExceptionKey(actual, expected, key, msg, keys, fn);\n        });\n        return true;\n      }\n      if (expected.prototype !== void 0 && actual instanceof expected) {\n        return true;\n      }\n      if (Error.isPrototypeOf(expected)) {\n        return false;\n      }\n      return expected.call({}, actual) === true;\n    }\n    function getActual(fn) {\n      if (typeof fn !== \"function\") {\n        throw new ERR_INVALID_ARG_TYPE(\"fn\", \"Function\", fn);\n      }\n      try {\n        fn();\n      } catch (e) {\n        return e;\n      }\n      return NO_EXCEPTION_SENTINEL;\n    }\n    function checkIsPromise(obj) {\n      return isPromise(obj) || obj !== null && _typeof(obj) === \"object\" && typeof obj.then === \"function\" && typeof obj.catch === \"function\";\n    }\n    function waitForActual(promiseFn) {\n      return Promise.resolve().then(function() {\n        var resultPromise;\n        if (typeof promiseFn === \"function\") {\n          resultPromise = promiseFn();\n          if (!checkIsPromise(resultPromise)) {\n            throw new ERR_INVALID_RETURN_VALUE(\"instance of Promise\", \"promiseFn\", resultPromise);\n          }\n        } else if (checkIsPromise(promiseFn)) {\n          resultPromise = promiseFn;\n        } else {\n          throw new ERR_INVALID_ARG_TYPE(\"promiseFn\", [\"Function\", \"Promise\"], promiseFn);\n        }\n        return Promise.resolve().then(function() {\n          return resultPromise;\n        }).then(function() {\n          return NO_EXCEPTION_SENTINEL;\n        }).catch(function(e) {\n          return e;\n        });\n      });\n    }\n    function expectsError(stackStartFn, actual, error, message) {\n      if (typeof error === \"string\") {\n        if (arguments.length === 4) {\n          throw new ERR_INVALID_ARG_TYPE(\"error\", [\"Object\", \"Error\", \"Function\", \"RegExp\"], error);\n        }\n        if (_typeof(actual) === \"object\" && actual !== null) {\n          if (actual.message === error) {\n            throw new ERR_AMBIGUOUS_ARGUMENT(\"error/message\", 'The error message \"'.concat(actual.message, '\" is identical to the message.'));\n          }\n        } else if (actual === error) {\n          throw new ERR_AMBIGUOUS_ARGUMENT(\"error/message\", 'The error \"'.concat(actual, '\" is identical to the message.'));\n        }\n        message = error;\n        error = void 0;\n      } else if (error != null && _typeof(error) !== \"object\" && typeof error !== \"function\") {\n        throw new ERR_INVALID_ARG_TYPE(\"error\", [\"Object\", \"Error\", \"Function\", \"RegExp\"], error);\n      }\n      if (actual === NO_EXCEPTION_SENTINEL) {\n        var details = \"\";\n        if (error && error.name) {\n          details += \" (\".concat(error.name, \")\");\n        }\n        details += message ? \": \".concat(message) : \".\";\n        var fnType = stackStartFn.name === \"rejects\" ? \"rejection\" : \"exception\";\n        innerFail({\n          actual: void 0,\n          expected: error,\n          operator: stackStartFn.name,\n          message: \"Missing expected \".concat(fnType).concat(details),\n          stackStartFn\n        });\n      }\n      if (error && !expectedException(actual, error, message, stackStartFn)) {\n        throw actual;\n      }\n    }\n    function expectsNoError(stackStartFn, actual, error, message) {\n      if (actual === NO_EXCEPTION_SENTINEL) return;\n      if (typeof error === \"string\") {\n        message = error;\n        error = void 0;\n      }\n      if (!error || expectedException(actual, error)) {\n        var details = message ? \": \".concat(message) : \".\";\n        var fnType = stackStartFn.name === \"doesNotReject\" ? \"rejection\" : \"exception\";\n        innerFail({\n          actual,\n          expected: error,\n          operator: stackStartFn.name,\n          message: \"Got unwanted \".concat(fnType).concat(details, \"\\n\") + 'Actual message: \"'.concat(actual && actual.message, '\"'),\n          stackStartFn\n        });\n      }\n      throw actual;\n    }\n    assert.throws = function throws(promiseFn) {\n      for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {\n        args[_key2 - 1] = arguments[_key2];\n      }\n      expectsError.apply(void 0, [throws, getActual(promiseFn)].concat(args));\n    };\n    assert.rejects = function rejects(promiseFn) {\n      for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {\n        args[_key3 - 1] = arguments[_key3];\n      }\n      return waitForActual(promiseFn).then(function(result) {\n        return expectsError.apply(void 0, [rejects, result].concat(args));\n      });\n    };\n    assert.doesNotThrow = function doesNotThrow(fn) {\n      for (var _len4 = arguments.length, args = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {\n        args[_key4 - 1] = arguments[_key4];\n      }\n      expectsNoError.apply(void 0, [doesNotThrow, getActual(fn)].concat(args));\n    };\n    assert.doesNotReject = function doesNotReject(fn) {\n      for (var _len5 = arguments.length, args = new Array(_len5 > 1 ? _len5 - 1 : 0), _key5 = 1; _key5 < _len5; _key5++) {\n        args[_key5 - 1] = arguments[_key5];\n      }\n      return waitForActual(fn).then(function(result) {\n        return expectsNoError.apply(void 0, [doesNotReject, result].concat(args));\n      });\n    };\n    assert.ifError = function ifError(err) {\n      if (err !== null && err !== void 0) {\n        var message = \"ifError got unwanted exception: \";\n        if (_typeof(err) === \"object\" && typeof err.message === \"string\") {\n          if (err.message.length === 0 && err.constructor) {\n            message += err.constructor.name;\n          } else {\n            message += err.message;\n          }\n        } else {\n          message += inspect(err);\n        }\n        var newErr = new AssertionError({\n          actual: err,\n          expected: null,\n          operator: \"ifError\",\n          message,\n          stackStartFn: ifError\n        });\n        var origStack = err.stack;\n        if (typeof origStack === \"string\") {\n          var tmp2 = origStack.split(\"\\n\");\n          tmp2.shift();\n          var tmp1 = newErr.stack.split(\"\\n\");\n          for (var i = 0; i < tmp2.length; i++) {\n            var pos = tmp1.indexOf(tmp2[i]);\n            if (pos !== -1) {\n              tmp1 = tmp1.slice(0, pos);\n              break;\n            }\n          }\n          newErr.stack = \"\".concat(tmp1.join(\"\\n\"), \"\\n\").concat(tmp2.join(\"\\n\"));\n        }\n        throw newErr;\n      }\n    };\n    function internalMatch(string, regexp, message, fn, fnName) {\n      if (!isRegExp(regexp)) {\n        throw new ERR_INVALID_ARG_TYPE(\"regexp\", \"RegExp\", regexp);\n      }\n      var match = fnName === \"match\";\n      if (typeof string !== \"string\" || RegExpPrototypeTest(regexp, string) !== match) {\n        if (message instanceof Error) {\n          throw message;\n        }\n        var generatedMessage = !message;\n        message = message || (typeof string !== \"string\" ? 'The \"string\" argument must be of type string. Received type ' + \"\".concat(_typeof(string), \" (\").concat(inspect(string), \")\") : (match ? \"The input did not match the regular expression \" : \"The input was expected to not match the regular expression \") + \"\".concat(inspect(regexp), \". Input:\\n\\n\").concat(inspect(string), \"\\n\"));\n        var err = new AssertionError({\n          actual: string,\n          expected: regexp,\n          message,\n          operator: fnName,\n          stackStartFn: fn\n        });\n        err.generatedMessage = generatedMessage;\n        throw err;\n      }\n    }\n    assert.match = function match(string, regexp, message) {\n      internalMatch(string, regexp, message, match, \"match\");\n    };\n    assert.doesNotMatch = function doesNotMatch(string, regexp, message) {\n      internalMatch(string, regexp, message, doesNotMatch, \"doesNotMatch\");\n    };\n    function strict() {\n      for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {\n        args[_key6] = arguments[_key6];\n      }\n      innerOk.apply(void 0, [strict, args.length].concat(args));\n    }\n    assert.strict = objectAssign(strict, assert, {\n      equal: assert.strictEqual,\n      deepEqual: assert.deepStrictEqual,\n      notEqual: assert.notStrictEqual,\n      notDeepEqual: assert.notDeepStrictEqual\n    });\n    assert.strict.strict = assert.strict;\n  }\n});\n\n// <stdin>\nvar imported = require_assert();\nvar resolved = imported.default ?? imported;\nmodule.exports = resolved;\n/*! Bundled license information:\n\nassert/build/internal/util/comparisons.js:\n  (*!\n   * The buffer module from node.js, for the browser.\n   *\n   * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n   * @license  MIT\n   *)\n*/\n\nif (module.exports && module.exports.default == null) module.exports.default = module.exports;\n";
+export const BROWSER_EVENTS_POLYFILL_CODE = "var process = globalThis.process || {\n  env: {},\n  cwd: () => '/',\n  nextTick: (fn, ...args) => queueMicrotask(() => fn(...args)),\n};\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __commonJS = (cb, mod) => function __require() {\n  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;\n};\n\n// ../../node_modules/.pnpm/events@3.3.0/node_modules/events/events.js\nvar require_events = __commonJS({\n  \"../../node_modules/.pnpm/events@3.3.0/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// <stdin>\nvar imported = require_events();\nvar resolved = imported.default ?? imported;\nmodule.exports = resolved;\n\nif (module.exports && module.exports.default == null) module.exports.default = module.exports;\n";
+export const BROWSER_QUERYSTRING_POLYFILL_CODE = "var process = globalThis.process || {\n  env: {},\n  cwd: () => '/',\n  nextTick: (fn, ...args) => queueMicrotask(() => fn(...args)),\n};\nvar __create = Object.create;\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __getProtoOf = Object.getPrototypeOf;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __esm = (fn, res) => function __init() {\n  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;\n};\nvar __commonJS = (cb, mod) => function __require() {\n  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;\n};\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(\n  // If the importer is in node compatibility mode or this is not an ESM\n  // file that has been converted to a CommonJS file using a Babel-\n  // compatible transform (i.e. \"__esModule\" has not been set), then set\n  // \"default\" to the CommonJS \"module.exports\" for node compatibility.\n  isNodeMode || !mod || !mod.__esModule ? __defProp(target, \"default\", { value: mod, enumerable: true }) : target,\n  mod\n));\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\n\n// ../../node_modules/.pnpm/querystring-es3@0.2.1/node_modules/querystring-es3/decode.js\nvar require_decode = __commonJS({\n  \"../../node_modules/.pnpm/querystring-es3@0.2.1/node_modules/querystring-es3/decode.js\"(exports2, module2) {\n    \"use strict\";\n    function hasOwnProperty(obj, prop) {\n      return Object.prototype.hasOwnProperty.call(obj, prop);\n    }\n    module2.exports = function(qs, sep, eq, options) {\n      sep = sep || \"&\";\n      eq = eq || \"=\";\n      var obj = {};\n      if (typeof qs !== \"string\" || qs.length === 0) {\n        return obj;\n      }\n      var regexp = /\\+/g;\n      qs = qs.split(sep);\n      var maxKeys = 1e3;\n      if (options && typeof options.maxKeys === \"number\") {\n        maxKeys = options.maxKeys;\n      }\n      var len = qs.length;\n      if (maxKeys > 0 && len > maxKeys) {\n        len = maxKeys;\n      }\n      for (var i = 0; i < len; ++i) {\n        var x = qs[i].replace(regexp, \"%20\"), idx = x.indexOf(eq), kstr, vstr, k, v;\n        if (idx >= 0) {\n          kstr = x.substr(0, idx);\n          vstr = x.substr(idx + 1);\n        } else {\n          kstr = x;\n          vstr = \"\";\n        }\n        k = decodeURIComponent(kstr);\n        v = decodeURIComponent(vstr);\n        if (!hasOwnProperty(obj, k)) {\n          obj[k] = v;\n        } else if (isArray(obj[k])) {\n          obj[k].push(v);\n        } else {\n          obj[k] = [obj[k], v];\n        }\n      }\n      return obj;\n    };\n    var isArray = Array.isArray || function(xs) {\n      return Object.prototype.toString.call(xs) === \"[object Array]\";\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/querystring-es3@0.2.1/node_modules/querystring-es3/encode.js\nvar require_encode = __commonJS({\n  \"../../node_modules/.pnpm/querystring-es3@0.2.1/node_modules/querystring-es3/encode.js\"(exports2, module2) {\n    \"use strict\";\n    var stringifyPrimitive = function(v) {\n      switch (typeof v) {\n        case \"string\":\n          return v;\n        case \"boolean\":\n          return v ? \"true\" : \"false\";\n        case \"number\":\n          return isFinite(v) ? v : \"\";\n        default:\n          return \"\";\n      }\n    };\n    module2.exports = function(obj, sep, eq, name) {\n      sep = sep || \"&\";\n      eq = eq || \"=\";\n      if (obj === null) {\n        obj = void 0;\n      }\n      if (typeof obj === \"object\") {\n        return map(objectKeys(obj), function(k) {\n          var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;\n          if (isArray(obj[k])) {\n            return map(obj[k], function(v) {\n              return ks + encodeURIComponent(stringifyPrimitive(v));\n            }).join(sep);\n          } else {\n            return ks + encodeURIComponent(stringifyPrimitive(obj[k]));\n          }\n        }).join(sep);\n      }\n      if (!name) return \"\";\n      return encodeURIComponent(stringifyPrimitive(name)) + eq + encodeURIComponent(stringifyPrimitive(obj));\n    };\n    var isArray = Array.isArray || function(xs) {\n      return Object.prototype.toString.call(xs) === \"[object Array]\";\n    };\n    function map(xs, f) {\n      if (xs.map) return xs.map(f);\n      var res = [];\n      for (var i = 0; i < xs.length; i++) {\n        res.push(f(xs[i], i));\n      }\n      return res;\n    }\n    var objectKeys = Object.keys || function(obj) {\n      var res = [];\n      for (var key in obj) {\n        if (Object.prototype.hasOwnProperty.call(obj, key)) res.push(key);\n      }\n      return res;\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/querystring-es3@0.2.1/node_modules/querystring-es3/index.js\nvar require_querystring_es3 = __commonJS({\n  \"../../node_modules/.pnpm/querystring-es3@0.2.1/node_modules/querystring-es3/index.js\"(exports2) {\n    \"use strict\";\n    exports2.decode = exports2.parse = require_decode();\n    exports2.encode = exports2.stringify = require_encode();\n  }\n});\n\n// ../../node_modules/.pnpm/node-stdlib-browser@1.3.1/node_modules/node-stdlib-browser/esm/proxy/querystring.js\nvar querystring_exports = {};\n__export(querystring_exports, {\n  decode: () => import_querystring_es32.decode,\n  default: () => api,\n  encode: () => import_querystring_es32.encode,\n  escape: () => qsEscape,\n  parse: () => import_querystring_es32.parse,\n  stringify: () => import_querystring_es32.stringify,\n  unescape: () => qsUnescape\n});\nfunction qsEscape(string) {\n  return encodeURIComponent(string);\n}\nfunction qsUnescape(string) {\n  return decodeURIComponent(string);\n}\nvar import_querystring_es3, import_querystring_es32, api;\nvar init_querystring = __esm({\n  \"../../node_modules/.pnpm/node-stdlib-browser@1.3.1/node_modules/node-stdlib-browser/esm/proxy/querystring.js\"() {\n    import_querystring_es3 = __toESM(require_querystring_es3(), 1);\n    import_querystring_es32 = __toESM(require_querystring_es3(), 1);\n    api = {\n      decode: import_querystring_es3.decode,\n      encode: import_querystring_es3.encode,\n      parse: import_querystring_es3.parse,\n      stringify: import_querystring_es3.stringify,\n      escape: qsEscape,\n      unescape: qsUnescape\n    };\n  }\n});\n\n// <stdin>\nvar imported = (init_querystring(), __toCommonJS(querystring_exports));\nvar resolved = imported.default ?? imported;\nmodule.exports = resolved;\n\nif (module.exports && module.exports.default == null) module.exports.default = module.exports;\n";
+export const BROWSER_STREAM_POLYFILL_CODE = "var process = globalThis.process || {\n  env: {},\n  cwd: () => '/',\n  nextTick: (fn, ...args) => queueMicrotask(() => fn(...args)),\n};\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __esm = (fn, res) => function __init() {\n  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;\n};\nvar __commonJS = (cb, mod) => function __require() {\n  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;\n};\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\n\n// ../../node_modules/.pnpm/base64-js@1.5.1/node_modules/base64-js/index.js\nvar require_base64_js = __commonJS({\n  \"../../node_modules/.pnpm/base64-js@1.5.1/node_modules/base64-js/index.js\"(exports2) {\n    \"use strict\";\n    exports2.byteLength = byteLength;\n    exports2.toByteArray = toByteArray;\n    exports2.fromByteArray = fromByteArray;\n    var lookup = [];\n    var revLookup = [];\n    var Arr = typeof Uint8Array !== \"undefined\" ? Uint8Array : Array;\n    var code = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\";\n    for (i = 0, len = code.length; i < len; ++i) {\n      lookup[i] = code[i];\n      revLookup[code.charCodeAt(i)] = i;\n    }\n    var i;\n    var len;\n    revLookup[\"-\".charCodeAt(0)] = 62;\n    revLookup[\"_\".charCodeAt(0)] = 63;\n    function getLens(b64) {\n      var len2 = b64.length;\n      if (len2 % 4 > 0) {\n        throw new Error(\"Invalid string. Length must be a multiple of 4\");\n      }\n      var validLen = b64.indexOf(\"=\");\n      if (validLen === -1) validLen = len2;\n      var placeHoldersLen = validLen === len2 ? 0 : 4 - validLen % 4;\n      return [validLen, placeHoldersLen];\n    }\n    function byteLength(b64) {\n      var lens = getLens(b64);\n      var validLen = lens[0];\n      var placeHoldersLen = lens[1];\n      return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;\n    }\n    function _byteLength(b64, validLen, placeHoldersLen) {\n      return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;\n    }\n    function toByteArray(b64) {\n      var tmp;\n      var lens = getLens(b64);\n      var validLen = lens[0];\n      var placeHoldersLen = lens[1];\n      var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));\n      var curByte = 0;\n      var len2 = placeHoldersLen > 0 ? validLen - 4 : validLen;\n      var i2;\n      for (i2 = 0; i2 < len2; i2 += 4) {\n        tmp = revLookup[b64.charCodeAt(i2)] << 18 | revLookup[b64.charCodeAt(i2 + 1)] << 12 | revLookup[b64.charCodeAt(i2 + 2)] << 6 | revLookup[b64.charCodeAt(i2 + 3)];\n        arr[curByte++] = tmp >> 16 & 255;\n        arr[curByte++] = tmp >> 8 & 255;\n        arr[curByte++] = tmp & 255;\n      }\n      if (placeHoldersLen === 2) {\n        tmp = revLookup[b64.charCodeAt(i2)] << 2 | revLookup[b64.charCodeAt(i2 + 1)] >> 4;\n        arr[curByte++] = tmp & 255;\n      }\n      if (placeHoldersLen === 1) {\n        tmp = revLookup[b64.charCodeAt(i2)] << 10 | revLookup[b64.charCodeAt(i2 + 1)] << 4 | revLookup[b64.charCodeAt(i2 + 2)] >> 2;\n        arr[curByte++] = tmp >> 8 & 255;\n        arr[curByte++] = tmp & 255;\n      }\n      return arr;\n    }\n    function tripletToBase64(num) {\n      return lookup[num >> 18 & 63] + lookup[num >> 12 & 63] + lookup[num >> 6 & 63] + lookup[num & 63];\n    }\n    function encodeChunk(uint8, start, end) {\n      var tmp;\n      var output = [];\n      for (var i2 = start; i2 < end; i2 += 3) {\n        tmp = (uint8[i2] << 16 & 16711680) + (uint8[i2 + 1] << 8 & 65280) + (uint8[i2 + 2] & 255);\n        output.push(tripletToBase64(tmp));\n      }\n      return output.join(\"\");\n    }\n    function fromByteArray(uint8) {\n      var tmp;\n      var len2 = uint8.length;\n      var extraBytes = len2 % 3;\n      var parts = [];\n      var maxChunkLength = 16383;\n      for (var i2 = 0, len22 = len2 - extraBytes; i2 < len22; i2 += maxChunkLength) {\n        parts.push(encodeChunk(uint8, i2, i2 + maxChunkLength > len22 ? len22 : i2 + maxChunkLength));\n      }\n      if (extraBytes === 1) {\n        tmp = uint8[len2 - 1];\n        parts.push(\n          lookup[tmp >> 2] + lookup[tmp << 4 & 63] + \"==\"\n        );\n      } else if (extraBytes === 2) {\n        tmp = (uint8[len2 - 2] << 8) + uint8[len2 - 1];\n        parts.push(\n          lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63] + \"=\"\n        );\n      }\n      return parts.join(\"\");\n    }\n  }\n});\n\n// ../../node_modules/.pnpm/ieee754@1.2.1/node_modules/ieee754/index.js\nvar require_ieee754 = __commonJS({\n  \"../../node_modules/.pnpm/ieee754@1.2.1/node_modules/ieee754/index.js\"(exports2) {\n    exports2.read = function(buffer, offset, isLE, mLen, nBytes) {\n      var e, m;\n      var eLen = nBytes * 8 - mLen - 1;\n      var eMax = (1 << eLen) - 1;\n      var eBias = eMax >> 1;\n      var nBits = -7;\n      var i = isLE ? nBytes - 1 : 0;\n      var d = isLE ? -1 : 1;\n      var s = buffer[offset + i];\n      i += d;\n      e = s & (1 << -nBits) - 1;\n      s >>= -nBits;\n      nBits += eLen;\n      for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {\n      }\n      m = e & (1 << -nBits) - 1;\n      e >>= -nBits;\n      nBits += mLen;\n      for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {\n      }\n      if (e === 0) {\n        e = 1 - eBias;\n      } else if (e === eMax) {\n        return m ? NaN : (s ? -1 : 1) * Infinity;\n      } else {\n        m = m + Math.pow(2, mLen);\n        e = e - eBias;\n      }\n      return (s ? -1 : 1) * m * Math.pow(2, e - mLen);\n    };\n    exports2.write = function(buffer, value, offset, isLE, mLen, nBytes) {\n      var e, m, c;\n      var eLen = nBytes * 8 - mLen - 1;\n      var eMax = (1 << eLen) - 1;\n      var eBias = eMax >> 1;\n      var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;\n      var i = isLE ? 0 : nBytes - 1;\n      var d = isLE ? 1 : -1;\n      var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;\n      value = Math.abs(value);\n      if (isNaN(value) || value === Infinity) {\n        m = isNaN(value) ? 1 : 0;\n        e = eMax;\n      } else {\n        e = Math.floor(Math.log(value) / Math.LN2);\n        if (value * (c = Math.pow(2, -e)) < 1) {\n          e--;\n          c *= 2;\n        }\n        if (e + eBias >= 1) {\n          value += rt / c;\n        } else {\n          value += rt * Math.pow(2, 1 - eBias);\n        }\n        if (value * c >= 2) {\n          e++;\n          c /= 2;\n        }\n        if (e + eBias >= eMax) {\n          m = 0;\n          e = eMax;\n        } else if (e + eBias >= 1) {\n          m = (value * c - 1) * Math.pow(2, mLen);\n          e = e + eBias;\n        } else {\n          m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);\n          e = 0;\n        }\n      }\n      for (; mLen >= 8; buffer[offset + i] = m & 255, i += d, m /= 256, mLen -= 8) {\n      }\n      e = e << mLen | m;\n      eLen += mLen;\n      for (; eLen > 0; buffer[offset + i] = e & 255, i += d, e /= 256, eLen -= 8) {\n      }\n      buffer[offset + i - d] |= s * 128;\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/buffer@5.7.1/node_modules/buffer/index.js\nvar require_buffer = __commonJS({\n  \"../../node_modules/.pnpm/buffer@5.7.1/node_modules/buffer/index.js\"(exports2) {\n    \"use strict\";\n    var base64 = require_base64_js();\n    var ieee754 = require_ieee754();\n    var customInspectSymbol = typeof Symbol === \"function\" && typeof Symbol[\"for\"] === \"function\" ? Symbol[\"for\"](\"nodejs.util.inspect.custom\") : null;\n    exports2.Buffer = Buffer2;\n    exports2.SlowBuffer = SlowBuffer;\n    exports2.INSPECT_MAX_BYTES = 50;\n    var K_MAX_LENGTH = 2147483647;\n    exports2.kMaxLength = K_MAX_LENGTH;\n    Buffer2.TYPED_ARRAY_SUPPORT = typedArraySupport();\n    if (!Buffer2.TYPED_ARRAY_SUPPORT && typeof console !== \"undefined\" && typeof console.error === \"function\") {\n      console.error(\n        \"This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support.\"\n      );\n    }\n    function typedArraySupport() {\n      try {\n        var arr = new Uint8Array(1);\n        var proto = { foo: function() {\n          return 42;\n        } };\n        Object.setPrototypeOf(proto, Uint8Array.prototype);\n        Object.setPrototypeOf(arr, proto);\n        return arr.foo() === 42;\n      } catch (e) {\n        return false;\n      }\n    }\n    Object.defineProperty(Buffer2.prototype, \"parent\", {\n      enumerable: true,\n      get: function() {\n        if (!Buffer2.isBuffer(this)) return void 0;\n        return this.buffer;\n      }\n    });\n    Object.defineProperty(Buffer2.prototype, \"offset\", {\n      enumerable: true,\n      get: function() {\n        if (!Buffer2.isBuffer(this)) return void 0;\n        return this.byteOffset;\n      }\n    });\n    function createBuffer(length) {\n      if (length > K_MAX_LENGTH) {\n        throw new RangeError('The value \"' + length + '\" is invalid for option \"size\"');\n      }\n      var buf = new Uint8Array(length);\n      Object.setPrototypeOf(buf, Buffer2.prototype);\n      return buf;\n    }\n    function Buffer2(arg, encodingOrOffset, length) {\n      if (typeof arg === \"number\") {\n        if (typeof encodingOrOffset === \"string\") {\n          throw new TypeError(\n            'The \"string\" argument must be of type string. Received type number'\n          );\n        }\n        return allocUnsafe(arg);\n      }\n      return from(arg, encodingOrOffset, length);\n    }\n    Buffer2.poolSize = 8192;\n    function from(value, encodingOrOffset, length) {\n      if (typeof value === \"string\") {\n        return fromString(value, encodingOrOffset);\n      }\n      if (ArrayBuffer.isView(value)) {\n        return fromArrayView(value);\n      }\n      if (value == null) {\n        throw new TypeError(\n          \"The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type \" + typeof value\n        );\n      }\n      if (isInstance(value, ArrayBuffer) || value && isInstance(value.buffer, ArrayBuffer)) {\n        return fromArrayBuffer(value, encodingOrOffset, length);\n      }\n      if (typeof SharedArrayBuffer !== \"undefined\" && (isInstance(value, SharedArrayBuffer) || value && isInstance(value.buffer, SharedArrayBuffer))) {\n        return fromArrayBuffer(value, encodingOrOffset, length);\n      }\n      if (typeof value === \"number\") {\n        throw new TypeError(\n          'The \"value\" argument must not be of type number. Received type number'\n        );\n      }\n      var valueOf = value.valueOf && value.valueOf();\n      if (valueOf != null && valueOf !== value) {\n        return Buffer2.from(valueOf, encodingOrOffset, length);\n      }\n      var b = fromObject(value);\n      if (b) return b;\n      if (typeof Symbol !== \"undefined\" && Symbol.toPrimitive != null && typeof value[Symbol.toPrimitive] === \"function\") {\n        return Buffer2.from(\n          value[Symbol.toPrimitive](\"string\"),\n          encodingOrOffset,\n          length\n        );\n      }\n      throw new TypeError(\n        \"The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type \" + typeof value\n      );\n    }\n    Buffer2.from = function(value, encodingOrOffset, length) {\n      return from(value, encodingOrOffset, length);\n    };\n    Object.setPrototypeOf(Buffer2.prototype, Uint8Array.prototype);\n    Object.setPrototypeOf(Buffer2, Uint8Array);\n    function assertSize(size) {\n      if (typeof size !== \"number\") {\n        throw new TypeError('\"size\" argument must be of type number');\n      } else if (size < 0) {\n        throw new RangeError('The value \"' + size + '\" is invalid for option \"size\"');\n      }\n    }\n    function alloc(size, fill, encoding) {\n      assertSize(size);\n      if (size <= 0) {\n        return createBuffer(size);\n      }\n      if (fill !== void 0) {\n        return typeof encoding === \"string\" ? createBuffer(size).fill(fill, encoding) : createBuffer(size).fill(fill);\n      }\n      return createBuffer(size);\n    }\n    Buffer2.alloc = function(size, fill, encoding) {\n      return alloc(size, fill, encoding);\n    };\n    function allocUnsafe(size) {\n      assertSize(size);\n      return createBuffer(size < 0 ? 0 : checked(size) | 0);\n    }\n    Buffer2.allocUnsafe = function(size) {\n      return allocUnsafe(size);\n    };\n    Buffer2.allocUnsafeSlow = function(size) {\n      return allocUnsafe(size);\n    };\n    function fromString(string, encoding) {\n      if (typeof encoding !== \"string\" || encoding === \"\") {\n        encoding = \"utf8\";\n      }\n      if (!Buffer2.isEncoding(encoding)) {\n        throw new TypeError(\"Unknown encoding: \" + encoding);\n      }\n      var length = byteLength(string, encoding) | 0;\n      var buf = createBuffer(length);\n      var actual = buf.write(string, encoding);\n      if (actual !== length) {\n        buf = buf.slice(0, actual);\n      }\n      return buf;\n    }\n    function fromArrayLike(array) {\n      var length = array.length < 0 ? 0 : checked(array.length) | 0;\n      var buf = createBuffer(length);\n      for (var i = 0; i < length; i += 1) {\n        buf[i] = array[i] & 255;\n      }\n      return buf;\n    }\n    function fromArrayView(arrayView) {\n      if (isInstance(arrayView, Uint8Array)) {\n        var copy = new Uint8Array(arrayView);\n        return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength);\n      }\n      return fromArrayLike(arrayView);\n    }\n    function fromArrayBuffer(array, byteOffset, length) {\n      if (byteOffset < 0 || array.byteLength < byteOffset) {\n        throw new RangeError('\"offset\" is outside of buffer bounds');\n      }\n      if (array.byteLength < byteOffset + (length || 0)) {\n        throw new RangeError('\"length\" is outside of buffer bounds');\n      }\n      var buf;\n      if (byteOffset === void 0 && length === void 0) {\n        buf = new Uint8Array(array);\n      } else if (length === void 0) {\n        buf = new Uint8Array(array, byteOffset);\n      } else {\n        buf = new Uint8Array(array, byteOffset, length);\n      }\n      Object.setPrototypeOf(buf, Buffer2.prototype);\n      return buf;\n    }\n    function fromObject(obj) {\n      if (Buffer2.isBuffer(obj)) {\n        var len = checked(obj.length) | 0;\n        var buf = createBuffer(len);\n        if (buf.length === 0) {\n          return buf;\n        }\n        obj.copy(buf, 0, 0, len);\n        return buf;\n      }\n      if (obj.length !== void 0) {\n        if (typeof obj.length !== \"number\" || numberIsNaN(obj.length)) {\n          return createBuffer(0);\n        }\n        return fromArrayLike(obj);\n      }\n      if (obj.type === \"Buffer\" && Array.isArray(obj.data)) {\n        return fromArrayLike(obj.data);\n      }\n    }\n    function checked(length) {\n      if (length >= K_MAX_LENGTH) {\n        throw new RangeError(\"Attempt to allocate Buffer larger than maximum size: 0x\" + K_MAX_LENGTH.toString(16) + \" bytes\");\n      }\n      return length | 0;\n    }\n    function SlowBuffer(length) {\n      if (+length != length) {\n        length = 0;\n      }\n      return Buffer2.alloc(+length);\n    }\n    Buffer2.isBuffer = function isBuffer(b) {\n      return b != null && b._isBuffer === true && b !== Buffer2.prototype;\n    };\n    Buffer2.compare = function compare(a, b) {\n      if (isInstance(a, Uint8Array)) a = Buffer2.from(a, a.offset, a.byteLength);\n      if (isInstance(b, Uint8Array)) b = Buffer2.from(b, b.offset, b.byteLength);\n      if (!Buffer2.isBuffer(a) || !Buffer2.isBuffer(b)) {\n        throw new TypeError(\n          'The \"buf1\", \"buf2\" arguments must be one of type Buffer or Uint8Array'\n        );\n      }\n      if (a === b) return 0;\n      var x = a.length;\n      var y = b.length;\n      for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n        if (a[i] !== b[i]) {\n          x = a[i];\n          y = b[i];\n          break;\n        }\n      }\n      if (x < y) return -1;\n      if (y < x) return 1;\n      return 0;\n    };\n    Buffer2.isEncoding = function isEncoding(encoding) {\n      switch (String(encoding).toLowerCase()) {\n        case \"hex\":\n        case \"utf8\":\n        case \"utf-8\":\n        case \"ascii\":\n        case \"latin1\":\n        case \"binary\":\n        case \"base64\":\n        case \"ucs2\":\n        case \"ucs-2\":\n        case \"utf16le\":\n        case \"utf-16le\":\n          return true;\n        default:\n          return false;\n      }\n    };\n    Buffer2.concat = function concat(list, length) {\n      if (!Array.isArray(list)) {\n        throw new TypeError('\"list\" argument must be an Array of Buffers');\n      }\n      if (list.length === 0) {\n        return Buffer2.alloc(0);\n      }\n      var i;\n      if (length === void 0) {\n        length = 0;\n        for (i = 0; i < list.length; ++i) {\n          length += list[i].length;\n        }\n      }\n      var buffer = Buffer2.allocUnsafe(length);\n      var pos = 0;\n      for (i = 0; i < list.length; ++i) {\n        var buf = list[i];\n        if (isInstance(buf, Uint8Array)) {\n          if (pos + buf.length > buffer.length) {\n            Buffer2.from(buf).copy(buffer, pos);\n          } else {\n            Uint8Array.prototype.set.call(\n              buffer,\n              buf,\n              pos\n            );\n          }\n        } else if (!Buffer2.isBuffer(buf)) {\n          throw new TypeError('\"list\" argument must be an Array of Buffers');\n        } else {\n          buf.copy(buffer, pos);\n        }\n        pos += buf.length;\n      }\n      return buffer;\n    };\n    function byteLength(string, encoding) {\n      if (Buffer2.isBuffer(string)) {\n        return string.length;\n      }\n      if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {\n        return string.byteLength;\n      }\n      if (typeof string !== \"string\") {\n        throw new TypeError(\n          'The \"string\" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof string\n        );\n      }\n      var len = string.length;\n      var mustMatch = arguments.length > 2 && arguments[2] === true;\n      if (!mustMatch && len === 0) return 0;\n      var loweredCase = false;\n      for (; ; ) {\n        switch (encoding) {\n          case \"ascii\":\n          case \"latin1\":\n          case \"binary\":\n            return len;\n          case \"utf8\":\n          case \"utf-8\":\n            return utf8ToBytes(string).length;\n          case \"ucs2\":\n          case \"ucs-2\":\n          case \"utf16le\":\n          case \"utf-16le\":\n            return len * 2;\n          case \"hex\":\n            return len >>> 1;\n          case \"base64\":\n            return base64ToBytes(string).length;\n          default:\n            if (loweredCase) {\n              return mustMatch ? -1 : utf8ToBytes(string).length;\n            }\n            encoding = (\"\" + encoding).toLowerCase();\n            loweredCase = true;\n        }\n      }\n    }\n    Buffer2.byteLength = byteLength;\n    function slowToString(encoding, start, end) {\n      var loweredCase = false;\n      if (start === void 0 || start < 0) {\n        start = 0;\n      }\n      if (start > this.length) {\n        return \"\";\n      }\n      if (end === void 0 || end > this.length) {\n        end = this.length;\n      }\n      if (end <= 0) {\n        return \"\";\n      }\n      end >>>= 0;\n      start >>>= 0;\n      if (end <= start) {\n        return \"\";\n      }\n      if (!encoding) encoding = \"utf8\";\n      while (true) {\n        switch (encoding) {\n          case \"hex\":\n            return hexSlice(this, start, end);\n          case \"utf8\":\n          case \"utf-8\":\n            return utf8Slice(this, start, end);\n          case \"ascii\":\n            return asciiSlice(this, start, end);\n          case \"latin1\":\n          case \"binary\":\n            return latin1Slice(this, start, end);\n          case \"base64\":\n            return base64Slice(this, start, end);\n          case \"ucs2\":\n          case \"ucs-2\":\n          case \"utf16le\":\n          case \"utf-16le\":\n            return utf16leSlice(this, start, end);\n          default:\n            if (loweredCase) throw new TypeError(\"Unknown encoding: \" + encoding);\n            encoding = (encoding + \"\").toLowerCase();\n            loweredCase = true;\n        }\n      }\n    }\n    Buffer2.prototype._isBuffer = true;\n    function swap(b, n, m) {\n      var i = b[n];\n      b[n] = b[m];\n      b[m] = i;\n    }\n    Buffer2.prototype.swap16 = function swap16() {\n      var len = this.length;\n      if (len % 2 !== 0) {\n        throw new RangeError(\"Buffer size must be a multiple of 16-bits\");\n      }\n      for (var i = 0; i < len; i += 2) {\n        swap(this, i, i + 1);\n      }\n      return this;\n    };\n    Buffer2.prototype.swap32 = function swap32() {\n      var len = this.length;\n      if (len % 4 !== 0) {\n        throw new RangeError(\"Buffer size must be a multiple of 32-bits\");\n      }\n      for (var i = 0; i < len; i += 4) {\n        swap(this, i, i + 3);\n        swap(this, i + 1, i + 2);\n      }\n      return this;\n    };\n    Buffer2.prototype.swap64 = function swap64() {\n      var len = this.length;\n      if (len % 8 !== 0) {\n        throw new RangeError(\"Buffer size must be a multiple of 64-bits\");\n      }\n      for (var i = 0; i < len; i += 8) {\n        swap(this, i, i + 7);\n        swap(this, i + 1, i + 6);\n        swap(this, i + 2, i + 5);\n        swap(this, i + 3, i + 4);\n      }\n      return this;\n    };\n    Buffer2.prototype.toString = function toString() {\n      var length = this.length;\n      if (length === 0) return \"\";\n      if (arguments.length === 0) return utf8Slice(this, 0, length);\n      return slowToString.apply(this, arguments);\n    };\n    Buffer2.prototype.toLocaleString = Buffer2.prototype.toString;\n    Buffer2.prototype.equals = function equals(b) {\n      if (!Buffer2.isBuffer(b)) throw new TypeError(\"Argument must be a Buffer\");\n      if (this === b) return true;\n      return Buffer2.compare(this, b) === 0;\n    };\n    Buffer2.prototype.inspect = function inspect() {\n      var str = \"\";\n      var max = exports2.INSPECT_MAX_BYTES;\n      str = this.toString(\"hex\", 0, max).replace(/(.{2})/g, \"$1 \").trim();\n      if (this.length > max) str += \" ... \";\n      return \"<Buffer \" + str + \">\";\n    };\n    if (customInspectSymbol) {\n      Buffer2.prototype[customInspectSymbol] = Buffer2.prototype.inspect;\n    }\n    Buffer2.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {\n      if (isInstance(target, Uint8Array)) {\n        target = Buffer2.from(target, target.offset, target.byteLength);\n      }\n      if (!Buffer2.isBuffer(target)) {\n        throw new TypeError(\n          'The \"target\" argument must be one of type Buffer or Uint8Array. Received type ' + typeof target\n        );\n      }\n      if (start === void 0) {\n        start = 0;\n      }\n      if (end === void 0) {\n        end = target ? target.length : 0;\n      }\n      if (thisStart === void 0) {\n        thisStart = 0;\n      }\n      if (thisEnd === void 0) {\n        thisEnd = this.length;\n      }\n      if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n        throw new RangeError(\"out of range index\");\n      }\n      if (thisStart >= thisEnd && start >= end) {\n        return 0;\n      }\n      if (thisStart >= thisEnd) {\n        return -1;\n      }\n      if (start >= end) {\n        return 1;\n      }\n      start >>>= 0;\n      end >>>= 0;\n      thisStart >>>= 0;\n      thisEnd >>>= 0;\n      if (this === target) return 0;\n      var x = thisEnd - thisStart;\n      var y = end - start;\n      var len = Math.min(x, y);\n      var thisCopy = this.slice(thisStart, thisEnd);\n      var targetCopy = target.slice(start, end);\n      for (var i = 0; i < len; ++i) {\n        if (thisCopy[i] !== targetCopy[i]) {\n          x = thisCopy[i];\n          y = targetCopy[i];\n          break;\n        }\n      }\n      if (x < y) return -1;\n      if (y < x) return 1;\n      return 0;\n    };\n    function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {\n      if (buffer.length === 0) return -1;\n      if (typeof byteOffset === \"string\") {\n        encoding = byteOffset;\n        byteOffset = 0;\n      } else if (byteOffset > 2147483647) {\n        byteOffset = 2147483647;\n      } else if (byteOffset < -2147483648) {\n        byteOffset = -2147483648;\n      }\n      byteOffset = +byteOffset;\n      if (numberIsNaN(byteOffset)) {\n        byteOffset = dir ? 0 : buffer.length - 1;\n      }\n      if (byteOffset < 0) byteOffset = buffer.length + byteOffset;\n      if (byteOffset >= buffer.length) {\n        if (dir) return -1;\n        else byteOffset = buffer.length - 1;\n      } else if (byteOffset < 0) {\n        if (dir) byteOffset = 0;\n        else return -1;\n      }\n      if (typeof val === \"string\") {\n        val = Buffer2.from(val, encoding);\n      }\n      if (Buffer2.isBuffer(val)) {\n        if (val.length === 0) {\n          return -1;\n        }\n        return arrayIndexOf(buffer, val, byteOffset, encoding, dir);\n      } else if (typeof val === \"number\") {\n        val = val & 255;\n        if (typeof Uint8Array.prototype.indexOf === \"function\") {\n          if (dir) {\n            return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset);\n          } else {\n            return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset);\n          }\n        }\n        return arrayIndexOf(buffer, [val], byteOffset, encoding, dir);\n      }\n      throw new TypeError(\"val must be string, number or Buffer\");\n    }\n    function arrayIndexOf(arr, val, byteOffset, encoding, dir) {\n      var indexSize = 1;\n      var arrLength = arr.length;\n      var valLength = val.length;\n      if (encoding !== void 0) {\n        encoding = String(encoding).toLowerCase();\n        if (encoding === \"ucs2\" || encoding === \"ucs-2\" || encoding === \"utf16le\" || encoding === \"utf-16le\") {\n          if (arr.length < 2 || val.length < 2) {\n            return -1;\n          }\n          indexSize = 2;\n          arrLength /= 2;\n          valLength /= 2;\n          byteOffset /= 2;\n        }\n      }\n      function read(buf, i2) {\n        if (indexSize === 1) {\n          return buf[i2];\n        } else {\n          return buf.readUInt16BE(i2 * indexSize);\n        }\n      }\n      var i;\n      if (dir) {\n        var foundIndex = -1;\n        for (i = byteOffset; i < arrLength; i++) {\n          if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n            if (foundIndex === -1) foundIndex = i;\n            if (i - foundIndex + 1 === valLength) return foundIndex * indexSize;\n          } else {\n            if (foundIndex !== -1) i -= i - foundIndex;\n            foundIndex = -1;\n          }\n        }\n      } else {\n        if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength;\n        for (i = byteOffset; i >= 0; i--) {\n          var found = true;\n          for (var j = 0; j < valLength; j++) {\n            if (read(arr, i + j) !== read(val, j)) {\n              found = false;\n              break;\n            }\n          }\n          if (found) return i;\n        }\n      }\n      return -1;\n    }\n    Buffer2.prototype.includes = function includes(val, byteOffset, encoding) {\n      return this.indexOf(val, byteOffset, encoding) !== -1;\n    };\n    Buffer2.prototype.indexOf = function indexOf(val, byteOffset, encoding) {\n      return bidirectionalIndexOf(this, val, byteOffset, encoding, true);\n    };\n    Buffer2.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {\n      return bidirectionalIndexOf(this, val, byteOffset, encoding, false);\n    };\n    function hexWrite(buf, string, offset, length) {\n      offset = Number(offset) || 0;\n      var remaining = buf.length - offset;\n      if (!length) {\n        length = remaining;\n      } else {\n        length = Number(length);\n        if (length > remaining) {\n          length = remaining;\n        }\n      }\n      var strLen = string.length;\n      if (length > strLen / 2) {\n        length = strLen / 2;\n      }\n      for (var i = 0; i < length; ++i) {\n        var parsed = parseInt(string.substr(i * 2, 2), 16);\n        if (numberIsNaN(parsed)) return i;\n        buf[offset + i] = parsed;\n      }\n      return i;\n    }\n    function utf8Write(buf, string, offset, length) {\n      return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length);\n    }\n    function asciiWrite(buf, string, offset, length) {\n      return blitBuffer(asciiToBytes(string), buf, offset, length);\n    }\n    function base64Write(buf, string, offset, length) {\n      return blitBuffer(base64ToBytes(string), buf, offset, length);\n    }\n    function ucs2Write(buf, string, offset, length) {\n      return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length);\n    }\n    Buffer2.prototype.write = function write(string, offset, length, encoding) {\n      if (offset === void 0) {\n        encoding = \"utf8\";\n        length = this.length;\n        offset = 0;\n      } else if (length === void 0 && typeof offset === \"string\") {\n        encoding = offset;\n        length = this.length;\n        offset = 0;\n      } else if (isFinite(offset)) {\n        offset = offset >>> 0;\n        if (isFinite(length)) {\n          length = length >>> 0;\n          if (encoding === void 0) encoding = \"utf8\";\n        } else {\n          encoding = length;\n          length = void 0;\n        }\n      } else {\n        throw new Error(\n          \"Buffer.write(string, encoding, offset[, length]) is no longer supported\"\n        );\n      }\n      var remaining = this.length - offset;\n      if (length === void 0 || length > remaining) length = remaining;\n      if (string.length > 0 && (length < 0 || offset < 0) || offset > this.length) {\n        throw new RangeError(\"Attempt to write outside buffer bounds\");\n      }\n      if (!encoding) encoding = \"utf8\";\n      var loweredCase = false;\n      for (; ; ) {\n        switch (encoding) {\n          case \"hex\":\n            return hexWrite(this, string, offset, length);\n          case \"utf8\":\n          case \"utf-8\":\n            return utf8Write(this, string, offset, length);\n          case \"ascii\":\n          case \"latin1\":\n          case \"binary\":\n            return asciiWrite(this, string, offset, length);\n          case \"base64\":\n            return base64Write(this, string, offset, length);\n          case \"ucs2\":\n          case \"ucs-2\":\n          case \"utf16le\":\n          case \"utf-16le\":\n            return ucs2Write(this, string, offset, length);\n          default:\n            if (loweredCase) throw new TypeError(\"Unknown encoding: \" + encoding);\n            encoding = (\"\" + encoding).toLowerCase();\n            loweredCase = true;\n        }\n      }\n    };\n    Buffer2.prototype.toJSON = function toJSON() {\n      return {\n        type: \"Buffer\",\n        data: Array.prototype.slice.call(this._arr || this, 0)\n      };\n    };\n    function base64Slice(buf, start, end) {\n      if (start === 0 && end === buf.length) {\n        return base64.fromByteArray(buf);\n      } else {\n        return base64.fromByteArray(buf.slice(start, end));\n      }\n    }\n    function utf8Slice(buf, start, end) {\n      end = Math.min(buf.length, end);\n      var res = [];\n      var i = start;\n      while (i < end) {\n        var firstByte = buf[i];\n        var codePoint = null;\n        var bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;\n        if (i + bytesPerSequence <= end) {\n          var secondByte, thirdByte, fourthByte, tempCodePoint;\n          switch (bytesPerSequence) {\n            case 1:\n              if (firstByte < 128) {\n                codePoint = firstByte;\n              }\n              break;\n            case 2:\n              secondByte = buf[i + 1];\n              if ((secondByte & 192) === 128) {\n                tempCodePoint = (firstByte & 31) << 6 | secondByte & 63;\n                if (tempCodePoint > 127) {\n                  codePoint = tempCodePoint;\n                }\n              }\n              break;\n            case 3:\n              secondByte = buf[i + 1];\n              thirdByte = buf[i + 2];\n              if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) {\n                tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63;\n                if (tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343)) {\n                  codePoint = tempCodePoint;\n                }\n              }\n              break;\n            case 4:\n              secondByte = buf[i + 1];\n              thirdByte = buf[i + 2];\n              fourthByte = buf[i + 3];\n              if ((secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) {\n                tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63;\n                if (tempCodePoint > 65535 && tempCodePoint < 1114112) {\n                  codePoint = tempCodePoint;\n                }\n              }\n          }\n        }\n        if (codePoint === null) {\n          codePoint = 65533;\n          bytesPerSequence = 1;\n        } else if (codePoint > 65535) {\n          codePoint -= 65536;\n          res.push(codePoint >>> 10 & 1023 | 55296);\n          codePoint = 56320 | codePoint & 1023;\n        }\n        res.push(codePoint);\n        i += bytesPerSequence;\n      }\n      return decodeCodePointsArray(res);\n    }\n    var MAX_ARGUMENTS_LENGTH = 4096;\n    function decodeCodePointsArray(codePoints) {\n      var len = codePoints.length;\n      if (len <= MAX_ARGUMENTS_LENGTH) {\n        return String.fromCharCode.apply(String, codePoints);\n      }\n      var res = \"\";\n      var i = 0;\n      while (i < len) {\n        res += String.fromCharCode.apply(\n          String,\n          codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n        );\n      }\n      return res;\n    }\n    function asciiSlice(buf, start, end) {\n      var ret = \"\";\n      end = Math.min(buf.length, end);\n      for (var i = start; i < end; ++i) {\n        ret += String.fromCharCode(buf[i] & 127);\n      }\n      return ret;\n    }\n    function latin1Slice(buf, start, end) {\n      var ret = \"\";\n      end = Math.min(buf.length, end);\n      for (var i = start; i < end; ++i) {\n        ret += String.fromCharCode(buf[i]);\n      }\n      return ret;\n    }\n    function hexSlice(buf, start, end) {\n      var len = buf.length;\n      if (!start || start < 0) start = 0;\n      if (!end || end < 0 || end > len) end = len;\n      var out = \"\";\n      for (var i = start; i < end; ++i) {\n        out += hexSliceLookupTable[buf[i]];\n      }\n      return out;\n    }\n    function utf16leSlice(buf, start, end) {\n      var bytes = buf.slice(start, end);\n      var res = \"\";\n      for (var i = 0; i < bytes.length - 1; i += 2) {\n        res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);\n      }\n      return res;\n    }\n    Buffer2.prototype.slice = function slice(start, end) {\n      var len = this.length;\n      start = ~~start;\n      end = end === void 0 ? len : ~~end;\n      if (start < 0) {\n        start += len;\n        if (start < 0) start = 0;\n      } else if (start > len) {\n        start = len;\n      }\n      if (end < 0) {\n        end += len;\n        if (end < 0) end = 0;\n      } else if (end > len) {\n        end = len;\n      }\n      if (end < start) end = start;\n      var newBuf = this.subarray(start, end);\n      Object.setPrototypeOf(newBuf, Buffer2.prototype);\n      return newBuf;\n    };\n    function checkOffset(offset, ext, length) {\n      if (offset % 1 !== 0 || offset < 0) throw new RangeError(\"offset is not uint\");\n      if (offset + ext > length) throw new RangeError(\"Trying to access beyond buffer length\");\n    }\n    Buffer2.prototype.readUintLE = Buffer2.prototype.readUIntLE = function readUIntLE(offset, byteLength2, noAssert) {\n      offset = offset >>> 0;\n      byteLength2 = byteLength2 >>> 0;\n      if (!noAssert) checkOffset(offset, byteLength2, this.length);\n      var val = this[offset];\n      var mul = 1;\n      var i = 0;\n      while (++i < byteLength2 && (mul *= 256)) {\n        val += this[offset + i] * mul;\n      }\n      return val;\n    };\n    Buffer2.prototype.readUintBE = Buffer2.prototype.readUIntBE = function readUIntBE(offset, byteLength2, noAssert) {\n      offset = offset >>> 0;\n      byteLength2 = byteLength2 >>> 0;\n      if (!noAssert) {\n        checkOffset(offset, byteLength2, this.length);\n      }\n      var val = this[offset + --byteLength2];\n      var mul = 1;\n      while (byteLength2 > 0 && (mul *= 256)) {\n        val += this[offset + --byteLength2] * mul;\n      }\n      return val;\n    };\n    Buffer2.prototype.readUint8 = Buffer2.prototype.readUInt8 = function readUInt8(offset, noAssert) {\n      offset = offset >>> 0;\n      if (!noAssert) checkOffset(offset, 1, this.length);\n      return this[offset];\n    };\n    Buffer2.prototype.readUint16LE = Buffer2.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {\n      offset = offset >>> 0;\n      if (!noAssert) checkOffset(offset, 2, this.length);\n      return this[offset] | this[offset + 1] << 8;\n    };\n    Buffer2.prototype.readUint16BE = Buffer2.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {\n      offset = offset >>> 0;\n      if (!noAssert) checkOffset(offset, 2, this.length);\n      return this[offset] << 8 | this[offset + 1];\n    };\n    Buffer2.prototype.readUint32LE = Buffer2.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {\n      offset = offset >>> 0;\n      if (!noAssert) checkOffset(offset, 4, this.length);\n      return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 16777216;\n    };\n    Buffer2.prototype.readUint32BE = Buffer2.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {\n      offset = offset >>> 0;\n      if (!noAssert) checkOffset(offset, 4, this.length);\n      return this[offset] * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);\n    };\n    Buffer2.prototype.readIntLE = function readIntLE(offset, byteLength2, noAssert) {\n      offset = offset >>> 0;\n      byteLength2 = byteLength2 >>> 0;\n      if (!noAssert) checkOffset(offset, byteLength2, this.length);\n      var val = this[offset];\n      var mul = 1;\n      var i = 0;\n      while (++i < byteLength2 && (mul *= 256)) {\n        val += this[offset + i] * mul;\n      }\n      mul *= 128;\n      if (val >= mul) val -= Math.pow(2, 8 * byteLength2);\n      return val;\n    };\n    Buffer2.prototype.readIntBE = function readIntBE(offset, byteLength2, noAssert) {\n      offset = offset >>> 0;\n      byteLength2 = byteLength2 >>> 0;\n      if (!noAssert) checkOffset(offset, byteLength2, this.length);\n      var i = byteLength2;\n      var mul = 1;\n      var val = this[offset + --i];\n      while (i > 0 && (mul *= 256)) {\n        val += this[offset + --i] * mul;\n      }\n      mul *= 128;\n      if (val >= mul) val -= Math.pow(2, 8 * byteLength2);\n      return val;\n    };\n    Buffer2.prototype.readInt8 = function readInt8(offset, noAssert) {\n      offset = offset >>> 0;\n      if (!noAssert) checkOffset(offset, 1, this.length);\n      if (!(this[offset] & 128)) return this[offset];\n      return (255 - this[offset] + 1) * -1;\n    };\n    Buffer2.prototype.readInt16LE = function readInt16LE(offset, noAssert) {\n      offset = offset >>> 0;\n      if (!noAssert) checkOffset(offset, 2, this.length);\n      var val = this[offset] | this[offset + 1] << 8;\n      return val & 32768 ? val | 4294901760 : val;\n    };\n    Buffer2.prototype.readInt16BE = function readInt16BE(offset, noAssert) {\n      offset = offset >>> 0;\n      if (!noAssert) checkOffset(offset, 2, this.length);\n      var val = this[offset + 1] | this[offset] << 8;\n      return val & 32768 ? val | 4294901760 : val;\n    };\n    Buffer2.prototype.readInt32LE = function readInt32LE(offset, noAssert) {\n      offset = offset >>> 0;\n      if (!noAssert) checkOffset(offset, 4, this.length);\n      return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24;\n    };\n    Buffer2.prototype.readInt32BE = function readInt32BE(offset, noAssert) {\n      offset = offset >>> 0;\n      if (!noAssert) checkOffset(offset, 4, this.length);\n      return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];\n    };\n    Buffer2.prototype.readFloatLE = function readFloatLE(offset, noAssert) {\n      offset = offset >>> 0;\n      if (!noAssert) checkOffset(offset, 4, this.length);\n      return ieee754.read(this, offset, true, 23, 4);\n    };\n    Buffer2.prototype.readFloatBE = function readFloatBE(offset, noAssert) {\n      offset = offset >>> 0;\n      if (!noAssert) checkOffset(offset, 4, this.length);\n      return ieee754.read(this, offset, false, 23, 4);\n    };\n    Buffer2.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {\n      offset = offset >>> 0;\n      if (!noAssert) checkOffset(offset, 8, this.length);\n      return ieee754.read(this, offset, true, 52, 8);\n    };\n    Buffer2.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {\n      offset = offset >>> 0;\n      if (!noAssert) checkOffset(offset, 8, this.length);\n      return ieee754.read(this, offset, false, 52, 8);\n    };\n    function checkInt(buf, value, offset, ext, max, min) {\n      if (!Buffer2.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance');\n      if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds');\n      if (offset + ext > buf.length) throw new RangeError(\"Index out of range\");\n    }\n    Buffer2.prototype.writeUintLE = Buffer2.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength2, noAssert) {\n      value = +value;\n      offset = offset >>> 0;\n      byteLength2 = byteLength2 >>> 0;\n      if (!noAssert) {\n        var maxBytes = Math.pow(2, 8 * byteLength2) - 1;\n        checkInt(this, value, offset, byteLength2, maxBytes, 0);\n      }\n      var mul = 1;\n      var i = 0;\n      this[offset] = value & 255;\n      while (++i < byteLength2 && (mul *= 256)) {\n        this[offset + i] = value / mul & 255;\n      }\n      return offset + byteLength2;\n    };\n    Buffer2.prototype.writeUintBE = Buffer2.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength2, noAssert) {\n      value = +value;\n      offset = offset >>> 0;\n      byteLength2 = byteLength2 >>> 0;\n      if (!noAssert) {\n        var maxBytes = Math.pow(2, 8 * byteLength2) - 1;\n        checkInt(this, value, offset, byteLength2, maxBytes, 0);\n      }\n      var i = byteLength2 - 1;\n      var mul = 1;\n      this[offset + i] = value & 255;\n      while (--i >= 0 && (mul *= 256)) {\n        this[offset + i] = value / mul & 255;\n      }\n      return offset + byteLength2;\n    };\n    Buffer2.prototype.writeUint8 = Buffer2.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {\n      value = +value;\n      offset = offset >>> 0;\n      if (!noAssert) checkInt(this, value, offset, 1, 255, 0);\n      this[offset] = value & 255;\n      return offset + 1;\n    };\n    Buffer2.prototype.writeUint16LE = Buffer2.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {\n      value = +value;\n      offset = offset >>> 0;\n      if (!noAssert) checkInt(this, value, offset, 2, 65535, 0);\n      this[offset] = value & 255;\n      this[offset + 1] = value >>> 8;\n      return offset + 2;\n    };\n    Buffer2.prototype.writeUint16BE = Buffer2.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {\n      value = +value;\n      offset = offset >>> 0;\n      if (!noAssert) checkInt(this, value, offset, 2, 65535, 0);\n      this[offset] = value >>> 8;\n      this[offset + 1] = value & 255;\n      return offset + 2;\n    };\n    Buffer2.prototype.writeUint32LE = Buffer2.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {\n      value = +value;\n      offset = offset >>> 0;\n      if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0);\n      this[offset + 3] = value >>> 24;\n      this[offset + 2] = value >>> 16;\n      this[offset + 1] = value >>> 8;\n      this[offset] = value & 255;\n      return offset + 4;\n    };\n    Buffer2.prototype.writeUint32BE = Buffer2.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {\n      value = +value;\n      offset = offset >>> 0;\n      if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0);\n      this[offset] = value >>> 24;\n      this[offset + 1] = value >>> 16;\n      this[offset + 2] = value >>> 8;\n      this[offset + 3] = value & 255;\n      return offset + 4;\n    };\n    Buffer2.prototype.writeIntLE = function writeIntLE(value, offset, byteLength2, noAssert) {\n      value = +value;\n      offset = offset >>> 0;\n      if (!noAssert) {\n        var limit = Math.pow(2, 8 * byteLength2 - 1);\n        checkInt(this, value, offset, byteLength2, limit - 1, -limit);\n      }\n      var i = 0;\n      var mul = 1;\n      var sub = 0;\n      this[offset] = value & 255;\n      while (++i < byteLength2 && (mul *= 256)) {\n        if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n          sub = 1;\n        }\n        this[offset + i] = (value / mul >> 0) - sub & 255;\n      }\n      return offset + byteLength2;\n    };\n    Buffer2.prototype.writeIntBE = function writeIntBE(value, offset, byteLength2, noAssert) {\n      value = +value;\n      offset = offset >>> 0;\n      if (!noAssert) {\n        var limit = Math.pow(2, 8 * byteLength2 - 1);\n        checkInt(this, value, offset, byteLength2, limit - 1, -limit);\n      }\n      var i = byteLength2 - 1;\n      var mul = 1;\n      var sub = 0;\n      this[offset + i] = value & 255;\n      while (--i >= 0 && (mul *= 256)) {\n        if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n          sub = 1;\n        }\n        this[offset + i] = (value / mul >> 0) - sub & 255;\n      }\n      return offset + byteLength2;\n    };\n    Buffer2.prototype.writeInt8 = function writeInt8(value, offset, noAssert) {\n      value = +value;\n      offset = offset >>> 0;\n      if (!noAssert) checkInt(this, value, offset, 1, 127, -128);\n      if (value < 0) value = 255 + value + 1;\n      this[offset] = value & 255;\n      return offset + 1;\n    };\n    Buffer2.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) {\n      value = +value;\n      offset = offset >>> 0;\n      if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768);\n      this[offset] = value & 255;\n      this[offset + 1] = value >>> 8;\n      return offset + 2;\n    };\n    Buffer2.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) {\n      value = +value;\n      offset = offset >>> 0;\n      if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768);\n      this[offset] = value >>> 8;\n      this[offset + 1] = value & 255;\n      return offset + 2;\n    };\n    Buffer2.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) {\n      value = +value;\n      offset = offset >>> 0;\n      if (!noAssert) checkInt(this, value, offset, 4, 2147483647, -2147483648);\n      this[offset] = value & 255;\n      this[offset + 1] = value >>> 8;\n      this[offset + 2] = value >>> 16;\n      this[offset + 3] = value >>> 24;\n      return offset + 4;\n    };\n    Buffer2.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) {\n      value = +value;\n      offset = offset >>> 0;\n      if (!noAssert) checkInt(this, value, offset, 4, 2147483647, -2147483648);\n      if (value < 0) value = 4294967295 + value + 1;\n      this[offset] = value >>> 24;\n      this[offset + 1] = value >>> 16;\n      this[offset + 2] = value >>> 8;\n      this[offset + 3] = value & 255;\n      return offset + 4;\n    };\n    function checkIEEE754(buf, value, offset, ext, max, min) {\n      if (offset + ext > buf.length) throw new RangeError(\"Index out of range\");\n      if (offset < 0) throw new RangeError(\"Index out of range\");\n    }\n    function writeFloat(buf, value, offset, littleEndian, noAssert) {\n      value = +value;\n      offset = offset >>> 0;\n      if (!noAssert) {\n        checkIEEE754(buf, value, offset, 4, 34028234663852886e22, -34028234663852886e22);\n      }\n      ieee754.write(buf, value, offset, littleEndian, 23, 4);\n      return offset + 4;\n    }\n    Buffer2.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {\n      return writeFloat(this, value, offset, true, noAssert);\n    };\n    Buffer2.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) {\n      return writeFloat(this, value, offset, false, noAssert);\n    };\n    function writeDouble(buf, value, offset, littleEndian, noAssert) {\n      value = +value;\n      offset = offset >>> 0;\n      if (!noAssert) {\n        checkIEEE754(buf, value, offset, 8, 17976931348623157e292, -17976931348623157e292);\n      }\n      ieee754.write(buf, value, offset, littleEndian, 52, 8);\n      return offset + 8;\n    }\n    Buffer2.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {\n      return writeDouble(this, value, offset, true, noAssert);\n    };\n    Buffer2.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {\n      return writeDouble(this, value, offset, false, noAssert);\n    };\n    Buffer2.prototype.copy = function copy(target, targetStart, start, end) {\n      if (!Buffer2.isBuffer(target)) throw new TypeError(\"argument should be a Buffer\");\n      if (!start) start = 0;\n      if (!end && end !== 0) end = this.length;\n      if (targetStart >= target.length) targetStart = target.length;\n      if (!targetStart) targetStart = 0;\n      if (end > 0 && end < start) end = start;\n      if (end === start) return 0;\n      if (target.length === 0 || this.length === 0) return 0;\n      if (targetStart < 0) {\n        throw new RangeError(\"targetStart out of bounds\");\n      }\n      if (start < 0 || start >= this.length) throw new RangeError(\"Index out of range\");\n      if (end < 0) throw new RangeError(\"sourceEnd out of bounds\");\n      if (end > this.length) end = this.length;\n      if (target.length - targetStart < end - start) {\n        end = target.length - targetStart + start;\n      }\n      var len = end - start;\n      if (this === target && typeof Uint8Array.prototype.copyWithin === \"function\") {\n        this.copyWithin(targetStart, start, end);\n      } else {\n        Uint8Array.prototype.set.call(\n          target,\n          this.subarray(start, end),\n          targetStart\n        );\n      }\n      return len;\n    };\n    Buffer2.prototype.fill = function fill(val, start, end, encoding) {\n      if (typeof val === \"string\") {\n        if (typeof start === \"string\") {\n          encoding = start;\n          start = 0;\n          end = this.length;\n        } else if (typeof end === \"string\") {\n          encoding = end;\n          end = this.length;\n        }\n        if (encoding !== void 0 && typeof encoding !== \"string\") {\n          throw new TypeError(\"encoding must be a string\");\n        }\n        if (typeof encoding === \"string\" && !Buffer2.isEncoding(encoding)) {\n          throw new TypeError(\"Unknown encoding: \" + encoding);\n        }\n        if (val.length === 1) {\n          var code = val.charCodeAt(0);\n          if (encoding === \"utf8\" && code < 128 || encoding === \"latin1\") {\n            val = code;\n          }\n        }\n      } else if (typeof val === \"number\") {\n        val = val & 255;\n      } else if (typeof val === \"boolean\") {\n        val = Number(val);\n      }\n      if (start < 0 || this.length < start || this.length < end) {\n        throw new RangeError(\"Out of range index\");\n      }\n      if (end <= start) {\n        return this;\n      }\n      start = start >>> 0;\n      end = end === void 0 ? this.length : end >>> 0;\n      if (!val) val = 0;\n      var i;\n      if (typeof val === \"number\") {\n        for (i = start; i < end; ++i) {\n          this[i] = val;\n        }\n      } else {\n        var bytes = Buffer2.isBuffer(val) ? val : Buffer2.from(val, encoding);\n        var len = bytes.length;\n        if (len === 0) {\n          throw new TypeError('The value \"' + val + '\" is invalid for argument \"value\"');\n        }\n        for (i = 0; i < end - start; ++i) {\n          this[i + start] = bytes[i % len];\n        }\n      }\n      return this;\n    };\n    var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;\n    function base64clean(str) {\n      str = str.split(\"=\")[0];\n      str = str.trim().replace(INVALID_BASE64_RE, \"\");\n      if (str.length < 2) return \"\";\n      while (str.length % 4 !== 0) {\n        str = str + \"=\";\n      }\n      return str;\n    }\n    function utf8ToBytes(string, units) {\n      units = units || Infinity;\n      var codePoint;\n      var length = string.length;\n      var leadSurrogate = null;\n      var bytes = [];\n      for (var i = 0; i < length; ++i) {\n        codePoint = string.charCodeAt(i);\n        if (codePoint > 55295 && codePoint < 57344) {\n          if (!leadSurrogate) {\n            if (codePoint > 56319) {\n              if ((units -= 3) > -1) bytes.push(239, 191, 189);\n              continue;\n            } else if (i + 1 === length) {\n              if ((units -= 3) > -1) bytes.push(239, 191, 189);\n              continue;\n            }\n            leadSurrogate = codePoint;\n            continue;\n          }\n          if (codePoint < 56320) {\n            if ((units -= 3) > -1) bytes.push(239, 191, 189);\n            leadSurrogate = codePoint;\n            continue;\n          }\n          codePoint = (leadSurrogate - 55296 << 10 | codePoint - 56320) + 65536;\n        } else if (leadSurrogate) {\n          if ((units -= 3) > -1) bytes.push(239, 191, 189);\n        }\n        leadSurrogate = null;\n        if (codePoint < 128) {\n          if ((units -= 1) < 0) break;\n          bytes.push(codePoint);\n        } else if (codePoint < 2048) {\n          if ((units -= 2) < 0) break;\n          bytes.push(\n            codePoint >> 6 | 192,\n            codePoint & 63 | 128\n          );\n        } else if (codePoint < 65536) {\n          if ((units -= 3) < 0) break;\n          bytes.push(\n            codePoint >> 12 | 224,\n            codePoint >> 6 & 63 | 128,\n            codePoint & 63 | 128\n          );\n        } else if (codePoint < 1114112) {\n          if ((units -= 4) < 0) break;\n          bytes.push(\n            codePoint >> 18 | 240,\n            codePoint >> 12 & 63 | 128,\n            codePoint >> 6 & 63 | 128,\n            codePoint & 63 | 128\n          );\n        } else {\n          throw new Error(\"Invalid code point\");\n        }\n      }\n      return bytes;\n    }\n    function asciiToBytes(str) {\n      var byteArray = [];\n      for (var i = 0; i < str.length; ++i) {\n        byteArray.push(str.charCodeAt(i) & 255);\n      }\n      return byteArray;\n    }\n    function utf16leToBytes(str, units) {\n      var c, hi, lo;\n      var byteArray = [];\n      for (var i = 0; i < str.length; ++i) {\n        if ((units -= 2) < 0) break;\n        c = str.charCodeAt(i);\n        hi = c >> 8;\n        lo = c % 256;\n        byteArray.push(lo);\n        byteArray.push(hi);\n      }\n      return byteArray;\n    }\n    function base64ToBytes(str) {\n      return base64.toByteArray(base64clean(str));\n    }\n    function blitBuffer(src, dst, offset, length) {\n      for (var i = 0; i < length; ++i) {\n        if (i + offset >= dst.length || i >= src.length) break;\n        dst[i + offset] = src[i];\n      }\n      return i;\n    }\n    function isInstance(obj, type) {\n      return obj instanceof type || obj != null && obj.constructor != null && obj.constructor.name != null && obj.constructor.name === type.name;\n    }\n    function numberIsNaN(obj) {\n      return obj !== obj;\n    }\n    var hexSliceLookupTable = (function() {\n      var alphabet = \"0123456789abcdef\";\n      var table = new Array(256);\n      for (var i = 0; i < 16; ++i) {\n        var i16 = i * 16;\n        for (var j = 0; j < 16; ++j) {\n          table[i16 + j] = alphabet[i] + alphabet[j];\n        }\n      }\n      return table;\n    })();\n  }\n});\n\n// ../../node_modules/.pnpm/readable-stream@4.7.0/node_modules/readable-stream/lib/ours/primordials.js\nvar require_primordials = __commonJS({\n  \"../../node_modules/.pnpm/readable-stream@4.7.0/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(self2) {\n        return Array.isArray(self2);\n      },\n      ArrayPrototypeIncludes(self2, el) {\n        return self2.includes(el);\n      },\n      ArrayPrototypeIndexOf(self2, el) {\n        return self2.indexOf(el);\n      },\n      ArrayPrototypeJoin(self2, sep) {\n        return self2.join(sep);\n      },\n      ArrayPrototypeMap(self2, fn) {\n        return self2.map(fn);\n      },\n      ArrayPrototypePop(self2, el) {\n        return self2.pop(el);\n      },\n      ArrayPrototypePush(self2, el) {\n        return self2.push(el);\n      },\n      ArrayPrototypeSlice(self2, start, end) {\n        return self2.slice(start, end);\n      },\n      Error,\n      FunctionPrototypeCall(fn, thisArgs, ...args) {\n        return fn.call(thisArgs, ...args);\n      },\n      FunctionPrototypeSymbolHasInstance(self2, instance) {\n        return Function.prototype[Symbol.hasInstance].call(self2, 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(self2, props) {\n        return Object.defineProperties(self2, props);\n      },\n      ObjectDefineProperty(self2, name, prop) {\n        return Object.defineProperty(self2, name, prop);\n      },\n      ObjectGetOwnPropertyDescriptor(self2, name) {\n        return Object.getOwnPropertyDescriptor(self2, 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(self2, fn) {\n        return self2.catch(fn);\n      },\n      PromisePrototypeThen(self2, thenFn, catchFn) {\n        return self2.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(self2, value) {\n        return self2.test(value);\n      },\n      SafeSet: Set,\n      String,\n      StringPrototypeSlice(self2, start, end) {\n        return self2.slice(start, end);\n      },\n      StringPrototypeToLowerCase(self2) {\n        return self2.toLowerCase();\n      },\n      StringPrototypeToUpperCase(self2) {\n        return self2.toUpperCase();\n      },\n      StringPrototypeTrim(self2) {\n        return self2.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(self2, buf, len) {\n        return self2.set(buf, len);\n      },\n      Boolean,\n      Uint8Array\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/readable-stream@4.7.0/node_modules/readable-stream/lib/ours/util/inspect.js\nvar require_inspect = __commonJS({\n  \"../../node_modules/.pnpm/readable-stream@4.7.0/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/.pnpm/readable-stream@4.7.0/node_modules/readable-stream/lib/ours/errors.js\nvar require_errors = __commonJS({\n  \"../../node_modules/.pnpm/readable-stream@4.7.0/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/.pnpm/abort-controller@3.0.0/node_modules/abort-controller/browser.js\nvar require_browser = __commonJS({\n  \"../../node_modules/.pnpm/abort-controller@3.0.0/node_modules/abort-controller/browser.js\"(exports2, module2) {\n    \"use strict\";\n    var { AbortController, AbortSignal } = typeof self !== \"undefined\" ? self : typeof window !== \"undefined\" ? window : (\n      /* otherwise */\n      void 0\n    );\n    module2.exports = AbortController;\n    module2.exports.AbortSignal = AbortSignal;\n    module2.exports.default = AbortController;\n  }\n});\n\n// ../../node_modules/.pnpm/events@3.3.0/node_modules/events/events.js\nvar require_events = __commonJS({\n  \"../../node_modules/.pnpm/events@3.3.0/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 = once2;\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 emit2(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 listeners2 = arrayClone(handler, len);\n        for (var i = 0; i < len; ++i)\n          ReflectApply(listeners2[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 addListener2(type, listener) {\n      return _addListener(this, type, listener, false);\n    };\n    EventEmitter.prototype.on = EventEmitter.prototype.addListener;\n    EventEmitter.prototype.prependListener = function prependListener2(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 once3(type, listener) {\n      checkListener(listener);\n      this.on(type, _onceWrap(this, type, listener));\n      return this;\n    };\n    EventEmitter.prototype.prependOnceListener = function prependOnceListener2(type, listener) {\n      checkListener(listener);\n      this.prependListener(type, _onceWrap(this, type, listener));\n      return this;\n    };\n    EventEmitter.prototype.removeListener = function removeListener2(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 removeAllListeners2(type) {\n      var listeners2, 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      listeners2 = events[type];\n      if (typeof listeners2 === \"function\") {\n        this.removeListener(type, listeners2);\n      } else if (listeners2 !== void 0) {\n        for (i = listeners2.length - 1; i >= 0; i--) {\n          this.removeListener(type, listeners2[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 listeners2(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 once2(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/.pnpm/readable-stream@4.7.0/node_modules/readable-stream/lib/ours/util.js\nvar require_util = __commonJS({\n  \"../../node_modules/.pnpm/readable-stream@4.7.0/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_browser().AbortSignal;\n    var AbortController = globalThis.AbortController || require_browser().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/.pnpm/readable-stream@4.7.0/node_modules/readable-stream/lib/internal/validators.js\nvar require_validators = __commonJS({\n  \"../../node_modules/.pnpm/readable-stream@4.7.0/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/.pnpm/node-stdlib-browser@1.3.1/node_modules/node-stdlib-browser/esm/proxy/process.js\nvar process_exports = {};\n__export(process_exports, {\n  addListener: () => addListener,\n  arch: () => arch,\n  argv: () => argv,\n  binding: () => binding,\n  browser: () => browser,\n  chdir: () => chdir,\n  cwd: () => cwd,\n  default: () => api,\n  dlopen: () => dlopen,\n  emit: () => emit,\n  emitWarning: () => emitWarning,\n  env: () => env,\n  execArgv: () => execArgv,\n  execPath: () => execPath,\n  exit: () => exit,\n  features: () => features,\n  kill: () => kill,\n  listeners: () => listeners,\n  memoryUsage: () => memoryUsage,\n  nextTick: () => nextTick,\n  off: () => off,\n  on: () => on,\n  once: () => once,\n  pid: () => pid,\n  platform: () => platform,\n  prependListener: () => prependListener,\n  prependOnceListener: () => prependOnceListener,\n  removeAllListeners: () => removeAllListeners,\n  removeListener: () => removeListener,\n  title: () => title,\n  umask: () => umask,\n  uptime: () => uptime,\n  uvCounters: () => uvCounters,\n  version: () => version,\n  versions: () => versions\n});\nfunction defaultSetTimout() {\n  throw new Error(\"setTimeout has not been defined\");\n}\nfunction defaultClearTimeout() {\n  throw new Error(\"clearTimeout has not been defined\");\n}\nfunction runTimeout(fun) {\n  if (cachedSetTimeout === setTimeout) {\n    return setTimeout(fun, 0);\n  }\n  if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n    cachedSetTimeout = setTimeout;\n    return setTimeout(fun, 0);\n  }\n  try {\n    return cachedSetTimeout(fun, 0);\n  } catch (e) {\n    try {\n      return cachedSetTimeout.call(null, fun, 0);\n    } catch (e2) {\n      return cachedSetTimeout.call(this, fun, 0);\n    }\n  }\n}\nfunction runClearTimeout(marker) {\n  if (cachedClearTimeout === clearTimeout) {\n    return clearTimeout(marker);\n  }\n  if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n    cachedClearTimeout = clearTimeout;\n    return clearTimeout(marker);\n  }\n  try {\n    return cachedClearTimeout(marker);\n  } catch (e) {\n    try {\n      return cachedClearTimeout.call(null, marker);\n    } catch (e2) {\n      return cachedClearTimeout.call(this, marker);\n    }\n  }\n}\nfunction cleanUpNextTick() {\n  if (!draining || !currentQueue) {\n    return;\n  }\n  draining = false;\n  if (currentQueue.length) {\n    queue = currentQueue.concat(queue);\n  } else {\n    queueIndex = -1;\n  }\n  if (queue.length) {\n    drainQueue();\n  }\n}\nfunction drainQueue() {\n  if (draining) {\n    return;\n  }\n  var timeout = runTimeout(cleanUpNextTick);\n  draining = true;\n  var len = queue.length;\n  while (len) {\n    currentQueue = queue;\n    queue = [];\n    while (++queueIndex < len) {\n      if (currentQueue) {\n        currentQueue[queueIndex].run();\n      }\n    }\n    queueIndex = -1;\n    len = queue.length;\n  }\n  currentQueue = null;\n  draining = false;\n  runClearTimeout(timeout);\n}\nfunction Item(fun, array) {\n  this.fun = fun;\n  this.array = array;\n}\nfunction noop$1() {\n}\nfunction noop() {\n}\nvar browser$1, process, cachedSetTimeout, cachedClearTimeout, queue, draining, currentQueue, queueIndex, browser, emitWarning, binding, exit, pid, features, kill, dlopen, uptime, memoryUsage, uvCounters, platform, arch, execPath, execArgv, api, addListener, argv, chdir, cwd, emit, env, listeners, nextTick, off, on, once, prependListener, prependOnceListener, removeAllListeners, removeListener, title, umask, version, versions;\nvar init_process = __esm({\n  \"../../node_modules/.pnpm/node-stdlib-browser@1.3.1/node_modules/node-stdlib-browser/esm/proxy/process.js\"() {\n    browser$1 = { exports: {} };\n    process = browser$1.exports = {};\n    (function() {\n      try {\n        if (typeof setTimeout === \"function\") {\n          cachedSetTimeout = setTimeout;\n        } else {\n          cachedSetTimeout = defaultSetTimout;\n        }\n      } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n      }\n      try {\n        if (typeof clearTimeout === \"function\") {\n          cachedClearTimeout = clearTimeout;\n        } else {\n          cachedClearTimeout = defaultClearTimeout;\n        }\n      } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n      }\n    })();\n    queue = [];\n    draining = false;\n    queueIndex = -1;\n    process.nextTick = function(fun) {\n      var args = new Array(arguments.length - 1);\n      if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n          args[i - 1] = arguments[i];\n        }\n      }\n      queue.push(new Item(fun, args));\n      if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n      }\n    };\n    Item.prototype.run = function() {\n      this.fun.apply(null, this.array);\n    };\n    process.title = \"browser\";\n    process.browser = true;\n    process.env = {};\n    process.argv = [];\n    process.version = \"\";\n    process.versions = {};\n    process.on = noop$1;\n    process.addListener = noop$1;\n    process.once = noop$1;\n    process.off = noop$1;\n    process.removeListener = noop$1;\n    process.removeAllListeners = noop$1;\n    process.emit = noop$1;\n    process.prependListener = noop$1;\n    process.prependOnceListener = noop$1;\n    process.listeners = function(name) {\n      return [];\n    };\n    process.binding = function(name) {\n      throw new Error(\"process.binding is not supported\");\n    };\n    process.cwd = function() {\n      return \"/\";\n    };\n    process.chdir = function(dir) {\n      throw new Error(\"process.chdir is not supported\");\n    };\n    process.umask = function() {\n      return 0;\n    };\n    browser = /** @type {boolean} */\n    browser$1.exports.browser;\n    emitWarning = noop;\n    binding = /** @type {Function} */\n    browser$1.exports.binding;\n    exit = noop;\n    pid = 1;\n    features = {};\n    kill = noop;\n    dlopen = noop;\n    uptime = noop;\n    memoryUsage = noop;\n    uvCounters = noop;\n    platform = \"browser\";\n    arch = \"browser\";\n    execPath = \"browser\";\n    execArgv = /** @type {string[]} */\n    [];\n    api = {\n      nextTick: browser$1.exports.nextTick,\n      title: browser$1.exports.title,\n      browser,\n      env: browser$1.exports.env,\n      argv: browser$1.exports.argv,\n      version: browser$1.exports.version,\n      versions: browser$1.exports.versions,\n      on: browser$1.exports.on,\n      addListener: browser$1.exports.addListener,\n      once: browser$1.exports.once,\n      off: browser$1.exports.off,\n      removeListener: browser$1.exports.removeListener,\n      removeAllListeners: browser$1.exports.removeAllListeners,\n      emit: browser$1.exports.emit,\n      emitWarning,\n      prependListener: browser$1.exports.prependListener,\n      prependOnceListener: browser$1.exports.prependOnceListener,\n      listeners: browser$1.exports.listeners,\n      binding,\n      cwd: browser$1.exports.cwd,\n      chdir: browser$1.exports.chdir,\n      umask: browser$1.exports.umask,\n      exit,\n      pid,\n      features,\n      kill,\n      dlopen,\n      uptime,\n      memoryUsage,\n      uvCounters,\n      platform,\n      arch,\n      execPath,\n      execArgv\n    };\n    addListener = browser$1.exports.addListener;\n    argv = browser$1.exports.argv;\n    chdir = browser$1.exports.chdir;\n    cwd = browser$1.exports.cwd;\n    emit = browser$1.exports.emit;\n    env = browser$1.exports.env;\n    listeners = browser$1.exports.listeners;\n    nextTick = browser$1.exports.nextTick;\n    off = browser$1.exports.off;\n    on = browser$1.exports.on;\n    once = browser$1.exports.once;\n    prependListener = browser$1.exports.prependListener;\n    prependOnceListener = browser$1.exports.prependOnceListener;\n    removeAllListeners = browser$1.exports.removeAllListeners;\n    removeListener = browser$1.exports.removeListener;\n    title = browser$1.exports.title;\n    umask = browser$1.exports.umask;\n    version = browser$1.exports.version;\n    versions = browser$1.exports.versions;\n  }\n});\n\n// ../../node_modules/.pnpm/readable-stream@4.7.0/node_modules/readable-stream/lib/internal/streams/utils.js\nvar require_utils = __commonJS({\n  \"../../node_modules/.pnpm/readable-stream@4.7.0/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/.pnpm/readable-stream@4.7.0/node_modules/readable-stream/lib/internal/streams/end-of-stream.js\nvar require_end_of_stream = __commonJS({\n  \"../../node_modules/.pnpm/readable-stream@4.7.0/node_modules/readable-stream/lib/internal/streams/end-of-stream.js\"(exports2, module2) {\n    \"use strict\";\n    var process2 = (init_process(), __toCommonJS(process_exports));\n    var { AbortError, codes } = require_errors();\n    var { ERR_INVALID_ARG_TYPE, ERR_STREAM_PREMATURE_CLOSE } = codes;\n    var { kEmptyObject, once: once2 } = 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 = once2(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        process2.nextTick(onclose);\n      } else if (wState !== null && wState !== void 0 && wState.errorEmitted || rState !== null && rState !== void 0 && rState.errorEmitted) {\n        if (!willEmitClose) {\n          process2.nextTick(onclosed);\n        }\n      } else if (!readable && (!willEmitClose || isReadable(stream)) && (writableFinished || isWritable(stream) === false)) {\n        process2.nextTick(onclosed);\n      } else if (!writable && (!willEmitClose || isWritable(stream)) && (readableFinished || isReadable(stream) === false)) {\n        process2.nextTick(onclosed);\n      } else if (rState && stream.req && stream.aborted) {\n        process2.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          process2.nextTick(abort);\n        } else {\n          addAbortListener = addAbortListener || require_util().addAbortListener;\n          const disposable = addAbortListener(options.signal, abort);\n          const originalCallback = callback;\n          callback = once2((...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          process2.nextTick(abort);\n        } else {\n          addAbortListener = addAbortListener || require_util().addAbortListener;\n          const disposable = addAbortListener(options.signal, abort);\n          const originalCallback = callback;\n          callback = once2((...args) => {\n            disposable[SymbolDispose]();\n            originalCallback.apply(stream, args);\n          });\n        }\n      }\n      const resolverFn = (...args) => {\n        if (!isAborted) {\n          process2.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/.pnpm/readable-stream@4.7.0/node_modules/readable-stream/lib/internal/streams/destroy.js\nvar require_destroy = __commonJS({\n  \"../../node_modules/.pnpm/readable-stream@4.7.0/node_modules/readable-stream/lib/internal/streams/destroy.js\"(exports2, module2) {\n    \"use strict\";\n    var process2 = (init_process(), __toCommonJS(process_exports));\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(self2, err, cb) {\n      let called = false;\n      function onDestroy(err2) {\n        if (called) {\n          return;\n        }\n        called = true;\n        const r = self2._readableState;\n        const w = self2._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          process2.nextTick(emitErrorCloseNT, self2, err2);\n        } else {\n          process2.nextTick(emitCloseNT, self2);\n        }\n      }\n      try {\n        self2._destroy(err || null, onDestroy);\n      } catch (err2) {\n        onDestroy(err2);\n      }\n    }\n    function emitErrorCloseNT(self2, err) {\n      emitErrorNT(self2, err);\n      emitCloseNT(self2);\n    }\n    function emitCloseNT(self2) {\n      const r = self2._readableState;\n      const w = self2._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        self2.emit(\"close\");\n      }\n    }\n    function emitErrorNT(self2, err) {\n      const r = self2._readableState;\n      const w = self2._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      self2.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          process2.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      process2.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          process2.nextTick(emitConstructNT, stream);\n        }\n      }\n      try {\n        stream._construct((err) => {\n          process2.nextTick(onConstruct, err);\n        });\n      } catch (err) {\n        process2.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      process2.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        process2.nextTick(emitErrorCloseLegacy, stream, err);\n      } else {\n        process2.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/.pnpm/readable-stream@4.7.0/node_modules/readable-stream/lib/internal/streams/legacy.js\nvar require_legacy = __commonJS({\n  \"../../node_modules/.pnpm/readable-stream@4.7.0/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        cleanup();\n        if (EE.listenerCount(this, \"error\") === 0) {\n          this.emit(\"error\", er);\n        }\n      }\n      prependListener2(source, \"error\", onerror);\n      prependListener2(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 prependListener2(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: prependListener2\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/readable-stream@4.7.0/node_modules/readable-stream/lib/internal/streams/add-abort-signal.js\nvar require_add_abort_signal = __commonJS({\n  \"../../node_modules/.pnpm/readable-stream@4.7.0/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/.pnpm/readable-stream@4.7.0/node_modules/readable-stream/lib/internal/streams/buffer_list.js\nvar require_buffer_list = __commonJS({\n  \"../../node_modules/.pnpm/readable-stream@4.7.0/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/.pnpm/readable-stream@4.7.0/node_modules/readable-stream/lib/internal/streams/state.js\nvar require_state = __commonJS({\n  \"../../node_modules/.pnpm/readable-stream@4.7.0/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 = 16 * 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/.pnpm/safe-buffer@5.2.1/node_modules/safe-buffer/index.js\nvar require_safe_buffer = __commonJS({\n  \"../../node_modules/.pnpm/safe-buffer@5.2.1/node_modules/safe-buffer/index.js\"(exports2, module2) {\n    var buffer = require_buffer();\n    var Buffer2 = buffer.Buffer;\n    function copyProps(src, dst) {\n      for (var key in src) {\n        dst[key] = src[key];\n      }\n    }\n    if (Buffer2.from && Buffer2.alloc && Buffer2.allocUnsafe && Buffer2.allocUnsafeSlow) {\n      module2.exports = buffer;\n    } else {\n      copyProps(buffer, exports2);\n      exports2.Buffer = SafeBuffer;\n    }\n    function SafeBuffer(arg, encodingOrOffset, length) {\n      return Buffer2(arg, encodingOrOffset, length);\n    }\n    SafeBuffer.prototype = Object.create(Buffer2.prototype);\n    copyProps(Buffer2, SafeBuffer);\n    SafeBuffer.from = function(arg, encodingOrOffset, length) {\n      if (typeof arg === \"number\") {\n        throw new TypeError(\"Argument must not be a number\");\n      }\n      return Buffer2(arg, encodingOrOffset, length);\n    };\n    SafeBuffer.alloc = function(size, fill, encoding) {\n      if (typeof size !== \"number\") {\n        throw new TypeError(\"Argument must be a number\");\n      }\n      var buf = Buffer2(size);\n      if (fill !== void 0) {\n        if (typeof encoding === \"string\") {\n          buf.fill(fill, encoding);\n        } else {\n          buf.fill(fill);\n        }\n      } else {\n        buf.fill(0);\n      }\n      return buf;\n    };\n    SafeBuffer.allocUnsafe = function(size) {\n      if (typeof size !== \"number\") {\n        throw new TypeError(\"Argument must be a number\");\n      }\n      return Buffer2(size);\n    };\n    SafeBuffer.allocUnsafeSlow = function(size) {\n      if (typeof size !== \"number\") {\n        throw new TypeError(\"Argument must be a number\");\n      }\n      return buffer.SlowBuffer(size);\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/string_decoder@1.3.0/node_modules/string_decoder/lib/string_decoder.js\nvar require_string_decoder = __commonJS({\n  \"../../node_modules/.pnpm/string_decoder@1.3.0/node_modules/string_decoder/lib/string_decoder.js\"(exports2) {\n    \"use strict\";\n    var Buffer2 = require_safe_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(self2, 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) self2.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) self2.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 self2.lastNeed = nb - 3;\n        }\n        return nb;\n      }\n      return 0;\n    }\n    function utf8CheckExtraBytes(self2, buf, p) {\n      if ((buf[0] & 192) !== 128) {\n        self2.lastNeed = 0;\n        return \"\\uFFFD\";\n      }\n      if (self2.lastNeed > 1 && buf.length > 1) {\n        if ((buf[1] & 192) !== 128) {\n          self2.lastNeed = 1;\n          return \"\\uFFFD\";\n        }\n        if (self2.lastNeed > 2 && buf.length > 2) {\n          if ((buf[2] & 192) !== 128) {\n            self2.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/.pnpm/readable-stream@4.7.0/node_modules/readable-stream/lib/internal/streams/from.js\nvar require_from = __commonJS({\n  \"../../node_modules/.pnpm/readable-stream@4.7.0/node_modules/readable-stream/lib/internal/streams/from.js\"(exports2, module2) {\n    \"use strict\";\n    var process2 = (init_process(), __toCommonJS(process_exports));\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          () => process2.nextTick(cb, error),\n          // nextTick is here in case cb throws\n          (e) => process2.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/.pnpm/readable-stream@4.7.0/node_modules/readable-stream/lib/internal/streams/readable.js\nvar require_readable = __commonJS({\n  \"../../node_modules/.pnpm/readable-stream@4.7.0/node_modules/readable-stream/lib/internal/streams/readable.js\"(exports2, module2) {\n    \"use strict\";\n    var process2 = (init_process(), __toCommonJS(process_exports));\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: prependListener2 } = 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        process2.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        process2.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 !== process2.stdout && dest !== process2.stderr;\n      const endFn = doEnd ? onend : unpipe;\n      if (state.endEmitted) process2.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      prependListener2(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            process2.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        process2.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        process2.nextTick(updateReadableListening, this);\n      }\n      return res;\n    };\n    function updateReadableListening(self2) {\n      const state = self2._readableState;\n      state.readableListening = self2.listenerCount(\"readable\") > 0;\n      if (state.resumeScheduled && state[kPaused] === false) {\n        state.flowing = true;\n      } else if (self2.listenerCount(\"data\") > 0) {\n        self2.resume();\n      } else if (!state.readableListening) {\n        state.flowing = null;\n      }\n    }\n    function nReadingNextTick(self2) {\n      debug(\"readable nexttick read 0\");\n      self2.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        process2.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        process2.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          process2.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/.pnpm/readable-stream@4.7.0/node_modules/readable-stream/lib/internal/streams/writable.js\nvar require_writable = __commonJS({\n  \"../../node_modules/.pnpm/readable-stream@4.7.0/node_modules/readable-stream/lib/internal/streams/writable.js\"(exports2, module2) {\n    \"use strict\";\n    var process2 = (init_process(), __toCommonJS(process_exports));\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        process2.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          process2.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            process2.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          process2.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          process2.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            process2.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        process2.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/.pnpm/readable-stream@4.7.0/node_modules/readable-stream/lib/internal/streams/duplexify.js\nvar require_duplexify = __commonJS({\n  \"../../node_modules/.pnpm/readable-stream@4.7.0/node_modules/readable-stream/lib/internal/streams/duplexify.js\"(exports2, module2) {\n    var process2 = (init_process(), __toCommonJS(process_exports));\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_browser().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                  process2.nextTick(cb, null);\n                } catch (err) {\n                  process2.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            process2.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/.pnpm/readable-stream@4.7.0/node_modules/readable-stream/lib/internal/streams/duplex.js\nvar require_duplex = __commonJS({\n  \"../../node_modules/.pnpm/readable-stream@4.7.0/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/.pnpm/readable-stream@4.7.0/node_modules/readable-stream/lib/internal/streams/transform.js\nvar require_transform = __commonJS({\n  \"../../node_modules/.pnpm/readable-stream@4.7.0/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/.pnpm/readable-stream@4.7.0/node_modules/readable-stream/lib/internal/streams/passthrough.js\nvar require_passthrough = __commonJS({\n  \"../../node_modules/.pnpm/readable-stream@4.7.0/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/.pnpm/readable-stream@4.7.0/node_modules/readable-stream/lib/internal/streams/pipeline.js\nvar require_pipeline = __commonJS({\n  \"../../node_modules/.pnpm/readable-stream@4.7.0/node_modules/readable-stream/lib/internal/streams/pipeline.js\"(exports2, module2) {\n    var process2 = (init_process(), __toCommonJS(process_exports));\n    var { ArrayIsArray, Promise: Promise2, SymbolAsyncIterator, SymbolDispose } = require_primordials();\n    var eos = require_end_of_stream();\n    var { once: once2 } = 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_browser().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, once2(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          process2.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                  process2.nextTick(finish);\n                },\n                (err) => {\n                  pt.destroy(err);\n                  process2.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        process2.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          process2.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/.pnpm/readable-stream@4.7.0/node_modules/readable-stream/lib/internal/streams/compose.js\nvar require_compose = __commonJS({\n  \"../../node_modules/.pnpm/readable-stream@4.7.0/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/.pnpm/readable-stream@4.7.0/node_modules/readable-stream/lib/internal/streams/operators.js\nvar require_operators = __commonJS({\n  \"../../node_modules/.pnpm/readable-stream@4.7.0/node_modules/readable-stream/lib/internal/streams/operators.js\"(exports2, module2) {\n    \"use strict\";\n    var AbortController = globalThis.AbortController || require_browser().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 queue2 = [];\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 && queue2.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              queue2.push(val);\n              if (next) {\n                next();\n                next = null;\n              }\n              if (!done && (queue2.length >= highWaterMark || cnt >= concurrency)) {\n                await new Promise2((resolve) => {\n                  resume = resolve;\n                });\n              }\n            }\n            queue2.push(kEof);\n          } catch (err) {\n            const val = PromiseReject(err);\n            PromisePrototypeThen(val, afterItemProcessed, onCatch);\n            queue2.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 (queue2.length > 0) {\n              const val = await queue2[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              queue2.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/.pnpm/readable-stream@4.7.0/node_modules/readable-stream/lib/stream/promises.js\nvar require_promises = __commonJS({\n  \"../../node_modules/.pnpm/readable-stream@4.7.0/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/.pnpm/readable-stream@4.7.0/node_modules/readable-stream/lib/stream.js\nvar require_stream = __commonJS({\n  \"../../node_modules/.pnpm/readable-stream@4.7.0/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 promises = 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 promises;\n      }\n    });\n    ObjectDefineProperty(pipeline, customPromisify, {\n      __proto__: null,\n      enumerable: true,\n      get() {\n        return promises.pipeline;\n      }\n    });\n    ObjectDefineProperty(eos, customPromisify, {\n      __proto__: null,\n      enumerable: true,\n      get() {\n        return promises.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/.pnpm/readable-stream@4.7.0/node_modules/readable-stream/lib/ours/browser.js\nvar require_browser2 = __commonJS({\n  \"../../node_modules/.pnpm/readable-stream@4.7.0/node_modules/readable-stream/lib/ours/browser.js\"(exports2, module2) {\n    \"use strict\";\n    var CustomStream = require_stream();\n    var promises = require_promises();\n    var originalDestroy = CustomStream.Readable.destroy;\n    module2.exports = CustomStream.Readable;\n    module2.exports._uint8ArrayToBuffer = CustomStream._uint8ArrayToBuffer;\n    module2.exports._isUint8Array = CustomStream._isUint8Array;\n    module2.exports.isDisturbed = CustomStream.isDisturbed;\n    module2.exports.isErrored = CustomStream.isErrored;\n    module2.exports.isReadable = CustomStream.isReadable;\n    module2.exports.Readable = CustomStream.Readable;\n    module2.exports.Writable = CustomStream.Writable;\n    module2.exports.Duplex = CustomStream.Duplex;\n    module2.exports.Transform = CustomStream.Transform;\n    module2.exports.PassThrough = CustomStream.PassThrough;\n    module2.exports.addAbortSignal = CustomStream.addAbortSignal;\n    module2.exports.finished = CustomStream.finished;\n    module2.exports.destroy = CustomStream.destroy;\n    module2.exports.destroy = originalDestroy;\n    module2.exports.pipeline = CustomStream.pipeline;\n    module2.exports.compose = CustomStream.compose;\n    Object.defineProperty(CustomStream, \"promises\", {\n      configurable: true,\n      enumerable: true,\n      get() {\n        return promises;\n      }\n    });\n    module2.exports.Stream = CustomStream.Stream;\n    module2.exports.default = module2.exports;\n  }\n});\n\n// <stdin>\nvar imported = require_browser2();\nvar resolved = imported.default ?? imported;\nresolved.Readable.toWeb = (stream) => new ReadableStream({\n  start(controller) {\n    stream.on(\"data\", (chunk) => controller.enqueue(chunk));\n    stream.once(\"end\", () => controller.close());\n    stream.once(\"error\", (error) => controller.error(error));\n    stream.resume?.();\n  },\n  cancel(reason) {\n    stream.destroy?.(reason instanceof Error ? reason : void 0);\n  }\n});\nresolved.Writable.toWeb = (stream) => new WritableStream({\n  start(controller) {\n    stream.on(\"error\", (error) => controller.error(error));\n  },\n  write(chunk) {\n    return new Promise((resolve, reject) => stream.write(chunk, void 0, (error) => error ? reject(error) : resolve()));\n  },\n  close() {\n    return new Promise((resolve, reject) => stream.end((error) => error ? reject(error) : resolve()));\n  },\n  abort(reason) {\n    stream.destroy?.(reason instanceof Error ? reason : new Error(String(reason)));\n  }\n});\nresolved.Duplex.toWeb = (stream) => ({\n  readable: resolved.Readable.toWeb(stream),\n  writable: resolved.Writable.toWeb(stream)\n});\nmodule.exports = resolved;\n/*! Bundled license information:\n\nieee754/index.js:\n  (*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> *)\n\nbuffer/index.js:\n  (*!\n   * The buffer module from node.js, for the browser.\n   *\n   * @author   Feross Aboukhadijeh <https://feross.org>\n   * @license  MIT\n   *)\n\nsafe-buffer/index.js:\n  (*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> *)\n*/\n\nif (module.exports && module.exports.default == null) module.exports.default = module.exports;\n";
+export const BROWSER_STRING_DECODER_POLYFILL_CODE = "var process = globalThis.process || {\n  env: {},\n  cwd: () => '/',\n  nextTick: (fn, ...args) => queueMicrotask(() => fn(...args)),\n};\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __commonJS = (cb, mod) => function __require() {\n  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;\n};\n\n// ../../node_modules/.pnpm/base64-js@1.5.1/node_modules/base64-js/index.js\nvar require_base64_js = __commonJS({\n  \"../../node_modules/.pnpm/base64-js@1.5.1/node_modules/base64-js/index.js\"(exports2) {\n    \"use strict\";\n    exports2.byteLength = byteLength;\n    exports2.toByteArray = toByteArray;\n    exports2.fromByteArray = fromByteArray;\n    var lookup = [];\n    var revLookup = [];\n    var Arr = typeof Uint8Array !== \"undefined\" ? Uint8Array : Array;\n    var code = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\";\n    for (i = 0, len = code.length; i < len; ++i) {\n      lookup[i] = code[i];\n      revLookup[code.charCodeAt(i)] = i;\n    }\n    var i;\n    var len;\n    revLookup[\"-\".charCodeAt(0)] = 62;\n    revLookup[\"_\".charCodeAt(0)] = 63;\n    function getLens(b64) {\n      var len2 = b64.length;\n      if (len2 % 4 > 0) {\n        throw new Error(\"Invalid string. Length must be a multiple of 4\");\n      }\n      var validLen = b64.indexOf(\"=\");\n      if (validLen === -1) validLen = len2;\n      var placeHoldersLen = validLen === len2 ? 0 : 4 - validLen % 4;\n      return [validLen, placeHoldersLen];\n    }\n    function byteLength(b64) {\n      var lens = getLens(b64);\n      var validLen = lens[0];\n      var placeHoldersLen = lens[1];\n      return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;\n    }\n    function _byteLength(b64, validLen, placeHoldersLen) {\n      return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;\n    }\n    function toByteArray(b64) {\n      var tmp;\n      var lens = getLens(b64);\n      var validLen = lens[0];\n      var placeHoldersLen = lens[1];\n      var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));\n      var curByte = 0;\n      var len2 = placeHoldersLen > 0 ? validLen - 4 : validLen;\n      var i2;\n      for (i2 = 0; i2 < len2; i2 += 4) {\n        tmp = revLookup[b64.charCodeAt(i2)] << 18 | revLookup[b64.charCodeAt(i2 + 1)] << 12 | revLookup[b64.charCodeAt(i2 + 2)] << 6 | revLookup[b64.charCodeAt(i2 + 3)];\n        arr[curByte++] = tmp >> 16 & 255;\n        arr[curByte++] = tmp >> 8 & 255;\n        arr[curByte++] = tmp & 255;\n      }\n      if (placeHoldersLen === 2) {\n        tmp = revLookup[b64.charCodeAt(i2)] << 2 | revLookup[b64.charCodeAt(i2 + 1)] >> 4;\n        arr[curByte++] = tmp & 255;\n      }\n      if (placeHoldersLen === 1) {\n        tmp = revLookup[b64.charCodeAt(i2)] << 10 | revLookup[b64.charCodeAt(i2 + 1)] << 4 | revLookup[b64.charCodeAt(i2 + 2)] >> 2;\n        arr[curByte++] = tmp >> 8 & 255;\n        arr[curByte++] = tmp & 255;\n      }\n      return arr;\n    }\n    function tripletToBase64(num) {\n      return lookup[num >> 18 & 63] + lookup[num >> 12 & 63] + lookup[num >> 6 & 63] + lookup[num & 63];\n    }\n    function encodeChunk(uint8, start, end) {\n      var tmp;\n      var output = [];\n      for (var i2 = start; i2 < end; i2 += 3) {\n        tmp = (uint8[i2] << 16 & 16711680) + (uint8[i2 + 1] << 8 & 65280) + (uint8[i2 + 2] & 255);\n        output.push(tripletToBase64(tmp));\n      }\n      return output.join(\"\");\n    }\n    function fromByteArray(uint8) {\n      var tmp;\n      var len2 = uint8.length;\n      var extraBytes = len2 % 3;\n      var parts = [];\n      var maxChunkLength = 16383;\n      for (var i2 = 0, len22 = len2 - extraBytes; i2 < len22; i2 += maxChunkLength) {\n        parts.push(encodeChunk(uint8, i2, i2 + maxChunkLength > len22 ? len22 : i2 + maxChunkLength));\n      }\n      if (extraBytes === 1) {\n        tmp = uint8[len2 - 1];\n        parts.push(\n          lookup[tmp >> 2] + lookup[tmp << 4 & 63] + \"==\"\n        );\n      } else if (extraBytes === 2) {\n        tmp = (uint8[len2 - 2] << 8) + uint8[len2 - 1];\n        parts.push(\n          lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63] + \"=\"\n        );\n      }\n      return parts.join(\"\");\n    }\n  }\n});\n\n// ../../node_modules/.pnpm/ieee754@1.2.1/node_modules/ieee754/index.js\nvar require_ieee754 = __commonJS({\n  \"../../node_modules/.pnpm/ieee754@1.2.1/node_modules/ieee754/index.js\"(exports2) {\n    exports2.read = function(buffer, offset, isLE, mLen, nBytes) {\n      var e, m;\n      var eLen = nBytes * 8 - mLen - 1;\n      var eMax = (1 << eLen) - 1;\n      var eBias = eMax >> 1;\n      var nBits = -7;\n      var i = isLE ? nBytes - 1 : 0;\n      var d = isLE ? -1 : 1;\n      var s = buffer[offset + i];\n      i += d;\n      e = s & (1 << -nBits) - 1;\n      s >>= -nBits;\n      nBits += eLen;\n      for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {\n      }\n      m = e & (1 << -nBits) - 1;\n      e >>= -nBits;\n      nBits += mLen;\n      for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {\n      }\n      if (e === 0) {\n        e = 1 - eBias;\n      } else if (e === eMax) {\n        return m ? NaN : (s ? -1 : 1) * Infinity;\n      } else {\n        m = m + Math.pow(2, mLen);\n        e = e - eBias;\n      }\n      return (s ? -1 : 1) * m * Math.pow(2, e - mLen);\n    };\n    exports2.write = function(buffer, value, offset, isLE, mLen, nBytes) {\n      var e, m, c;\n      var eLen = nBytes * 8 - mLen - 1;\n      var eMax = (1 << eLen) - 1;\n      var eBias = eMax >> 1;\n      var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;\n      var i = isLE ? 0 : nBytes - 1;\n      var d = isLE ? 1 : -1;\n      var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;\n      value = Math.abs(value);\n      if (isNaN(value) || value === Infinity) {\n        m = isNaN(value) ? 1 : 0;\n        e = eMax;\n      } else {\n        e = Math.floor(Math.log(value) / Math.LN2);\n        if (value * (c = Math.pow(2, -e)) < 1) {\n          e--;\n          c *= 2;\n        }\n        if (e + eBias >= 1) {\n          value += rt / c;\n        } else {\n          value += rt * Math.pow(2, 1 - eBias);\n        }\n        if (value * c >= 2) {\n          e++;\n          c /= 2;\n        }\n        if (e + eBias >= eMax) {\n          m = 0;\n          e = eMax;\n        } else if (e + eBias >= 1) {\n          m = (value * c - 1) * Math.pow(2, mLen);\n          e = e + eBias;\n        } else {\n          m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);\n          e = 0;\n        }\n      }\n      for (; mLen >= 8; buffer[offset + i] = m & 255, i += d, m /= 256, mLen -= 8) {\n      }\n      e = e << mLen | m;\n      eLen += mLen;\n      for (; eLen > 0; buffer[offset + i] = e & 255, i += d, e /= 256, eLen -= 8) {\n      }\n      buffer[offset + i - d] |= s * 128;\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/buffer@5.7.1/node_modules/buffer/index.js\nvar require_buffer = __commonJS({\n  \"../../node_modules/.pnpm/buffer@5.7.1/node_modules/buffer/index.js\"(exports2) {\n    \"use strict\";\n    var base64 = require_base64_js();\n    var ieee754 = require_ieee754();\n    var customInspectSymbol = typeof Symbol === \"function\" && typeof Symbol[\"for\"] === \"function\" ? Symbol[\"for\"](\"nodejs.util.inspect.custom\") : null;\n    exports2.Buffer = Buffer2;\n    exports2.SlowBuffer = SlowBuffer;\n    exports2.INSPECT_MAX_BYTES = 50;\n    var K_MAX_LENGTH = 2147483647;\n    exports2.kMaxLength = K_MAX_LENGTH;\n    Buffer2.TYPED_ARRAY_SUPPORT = typedArraySupport();\n    if (!Buffer2.TYPED_ARRAY_SUPPORT && typeof console !== \"undefined\" && typeof console.error === \"function\") {\n      console.error(\n        \"This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support.\"\n      );\n    }\n    function typedArraySupport() {\n      try {\n        var arr = new Uint8Array(1);\n        var proto = { foo: function() {\n          return 42;\n        } };\n        Object.setPrototypeOf(proto, Uint8Array.prototype);\n        Object.setPrototypeOf(arr, proto);\n        return arr.foo() === 42;\n      } catch (e) {\n        return false;\n      }\n    }\n    Object.defineProperty(Buffer2.prototype, \"parent\", {\n      enumerable: true,\n      get: function() {\n        if (!Buffer2.isBuffer(this)) return void 0;\n        return this.buffer;\n      }\n    });\n    Object.defineProperty(Buffer2.prototype, \"offset\", {\n      enumerable: true,\n      get: function() {\n        if (!Buffer2.isBuffer(this)) return void 0;\n        return this.byteOffset;\n      }\n    });\n    function createBuffer(length) {\n      if (length > K_MAX_LENGTH) {\n        throw new RangeError('The value \"' + length + '\" is invalid for option \"size\"');\n      }\n      var buf = new Uint8Array(length);\n      Object.setPrototypeOf(buf, Buffer2.prototype);\n      return buf;\n    }\n    function Buffer2(arg, encodingOrOffset, length) {\n      if (typeof arg === \"number\") {\n        if (typeof encodingOrOffset === \"string\") {\n          throw new TypeError(\n            'The \"string\" argument must be of type string. Received type number'\n          );\n        }\n        return allocUnsafe(arg);\n      }\n      return from(arg, encodingOrOffset, length);\n    }\n    Buffer2.poolSize = 8192;\n    function from(value, encodingOrOffset, length) {\n      if (typeof value === \"string\") {\n        return fromString(value, encodingOrOffset);\n      }\n      if (ArrayBuffer.isView(value)) {\n        return fromArrayView(value);\n      }\n      if (value == null) {\n        throw new TypeError(\n          \"The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type \" + typeof value\n        );\n      }\n      if (isInstance(value, ArrayBuffer) || value && isInstance(value.buffer, ArrayBuffer)) {\n        return fromArrayBuffer(value, encodingOrOffset, length);\n      }\n      if (typeof SharedArrayBuffer !== \"undefined\" && (isInstance(value, SharedArrayBuffer) || value && isInstance(value.buffer, SharedArrayBuffer))) {\n        return fromArrayBuffer(value, encodingOrOffset, length);\n      }\n      if (typeof value === \"number\") {\n        throw new TypeError(\n          'The \"value\" argument must not be of type number. Received type number'\n        );\n      }\n      var valueOf = value.valueOf && value.valueOf();\n      if (valueOf != null && valueOf !== value) {\n        return Buffer2.from(valueOf, encodingOrOffset, length);\n      }\n      var b = fromObject(value);\n      if (b) return b;\n      if (typeof Symbol !== \"undefined\" && Symbol.toPrimitive != null && typeof value[Symbol.toPrimitive] === \"function\") {\n        return Buffer2.from(\n          value[Symbol.toPrimitive](\"string\"),\n          encodingOrOffset,\n          length\n        );\n      }\n      throw new TypeError(\n        \"The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type \" + typeof value\n      );\n    }\n    Buffer2.from = function(value, encodingOrOffset, length) {\n      return from(value, encodingOrOffset, length);\n    };\n    Object.setPrototypeOf(Buffer2.prototype, Uint8Array.prototype);\n    Object.setPrototypeOf(Buffer2, Uint8Array);\n    function assertSize(size) {\n      if (typeof size !== \"number\") {\n        throw new TypeError('\"size\" argument must be of type number');\n      } else if (size < 0) {\n        throw new RangeError('The value \"' + size + '\" is invalid for option \"size\"');\n      }\n    }\n    function alloc(size, fill, encoding) {\n      assertSize(size);\n      if (size <= 0) {\n        return createBuffer(size);\n      }\n      if (fill !== void 0) {\n        return typeof encoding === \"string\" ? createBuffer(size).fill(fill, encoding) : createBuffer(size).fill(fill);\n      }\n      return createBuffer(size);\n    }\n    Buffer2.alloc = function(size, fill, encoding) {\n      return alloc(size, fill, encoding);\n    };\n    function allocUnsafe(size) {\n      assertSize(size);\n      return createBuffer(size < 0 ? 0 : checked(size) | 0);\n    }\n    Buffer2.allocUnsafe = function(size) {\n      return allocUnsafe(size);\n    };\n    Buffer2.allocUnsafeSlow = function(size) {\n      return allocUnsafe(size);\n    };\n    function fromString(string, encoding) {\n      if (typeof encoding !== \"string\" || encoding === \"\") {\n        encoding = \"utf8\";\n      }\n      if (!Buffer2.isEncoding(encoding)) {\n        throw new TypeError(\"Unknown encoding: \" + encoding);\n      }\n      var length = byteLength(string, encoding) | 0;\n      var buf = createBuffer(length);\n      var actual = buf.write(string, encoding);\n      if (actual !== length) {\n        buf = buf.slice(0, actual);\n      }\n      return buf;\n    }\n    function fromArrayLike(array) {\n      var length = array.length < 0 ? 0 : checked(array.length) | 0;\n      var buf = createBuffer(length);\n      for (var i = 0; i < length; i += 1) {\n        buf[i] = array[i] & 255;\n      }\n      return buf;\n    }\n    function fromArrayView(arrayView) {\n      if (isInstance(arrayView, Uint8Array)) {\n        var copy = new Uint8Array(arrayView);\n        return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength);\n      }\n      return fromArrayLike(arrayView);\n    }\n    function fromArrayBuffer(array, byteOffset, length) {\n      if (byteOffset < 0 || array.byteLength < byteOffset) {\n        throw new RangeError('\"offset\" is outside of buffer bounds');\n      }\n      if (array.byteLength < byteOffset + (length || 0)) {\n        throw new RangeError('\"length\" is outside of buffer bounds');\n      }\n      var buf;\n      if (byteOffset === void 0 && length === void 0) {\n        buf = new Uint8Array(array);\n      } else if (length === void 0) {\n        buf = new Uint8Array(array, byteOffset);\n      } else {\n        buf = new Uint8Array(array, byteOffset, length);\n      }\n      Object.setPrototypeOf(buf, Buffer2.prototype);\n      return buf;\n    }\n    function fromObject(obj) {\n      if (Buffer2.isBuffer(obj)) {\n        var len = checked(obj.length) | 0;\n        var buf = createBuffer(len);\n        if (buf.length === 0) {\n          return buf;\n        }\n        obj.copy(buf, 0, 0, len);\n        return buf;\n      }\n      if (obj.length !== void 0) {\n        if (typeof obj.length !== \"number\" || numberIsNaN(obj.length)) {\n          return createBuffer(0);\n        }\n        return fromArrayLike(obj);\n      }\n      if (obj.type === \"Buffer\" && Array.isArray(obj.data)) {\n        return fromArrayLike(obj.data);\n      }\n    }\n    function checked(length) {\n      if (length >= K_MAX_LENGTH) {\n        throw new RangeError(\"Attempt to allocate Buffer larger than maximum size: 0x\" + K_MAX_LENGTH.toString(16) + \" bytes\");\n      }\n      return length | 0;\n    }\n    function SlowBuffer(length) {\n      if (+length != length) {\n        length = 0;\n      }\n      return Buffer2.alloc(+length);\n    }\n    Buffer2.isBuffer = function isBuffer(b) {\n      return b != null && b._isBuffer === true && b !== Buffer2.prototype;\n    };\n    Buffer2.compare = function compare(a, b) {\n      if (isInstance(a, Uint8Array)) a = Buffer2.from(a, a.offset, a.byteLength);\n      if (isInstance(b, Uint8Array)) b = Buffer2.from(b, b.offset, b.byteLength);\n      if (!Buffer2.isBuffer(a) || !Buffer2.isBuffer(b)) {\n        throw new TypeError(\n          'The \"buf1\", \"buf2\" arguments must be one of type Buffer or Uint8Array'\n        );\n      }\n      if (a === b) return 0;\n      var x = a.length;\n      var y = b.length;\n      for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n        if (a[i] !== b[i]) {\n          x = a[i];\n          y = b[i];\n          break;\n        }\n      }\n      if (x < y) return -1;\n      if (y < x) return 1;\n      return 0;\n    };\n    Buffer2.isEncoding = function isEncoding(encoding) {\n      switch (String(encoding).toLowerCase()) {\n        case \"hex\":\n        case \"utf8\":\n        case \"utf-8\":\n        case \"ascii\":\n        case \"latin1\":\n        case \"binary\":\n        case \"base64\":\n        case \"ucs2\":\n        case \"ucs-2\":\n        case \"utf16le\":\n        case \"utf-16le\":\n          return true;\n        default:\n          return false;\n      }\n    };\n    Buffer2.concat = function concat(list, length) {\n      if (!Array.isArray(list)) {\n        throw new TypeError('\"list\" argument must be an Array of Buffers');\n      }\n      if (list.length === 0) {\n        return Buffer2.alloc(0);\n      }\n      var i;\n      if (length === void 0) {\n        length = 0;\n        for (i = 0; i < list.length; ++i) {\n          length += list[i].length;\n        }\n      }\n      var buffer = Buffer2.allocUnsafe(length);\n      var pos = 0;\n      for (i = 0; i < list.length; ++i) {\n        var buf = list[i];\n        if (isInstance(buf, Uint8Array)) {\n          if (pos + buf.length > buffer.length) {\n            Buffer2.from(buf).copy(buffer, pos);\n          } else {\n            Uint8Array.prototype.set.call(\n              buffer,\n              buf,\n              pos\n            );\n          }\n        } else if (!Buffer2.isBuffer(buf)) {\n          throw new TypeError('\"list\" argument must be an Array of Buffers');\n        } else {\n          buf.copy(buffer, pos);\n        }\n        pos += buf.length;\n      }\n      return buffer;\n    };\n    function byteLength(string, encoding) {\n      if (Buffer2.isBuffer(string)) {\n        return string.length;\n      }\n      if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {\n        return string.byteLength;\n      }\n      if (typeof string !== \"string\") {\n        throw new TypeError(\n          'The \"string\" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof string\n        );\n      }\n      var len = string.length;\n      var mustMatch = arguments.length > 2 && arguments[2] === true;\n      if (!mustMatch && len === 0) return 0;\n      var loweredCase = false;\n      for (; ; ) {\n        switch (encoding) {\n          case \"ascii\":\n          case \"latin1\":\n          case \"binary\":\n            return len;\n          case \"utf8\":\n          case \"utf-8\":\n            return utf8ToBytes(string).length;\n          case \"ucs2\":\n          case \"ucs-2\":\n          case \"utf16le\":\n          case \"utf-16le\":\n            return len * 2;\n          case \"hex\":\n            return len >>> 1;\n          case \"base64\":\n            return base64ToBytes(string).length;\n          default:\n            if (loweredCase) {\n              return mustMatch ? -1 : utf8ToBytes(string).length;\n            }\n            encoding = (\"\" + encoding).toLowerCase();\n            loweredCase = true;\n        }\n      }\n    }\n    Buffer2.byteLength = byteLength;\n    function slowToString(encoding, start, end) {\n      var loweredCase = false;\n      if (start === void 0 || start < 0) {\n        start = 0;\n      }\n      if (start > this.length) {\n        return \"\";\n      }\n      if (end === void 0 || end > this.length) {\n        end = this.length;\n      }\n      if (end <= 0) {\n        return \"\";\n      }\n      end >>>= 0;\n      start >>>= 0;\n      if (end <= start) {\n        return \"\";\n      }\n      if (!encoding) encoding = \"utf8\";\n      while (true) {\n        switch (encoding) {\n          case \"hex\":\n            return hexSlice(this, start, end);\n          case \"utf8\":\n          case \"utf-8\":\n            return utf8Slice(this, start, end);\n          case \"ascii\":\n            return asciiSlice(this, start, end);\n          case \"latin1\":\n          case \"binary\":\n            return latin1Slice(this, start, end);\n          case \"base64\":\n            return base64Slice(this, start, end);\n          case \"ucs2\":\n          case \"ucs-2\":\n          case \"utf16le\":\n          case \"utf-16le\":\n            return utf16leSlice(this, start, end);\n          default:\n            if (loweredCase) throw new TypeError(\"Unknown encoding: \" + encoding);\n            encoding = (encoding + \"\").toLowerCase();\n            loweredCase = true;\n        }\n      }\n    }\n    Buffer2.prototype._isBuffer = true;\n    function swap(b, n, m) {\n      var i = b[n];\n      b[n] = b[m];\n      b[m] = i;\n    }\n    Buffer2.prototype.swap16 = function swap16() {\n      var len = this.length;\n      if (len % 2 !== 0) {\n        throw new RangeError(\"Buffer size must be a multiple of 16-bits\");\n      }\n      for (var i = 0; i < len; i += 2) {\n        swap(this, i, i + 1);\n      }\n      return this;\n    };\n    Buffer2.prototype.swap32 = function swap32() {\n      var len = this.length;\n      if (len % 4 !== 0) {\n        throw new RangeError(\"Buffer size must be a multiple of 32-bits\");\n      }\n      for (var i = 0; i < len; i += 4) {\n        swap(this, i, i + 3);\n        swap(this, i + 1, i + 2);\n      }\n      return this;\n    };\n    Buffer2.prototype.swap64 = function swap64() {\n      var len = this.length;\n      if (len % 8 !== 0) {\n        throw new RangeError(\"Buffer size must be a multiple of 64-bits\");\n      }\n      for (var i = 0; i < len; i += 8) {\n        swap(this, i, i + 7);\n        swap(this, i + 1, i + 6);\n        swap(this, i + 2, i + 5);\n        swap(this, i + 3, i + 4);\n      }\n      return this;\n    };\n    Buffer2.prototype.toString = function toString() {\n      var length = this.length;\n      if (length === 0) return \"\";\n      if (arguments.length === 0) return utf8Slice(this, 0, length);\n      return slowToString.apply(this, arguments);\n    };\n    Buffer2.prototype.toLocaleString = Buffer2.prototype.toString;\n    Buffer2.prototype.equals = function equals(b) {\n      if (!Buffer2.isBuffer(b)) throw new TypeError(\"Argument must be a Buffer\");\n      if (this === b) return true;\n      return Buffer2.compare(this, b) === 0;\n    };\n    Buffer2.prototype.inspect = function inspect() {\n      var str = \"\";\n      var max = exports2.INSPECT_MAX_BYTES;\n      str = this.toString(\"hex\", 0, max).replace(/(.{2})/g, \"$1 \").trim();\n      if (this.length > max) str += \" ... \";\n      return \"<Buffer \" + str + \">\";\n    };\n    if (customInspectSymbol) {\n      Buffer2.prototype[customInspectSymbol] = Buffer2.prototype.inspect;\n    }\n    Buffer2.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {\n      if (isInstance(target, Uint8Array)) {\n        target = Buffer2.from(target, target.offset, target.byteLength);\n      }\n      if (!Buffer2.isBuffer(target)) {\n        throw new TypeError(\n          'The \"target\" argument must be one of type Buffer or Uint8Array. Received type ' + typeof target\n        );\n      }\n      if (start === void 0) {\n        start = 0;\n      }\n      if (end === void 0) {\n        end = target ? target.length : 0;\n      }\n      if (thisStart === void 0) {\n        thisStart = 0;\n      }\n      if (thisEnd === void 0) {\n        thisEnd = this.length;\n      }\n      if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n        throw new RangeError(\"out of range index\");\n      }\n      if (thisStart >= thisEnd && start >= end) {\n        return 0;\n      }\n      if (thisStart >= thisEnd) {\n        return -1;\n      }\n      if (start >= end) {\n        return 1;\n      }\n      start >>>= 0;\n      end >>>= 0;\n      thisStart >>>= 0;\n      thisEnd >>>= 0;\n      if (this === target) return 0;\n      var x = thisEnd - thisStart;\n      var y = end - start;\n      var len = Math.min(x, y);\n      var thisCopy = this.slice(thisStart, thisEnd);\n      var targetCopy = target.slice(start, end);\n      for (var i = 0; i < len; ++i) {\n        if (thisCopy[i] !== targetCopy[i]) {\n          x = thisCopy[i];\n          y = targetCopy[i];\n          break;\n        }\n      }\n      if (x < y) return -1;\n      if (y < x) return 1;\n      return 0;\n    };\n    function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {\n      if (buffer.length === 0) return -1;\n      if (typeof byteOffset === \"string\") {\n        encoding = byteOffset;\n        byteOffset = 0;\n      } else if (byteOffset > 2147483647) {\n        byteOffset = 2147483647;\n      } else if (byteOffset < -2147483648) {\n        byteOffset = -2147483648;\n      }\n      byteOffset = +byteOffset;\n      if (numberIsNaN(byteOffset)) {\n        byteOffset = dir ? 0 : buffer.length - 1;\n      }\n      if (byteOffset < 0) byteOffset = buffer.length + byteOffset;\n      if (byteOffset >= buffer.length) {\n        if (dir) return -1;\n        else byteOffset = buffer.length - 1;\n      } else if (byteOffset < 0) {\n        if (dir) byteOffset = 0;\n        else return -1;\n      }\n      if (typeof val === \"string\") {\n        val = Buffer2.from(val, encoding);\n      }\n      if (Buffer2.isBuffer(val)) {\n        if (val.length === 0) {\n          return -1;\n        }\n        return arrayIndexOf(buffer, val, byteOffset, encoding, dir);\n      } else if (typeof val === \"number\") {\n        val = val & 255;\n        if (typeof Uint8Array.prototype.indexOf === \"function\") {\n          if (dir) {\n            return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset);\n          } else {\n            return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset);\n          }\n        }\n        return arrayIndexOf(buffer, [val], byteOffset, encoding, dir);\n      }\n      throw new TypeError(\"val must be string, number or Buffer\");\n    }\n    function arrayIndexOf(arr, val, byteOffset, encoding, dir) {\n      var indexSize = 1;\n      var arrLength = arr.length;\n      var valLength = val.length;\n      if (encoding !== void 0) {\n        encoding = String(encoding).toLowerCase();\n        if (encoding === \"ucs2\" || encoding === \"ucs-2\" || encoding === \"utf16le\" || encoding === \"utf-16le\") {\n          if (arr.length < 2 || val.length < 2) {\n            return -1;\n          }\n          indexSize = 2;\n          arrLength /= 2;\n          valLength /= 2;\n          byteOffset /= 2;\n        }\n      }\n      function read(buf, i2) {\n        if (indexSize === 1) {\n          return buf[i2];\n        } else {\n          return buf.readUInt16BE(i2 * indexSize);\n        }\n      }\n      var i;\n      if (dir) {\n        var foundIndex = -1;\n        for (i = byteOffset; i < arrLength; i++) {\n          if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n            if (foundIndex === -1) foundIndex = i;\n            if (i - foundIndex + 1 === valLength) return foundIndex * indexSize;\n          } else {\n            if (foundIndex !== -1) i -= i - foundIndex;\n            foundIndex = -1;\n          }\n        }\n      } else {\n        if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength;\n        for (i = byteOffset; i >= 0; i--) {\n          var found = true;\n          for (var j = 0; j < valLength; j++) {\n            if (read(arr, i + j) !== read(val, j)) {\n              found = false;\n              break;\n            }\n          }\n          if (found) return i;\n        }\n      }\n      return -1;\n    }\n    Buffer2.prototype.includes = function includes(val, byteOffset, encoding) {\n      return this.indexOf(val, byteOffset, encoding) !== -1;\n    };\n    Buffer2.prototype.indexOf = function indexOf(val, byteOffset, encoding) {\n      return bidirectionalIndexOf(this, val, byteOffset, encoding, true);\n    };\n    Buffer2.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {\n      return bidirectionalIndexOf(this, val, byteOffset, encoding, false);\n    };\n    function hexWrite(buf, string, offset, length) {\n      offset = Number(offset) || 0;\n      var remaining = buf.length - offset;\n      if (!length) {\n        length = remaining;\n      } else {\n        length = Number(length);\n        if (length > remaining) {\n          length = remaining;\n        }\n      }\n      var strLen = string.length;\n      if (length > strLen / 2) {\n        length = strLen / 2;\n      }\n      for (var i = 0; i < length; ++i) {\n        var parsed = parseInt(string.substr(i * 2, 2), 16);\n        if (numberIsNaN(parsed)) return i;\n        buf[offset + i] = parsed;\n      }\n      return i;\n    }\n    function utf8Write(buf, string, offset, length) {\n      return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length);\n    }\n    function asciiWrite(buf, string, offset, length) {\n      return blitBuffer(asciiToBytes(string), buf, offset, length);\n    }\n    function base64Write(buf, string, offset, length) {\n      return blitBuffer(base64ToBytes(string), buf, offset, length);\n    }\n    function ucs2Write(buf, string, offset, length) {\n      return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length);\n    }\n    Buffer2.prototype.write = function write(string, offset, length, encoding) {\n      if (offset === void 0) {\n        encoding = \"utf8\";\n        length = this.length;\n        offset = 0;\n      } else if (length === void 0 && typeof offset === \"string\") {\n        encoding = offset;\n        length = this.length;\n        offset = 0;\n      } else if (isFinite(offset)) {\n        offset = offset >>> 0;\n        if (isFinite(length)) {\n          length = length >>> 0;\n          if (encoding === void 0) encoding = \"utf8\";\n        } else {\n          encoding = length;\n          length = void 0;\n        }\n      } else {\n        throw new Error(\n          \"Buffer.write(string, encoding, offset[, length]) is no longer supported\"\n        );\n      }\n      var remaining = this.length - offset;\n      if (length === void 0 || length > remaining) length = remaining;\n      if (string.length > 0 && (length < 0 || offset < 0) || offset > this.length) {\n        throw new RangeError(\"Attempt to write outside buffer bounds\");\n      }\n      if (!encoding) encoding = \"utf8\";\n      var loweredCase = false;\n      for (; ; ) {\n        switch (encoding) {\n          case \"hex\":\n            return hexWrite(this, string, offset, length);\n          case \"utf8\":\n          case \"utf-8\":\n            return utf8Write(this, string, offset, length);\n          case \"ascii\":\n          case \"latin1\":\n          case \"binary\":\n            return asciiWrite(this, string, offset, length);\n          case \"base64\":\n            return base64Write(this, string, offset, length);\n          case \"ucs2\":\n          case \"ucs-2\":\n          case \"utf16le\":\n          case \"utf-16le\":\n            return ucs2Write(this, string, offset, length);\n          default:\n            if (loweredCase) throw new TypeError(\"Unknown encoding: \" + encoding);\n            encoding = (\"\" + encoding).toLowerCase();\n            loweredCase = true;\n        }\n      }\n    };\n    Buffer2.prototype.toJSON = function toJSON() {\n      return {\n        type: \"Buffer\",\n        data: Array.prototype.slice.call(this._arr || this, 0)\n      };\n    };\n    function base64Slice(buf, start, end) {\n      if (start === 0 && end === buf.length) {\n        return base64.fromByteArray(buf);\n      } else {\n        return base64.fromByteArray(buf.slice(start, end));\n      }\n    }\n    function utf8Slice(buf, start, end) {\n      end = Math.min(buf.length, end);\n      var res = [];\n      var i = start;\n      while (i < end) {\n        var firstByte = buf[i];\n        var codePoint = null;\n        var bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;\n        if (i + bytesPerSequence <= end) {\n          var secondByte, thirdByte, fourthByte, tempCodePoint;\n          switch (bytesPerSequence) {\n            case 1:\n              if (firstByte < 128) {\n                codePoint = firstByte;\n              }\n              break;\n            case 2:\n              secondByte = buf[i + 1];\n              if ((secondByte & 192) === 128) {\n                tempCodePoint = (firstByte & 31) << 6 | secondByte & 63;\n                if (tempCodePoint > 127) {\n                  codePoint = tempCodePoint;\n                }\n              }\n              break;\n            case 3:\n              secondByte = buf[i + 1];\n              thirdByte = buf[i + 2];\n              if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) {\n                tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63;\n                if (tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343)) {\n                  codePoint = tempCodePoint;\n                }\n              }\n              break;\n            case 4:\n              secondByte = buf[i + 1];\n              thirdByte = buf[i + 2];\n              fourthByte = buf[i + 3];\n              if ((secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) {\n                tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63;\n                if (tempCodePoint > 65535 && tempCodePoint < 1114112) {\n                  codePoint = tempCodePoint;\n                }\n              }\n          }\n        }\n        if (codePoint === null) {\n          codePoint = 65533;\n          bytesPerSequence = 1;\n        } else if (codePoint > 65535) {\n          codePoint -= 65536;\n          res.push(codePoint >>> 10 & 1023 | 55296);\n          codePoint = 56320 | codePoint & 1023;\n        }\n        res.push(codePoint);\n        i += bytesPerSequence;\n      }\n      return decodeCodePointsArray(res);\n    }\n    var MAX_ARGUMENTS_LENGTH = 4096;\n    function decodeCodePointsArray(codePoints) {\n      var len = codePoints.length;\n      if (len <= MAX_ARGUMENTS_LENGTH) {\n        return String.fromCharCode.apply(String, codePoints);\n      }\n      var res = \"\";\n      var i = 0;\n      while (i < len) {\n        res += String.fromCharCode.apply(\n          String,\n          codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n        );\n      }\n      return res;\n    }\n    function asciiSlice(buf, start, end) {\n      var ret = \"\";\n      end = Math.min(buf.length, end);\n      for (var i = start; i < end; ++i) {\n        ret += String.fromCharCode(buf[i] & 127);\n      }\n      return ret;\n    }\n    function latin1Slice(buf, start, end) {\n      var ret = \"\";\n      end = Math.min(buf.length, end);\n      for (var i = start; i < end; ++i) {\n        ret += String.fromCharCode(buf[i]);\n      }\n      return ret;\n    }\n    function hexSlice(buf, start, end) {\n      var len = buf.length;\n      if (!start || start < 0) start = 0;\n      if (!end || end < 0 || end > len) end = len;\n      var out = \"\";\n      for (var i = start; i < end; ++i) {\n        out += hexSliceLookupTable[buf[i]];\n      }\n      return out;\n    }\n    function utf16leSlice(buf, start, end) {\n      var bytes = buf.slice(start, end);\n      var res = \"\";\n      for (var i = 0; i < bytes.length - 1; i += 2) {\n        res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);\n      }\n      return res;\n    }\n    Buffer2.prototype.slice = function slice(start, end) {\n      var len = this.length;\n      start = ~~start;\n      end = end === void 0 ? len : ~~end;\n      if (start < 0) {\n        start += len;\n        if (start < 0) start = 0;\n      } else if (start > len) {\n        start = len;\n      }\n      if (end < 0) {\n        end += len;\n        if (end < 0) end = 0;\n      } else if (end > len) {\n        end = len;\n      }\n      if (end < start) end = start;\n      var newBuf = this.subarray(start, end);\n      Object.setPrototypeOf(newBuf, Buffer2.prototype);\n      return newBuf;\n    };\n    function checkOffset(offset, ext, length) {\n      if (offset % 1 !== 0 || offset < 0) throw new RangeError(\"offset is not uint\");\n      if (offset + ext > length) throw new RangeError(\"Trying to access beyond buffer length\");\n    }\n    Buffer2.prototype.readUintLE = Buffer2.prototype.readUIntLE = function readUIntLE(offset, byteLength2, noAssert) {\n      offset = offset >>> 0;\n      byteLength2 = byteLength2 >>> 0;\n      if (!noAssert) checkOffset(offset, byteLength2, this.length);\n      var val = this[offset];\n      var mul = 1;\n      var i = 0;\n      while (++i < byteLength2 && (mul *= 256)) {\n        val += this[offset + i] * mul;\n      }\n      return val;\n    };\n    Buffer2.prototype.readUintBE = Buffer2.prototype.readUIntBE = function readUIntBE(offset, byteLength2, noAssert) {\n      offset = offset >>> 0;\n      byteLength2 = byteLength2 >>> 0;\n      if (!noAssert) {\n        checkOffset(offset, byteLength2, this.length);\n      }\n      var val = this[offset + --byteLength2];\n      var mul = 1;\n      while (byteLength2 > 0 && (mul *= 256)) {\n        val += this[offset + --byteLength2] * mul;\n      }\n      return val;\n    };\n    Buffer2.prototype.readUint8 = Buffer2.prototype.readUInt8 = function readUInt8(offset, noAssert) {\n      offset = offset >>> 0;\n      if (!noAssert) checkOffset(offset, 1, this.length);\n      return this[offset];\n    };\n    Buffer2.prototype.readUint16LE = Buffer2.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {\n      offset = offset >>> 0;\n      if (!noAssert) checkOffset(offset, 2, this.length);\n      return this[offset] | this[offset + 1] << 8;\n    };\n    Buffer2.prototype.readUint16BE = Buffer2.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {\n      offset = offset >>> 0;\n      if (!noAssert) checkOffset(offset, 2, this.length);\n      return this[offset] << 8 | this[offset + 1];\n    };\n    Buffer2.prototype.readUint32LE = Buffer2.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {\n      offset = offset >>> 0;\n      if (!noAssert) checkOffset(offset, 4, this.length);\n      return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 16777216;\n    };\n    Buffer2.prototype.readUint32BE = Buffer2.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {\n      offset = offset >>> 0;\n      if (!noAssert) checkOffset(offset, 4, this.length);\n      return this[offset] * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);\n    };\n    Buffer2.prototype.readIntLE = function readIntLE(offset, byteLength2, noAssert) {\n      offset = offset >>> 0;\n      byteLength2 = byteLength2 >>> 0;\n      if (!noAssert) checkOffset(offset, byteLength2, this.length);\n      var val = this[offset];\n      var mul = 1;\n      var i = 0;\n      while (++i < byteLength2 && (mul *= 256)) {\n        val += this[offset + i] * mul;\n      }\n      mul *= 128;\n      if (val >= mul) val -= Math.pow(2, 8 * byteLength2);\n      return val;\n    };\n    Buffer2.prototype.readIntBE = function readIntBE(offset, byteLength2, noAssert) {\n      offset = offset >>> 0;\n      byteLength2 = byteLength2 >>> 0;\n      if (!noAssert) checkOffset(offset, byteLength2, this.length);\n      var i = byteLength2;\n      var mul = 1;\n      var val = this[offset + --i];\n      while (i > 0 && (mul *= 256)) {\n        val += this[offset + --i] * mul;\n      }\n      mul *= 128;\n      if (val >= mul) val -= Math.pow(2, 8 * byteLength2);\n      return val;\n    };\n    Buffer2.prototype.readInt8 = function readInt8(offset, noAssert) {\n      offset = offset >>> 0;\n      if (!noAssert) checkOffset(offset, 1, this.length);\n      if (!(this[offset] & 128)) return this[offset];\n      return (255 - this[offset] + 1) * -1;\n    };\n    Buffer2.prototype.readInt16LE = function readInt16LE(offset, noAssert) {\n      offset = offset >>> 0;\n      if (!noAssert) checkOffset(offset, 2, this.length);\n      var val = this[offset] | this[offset + 1] << 8;\n      return val & 32768 ? val | 4294901760 : val;\n    };\n    Buffer2.prototype.readInt16BE = function readInt16BE(offset, noAssert) {\n      offset = offset >>> 0;\n      if (!noAssert) checkOffset(offset, 2, this.length);\n      var val = this[offset + 1] | this[offset] << 8;\n      return val & 32768 ? val | 4294901760 : val;\n    };\n    Buffer2.prototype.readInt32LE = function readInt32LE(offset, noAssert) {\n      offset = offset >>> 0;\n      if (!noAssert) checkOffset(offset, 4, this.length);\n      return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24;\n    };\n    Buffer2.prototype.readInt32BE = function readInt32BE(offset, noAssert) {\n      offset = offset >>> 0;\n      if (!noAssert) checkOffset(offset, 4, this.length);\n      return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];\n    };\n    Buffer2.prototype.readFloatLE = function readFloatLE(offset, noAssert) {\n      offset = offset >>> 0;\n      if (!noAssert) checkOffset(offset, 4, this.length);\n      return ieee754.read(this, offset, true, 23, 4);\n    };\n    Buffer2.prototype.readFloatBE = function readFloatBE(offset, noAssert) {\n      offset = offset >>> 0;\n      if (!noAssert) checkOffset(offset, 4, this.length);\n      return ieee754.read(this, offset, false, 23, 4);\n    };\n    Buffer2.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {\n      offset = offset >>> 0;\n      if (!noAssert) checkOffset(offset, 8, this.length);\n      return ieee754.read(this, offset, true, 52, 8);\n    };\n    Buffer2.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {\n      offset = offset >>> 0;\n      if (!noAssert) checkOffset(offset, 8, this.length);\n      return ieee754.read(this, offset, false, 52, 8);\n    };\n    function checkInt(buf, value, offset, ext, max, min) {\n      if (!Buffer2.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance');\n      if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds');\n      if (offset + ext > buf.length) throw new RangeError(\"Index out of range\");\n    }\n    Buffer2.prototype.writeUintLE = Buffer2.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength2, noAssert) {\n      value = +value;\n      offset = offset >>> 0;\n      byteLength2 = byteLength2 >>> 0;\n      if (!noAssert) {\n        var maxBytes = Math.pow(2, 8 * byteLength2) - 1;\n        checkInt(this, value, offset, byteLength2, maxBytes, 0);\n      }\n      var mul = 1;\n      var i = 0;\n      this[offset] = value & 255;\n      while (++i < byteLength2 && (mul *= 256)) {\n        this[offset + i] = value / mul & 255;\n      }\n      return offset + byteLength2;\n    };\n    Buffer2.prototype.writeUintBE = Buffer2.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength2, noAssert) {\n      value = +value;\n      offset = offset >>> 0;\n      byteLength2 = byteLength2 >>> 0;\n      if (!noAssert) {\n        var maxBytes = Math.pow(2, 8 * byteLength2) - 1;\n        checkInt(this, value, offset, byteLength2, maxBytes, 0);\n      }\n      var i = byteLength2 - 1;\n      var mul = 1;\n      this[offset + i] = value & 255;\n      while (--i >= 0 && (mul *= 256)) {\n        this[offset + i] = value / mul & 255;\n      }\n      return offset + byteLength2;\n    };\n    Buffer2.prototype.writeUint8 = Buffer2.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {\n      value = +value;\n      offset = offset >>> 0;\n      if (!noAssert) checkInt(this, value, offset, 1, 255, 0);\n      this[offset] = value & 255;\n      return offset + 1;\n    };\n    Buffer2.prototype.writeUint16LE = Buffer2.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {\n      value = +value;\n      offset = offset >>> 0;\n      if (!noAssert) checkInt(this, value, offset, 2, 65535, 0);\n      this[offset] = value & 255;\n      this[offset + 1] = value >>> 8;\n      return offset + 2;\n    };\n    Buffer2.prototype.writeUint16BE = Buffer2.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {\n      value = +value;\n      offset = offset >>> 0;\n      if (!noAssert) checkInt(this, value, offset, 2, 65535, 0);\n      this[offset] = value >>> 8;\n      this[offset + 1] = value & 255;\n      return offset + 2;\n    };\n    Buffer2.prototype.writeUint32LE = Buffer2.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {\n      value = +value;\n      offset = offset >>> 0;\n      if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0);\n      this[offset + 3] = value >>> 24;\n      this[offset + 2] = value >>> 16;\n      this[offset + 1] = value >>> 8;\n      this[offset] = value & 255;\n      return offset + 4;\n    };\n    Buffer2.prototype.writeUint32BE = Buffer2.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {\n      value = +value;\n      offset = offset >>> 0;\n      if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0);\n      this[offset] = value >>> 24;\n      this[offset + 1] = value >>> 16;\n      this[offset + 2] = value >>> 8;\n      this[offset + 3] = value & 255;\n      return offset + 4;\n    };\n    Buffer2.prototype.writeIntLE = function writeIntLE(value, offset, byteLength2, noAssert) {\n      value = +value;\n      offset = offset >>> 0;\n      if (!noAssert) {\n        var limit = Math.pow(2, 8 * byteLength2 - 1);\n        checkInt(this, value, offset, byteLength2, limit - 1, -limit);\n      }\n      var i = 0;\n      var mul = 1;\n      var sub = 0;\n      this[offset] = value & 255;\n      while (++i < byteLength2 && (mul *= 256)) {\n        if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n          sub = 1;\n        }\n        this[offset + i] = (value / mul >> 0) - sub & 255;\n      }\n      return offset + byteLength2;\n    };\n    Buffer2.prototype.writeIntBE = function writeIntBE(value, offset, byteLength2, noAssert) {\n      value = +value;\n      offset = offset >>> 0;\n      if (!noAssert) {\n        var limit = Math.pow(2, 8 * byteLength2 - 1);\n        checkInt(this, value, offset, byteLength2, limit - 1, -limit);\n      }\n      var i = byteLength2 - 1;\n      var mul = 1;\n      var sub = 0;\n      this[offset + i] = value & 255;\n      while (--i >= 0 && (mul *= 256)) {\n        if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n          sub = 1;\n        }\n        this[offset + i] = (value / mul >> 0) - sub & 255;\n      }\n      return offset + byteLength2;\n    };\n    Buffer2.prototype.writeInt8 = function writeInt8(value, offset, noAssert) {\n      value = +value;\n      offset = offset >>> 0;\n      if (!noAssert) checkInt(this, value, offset, 1, 127, -128);\n      if (value < 0) value = 255 + value + 1;\n      this[offset] = value & 255;\n      return offset + 1;\n    };\n    Buffer2.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) {\n      value = +value;\n      offset = offset >>> 0;\n      if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768);\n      this[offset] = value & 255;\n      this[offset + 1] = value >>> 8;\n      return offset + 2;\n    };\n    Buffer2.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) {\n      value = +value;\n      offset = offset >>> 0;\n      if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768);\n      this[offset] = value >>> 8;\n      this[offset + 1] = value & 255;\n      return offset + 2;\n    };\n    Buffer2.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) {\n      value = +value;\n      offset = offset >>> 0;\n      if (!noAssert) checkInt(this, value, offset, 4, 2147483647, -2147483648);\n      this[offset] = value & 255;\n      this[offset + 1] = value >>> 8;\n      this[offset + 2] = value >>> 16;\n      this[offset + 3] = value >>> 24;\n      return offset + 4;\n    };\n    Buffer2.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) {\n      value = +value;\n      offset = offset >>> 0;\n      if (!noAssert) checkInt(this, value, offset, 4, 2147483647, -2147483648);\n      if (value < 0) value = 4294967295 + value + 1;\n      this[offset] = value >>> 24;\n      this[offset + 1] = value >>> 16;\n      this[offset + 2] = value >>> 8;\n      this[offset + 3] = value & 255;\n      return offset + 4;\n    };\n    function checkIEEE754(buf, value, offset, ext, max, min) {\n      if (offset + ext > buf.length) throw new RangeError(\"Index out of range\");\n      if (offset < 0) throw new RangeError(\"Index out of range\");\n    }\n    function writeFloat(buf, value, offset, littleEndian, noAssert) {\n      value = +value;\n      offset = offset >>> 0;\n      if (!noAssert) {\n        checkIEEE754(buf, value, offset, 4, 34028234663852886e22, -34028234663852886e22);\n      }\n      ieee754.write(buf, value, offset, littleEndian, 23, 4);\n      return offset + 4;\n    }\n    Buffer2.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {\n      return writeFloat(this, value, offset, true, noAssert);\n    };\n    Buffer2.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) {\n      return writeFloat(this, value, offset, false, noAssert);\n    };\n    function writeDouble(buf, value, offset, littleEndian, noAssert) {\n      value = +value;\n      offset = offset >>> 0;\n      if (!noAssert) {\n        checkIEEE754(buf, value, offset, 8, 17976931348623157e292, -17976931348623157e292);\n      }\n      ieee754.write(buf, value, offset, littleEndian, 52, 8);\n      return offset + 8;\n    }\n    Buffer2.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {\n      return writeDouble(this, value, offset, true, noAssert);\n    };\n    Buffer2.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {\n      return writeDouble(this, value, offset, false, noAssert);\n    };\n    Buffer2.prototype.copy = function copy(target, targetStart, start, end) {\n      if (!Buffer2.isBuffer(target)) throw new TypeError(\"argument should be a Buffer\");\n      if (!start) start = 0;\n      if (!end && end !== 0) end = this.length;\n      if (targetStart >= target.length) targetStart = target.length;\n      if (!targetStart) targetStart = 0;\n      if (end > 0 && end < start) end = start;\n      if (end === start) return 0;\n      if (target.length === 0 || this.length === 0) return 0;\n      if (targetStart < 0) {\n        throw new RangeError(\"targetStart out of bounds\");\n      }\n      if (start < 0 || start >= this.length) throw new RangeError(\"Index out of range\");\n      if (end < 0) throw new RangeError(\"sourceEnd out of bounds\");\n      if (end > this.length) end = this.length;\n      if (target.length - targetStart < end - start) {\n        end = target.length - targetStart + start;\n      }\n      var len = end - start;\n      if (this === target && typeof Uint8Array.prototype.copyWithin === \"function\") {\n        this.copyWithin(targetStart, start, end);\n      } else {\n        Uint8Array.prototype.set.call(\n          target,\n          this.subarray(start, end),\n          targetStart\n        );\n      }\n      return len;\n    };\n    Buffer2.prototype.fill = function fill(val, start, end, encoding) {\n      if (typeof val === \"string\") {\n        if (typeof start === \"string\") {\n          encoding = start;\n          start = 0;\n          end = this.length;\n        } else if (typeof end === \"string\") {\n          encoding = end;\n          end = this.length;\n        }\n        if (encoding !== void 0 && typeof encoding !== \"string\") {\n          throw new TypeError(\"encoding must be a string\");\n        }\n        if (typeof encoding === \"string\" && !Buffer2.isEncoding(encoding)) {\n          throw new TypeError(\"Unknown encoding: \" + encoding);\n        }\n        if (val.length === 1) {\n          var code = val.charCodeAt(0);\n          if (encoding === \"utf8\" && code < 128 || encoding === \"latin1\") {\n            val = code;\n          }\n        }\n      } else if (typeof val === \"number\") {\n        val = val & 255;\n      } else if (typeof val === \"boolean\") {\n        val = Number(val);\n      }\n      if (start < 0 || this.length < start || this.length < end) {\n        throw new RangeError(\"Out of range index\");\n      }\n      if (end <= start) {\n        return this;\n      }\n      start = start >>> 0;\n      end = end === void 0 ? this.length : end >>> 0;\n      if (!val) val = 0;\n      var i;\n      if (typeof val === \"number\") {\n        for (i = start; i < end; ++i) {\n          this[i] = val;\n        }\n      } else {\n        var bytes = Buffer2.isBuffer(val) ? val : Buffer2.from(val, encoding);\n        var len = bytes.length;\n        if (len === 0) {\n          throw new TypeError('The value \"' + val + '\" is invalid for argument \"value\"');\n        }\n        for (i = 0; i < end - start; ++i) {\n          this[i + start] = bytes[i % len];\n        }\n      }\n      return this;\n    };\n    var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;\n    function base64clean(str) {\n      str = str.split(\"=\")[0];\n      str = str.trim().replace(INVALID_BASE64_RE, \"\");\n      if (str.length < 2) return \"\";\n      while (str.length % 4 !== 0) {\n        str = str + \"=\";\n      }\n      return str;\n    }\n    function utf8ToBytes(string, units) {\n      units = units || Infinity;\n      var codePoint;\n      var length = string.length;\n      var leadSurrogate = null;\n      var bytes = [];\n      for (var i = 0; i < length; ++i) {\n        codePoint = string.charCodeAt(i);\n        if (codePoint > 55295 && codePoint < 57344) {\n          if (!leadSurrogate) {\n            if (codePoint > 56319) {\n              if ((units -= 3) > -1) bytes.push(239, 191, 189);\n              continue;\n            } else if (i + 1 === length) {\n              if ((units -= 3) > -1) bytes.push(239, 191, 189);\n              continue;\n            }\n            leadSurrogate = codePoint;\n            continue;\n          }\n          if (codePoint < 56320) {\n            if ((units -= 3) > -1) bytes.push(239, 191, 189);\n            leadSurrogate = codePoint;\n            continue;\n          }\n          codePoint = (leadSurrogate - 55296 << 10 | codePoint - 56320) + 65536;\n        } else if (leadSurrogate) {\n          if ((units -= 3) > -1) bytes.push(239, 191, 189);\n        }\n        leadSurrogate = null;\n        if (codePoint < 128) {\n          if ((units -= 1) < 0) break;\n          bytes.push(codePoint);\n        } else if (codePoint < 2048) {\n          if ((units -= 2) < 0) break;\n          bytes.push(\n            codePoint >> 6 | 192,\n            codePoint & 63 | 128\n          );\n        } else if (codePoint < 65536) {\n          if ((units -= 3) < 0) break;\n          bytes.push(\n            codePoint >> 12 | 224,\n            codePoint >> 6 & 63 | 128,\n            codePoint & 63 | 128\n          );\n        } else if (codePoint < 1114112) {\n          if ((units -= 4) < 0) break;\n          bytes.push(\n            codePoint >> 18 | 240,\n            codePoint >> 12 & 63 | 128,\n            codePoint >> 6 & 63 | 128,\n            codePoint & 63 | 128\n          );\n        } else {\n          throw new Error(\"Invalid code point\");\n        }\n      }\n      return bytes;\n    }\n    function asciiToBytes(str) {\n      var byteArray = [];\n      for (var i = 0; i < str.length; ++i) {\n        byteArray.push(str.charCodeAt(i) & 255);\n      }\n      return byteArray;\n    }\n    function utf16leToBytes(str, units) {\n      var c, hi, lo;\n      var byteArray = [];\n      for (var i = 0; i < str.length; ++i) {\n        if ((units -= 2) < 0) break;\n        c = str.charCodeAt(i);\n        hi = c >> 8;\n        lo = c % 256;\n        byteArray.push(lo);\n        byteArray.push(hi);\n      }\n      return byteArray;\n    }\n    function base64ToBytes(str) {\n      return base64.toByteArray(base64clean(str));\n    }\n    function blitBuffer(src, dst, offset, length) {\n      for (var i = 0; i < length; ++i) {\n        if (i + offset >= dst.length || i >= src.length) break;\n        dst[i + offset] = src[i];\n      }\n      return i;\n    }\n    function isInstance(obj, type) {\n      return obj instanceof type || obj != null && obj.constructor != null && obj.constructor.name != null && obj.constructor.name === type.name;\n    }\n    function numberIsNaN(obj) {\n      return obj !== obj;\n    }\n    var hexSliceLookupTable = (function() {\n      var alphabet = \"0123456789abcdef\";\n      var table = new Array(256);\n      for (var i = 0; i < 16; ++i) {\n        var i16 = i * 16;\n        for (var j = 0; j < 16; ++j) {\n          table[i16 + j] = alphabet[i] + alphabet[j];\n        }\n      }\n      return table;\n    })();\n  }\n});\n\n// ../../node_modules/.pnpm/safe-buffer@5.2.1/node_modules/safe-buffer/index.js\nvar require_safe_buffer = __commonJS({\n  \"../../node_modules/.pnpm/safe-buffer@5.2.1/node_modules/safe-buffer/index.js\"(exports2, module2) {\n    var buffer = require_buffer();\n    var Buffer2 = buffer.Buffer;\n    function copyProps(src, dst) {\n      for (var key in src) {\n        dst[key] = src[key];\n      }\n    }\n    if (Buffer2.from && Buffer2.alloc && Buffer2.allocUnsafe && Buffer2.allocUnsafeSlow) {\n      module2.exports = buffer;\n    } else {\n      copyProps(buffer, exports2);\n      exports2.Buffer = SafeBuffer;\n    }\n    function SafeBuffer(arg, encodingOrOffset, length) {\n      return Buffer2(arg, encodingOrOffset, length);\n    }\n    SafeBuffer.prototype = Object.create(Buffer2.prototype);\n    copyProps(Buffer2, SafeBuffer);\n    SafeBuffer.from = function(arg, encodingOrOffset, length) {\n      if (typeof arg === \"number\") {\n        throw new TypeError(\"Argument must not be a number\");\n      }\n      return Buffer2(arg, encodingOrOffset, length);\n    };\n    SafeBuffer.alloc = function(size, fill, encoding) {\n      if (typeof size !== \"number\") {\n        throw new TypeError(\"Argument must be a number\");\n      }\n      var buf = Buffer2(size);\n      if (fill !== void 0) {\n        if (typeof encoding === \"string\") {\n          buf.fill(fill, encoding);\n        } else {\n          buf.fill(fill);\n        }\n      } else {\n        buf.fill(0);\n      }\n      return buf;\n    };\n    SafeBuffer.allocUnsafe = function(size) {\n      if (typeof size !== \"number\") {\n        throw new TypeError(\"Argument must be a number\");\n      }\n      return Buffer2(size);\n    };\n    SafeBuffer.allocUnsafeSlow = function(size) {\n      if (typeof size !== \"number\") {\n        throw new TypeError(\"Argument must be a number\");\n      }\n      return buffer.SlowBuffer(size);\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/string_decoder@1.3.0/node_modules/string_decoder/lib/string_decoder.js\nvar require_string_decoder = __commonJS({\n  \"../../node_modules/.pnpm/string_decoder@1.3.0/node_modules/string_decoder/lib/string_decoder.js\"(exports2) {\n    \"use strict\";\n    var Buffer2 = require_safe_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// <stdin>\nvar imported = require_string_decoder();\nvar resolved = imported.default ?? imported;\nmodule.exports = resolved;\n/*! Bundled license information:\n\nieee754/index.js:\n  (*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> *)\n\nbuffer/index.js:\n  (*!\n   * The buffer module from node.js, for the browser.\n   *\n   * @author   Feross Aboukhadijeh <https://feross.org>\n   * @license  MIT\n   *)\n\nsafe-buffer/index.js:\n  (*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> *)\n*/\n\nif (module.exports && module.exports.default == null) module.exports.default = module.exports;\n";
+export const BROWSER_URL_POLYFILL_CODE = "var process = globalThis.process || {\n  env: {},\n  cwd: () => '/',\n  nextTick: (fn, ...args) => queueMicrotask(() => fn(...args)),\n};\nvar __create = Object.create;\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __getProtoOf = Object.getPrototypeOf;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __esm = (fn, res) => function __init() {\n  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;\n};\nvar __commonJS = (cb, mod) => function __require() {\n  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;\n};\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(\n  // If the importer is in node compatibility mode or this is not an ESM\n  // file that has been converted to a CommonJS file using a Babel-\n  // compatible transform (i.e. \"__esModule\" has not been set), then set\n  // \"default\" to the CommonJS \"module.exports\" for node compatibility.\n  isNodeMode || !mod || !mod.__esModule ? __defProp(target, \"default\", { value: mod, enumerable: true }) : target,\n  mod\n));\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\n\n// ../../node_modules/.pnpm/punycode@1.4.1/node_modules/punycode/punycode.js\nvar require_punycode = __commonJS({\n  \"../../node_modules/.pnpm/punycode@1.4.1/node_modules/punycode/punycode.js\"(exports2, module2) {\n    (function(root) {\n      var freeExports = typeof exports2 == \"object\" && exports2 && !exports2.nodeType && exports2;\n      var freeModule = typeof module2 == \"object\" && module2 && !module2.nodeType && module2;\n      var freeGlobal = typeof global == \"object\" && global;\n      if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal || freeGlobal.self === freeGlobal) {\n        root = freeGlobal;\n      }\n      var punycode3, maxInt = 2147483647, base = 36, tMin = 1, tMax = 26, skew = 38, damp = 700, initialBias = 72, initialN = 128, delimiter = \"-\", regexPunycode = /^xn--/, regexNonASCII = /[^\\x20-\\x7E]/, regexSeparators = /[\\x2E\\u3002\\uFF0E\\uFF61]/g, errors = {\n        \"overflow\": \"Overflow: input needs wider integers to process\",\n        \"not-basic\": \"Illegal input >= 0x80 (not a basic code point)\",\n        \"invalid-input\": \"Invalid input\"\n      }, baseMinusTMin = base - tMin, floor = Math.floor, stringFromCharCode = String.fromCharCode, key;\n      function error(type) {\n        throw new RangeError(errors[type]);\n      }\n      function map(array, fn) {\n        var length = array.length;\n        var result = [];\n        while (length--) {\n          result[length] = fn(array[length]);\n        }\n        return result;\n      }\n      function mapDomain(string, fn) {\n        var parts = string.split(\"@\");\n        var result = \"\";\n        if (parts.length > 1) {\n          result = parts[0] + \"@\";\n          string = parts[1];\n        }\n        string = string.replace(regexSeparators, \".\");\n        var labels = string.split(\".\");\n        var encoded = map(labels, fn).join(\".\");\n        return result + encoded;\n      }\n      function ucs2decode(string) {\n        var output = [], counter = 0, length = string.length, value, extra;\n        while (counter < length) {\n          value = string.charCodeAt(counter++);\n          if (value >= 55296 && value <= 56319 && counter < length) {\n            extra = string.charCodeAt(counter++);\n            if ((extra & 64512) == 56320) {\n              output.push(((value & 1023) << 10) + (extra & 1023) + 65536);\n            } else {\n              output.push(value);\n              counter--;\n            }\n          } else {\n            output.push(value);\n          }\n        }\n        return output;\n      }\n      function ucs2encode(array) {\n        return map(array, function(value) {\n          var output = \"\";\n          if (value > 65535) {\n            value -= 65536;\n            output += stringFromCharCode(value >>> 10 & 1023 | 55296);\n            value = 56320 | value & 1023;\n          }\n          output += stringFromCharCode(value);\n          return output;\n        }).join(\"\");\n      }\n      function basicToDigit(codePoint) {\n        if (codePoint - 48 < 10) {\n          return codePoint - 22;\n        }\n        if (codePoint - 65 < 26) {\n          return codePoint - 65;\n        }\n        if (codePoint - 97 < 26) {\n          return codePoint - 97;\n        }\n        return base;\n      }\n      function digitToBasic(digit, flag) {\n        return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);\n      }\n      function adapt(delta, numPoints, firstTime) {\n        var k = 0;\n        delta = firstTime ? floor(delta / damp) : delta >> 1;\n        delta += floor(delta / numPoints);\n        for (; delta > baseMinusTMin * tMax >> 1; k += base) {\n          delta = floor(delta / baseMinusTMin);\n        }\n        return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));\n      }\n      function decode(input) {\n        var output = [], inputLength = input.length, out, i = 0, n = initialN, bias = initialBias, basic, j, index, oldi, w, k, digit, t, baseMinusT;\n        basic = input.lastIndexOf(delimiter);\n        if (basic < 0) {\n          basic = 0;\n        }\n        for (j = 0; j < basic; ++j) {\n          if (input.charCodeAt(j) >= 128) {\n            error(\"not-basic\");\n          }\n          output.push(input.charCodeAt(j));\n        }\n        for (index = basic > 0 ? basic + 1 : 0; index < inputLength; ) {\n          for (oldi = i, w = 1, k = base; ; k += base) {\n            if (index >= inputLength) {\n              error(\"invalid-input\");\n            }\n            digit = basicToDigit(input.charCodeAt(index++));\n            if (digit >= base || digit > floor((maxInt - i) / w)) {\n              error(\"overflow\");\n            }\n            i += digit * w;\n            t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;\n            if (digit < t) {\n              break;\n            }\n            baseMinusT = base - t;\n            if (w > floor(maxInt / baseMinusT)) {\n              error(\"overflow\");\n            }\n            w *= baseMinusT;\n          }\n          out = output.length + 1;\n          bias = adapt(i - oldi, out, oldi == 0);\n          if (floor(i / out) > maxInt - n) {\n            error(\"overflow\");\n          }\n          n += floor(i / out);\n          i %= out;\n          output.splice(i++, 0, n);\n        }\n        return ucs2encode(output);\n      }\n      function encode(input) {\n        var n, delta, handledCPCount, basicLength, bias, j, m, q, k, t, currentValue, output = [], inputLength, handledCPCountPlusOne, baseMinusT, qMinusT;\n        input = ucs2decode(input);\n        inputLength = input.length;\n        n = initialN;\n        delta = 0;\n        bias = initialBias;\n        for (j = 0; j < inputLength; ++j) {\n          currentValue = input[j];\n          if (currentValue < 128) {\n            output.push(stringFromCharCode(currentValue));\n          }\n        }\n        handledCPCount = basicLength = output.length;\n        if (basicLength) {\n          output.push(delimiter);\n        }\n        while (handledCPCount < inputLength) {\n          for (m = maxInt, j = 0; j < inputLength; ++j) {\n            currentValue = input[j];\n            if (currentValue >= n && currentValue < m) {\n              m = currentValue;\n            }\n          }\n          handledCPCountPlusOne = handledCPCount + 1;\n          if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {\n            error(\"overflow\");\n          }\n          delta += (m - n) * handledCPCountPlusOne;\n          n = m;\n          for (j = 0; j < inputLength; ++j) {\n            currentValue = input[j];\n            if (currentValue < n && ++delta > maxInt) {\n              error(\"overflow\");\n            }\n            if (currentValue == n) {\n              for (q = delta, k = base; ; k += base) {\n                t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;\n                if (q < t) {\n                  break;\n                }\n                qMinusT = q - t;\n                baseMinusT = base - t;\n                output.push(\n                  stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))\n                );\n                q = floor(qMinusT / baseMinusT);\n              }\n              output.push(stringFromCharCode(digitToBasic(q, 0)));\n              bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);\n              delta = 0;\n              ++handledCPCount;\n            }\n          }\n          ++delta;\n          ++n;\n        }\n        return output.join(\"\");\n      }\n      function toUnicode(input) {\n        return mapDomain(input, function(string) {\n          return regexPunycode.test(string) ? decode(string.slice(4).toLowerCase()) : string;\n        });\n      }\n      function toASCII(input) {\n        return mapDomain(input, function(string) {\n          return regexNonASCII.test(string) ? \"xn--\" + encode(string) : string;\n        });\n      }\n      punycode3 = {\n        /**\n         * A string representing the current Punycode.js version number.\n         * @memberOf punycode\n         * @type String\n         */\n        \"version\": \"1.4.1\",\n        /**\n         * An object of methods to convert from JavaScript's internal character\n         * representation (UCS-2) to Unicode code points, and back.\n         * @see <https://mathiasbynens.be/notes/javascript-encoding>\n         * @memberOf punycode\n         * @type Object\n         */\n        \"ucs2\": {\n          \"decode\": ucs2decode,\n          \"encode\": ucs2encode\n        },\n        \"decode\": decode,\n        \"encode\": encode,\n        \"toASCII\": toASCII,\n        \"toUnicode\": toUnicode\n      };\n      if (typeof define == \"function\" && typeof define.amd == \"object\" && define.amd) {\n        define(\"punycode\", function() {\n          return punycode3;\n        });\n      } else if (freeExports && freeModule) {\n        if (module2.exports == freeExports) {\n          freeModule.exports = punycode3;\n        } else {\n          for (key in punycode3) {\n            punycode3.hasOwnProperty(key) && (freeExports[key] = punycode3[key]);\n          }\n        }\n      } else {\n        root.punycode = punycode3;\n      }\n    })(exports2);\n  }\n});\n\n// ../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/type.js\nvar require_type = __commonJS({\n  \"../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/type.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = TypeError;\n  }\n});\n\n// (disabled):../../node_modules/.pnpm/object-inspect@1.13.4/node_modules/object-inspect/util.inspect\nvar require_util = __commonJS({\n  \"(disabled):../../node_modules/.pnpm/object-inspect@1.13.4/node_modules/object-inspect/util.inspect\"() {\n  }\n});\n\n// ../../node_modules/.pnpm/object-inspect@1.13.4/node_modules/object-inspect/index.js\nvar require_object_inspect = __commonJS({\n  \"../../node_modules/.pnpm/object-inspect@1.13.4/node_modules/object-inspect/index.js\"(exports2, module2) {\n    var hasMap = typeof Map === \"function\" && Map.prototype;\n    var mapSizeDescriptor = Object.getOwnPropertyDescriptor && hasMap ? Object.getOwnPropertyDescriptor(Map.prototype, \"size\") : null;\n    var mapSize = hasMap && mapSizeDescriptor && typeof mapSizeDescriptor.get === \"function\" ? mapSizeDescriptor.get : null;\n    var mapForEach = hasMap && Map.prototype.forEach;\n    var hasSet = typeof Set === \"function\" && Set.prototype;\n    var setSizeDescriptor = Object.getOwnPropertyDescriptor && hasSet ? Object.getOwnPropertyDescriptor(Set.prototype, \"size\") : null;\n    var setSize = hasSet && setSizeDescriptor && typeof setSizeDescriptor.get === \"function\" ? setSizeDescriptor.get : null;\n    var setForEach = hasSet && Set.prototype.forEach;\n    var hasWeakMap = typeof WeakMap === \"function\" && WeakMap.prototype;\n    var weakMapHas = hasWeakMap ? WeakMap.prototype.has : null;\n    var hasWeakSet = typeof WeakSet === \"function\" && WeakSet.prototype;\n    var weakSetHas = hasWeakSet ? WeakSet.prototype.has : null;\n    var hasWeakRef = typeof WeakRef === \"function\" && WeakRef.prototype;\n    var weakRefDeref = hasWeakRef ? WeakRef.prototype.deref : null;\n    var booleanValueOf = Boolean.prototype.valueOf;\n    var objectToString = Object.prototype.toString;\n    var functionToString = Function.prototype.toString;\n    var $match = String.prototype.match;\n    var $slice = String.prototype.slice;\n    var $replace = String.prototype.replace;\n    var $toUpperCase = String.prototype.toUpperCase;\n    var $toLowerCase = String.prototype.toLowerCase;\n    var $test = RegExp.prototype.test;\n    var $concat = Array.prototype.concat;\n    var $join = Array.prototype.join;\n    var $arrSlice = Array.prototype.slice;\n    var $floor = Math.floor;\n    var bigIntValueOf = typeof BigInt === \"function\" ? BigInt.prototype.valueOf : null;\n    var gOPS = Object.getOwnPropertySymbols;\n    var symToString = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? Symbol.prototype.toString : null;\n    var hasShammedSymbols = typeof Symbol === \"function\" && typeof Symbol.iterator === \"object\";\n    var toStringTag = typeof Symbol === \"function\" && Symbol.toStringTag && (typeof Symbol.toStringTag === hasShammedSymbols ? \"object\" : \"symbol\") ? Symbol.toStringTag : null;\n    var isEnumerable = Object.prototype.propertyIsEnumerable;\n    var gPO = (typeof Reflect === \"function\" ? Reflect.getPrototypeOf : Object.getPrototypeOf) || ([].__proto__ === Array.prototype ? function(O) {\n      return O.__proto__;\n    } : null);\n    function addNumericSeparator(num, str) {\n      if (num === Infinity || num === -Infinity || num !== num || num && num > -1e3 && num < 1e3 || $test.call(/e/, str)) {\n        return str;\n      }\n      var sepRegex = /[0-9](?=(?:[0-9]{3})+(?![0-9]))/g;\n      if (typeof num === \"number\") {\n        var int = num < 0 ? -$floor(-num) : $floor(num);\n        if (int !== num) {\n          var intStr = String(int);\n          var dec = $slice.call(str, intStr.length + 1);\n          return $replace.call(intStr, sepRegex, \"$&_\") + \".\" + $replace.call($replace.call(dec, /([0-9]{3})/g, \"$&_\"), /_$/, \"\");\n        }\n      }\n      return $replace.call(str, sepRegex, \"$&_\");\n    }\n    var utilInspect = require_util();\n    var inspectCustom = utilInspect.custom;\n    var inspectSymbol = isSymbol(inspectCustom) ? inspectCustom : null;\n    var quotes = {\n      __proto__: null,\n      \"double\": '\"',\n      single: \"'\"\n    };\n    var quoteREs = {\n      __proto__: null,\n      \"double\": /([\"\\\\])/g,\n      single: /(['\\\\])/g\n    };\n    module2.exports = function inspect_(obj, options, depth, seen) {\n      var opts = options || {};\n      if (has(opts, \"quoteStyle\") && !has(quotes, opts.quoteStyle)) {\n        throw new TypeError('option \"quoteStyle\" must be \"single\" or \"double\"');\n      }\n      if (has(opts, \"maxStringLength\") && (typeof opts.maxStringLength === \"number\" ? opts.maxStringLength < 0 && opts.maxStringLength !== Infinity : opts.maxStringLength !== null)) {\n        throw new TypeError('option \"maxStringLength\", if provided, must be a positive integer, Infinity, or `null`');\n      }\n      var customInspect = has(opts, \"customInspect\") ? opts.customInspect : true;\n      if (typeof customInspect !== \"boolean\" && customInspect !== \"symbol\") {\n        throw new TypeError(\"option \\\"customInspect\\\", if provided, must be `true`, `false`, or `'symbol'`\");\n      }\n      if (has(opts, \"indent\") && opts.indent !== null && opts.indent !== \"\t\" && !(parseInt(opts.indent, 10) === opts.indent && opts.indent > 0)) {\n        throw new TypeError('option \"indent\" must be \"\\\\t\", an integer > 0, or `null`');\n      }\n      if (has(opts, \"numericSeparator\") && typeof opts.numericSeparator !== \"boolean\") {\n        throw new TypeError('option \"numericSeparator\", if provided, must be `true` or `false`');\n      }\n      var numericSeparator = opts.numericSeparator;\n      if (typeof obj === \"undefined\") {\n        return \"undefined\";\n      }\n      if (obj === null) {\n        return \"null\";\n      }\n      if (typeof obj === \"boolean\") {\n        return obj ? \"true\" : \"false\";\n      }\n      if (typeof obj === \"string\") {\n        return inspectString(obj, opts);\n      }\n      if (typeof obj === \"number\") {\n        if (obj === 0) {\n          return Infinity / obj > 0 ? \"0\" : \"-0\";\n        }\n        var str = String(obj);\n        return numericSeparator ? addNumericSeparator(obj, str) : str;\n      }\n      if (typeof obj === \"bigint\") {\n        var bigIntStr = String(obj) + \"n\";\n        return numericSeparator ? addNumericSeparator(obj, bigIntStr) : bigIntStr;\n      }\n      var maxDepth = typeof opts.depth === \"undefined\" ? 5 : opts.depth;\n      if (typeof depth === \"undefined\") {\n        depth = 0;\n      }\n      if (depth >= maxDepth && maxDepth > 0 && typeof obj === \"object\") {\n        return isArray(obj) ? \"[Array]\" : \"[Object]\";\n      }\n      var indent = getIndent(opts, depth);\n      if (typeof seen === \"undefined\") {\n        seen = [];\n      } else if (indexOf(seen, obj) >= 0) {\n        return \"[Circular]\";\n      }\n      function inspect(value, from, noIndent) {\n        if (from) {\n          seen = $arrSlice.call(seen);\n          seen.push(from);\n        }\n        if (noIndent) {\n          var newOpts = {\n            depth: opts.depth\n          };\n          if (has(opts, \"quoteStyle\")) {\n            newOpts.quoteStyle = opts.quoteStyle;\n          }\n          return inspect_(value, newOpts, depth + 1, seen);\n        }\n        return inspect_(value, opts, depth + 1, seen);\n      }\n      if (typeof obj === \"function\" && !isRegExp(obj)) {\n        var name = nameOf(obj);\n        var keys = arrObjKeys(obj, inspect);\n        return \"[Function\" + (name ? \": \" + name : \" (anonymous)\") + \"]\" + (keys.length > 0 ? \" { \" + $join.call(keys, \", \") + \" }\" : \"\");\n      }\n      if (isSymbol(obj)) {\n        var symString = hasShammedSymbols ? $replace.call(String(obj), /^(Symbol\\(.*\\))_[^)]*$/, \"$1\") : symToString.call(obj);\n        return typeof obj === \"object\" && !hasShammedSymbols ? markBoxed(symString) : symString;\n      }\n      if (isElement(obj)) {\n        var s = \"<\" + $toLowerCase.call(String(obj.nodeName));\n        var attrs = obj.attributes || [];\n        for (var i = 0; i < attrs.length; i++) {\n          s += \" \" + attrs[i].name + \"=\" + wrapQuotes(quote(attrs[i].value), \"double\", opts);\n        }\n        s += \">\";\n        if (obj.childNodes && obj.childNodes.length) {\n          s += \"...\";\n        }\n        s += \"</\" + $toLowerCase.call(String(obj.nodeName)) + \">\";\n        return s;\n      }\n      if (isArray(obj)) {\n        if (obj.length === 0) {\n          return \"[]\";\n        }\n        var xs = arrObjKeys(obj, inspect);\n        if (indent && !singleLineValues(xs)) {\n          return \"[\" + indentedJoin(xs, indent) + \"]\";\n        }\n        return \"[ \" + $join.call(xs, \", \") + \" ]\";\n      }\n      if (isError(obj)) {\n        var parts = arrObjKeys(obj, inspect);\n        if (!(\"cause\" in Error.prototype) && \"cause\" in obj && !isEnumerable.call(obj, \"cause\")) {\n          return \"{ [\" + String(obj) + \"] \" + $join.call($concat.call(\"[cause]: \" + inspect(obj.cause), parts), \", \") + \" }\";\n        }\n        if (parts.length === 0) {\n          return \"[\" + String(obj) + \"]\";\n        }\n        return \"{ [\" + String(obj) + \"] \" + $join.call(parts, \", \") + \" }\";\n      }\n      if (typeof obj === \"object\" && customInspect) {\n        if (inspectSymbol && typeof obj[inspectSymbol] === \"function\" && utilInspect) {\n          return utilInspect(obj, { depth: maxDepth - depth });\n        } else if (customInspect !== \"symbol\" && typeof obj.inspect === \"function\") {\n          return obj.inspect();\n        }\n      }\n      if (isMap(obj)) {\n        var mapParts = [];\n        if (mapForEach) {\n          mapForEach.call(obj, function(value, key) {\n            mapParts.push(inspect(key, obj, true) + \" => \" + inspect(value, obj));\n          });\n        }\n        return collectionOf(\"Map\", mapSize.call(obj), mapParts, indent);\n      }\n      if (isSet(obj)) {\n        var setParts = [];\n        if (setForEach) {\n          setForEach.call(obj, function(value) {\n            setParts.push(inspect(value, obj));\n          });\n        }\n        return collectionOf(\"Set\", setSize.call(obj), setParts, indent);\n      }\n      if (isWeakMap(obj)) {\n        return weakCollectionOf(\"WeakMap\");\n      }\n      if (isWeakSet(obj)) {\n        return weakCollectionOf(\"WeakSet\");\n      }\n      if (isWeakRef(obj)) {\n        return weakCollectionOf(\"WeakRef\");\n      }\n      if (isNumber(obj)) {\n        return markBoxed(inspect(Number(obj)));\n      }\n      if (isBigInt(obj)) {\n        return markBoxed(inspect(bigIntValueOf.call(obj)));\n      }\n      if (isBoolean(obj)) {\n        return markBoxed(booleanValueOf.call(obj));\n      }\n      if (isString(obj)) {\n        return markBoxed(inspect(String(obj)));\n      }\n      if (typeof window !== \"undefined\" && obj === window) {\n        return \"{ [object Window] }\";\n      }\n      if (typeof globalThis !== \"undefined\" && obj === globalThis || typeof global !== \"undefined\" && obj === global) {\n        return \"{ [object globalThis] }\";\n      }\n      if (!isDate(obj) && !isRegExp(obj)) {\n        var ys = arrObjKeys(obj, inspect);\n        var isPlainObject = gPO ? gPO(obj) === Object.prototype : obj instanceof Object || obj.constructor === Object;\n        var protoTag = obj instanceof Object ? \"\" : \"null prototype\";\n        var stringTag = !isPlainObject && toStringTag && Object(obj) === obj && toStringTag in obj ? $slice.call(toStr(obj), 8, -1) : protoTag ? \"Object\" : \"\";\n        var constructorTag = isPlainObject || typeof obj.constructor !== \"function\" ? \"\" : obj.constructor.name ? obj.constructor.name + \" \" : \"\";\n        var tag = constructorTag + (stringTag || protoTag ? \"[\" + $join.call($concat.call([], stringTag || [], protoTag || []), \": \") + \"] \" : \"\");\n        if (ys.length === 0) {\n          return tag + \"{}\";\n        }\n        if (indent) {\n          return tag + \"{\" + indentedJoin(ys, indent) + \"}\";\n        }\n        return tag + \"{ \" + $join.call(ys, \", \") + \" }\";\n      }\n      return String(obj);\n    };\n    function wrapQuotes(s, defaultStyle, opts) {\n      var style = opts.quoteStyle || defaultStyle;\n      var quoteChar = quotes[style];\n      return quoteChar + s + quoteChar;\n    }\n    function quote(s) {\n      return $replace.call(String(s), /\"/g, \"&quot;\");\n    }\n    function canTrustToString(obj) {\n      return !toStringTag || !(typeof obj === \"object\" && (toStringTag in obj || typeof obj[toStringTag] !== \"undefined\"));\n    }\n    function isArray(obj) {\n      return toStr(obj) === \"[object Array]\" && canTrustToString(obj);\n    }\n    function isDate(obj) {\n      return toStr(obj) === \"[object Date]\" && canTrustToString(obj);\n    }\n    function isRegExp(obj) {\n      return toStr(obj) === \"[object RegExp]\" && canTrustToString(obj);\n    }\n    function isError(obj) {\n      return toStr(obj) === \"[object Error]\" && canTrustToString(obj);\n    }\n    function isString(obj) {\n      return toStr(obj) === \"[object String]\" && canTrustToString(obj);\n    }\n    function isNumber(obj) {\n      return toStr(obj) === \"[object Number]\" && canTrustToString(obj);\n    }\n    function isBoolean(obj) {\n      return toStr(obj) === \"[object Boolean]\" && canTrustToString(obj);\n    }\n    function isSymbol(obj) {\n      if (hasShammedSymbols) {\n        return obj && typeof obj === \"object\" && obj instanceof Symbol;\n      }\n      if (typeof obj === \"symbol\") {\n        return true;\n      }\n      if (!obj || typeof obj !== \"object\" || !symToString) {\n        return false;\n      }\n      try {\n        symToString.call(obj);\n        return true;\n      } catch (e) {\n      }\n      return false;\n    }\n    function isBigInt(obj) {\n      if (!obj || typeof obj !== \"object\" || !bigIntValueOf) {\n        return false;\n      }\n      try {\n        bigIntValueOf.call(obj);\n        return true;\n      } catch (e) {\n      }\n      return false;\n    }\n    var hasOwn = Object.prototype.hasOwnProperty || function(key) {\n      return key in this;\n    };\n    function has(obj, key) {\n      return hasOwn.call(obj, key);\n    }\n    function toStr(obj) {\n      return objectToString.call(obj);\n    }\n    function nameOf(f) {\n      if (f.name) {\n        return f.name;\n      }\n      var m = $match.call(functionToString.call(f), /^function\\s*([\\w$]+)/);\n      if (m) {\n        return m[1];\n      }\n      return null;\n    }\n    function indexOf(xs, x) {\n      if (xs.indexOf) {\n        return xs.indexOf(x);\n      }\n      for (var i = 0, l = xs.length; i < l; i++) {\n        if (xs[i] === x) {\n          return i;\n        }\n      }\n      return -1;\n    }\n    function isMap(x) {\n      if (!mapSize || !x || typeof x !== \"object\") {\n        return false;\n      }\n      try {\n        mapSize.call(x);\n        try {\n          setSize.call(x);\n        } catch (s) {\n          return true;\n        }\n        return x instanceof Map;\n      } catch (e) {\n      }\n      return false;\n    }\n    function isWeakMap(x) {\n      if (!weakMapHas || !x || typeof x !== \"object\") {\n        return false;\n      }\n      try {\n        weakMapHas.call(x, weakMapHas);\n        try {\n          weakSetHas.call(x, weakSetHas);\n        } catch (s) {\n          return true;\n        }\n        return x instanceof WeakMap;\n      } catch (e) {\n      }\n      return false;\n    }\n    function isWeakRef(x) {\n      if (!weakRefDeref || !x || typeof x !== \"object\") {\n        return false;\n      }\n      try {\n        weakRefDeref.call(x);\n        return true;\n      } catch (e) {\n      }\n      return false;\n    }\n    function isSet(x) {\n      if (!setSize || !x || typeof x !== \"object\") {\n        return false;\n      }\n      try {\n        setSize.call(x);\n        try {\n          mapSize.call(x);\n        } catch (m) {\n          return true;\n        }\n        return x instanceof Set;\n      } catch (e) {\n      }\n      return false;\n    }\n    function isWeakSet(x) {\n      if (!weakSetHas || !x || typeof x !== \"object\") {\n        return false;\n      }\n      try {\n        weakSetHas.call(x, weakSetHas);\n        try {\n          weakMapHas.call(x, weakMapHas);\n        } catch (s) {\n          return true;\n        }\n        return x instanceof WeakSet;\n      } catch (e) {\n      }\n      return false;\n    }\n    function isElement(x) {\n      if (!x || typeof x !== \"object\") {\n        return false;\n      }\n      if (typeof HTMLElement !== \"undefined\" && x instanceof HTMLElement) {\n        return true;\n      }\n      return typeof x.nodeName === \"string\" && typeof x.getAttribute === \"function\";\n    }\n    function inspectString(str, opts) {\n      if (str.length > opts.maxStringLength) {\n        var remaining = str.length - opts.maxStringLength;\n        var trailer = \"... \" + remaining + \" more character\" + (remaining > 1 ? \"s\" : \"\");\n        return inspectString($slice.call(str, 0, opts.maxStringLength), opts) + trailer;\n      }\n      var quoteRE = quoteREs[opts.quoteStyle || \"single\"];\n      quoteRE.lastIndex = 0;\n      var s = $replace.call($replace.call(str, quoteRE, \"\\\\$1\"), /[\\x00-\\x1f]/g, lowbyte);\n      return wrapQuotes(s, \"single\", opts);\n    }\n    function lowbyte(c) {\n      var n = c.charCodeAt(0);\n      var x = {\n        8: \"b\",\n        9: \"t\",\n        10: \"n\",\n        12: \"f\",\n        13: \"r\"\n      }[n];\n      if (x) {\n        return \"\\\\\" + x;\n      }\n      return \"\\\\x\" + (n < 16 ? \"0\" : \"\") + $toUpperCase.call(n.toString(16));\n    }\n    function markBoxed(str) {\n      return \"Object(\" + str + \")\";\n    }\n    function weakCollectionOf(type) {\n      return type + \" { ? }\";\n    }\n    function collectionOf(type, size, entries, indent) {\n      var joinedEntries = indent ? indentedJoin(entries, indent) : $join.call(entries, \", \");\n      return type + \" (\" + size + \") {\" + joinedEntries + \"}\";\n    }\n    function singleLineValues(xs) {\n      for (var i = 0; i < xs.length; i++) {\n        if (indexOf(xs[i], \"\\n\") >= 0) {\n          return false;\n        }\n      }\n      return true;\n    }\n    function getIndent(opts, depth) {\n      var baseIndent;\n      if (opts.indent === \"\t\") {\n        baseIndent = \"\t\";\n      } else if (typeof opts.indent === \"number\" && opts.indent > 0) {\n        baseIndent = $join.call(Array(opts.indent + 1), \" \");\n      } else {\n        return null;\n      }\n      return {\n        base: baseIndent,\n        prev: $join.call(Array(depth + 1), baseIndent)\n      };\n    }\n    function indentedJoin(xs, indent) {\n      if (xs.length === 0) {\n        return \"\";\n      }\n      var lineJoiner = \"\\n\" + indent.prev + indent.base;\n      return lineJoiner + $join.call(xs, \",\" + lineJoiner) + \"\\n\" + indent.prev;\n    }\n    function arrObjKeys(obj, inspect) {\n      var isArr = isArray(obj);\n      var xs = [];\n      if (isArr) {\n        xs.length = obj.length;\n        for (var i = 0; i < obj.length; i++) {\n          xs[i] = has(obj, i) ? inspect(obj[i], obj) : \"\";\n        }\n      }\n      var syms = typeof gOPS === \"function\" ? gOPS(obj) : [];\n      var symMap;\n      if (hasShammedSymbols) {\n        symMap = {};\n        for (var k = 0; k < syms.length; k++) {\n          symMap[\"$\" + syms[k]] = syms[k];\n        }\n      }\n      for (var key in obj) {\n        if (!has(obj, key)) {\n          continue;\n        }\n        if (isArr && String(Number(key)) === key && key < obj.length) {\n          continue;\n        }\n        if (hasShammedSymbols && symMap[\"$\" + key] instanceof Symbol) {\n          continue;\n        } else if ($test.call(/[^\\w$]/, key)) {\n          xs.push(inspect(key, obj) + \": \" + inspect(obj[key], obj));\n        } else {\n          xs.push(key + \": \" + inspect(obj[key], obj));\n        }\n      }\n      if (typeof gOPS === \"function\") {\n        for (var j = 0; j < syms.length; j++) {\n          if (isEnumerable.call(obj, syms[j])) {\n            xs.push(\"[\" + inspect(syms[j]) + \"]: \" + inspect(obj[syms[j]], obj));\n          }\n        }\n      }\n      return xs;\n    }\n  }\n});\n\n// ../../node_modules/.pnpm/side-channel-list@1.0.0/node_modules/side-channel-list/index.js\nvar require_side_channel_list = __commonJS({\n  \"../../node_modules/.pnpm/side-channel-list@1.0.0/node_modules/side-channel-list/index.js\"(exports2, module2) {\n    \"use strict\";\n    var inspect = require_object_inspect();\n    var $TypeError = require_type();\n    var listGetNode = function(list, key, isDelete) {\n      var prev = list;\n      var curr;\n      for (; (curr = prev.next) != null; prev = curr) {\n        if (curr.key === key) {\n          prev.next = curr.next;\n          if (!isDelete) {\n            curr.next = /** @type {NonNullable<typeof list.next>} */\n            list.next;\n            list.next = curr;\n          }\n          return curr;\n        }\n      }\n    };\n    var listGet = function(objects, key) {\n      if (!objects) {\n        return void 0;\n      }\n      var node = listGetNode(objects, key);\n      return node && node.value;\n    };\n    var listSet = function(objects, key, value) {\n      var node = listGetNode(objects, key);\n      if (node) {\n        node.value = value;\n      } else {\n        objects.next = /** @type {import('./list.d.ts').ListNode<typeof value, typeof key>} */\n        {\n          // eslint-disable-line no-param-reassign, no-extra-parens\n          key,\n          next: objects.next,\n          value\n        };\n      }\n    };\n    var listHas = function(objects, key) {\n      if (!objects) {\n        return false;\n      }\n      return !!listGetNode(objects, key);\n    };\n    var listDelete = function(objects, key) {\n      if (objects) {\n        return listGetNode(objects, key, true);\n      }\n    };\n    module2.exports = function getSideChannelList() {\n      var $o;\n      var channel = {\n        assert: function(key) {\n          if (!channel.has(key)) {\n            throw new $TypeError(\"Side channel does not contain \" + inspect(key));\n          }\n        },\n        \"delete\": function(key) {\n          var root = $o && $o.next;\n          var deletedNode = listDelete($o, key);\n          if (deletedNode && root && root === deletedNode) {\n            $o = void 0;\n          }\n          return !!deletedNode;\n        },\n        get: function(key) {\n          return listGet($o, key);\n        },\n        has: function(key) {\n          return listHas($o, key);\n        },\n        set: function(key, value) {\n          if (!$o) {\n            $o = {\n              next: void 0\n            };\n          }\n          listSet(\n            /** @type {NonNullable<typeof $o>} */\n            $o,\n            key,\n            value\n          );\n        }\n      };\n      return channel;\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/es-object-atoms@1.1.1/node_modules/es-object-atoms/index.js\nvar require_es_object_atoms = __commonJS({\n  \"../../node_modules/.pnpm/es-object-atoms@1.1.1/node_modules/es-object-atoms/index.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = Object;\n  }\n});\n\n// ../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/index.js\nvar require_es_errors = __commonJS({\n  \"../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/index.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = Error;\n  }\n});\n\n// ../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/eval.js\nvar require_eval = __commonJS({\n  \"../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/eval.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = EvalError;\n  }\n});\n\n// ../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/range.js\nvar require_range = __commonJS({\n  \"../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/range.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = RangeError;\n  }\n});\n\n// ../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/ref.js\nvar require_ref = __commonJS({\n  \"../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/ref.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = ReferenceError;\n  }\n});\n\n// ../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/syntax.js\nvar require_syntax = __commonJS({\n  \"../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/syntax.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = SyntaxError;\n  }\n});\n\n// ../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/uri.js\nvar require_uri = __commonJS({\n  \"../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/uri.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = URIError;\n  }\n});\n\n// ../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/abs.js\nvar require_abs = __commonJS({\n  \"../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/abs.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = Math.abs;\n  }\n});\n\n// ../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/floor.js\nvar require_floor = __commonJS({\n  \"../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/floor.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = Math.floor;\n  }\n});\n\n// ../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/max.js\nvar require_max = __commonJS({\n  \"../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/max.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = Math.max;\n  }\n});\n\n// ../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/min.js\nvar require_min = __commonJS({\n  \"../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/min.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = Math.min;\n  }\n});\n\n// ../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/pow.js\nvar require_pow = __commonJS({\n  \"../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/pow.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = Math.pow;\n  }\n});\n\n// ../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/round.js\nvar require_round = __commonJS({\n  \"../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/round.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = Math.round;\n  }\n});\n\n// ../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/isNaN.js\nvar require_isNaN = __commonJS({\n  \"../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/isNaN.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = Number.isNaN || function isNaN2(a) {\n      return a !== a;\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/sign.js\nvar require_sign = __commonJS({\n  \"../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/sign.js\"(exports2, module2) {\n    \"use strict\";\n    var $isNaN = require_isNaN();\n    module2.exports = function sign(number) {\n      if ($isNaN(number) || number === 0) {\n        return number;\n      }\n      return number < 0 ? -1 : 1;\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/gOPD.js\nvar require_gOPD = __commonJS({\n  \"../../node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/gOPD.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = Object.getOwnPropertyDescriptor;\n  }\n});\n\n// ../../node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/index.js\nvar require_gopd = __commonJS({\n  \"../../node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/index.js\"(exports2, module2) {\n    \"use strict\";\n    var $gOPD = require_gOPD();\n    if ($gOPD) {\n      try {\n        $gOPD([], \"length\");\n      } catch (e) {\n        $gOPD = null;\n      }\n    }\n    module2.exports = $gOPD;\n  }\n});\n\n// ../../node_modules/.pnpm/es-define-property@1.0.1/node_modules/es-define-property/index.js\nvar require_es_define_property = __commonJS({\n  \"../../node_modules/.pnpm/es-define-property@1.0.1/node_modules/es-define-property/index.js\"(exports2, module2) {\n    \"use strict\";\n    var $defineProperty = Object.defineProperty || false;\n    if ($defineProperty) {\n      try {\n        $defineProperty({}, \"a\", { value: 1 });\n      } catch (e) {\n        $defineProperty = false;\n      }\n    }\n    module2.exports = $defineProperty;\n  }\n});\n\n// ../../node_modules/.pnpm/has-symbols@1.1.0/node_modules/has-symbols/shams.js\nvar require_shams = __commonJS({\n  \"../../node_modules/.pnpm/has-symbols@1.1.0/node_modules/has-symbols/shams.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = function hasSymbols() {\n      if (typeof Symbol !== \"function\" || typeof Object.getOwnPropertySymbols !== \"function\") {\n        return false;\n      }\n      if (typeof Symbol.iterator === \"symbol\") {\n        return true;\n      }\n      var obj = {};\n      var sym = /* @__PURE__ */ Symbol(\"test\");\n      var symObj = Object(sym);\n      if (typeof sym === \"string\") {\n        return false;\n      }\n      if (Object.prototype.toString.call(sym) !== \"[object Symbol]\") {\n        return false;\n      }\n      if (Object.prototype.toString.call(symObj) !== \"[object Symbol]\") {\n        return false;\n      }\n      var symVal = 42;\n      obj[sym] = symVal;\n      for (var _ in obj) {\n        return false;\n      }\n      if (typeof Object.keys === \"function\" && Object.keys(obj).length !== 0) {\n        return false;\n      }\n      if (typeof Object.getOwnPropertyNames === \"function\" && Object.getOwnPropertyNames(obj).length !== 0) {\n        return false;\n      }\n      var syms = Object.getOwnPropertySymbols(obj);\n      if (syms.length !== 1 || syms[0] !== sym) {\n        return false;\n      }\n      if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) {\n        return false;\n      }\n      if (typeof Object.getOwnPropertyDescriptor === \"function\") {\n        var descriptor = (\n          /** @type {PropertyDescriptor} */\n          Object.getOwnPropertyDescriptor(obj, sym)\n        );\n        if (descriptor.value !== symVal || descriptor.enumerable !== true) {\n          return false;\n        }\n      }\n      return true;\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/has-symbols@1.1.0/node_modules/has-symbols/index.js\nvar require_has_symbols = __commonJS({\n  \"../../node_modules/.pnpm/has-symbols@1.1.0/node_modules/has-symbols/index.js\"(exports2, module2) {\n    \"use strict\";\n    var origSymbol = typeof Symbol !== \"undefined\" && Symbol;\n    var hasSymbolSham = require_shams();\n    module2.exports = function hasNativeSymbols() {\n      if (typeof origSymbol !== \"function\") {\n        return false;\n      }\n      if (typeof Symbol !== \"function\") {\n        return false;\n      }\n      if (typeof origSymbol(\"foo\") !== \"symbol\") {\n        return false;\n      }\n      if (typeof /* @__PURE__ */ Symbol(\"bar\") !== \"symbol\") {\n        return false;\n      }\n      return hasSymbolSham();\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/Reflect.getPrototypeOf.js\nvar require_Reflect_getPrototypeOf = __commonJS({\n  \"../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/Reflect.getPrototypeOf.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = typeof Reflect !== \"undefined\" && Reflect.getPrototypeOf || null;\n  }\n});\n\n// ../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/Object.getPrototypeOf.js\nvar require_Object_getPrototypeOf = __commonJS({\n  \"../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/Object.getPrototypeOf.js\"(exports2, module2) {\n    \"use strict\";\n    var $Object = require_es_object_atoms();\n    module2.exports = $Object.getPrototypeOf || null;\n  }\n});\n\n// ../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/implementation.js\nvar require_implementation = __commonJS({\n  \"../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/implementation.js\"(exports2, module2) {\n    \"use strict\";\n    var ERROR_MESSAGE = \"Function.prototype.bind called on incompatible \";\n    var toStr = Object.prototype.toString;\n    var max = Math.max;\n    var funcType = \"[object Function]\";\n    var concatty = function concatty2(a, b) {\n      var arr = [];\n      for (var i = 0; i < a.length; i += 1) {\n        arr[i] = a[i];\n      }\n      for (var j = 0; j < b.length; j += 1) {\n        arr[j + a.length] = b[j];\n      }\n      return arr;\n    };\n    var slicy = function slicy2(arrLike, offset) {\n      var arr = [];\n      for (var i = offset || 0, j = 0; i < arrLike.length; i += 1, j += 1) {\n        arr[j] = arrLike[i];\n      }\n      return arr;\n    };\n    var joiny = function(arr, joiner) {\n      var str = \"\";\n      for (var i = 0; i < arr.length; i += 1) {\n        str += arr[i];\n        if (i + 1 < arr.length) {\n          str += joiner;\n        }\n      }\n      return str;\n    };\n    module2.exports = function bind(that) {\n      var target = this;\n      if (typeof target !== \"function\" || toStr.apply(target) !== funcType) {\n        throw new TypeError(ERROR_MESSAGE + target);\n      }\n      var args = slicy(arguments, 1);\n      var bound;\n      var binder = function() {\n        if (this instanceof bound) {\n          var result = target.apply(\n            this,\n            concatty(args, arguments)\n          );\n          if (Object(result) === result) {\n            return result;\n          }\n          return this;\n        }\n        return target.apply(\n          that,\n          concatty(args, arguments)\n        );\n      };\n      var boundLength = max(0, target.length - args.length);\n      var boundArgs = [];\n      for (var i = 0; i < boundLength; i++) {\n        boundArgs[i] = \"$\" + i;\n      }\n      bound = Function(\"binder\", \"return function (\" + joiny(boundArgs, \",\") + \"){ return binder.apply(this,arguments); }\")(binder);\n      if (target.prototype) {\n        var Empty = function Empty2() {\n        };\n        Empty.prototype = target.prototype;\n        bound.prototype = new Empty();\n        Empty.prototype = null;\n      }\n      return bound;\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/index.js\nvar require_function_bind = __commonJS({\n  \"../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/index.js\"(exports2, module2) {\n    \"use strict\";\n    var implementation = require_implementation();\n    module2.exports = Function.prototype.bind || implementation;\n  }\n});\n\n// ../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionCall.js\nvar require_functionCall = __commonJS({\n  \"../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionCall.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = Function.prototype.call;\n  }\n});\n\n// ../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionApply.js\nvar require_functionApply = __commonJS({\n  \"../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionApply.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = Function.prototype.apply;\n  }\n});\n\n// ../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/reflectApply.js\nvar require_reflectApply = __commonJS({\n  \"../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/reflectApply.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = typeof Reflect !== \"undefined\" && Reflect && Reflect.apply;\n  }\n});\n\n// ../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/actualApply.js\nvar require_actualApply = __commonJS({\n  \"../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/actualApply.js\"(exports2, module2) {\n    \"use strict\";\n    var bind = require_function_bind();\n    var $apply = require_functionApply();\n    var $call = require_functionCall();\n    var $reflectApply = require_reflectApply();\n    module2.exports = $reflectApply || bind.call($call, $apply);\n  }\n});\n\n// ../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/index.js\nvar require_call_bind_apply_helpers = __commonJS({\n  \"../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/index.js\"(exports2, module2) {\n    \"use strict\";\n    var bind = require_function_bind();\n    var $TypeError = require_type();\n    var $call = require_functionCall();\n    var $actualApply = require_actualApply();\n    module2.exports = function callBindBasic(args) {\n      if (args.length < 1 || typeof args[0] !== \"function\") {\n        throw new $TypeError(\"a function is required\");\n      }\n      return $actualApply(bind, $call, args);\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/dunder-proto@1.0.1/node_modules/dunder-proto/get.js\nvar require_get = __commonJS({\n  \"../../node_modules/.pnpm/dunder-proto@1.0.1/node_modules/dunder-proto/get.js\"(exports2, module2) {\n    \"use strict\";\n    var callBind = require_call_bind_apply_helpers();\n    var gOPD = require_gopd();\n    var hasProtoAccessor;\n    try {\n      hasProtoAccessor = /** @type {{ __proto__?: typeof Array.prototype }} */\n      [].__proto__ === Array.prototype;\n    } catch (e) {\n      if (!e || typeof e !== \"object\" || !(\"code\" in e) || e.code !== \"ERR_PROTO_ACCESS\") {\n        throw e;\n      }\n    }\n    var desc = !!hasProtoAccessor && gOPD && gOPD(\n      Object.prototype,\n      /** @type {keyof typeof Object.prototype} */\n      \"__proto__\"\n    );\n    var $Object = Object;\n    var $getPrototypeOf = $Object.getPrototypeOf;\n    module2.exports = desc && typeof desc.get === \"function\" ? callBind([desc.get]) : typeof $getPrototypeOf === \"function\" ? (\n      /** @type {import('./get')} */\n      function getDunder(value) {\n        return $getPrototypeOf(value == null ? value : $Object(value));\n      }\n    ) : false;\n  }\n});\n\n// ../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/index.js\nvar require_get_proto = __commonJS({\n  \"../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/index.js\"(exports2, module2) {\n    \"use strict\";\n    var reflectGetProto = require_Reflect_getPrototypeOf();\n    var originalGetProto = require_Object_getPrototypeOf();\n    var getDunderProto = require_get();\n    module2.exports = reflectGetProto ? function getProto(O) {\n      return reflectGetProto(O);\n    } : originalGetProto ? function getProto(O) {\n      if (!O || typeof O !== \"object\" && typeof O !== \"function\") {\n        throw new TypeError(\"getProto: not an object\");\n      }\n      return originalGetProto(O);\n    } : getDunderProto ? function getProto(O) {\n      return getDunderProto(O);\n    } : null;\n  }\n});\n\n// ../../node_modules/.pnpm/hasown@2.0.2/node_modules/hasown/index.js\nvar require_hasown = __commonJS({\n  \"../../node_modules/.pnpm/hasown@2.0.2/node_modules/hasown/index.js\"(exports2, module2) {\n    \"use strict\";\n    var call = Function.prototype.call;\n    var $hasOwn = Object.prototype.hasOwnProperty;\n    var bind = require_function_bind();\n    module2.exports = bind.call(call, $hasOwn);\n  }\n});\n\n// ../../node_modules/.pnpm/get-intrinsic@1.3.0/node_modules/get-intrinsic/index.js\nvar require_get_intrinsic = __commonJS({\n  \"../../node_modules/.pnpm/get-intrinsic@1.3.0/node_modules/get-intrinsic/index.js\"(exports2, module2) {\n    \"use strict\";\n    var undefined2;\n    var $Object = require_es_object_atoms();\n    var $Error = require_es_errors();\n    var $EvalError = require_eval();\n    var $RangeError = require_range();\n    var $ReferenceError = require_ref();\n    var $SyntaxError = require_syntax();\n    var $TypeError = require_type();\n    var $URIError = require_uri();\n    var abs = require_abs();\n    var floor = require_floor();\n    var max = require_max();\n    var min = require_min();\n    var pow = require_pow();\n    var round = require_round();\n    var sign = require_sign();\n    var $Function = Function;\n    var getEvalledConstructor = function(expressionSyntax) {\n      try {\n        return $Function('\"use strict\"; return (' + expressionSyntax + \").constructor;\")();\n      } catch (e) {\n      }\n    };\n    var $gOPD = require_gopd();\n    var $defineProperty = require_es_define_property();\n    var throwTypeError = function() {\n      throw new $TypeError();\n    };\n    var ThrowTypeError = $gOPD ? (function() {\n      try {\n        arguments.callee;\n        return throwTypeError;\n      } catch (calleeThrows) {\n        try {\n          return $gOPD(arguments, \"callee\").get;\n        } catch (gOPDthrows) {\n          return throwTypeError;\n        }\n      }\n    })() : throwTypeError;\n    var hasSymbols = require_has_symbols()();\n    var getProto = require_get_proto();\n    var $ObjectGPO = require_Object_getPrototypeOf();\n    var $ReflectGPO = require_Reflect_getPrototypeOf();\n    var $apply = require_functionApply();\n    var $call = require_functionCall();\n    var needsEval = {};\n    var TypedArray = typeof Uint8Array === \"undefined\" || !getProto ? undefined2 : getProto(Uint8Array);\n    var INTRINSICS = {\n      __proto__: null,\n      \"%AggregateError%\": typeof AggregateError === \"undefined\" ? undefined2 : AggregateError,\n      \"%Array%\": Array,\n      \"%ArrayBuffer%\": typeof ArrayBuffer === \"undefined\" ? undefined2 : ArrayBuffer,\n      \"%ArrayIteratorPrototype%\": hasSymbols && getProto ? getProto([][Symbol.iterator]()) : undefined2,\n      \"%AsyncFromSyncIteratorPrototype%\": undefined2,\n      \"%AsyncFunction%\": needsEval,\n      \"%AsyncGenerator%\": needsEval,\n      \"%AsyncGeneratorFunction%\": needsEval,\n      \"%AsyncIteratorPrototype%\": needsEval,\n      \"%Atomics%\": typeof Atomics === \"undefined\" ? undefined2 : Atomics,\n      \"%BigInt%\": typeof BigInt === \"undefined\" ? undefined2 : BigInt,\n      \"%BigInt64Array%\": typeof BigInt64Array === \"undefined\" ? undefined2 : BigInt64Array,\n      \"%BigUint64Array%\": typeof BigUint64Array === \"undefined\" ? undefined2 : BigUint64Array,\n      \"%Boolean%\": Boolean,\n      \"%DataView%\": typeof DataView === \"undefined\" ? undefined2 : DataView,\n      \"%Date%\": Date,\n      \"%decodeURI%\": decodeURI,\n      \"%decodeURIComponent%\": decodeURIComponent,\n      \"%encodeURI%\": encodeURI,\n      \"%encodeURIComponent%\": encodeURIComponent,\n      \"%Error%\": $Error,\n      \"%eval%\": eval,\n      // eslint-disable-line no-eval\n      \"%EvalError%\": $EvalError,\n      \"%Float16Array%\": typeof Float16Array === \"undefined\" ? undefined2 : Float16Array,\n      \"%Float32Array%\": typeof Float32Array === \"undefined\" ? undefined2 : Float32Array,\n      \"%Float64Array%\": typeof Float64Array === \"undefined\" ? undefined2 : Float64Array,\n      \"%FinalizationRegistry%\": typeof FinalizationRegistry === \"undefined\" ? undefined2 : FinalizationRegistry,\n      \"%Function%\": $Function,\n      \"%GeneratorFunction%\": needsEval,\n      \"%Int8Array%\": typeof Int8Array === \"undefined\" ? undefined2 : Int8Array,\n      \"%Int16Array%\": typeof Int16Array === \"undefined\" ? undefined2 : Int16Array,\n      \"%Int32Array%\": typeof Int32Array === \"undefined\" ? undefined2 : Int32Array,\n      \"%isFinite%\": isFinite,\n      \"%isNaN%\": isNaN,\n      \"%IteratorPrototype%\": hasSymbols && getProto ? getProto(getProto([][Symbol.iterator]())) : undefined2,\n      \"%JSON%\": typeof JSON === \"object\" ? JSON : undefined2,\n      \"%Map%\": typeof Map === \"undefined\" ? undefined2 : Map,\n      \"%MapIteratorPrototype%\": typeof Map === \"undefined\" || !hasSymbols || !getProto ? undefined2 : getProto((/* @__PURE__ */ new Map())[Symbol.iterator]()),\n      \"%Math%\": Math,\n      \"%Number%\": Number,\n      \"%Object%\": $Object,\n      \"%Object.getOwnPropertyDescriptor%\": $gOPD,\n      \"%parseFloat%\": parseFloat,\n      \"%parseInt%\": parseInt,\n      \"%Promise%\": typeof Promise === \"undefined\" ? undefined2 : Promise,\n      \"%Proxy%\": typeof Proxy === \"undefined\" ? undefined2 : Proxy,\n      \"%RangeError%\": $RangeError,\n      \"%ReferenceError%\": $ReferenceError,\n      \"%Reflect%\": typeof Reflect === \"undefined\" ? undefined2 : Reflect,\n      \"%RegExp%\": RegExp,\n      \"%Set%\": typeof Set === \"undefined\" ? undefined2 : Set,\n      \"%SetIteratorPrototype%\": typeof Set === \"undefined\" || !hasSymbols || !getProto ? undefined2 : getProto((/* @__PURE__ */ new Set())[Symbol.iterator]()),\n      \"%SharedArrayBuffer%\": typeof SharedArrayBuffer === \"undefined\" ? undefined2 : SharedArrayBuffer,\n      \"%String%\": String,\n      \"%StringIteratorPrototype%\": hasSymbols && getProto ? getProto(\"\"[Symbol.iterator]()) : undefined2,\n      \"%Symbol%\": hasSymbols ? Symbol : undefined2,\n      \"%SyntaxError%\": $SyntaxError,\n      \"%ThrowTypeError%\": ThrowTypeError,\n      \"%TypedArray%\": TypedArray,\n      \"%TypeError%\": $TypeError,\n      \"%Uint8Array%\": typeof Uint8Array === \"undefined\" ? undefined2 : Uint8Array,\n      \"%Uint8ClampedArray%\": typeof Uint8ClampedArray === \"undefined\" ? undefined2 : Uint8ClampedArray,\n      \"%Uint16Array%\": typeof Uint16Array === \"undefined\" ? undefined2 : Uint16Array,\n      \"%Uint32Array%\": typeof Uint32Array === \"undefined\" ? undefined2 : Uint32Array,\n      \"%URIError%\": $URIError,\n      \"%WeakMap%\": typeof WeakMap === \"undefined\" ? undefined2 : WeakMap,\n      \"%WeakRef%\": typeof WeakRef === \"undefined\" ? undefined2 : WeakRef,\n      \"%WeakSet%\": typeof WeakSet === \"undefined\" ? undefined2 : WeakSet,\n      \"%Function.prototype.call%\": $call,\n      \"%Function.prototype.apply%\": $apply,\n      \"%Object.defineProperty%\": $defineProperty,\n      \"%Object.getPrototypeOf%\": $ObjectGPO,\n      \"%Math.abs%\": abs,\n      \"%Math.floor%\": floor,\n      \"%Math.max%\": max,\n      \"%Math.min%\": min,\n      \"%Math.pow%\": pow,\n      \"%Math.round%\": round,\n      \"%Math.sign%\": sign,\n      \"%Reflect.getPrototypeOf%\": $ReflectGPO\n    };\n    if (getProto) {\n      try {\n        null.error;\n      } catch (e) {\n        errorProto = getProto(getProto(e));\n        INTRINSICS[\"%Error.prototype%\"] = errorProto;\n      }\n    }\n    var errorProto;\n    var doEval = function doEval2(name) {\n      var value;\n      if (name === \"%AsyncFunction%\") {\n        value = getEvalledConstructor(\"async function () {}\");\n      } else if (name === \"%GeneratorFunction%\") {\n        value = getEvalledConstructor(\"function* () {}\");\n      } else if (name === \"%AsyncGeneratorFunction%\") {\n        value = getEvalledConstructor(\"async function* () {}\");\n      } else if (name === \"%AsyncGenerator%\") {\n        var fn = doEval2(\"%AsyncGeneratorFunction%\");\n        if (fn) {\n          value = fn.prototype;\n        }\n      } else if (name === \"%AsyncIteratorPrototype%\") {\n        var gen = doEval2(\"%AsyncGenerator%\");\n        if (gen && getProto) {\n          value = getProto(gen.prototype);\n        }\n      }\n      INTRINSICS[name] = value;\n      return value;\n    };\n    var LEGACY_ALIASES = {\n      __proto__: null,\n      \"%ArrayBufferPrototype%\": [\"ArrayBuffer\", \"prototype\"],\n      \"%ArrayPrototype%\": [\"Array\", \"prototype\"],\n      \"%ArrayProto_entries%\": [\"Array\", \"prototype\", \"entries\"],\n      \"%ArrayProto_forEach%\": [\"Array\", \"prototype\", \"forEach\"],\n      \"%ArrayProto_keys%\": [\"Array\", \"prototype\", \"keys\"],\n      \"%ArrayProto_values%\": [\"Array\", \"prototype\", \"values\"],\n      \"%AsyncFunctionPrototype%\": [\"AsyncFunction\", \"prototype\"],\n      \"%AsyncGenerator%\": [\"AsyncGeneratorFunction\", \"prototype\"],\n      \"%AsyncGeneratorPrototype%\": [\"AsyncGeneratorFunction\", \"prototype\", \"prototype\"],\n      \"%BooleanPrototype%\": [\"Boolean\", \"prototype\"],\n      \"%DataViewPrototype%\": [\"DataView\", \"prototype\"],\n      \"%DatePrototype%\": [\"Date\", \"prototype\"],\n      \"%ErrorPrototype%\": [\"Error\", \"prototype\"],\n      \"%EvalErrorPrototype%\": [\"EvalError\", \"prototype\"],\n      \"%Float32ArrayPrototype%\": [\"Float32Array\", \"prototype\"],\n      \"%Float64ArrayPrototype%\": [\"Float64Array\", \"prototype\"],\n      \"%FunctionPrototype%\": [\"Function\", \"prototype\"],\n      \"%Generator%\": [\"GeneratorFunction\", \"prototype\"],\n      \"%GeneratorPrototype%\": [\"GeneratorFunction\", \"prototype\", \"prototype\"],\n      \"%Int8ArrayPrototype%\": [\"Int8Array\", \"prototype\"],\n      \"%Int16ArrayPrototype%\": [\"Int16Array\", \"prototype\"],\n      \"%Int32ArrayPrototype%\": [\"Int32Array\", \"prototype\"],\n      \"%JSONParse%\": [\"JSON\", \"parse\"],\n      \"%JSONStringify%\": [\"JSON\", \"stringify\"],\n      \"%MapPrototype%\": [\"Map\", \"prototype\"],\n      \"%NumberPrototype%\": [\"Number\", \"prototype\"],\n      \"%ObjectPrototype%\": [\"Object\", \"prototype\"],\n      \"%ObjProto_toString%\": [\"Object\", \"prototype\", \"toString\"],\n      \"%ObjProto_valueOf%\": [\"Object\", \"prototype\", \"valueOf\"],\n      \"%PromisePrototype%\": [\"Promise\", \"prototype\"],\n      \"%PromiseProto_then%\": [\"Promise\", \"prototype\", \"then\"],\n      \"%Promise_all%\": [\"Promise\", \"all\"],\n      \"%Promise_reject%\": [\"Promise\", \"reject\"],\n      \"%Promise_resolve%\": [\"Promise\", \"resolve\"],\n      \"%RangeErrorPrototype%\": [\"RangeError\", \"prototype\"],\n      \"%ReferenceErrorPrototype%\": [\"ReferenceError\", \"prototype\"],\n      \"%RegExpPrototype%\": [\"RegExp\", \"prototype\"],\n      \"%SetPrototype%\": [\"Set\", \"prototype\"],\n      \"%SharedArrayBufferPrototype%\": [\"SharedArrayBuffer\", \"prototype\"],\n      \"%StringPrototype%\": [\"String\", \"prototype\"],\n      \"%SymbolPrototype%\": [\"Symbol\", \"prototype\"],\n      \"%SyntaxErrorPrototype%\": [\"SyntaxError\", \"prototype\"],\n      \"%TypedArrayPrototype%\": [\"TypedArray\", \"prototype\"],\n      \"%TypeErrorPrototype%\": [\"TypeError\", \"prototype\"],\n      \"%Uint8ArrayPrototype%\": [\"Uint8Array\", \"prototype\"],\n      \"%Uint8ClampedArrayPrototype%\": [\"Uint8ClampedArray\", \"prototype\"],\n      \"%Uint16ArrayPrototype%\": [\"Uint16Array\", \"prototype\"],\n      \"%Uint32ArrayPrototype%\": [\"Uint32Array\", \"prototype\"],\n      \"%URIErrorPrototype%\": [\"URIError\", \"prototype\"],\n      \"%WeakMapPrototype%\": [\"WeakMap\", \"prototype\"],\n      \"%WeakSetPrototype%\": [\"WeakSet\", \"prototype\"]\n    };\n    var bind = require_function_bind();\n    var hasOwn = require_hasown();\n    var $concat = bind.call($call, Array.prototype.concat);\n    var $spliceApply = bind.call($apply, Array.prototype.splice);\n    var $replace = bind.call($call, String.prototype.replace);\n    var $strSlice = bind.call($call, String.prototype.slice);\n    var $exec = bind.call($call, RegExp.prototype.exec);\n    var rePropName = /[^%.[\\]]+|\\[(?:(-?\\d+(?:\\.\\d+)?)|([\"'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2)\\]|(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|%$))/g;\n    var reEscapeChar = /\\\\(\\\\)?/g;\n    var stringToPath = function stringToPath2(string) {\n      var first = $strSlice(string, 0, 1);\n      var last = $strSlice(string, -1);\n      if (first === \"%\" && last !== \"%\") {\n        throw new $SyntaxError(\"invalid intrinsic syntax, expected closing `%`\");\n      } else if (last === \"%\" && first !== \"%\") {\n        throw new $SyntaxError(\"invalid intrinsic syntax, expected opening `%`\");\n      }\n      var result = [];\n      $replace(string, rePropName, function(match, number, quote, subString) {\n        result[result.length] = quote ? $replace(subString, reEscapeChar, \"$1\") : number || match;\n      });\n      return result;\n    };\n    var getBaseIntrinsic = function getBaseIntrinsic2(name, allowMissing) {\n      var intrinsicName = name;\n      var alias;\n      if (hasOwn(LEGACY_ALIASES, intrinsicName)) {\n        alias = LEGACY_ALIASES[intrinsicName];\n        intrinsicName = \"%\" + alias[0] + \"%\";\n      }\n      if (hasOwn(INTRINSICS, intrinsicName)) {\n        var value = INTRINSICS[intrinsicName];\n        if (value === needsEval) {\n          value = doEval(intrinsicName);\n        }\n        if (typeof value === \"undefined\" && !allowMissing) {\n          throw new $TypeError(\"intrinsic \" + name + \" exists, but is not available. Please file an issue!\");\n        }\n        return {\n          alias,\n          name: intrinsicName,\n          value\n        };\n      }\n      throw new $SyntaxError(\"intrinsic \" + name + \" does not exist!\");\n    };\n    module2.exports = function GetIntrinsic(name, allowMissing) {\n      if (typeof name !== \"string\" || name.length === 0) {\n        throw new $TypeError(\"intrinsic name must be a non-empty string\");\n      }\n      if (arguments.length > 1 && typeof allowMissing !== \"boolean\") {\n        throw new $TypeError('\"allowMissing\" argument must be a boolean');\n      }\n      if ($exec(/^%?[^%]*%?$/, name) === null) {\n        throw new $SyntaxError(\"`%` may not be present anywhere but at the beginning and end of the intrinsic name\");\n      }\n      var parts = stringToPath(name);\n      var intrinsicBaseName = parts.length > 0 ? parts[0] : \"\";\n      var intrinsic = getBaseIntrinsic(\"%\" + intrinsicBaseName + \"%\", allowMissing);\n      var intrinsicRealName = intrinsic.name;\n      var value = intrinsic.value;\n      var skipFurtherCaching = false;\n      var alias = intrinsic.alias;\n      if (alias) {\n        intrinsicBaseName = alias[0];\n        $spliceApply(parts, $concat([0, 1], alias));\n      }\n      for (var i = 1, isOwn = true; i < parts.length; i += 1) {\n        var part = parts[i];\n        var first = $strSlice(part, 0, 1);\n        var last = $strSlice(part, -1);\n        if ((first === '\"' || first === \"'\" || first === \"`\" || (last === '\"' || last === \"'\" || last === \"`\")) && first !== last) {\n          throw new $SyntaxError(\"property names with quotes must have matching quotes\");\n        }\n        if (part === \"constructor\" || !isOwn) {\n          skipFurtherCaching = true;\n        }\n        intrinsicBaseName += \".\" + part;\n        intrinsicRealName = \"%\" + intrinsicBaseName + \"%\";\n        if (hasOwn(INTRINSICS, intrinsicRealName)) {\n          value = INTRINSICS[intrinsicRealName];\n        } else if (value != null) {\n          if (!(part in value)) {\n            if (!allowMissing) {\n              throw new $TypeError(\"base intrinsic for \" + name + \" exists, but the property is not available.\");\n            }\n            return void undefined2;\n          }\n          if ($gOPD && i + 1 >= parts.length) {\n            var desc = $gOPD(value, part);\n            isOwn = !!desc;\n            if (isOwn && \"get\" in desc && !(\"originalValue\" in desc.get)) {\n              value = desc.get;\n            } else {\n              value = value[part];\n            }\n          } else {\n            isOwn = hasOwn(value, part);\n            value = value[part];\n          }\n          if (isOwn && !skipFurtherCaching) {\n            INTRINSICS[intrinsicRealName] = value;\n          }\n        }\n      }\n      return value;\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/call-bound@1.0.4/node_modules/call-bound/index.js\nvar require_call_bound = __commonJS({\n  \"../../node_modules/.pnpm/call-bound@1.0.4/node_modules/call-bound/index.js\"(exports2, module2) {\n    \"use strict\";\n    var GetIntrinsic = require_get_intrinsic();\n    var callBindBasic = require_call_bind_apply_helpers();\n    var $indexOf = callBindBasic([GetIntrinsic(\"%String.prototype.indexOf%\")]);\n    module2.exports = function callBoundIntrinsic(name, allowMissing) {\n      var intrinsic = (\n        /** @type {(this: unknown, ...args: unknown[]) => unknown} */\n        GetIntrinsic(name, !!allowMissing)\n      );\n      if (typeof intrinsic === \"function\" && $indexOf(name, \".prototype.\") > -1) {\n        return callBindBasic(\n          /** @type {const} */\n          [intrinsic]\n        );\n      }\n      return intrinsic;\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/side-channel-map@1.0.1/node_modules/side-channel-map/index.js\nvar require_side_channel_map = __commonJS({\n  \"../../node_modules/.pnpm/side-channel-map@1.0.1/node_modules/side-channel-map/index.js\"(exports2, module2) {\n    \"use strict\";\n    var GetIntrinsic = require_get_intrinsic();\n    var callBound = require_call_bound();\n    var inspect = require_object_inspect();\n    var $TypeError = require_type();\n    var $Map = GetIntrinsic(\"%Map%\", true);\n    var $mapGet = callBound(\"Map.prototype.get\", true);\n    var $mapSet = callBound(\"Map.prototype.set\", true);\n    var $mapHas = callBound(\"Map.prototype.has\", true);\n    var $mapDelete = callBound(\"Map.prototype.delete\", true);\n    var $mapSize = callBound(\"Map.prototype.size\", true);\n    module2.exports = !!$Map && /** @type {Exclude<import('.'), false>} */\n    function getSideChannelMap() {\n      var $m;\n      var channel = {\n        assert: function(key) {\n          if (!channel.has(key)) {\n            throw new $TypeError(\"Side channel does not contain \" + inspect(key));\n          }\n        },\n        \"delete\": function(key) {\n          if ($m) {\n            var result = $mapDelete($m, key);\n            if ($mapSize($m) === 0) {\n              $m = void 0;\n            }\n            return result;\n          }\n          return false;\n        },\n        get: function(key) {\n          if ($m) {\n            return $mapGet($m, key);\n          }\n        },\n        has: function(key) {\n          if ($m) {\n            return $mapHas($m, key);\n          }\n          return false;\n        },\n        set: function(key, value) {\n          if (!$m) {\n            $m = new $Map();\n          }\n          $mapSet($m, key, value);\n        }\n      };\n      return channel;\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/side-channel-weakmap@1.0.2/node_modules/side-channel-weakmap/index.js\nvar require_side_channel_weakmap = __commonJS({\n  \"../../node_modules/.pnpm/side-channel-weakmap@1.0.2/node_modules/side-channel-weakmap/index.js\"(exports2, module2) {\n    \"use strict\";\n    var GetIntrinsic = require_get_intrinsic();\n    var callBound = require_call_bound();\n    var inspect = require_object_inspect();\n    var getSideChannelMap = require_side_channel_map();\n    var $TypeError = require_type();\n    var $WeakMap = GetIntrinsic(\"%WeakMap%\", true);\n    var $weakMapGet = callBound(\"WeakMap.prototype.get\", true);\n    var $weakMapSet = callBound(\"WeakMap.prototype.set\", true);\n    var $weakMapHas = callBound(\"WeakMap.prototype.has\", true);\n    var $weakMapDelete = callBound(\"WeakMap.prototype.delete\", true);\n    module2.exports = $WeakMap ? (\n      /** @type {Exclude<import('.'), false>} */\n      function getSideChannelWeakMap() {\n        var $wm;\n        var $m;\n        var channel = {\n          assert: function(key) {\n            if (!channel.has(key)) {\n              throw new $TypeError(\"Side channel does not contain \" + inspect(key));\n            }\n          },\n          \"delete\": function(key) {\n            if ($WeakMap && key && (typeof key === \"object\" || typeof key === \"function\")) {\n              if ($wm) {\n                return $weakMapDelete($wm, key);\n              }\n            } else if (getSideChannelMap) {\n              if ($m) {\n                return $m[\"delete\"](key);\n              }\n            }\n            return false;\n          },\n          get: function(key) {\n            if ($WeakMap && key && (typeof key === \"object\" || typeof key === \"function\")) {\n              if ($wm) {\n                return $weakMapGet($wm, key);\n              }\n            }\n            return $m && $m.get(key);\n          },\n          has: function(key) {\n            if ($WeakMap && key && (typeof key === \"object\" || typeof key === \"function\")) {\n              if ($wm) {\n                return $weakMapHas($wm, key);\n              }\n            }\n            return !!$m && $m.has(key);\n          },\n          set: function(key, value) {\n            if ($WeakMap && key && (typeof key === \"object\" || typeof key === \"function\")) {\n              if (!$wm) {\n                $wm = new $WeakMap();\n              }\n              $weakMapSet($wm, key, value);\n            } else if (getSideChannelMap) {\n              if (!$m) {\n                $m = getSideChannelMap();\n              }\n              $m.set(key, value);\n            }\n          }\n        };\n        return channel;\n      }\n    ) : getSideChannelMap;\n  }\n});\n\n// ../../node_modules/.pnpm/side-channel@1.1.0/node_modules/side-channel/index.js\nvar require_side_channel = __commonJS({\n  \"../../node_modules/.pnpm/side-channel@1.1.0/node_modules/side-channel/index.js\"(exports2, module2) {\n    \"use strict\";\n    var $TypeError = require_type();\n    var inspect = require_object_inspect();\n    var getSideChannelList = require_side_channel_list();\n    var getSideChannelMap = require_side_channel_map();\n    var getSideChannelWeakMap = require_side_channel_weakmap();\n    var makeChannel = getSideChannelWeakMap || getSideChannelMap || getSideChannelList;\n    module2.exports = function getSideChannel() {\n      var $channelData;\n      var channel = {\n        assert: function(key) {\n          if (!channel.has(key)) {\n            throw new $TypeError(\"Side channel does not contain \" + inspect(key));\n          }\n        },\n        \"delete\": function(key) {\n          return !!$channelData && $channelData[\"delete\"](key);\n        },\n        get: function(key) {\n          return $channelData && $channelData.get(key);\n        },\n        has: function(key) {\n          return !!$channelData && $channelData.has(key);\n        },\n        set: function(key, value) {\n          if (!$channelData) {\n            $channelData = makeChannel();\n          }\n          $channelData.set(key, value);\n        }\n      };\n      return channel;\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/qs@6.15.0/node_modules/qs/lib/formats.js\nvar require_formats = __commonJS({\n  \"../../node_modules/.pnpm/qs@6.15.0/node_modules/qs/lib/formats.js\"(exports2, module2) {\n    \"use strict\";\n    var replace = String.prototype.replace;\n    var percentTwenties = /%20/g;\n    var Format = {\n      RFC1738: \"RFC1738\",\n      RFC3986: \"RFC3986\"\n    };\n    module2.exports = {\n      \"default\": Format.RFC3986,\n      formatters: {\n        RFC1738: function(value) {\n          return replace.call(value, percentTwenties, \"+\");\n        },\n        RFC3986: function(value) {\n          return String(value);\n        }\n      },\n      RFC1738: Format.RFC1738,\n      RFC3986: Format.RFC3986\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/qs@6.15.0/node_modules/qs/lib/utils.js\nvar require_utils = __commonJS({\n  \"../../node_modules/.pnpm/qs@6.15.0/node_modules/qs/lib/utils.js\"(exports2, module2) {\n    \"use strict\";\n    var formats = require_formats();\n    var getSideChannel = require_side_channel();\n    var has = Object.prototype.hasOwnProperty;\n    var isArray = Array.isArray;\n    var overflowChannel = getSideChannel();\n    var markOverflow = function markOverflow2(obj, maxIndex) {\n      overflowChannel.set(obj, maxIndex);\n      return obj;\n    };\n    var isOverflow = function isOverflow2(obj) {\n      return overflowChannel.has(obj);\n    };\n    var getMaxIndex = function getMaxIndex2(obj) {\n      return overflowChannel.get(obj);\n    };\n    var setMaxIndex = function setMaxIndex2(obj, maxIndex) {\n      overflowChannel.set(obj, maxIndex);\n    };\n    var hexTable = (function() {\n      var array = [];\n      for (var i = 0; i < 256; ++i) {\n        array[array.length] = \"%\" + ((i < 16 ? \"0\" : \"\") + i.toString(16)).toUpperCase();\n      }\n      return array;\n    })();\n    var compactQueue = function compactQueue2(queue) {\n      while (queue.length > 1) {\n        var item = queue.pop();\n        var obj = item.obj[item.prop];\n        if (isArray(obj)) {\n          var compacted = [];\n          for (var j = 0; j < obj.length; ++j) {\n            if (typeof obj[j] !== \"undefined\") {\n              compacted[compacted.length] = obj[j];\n            }\n          }\n          item.obj[item.prop] = compacted;\n        }\n      }\n    };\n    var arrayToObject = function arrayToObject2(source, options) {\n      var obj = options && options.plainObjects ? { __proto__: null } : {};\n      for (var i = 0; i < source.length; ++i) {\n        if (typeof source[i] !== \"undefined\") {\n          obj[i] = source[i];\n        }\n      }\n      return obj;\n    };\n    var merge = function merge2(target, source, options) {\n      if (!source) {\n        return target;\n      }\n      if (typeof source !== \"object\" && typeof source !== \"function\") {\n        if (isArray(target)) {\n          var nextIndex = target.length;\n          if (options && typeof options.arrayLimit === \"number\" && nextIndex > options.arrayLimit) {\n            return markOverflow(arrayToObject(target.concat(source), options), nextIndex);\n          }\n          target[nextIndex] = source;\n        } else if (target && typeof target === \"object\") {\n          if (isOverflow(target)) {\n            var newIndex = getMaxIndex(target) + 1;\n            target[newIndex] = source;\n            setMaxIndex(target, newIndex);\n          } else if (options && options.strictMerge) {\n            return [target, source];\n          } else if (options && (options.plainObjects || options.allowPrototypes) || !has.call(Object.prototype, source)) {\n            target[source] = true;\n          }\n        } else {\n          return [target, source];\n        }\n        return target;\n      }\n      if (!target || typeof target !== \"object\") {\n        if (isOverflow(source)) {\n          var sourceKeys = Object.keys(source);\n          var result = options && options.plainObjects ? { __proto__: null, 0: target } : { 0: target };\n          for (var m = 0; m < sourceKeys.length; m++) {\n            var oldKey = parseInt(sourceKeys[m], 10);\n            result[oldKey + 1] = source[sourceKeys[m]];\n          }\n          return markOverflow(result, getMaxIndex(source) + 1);\n        }\n        var combined = [target].concat(source);\n        if (options && typeof options.arrayLimit === \"number\" && combined.length > options.arrayLimit) {\n          return markOverflow(arrayToObject(combined, options), combined.length - 1);\n        }\n        return combined;\n      }\n      var mergeTarget = target;\n      if (isArray(target) && !isArray(source)) {\n        mergeTarget = arrayToObject(target, options);\n      }\n      if (isArray(target) && isArray(source)) {\n        source.forEach(function(item, i) {\n          if (has.call(target, i)) {\n            var targetItem = target[i];\n            if (targetItem && typeof targetItem === \"object\" && item && typeof item === \"object\") {\n              target[i] = merge2(targetItem, item, options);\n            } else {\n              target[target.length] = item;\n            }\n          } else {\n            target[i] = item;\n          }\n        });\n        return target;\n      }\n      return Object.keys(source).reduce(function(acc, key) {\n        var value = source[key];\n        if (has.call(acc, key)) {\n          acc[key] = merge2(acc[key], value, options);\n        } else {\n          acc[key] = value;\n        }\n        if (isOverflow(source) && !isOverflow(acc)) {\n          markOverflow(acc, getMaxIndex(source));\n        }\n        if (isOverflow(acc)) {\n          var keyNum = parseInt(key, 10);\n          if (String(keyNum) === key && keyNum >= 0 && keyNum > getMaxIndex(acc)) {\n            setMaxIndex(acc, keyNum);\n          }\n        }\n        return acc;\n      }, mergeTarget);\n    };\n    var assign = function assignSingleSource(target, source) {\n      return Object.keys(source).reduce(function(acc, key) {\n        acc[key] = source[key];\n        return acc;\n      }, target);\n    };\n    var decode = function(str, defaultDecoder, charset) {\n      var strWithoutPlus = str.replace(/\\+/g, \" \");\n      if (charset === \"iso-8859-1\") {\n        return strWithoutPlus.replace(/%[0-9a-f]{2}/gi, unescape);\n      }\n      try {\n        return decodeURIComponent(strWithoutPlus);\n      } catch (e) {\n        return strWithoutPlus;\n      }\n    };\n    var limit = 1024;\n    var encode = function encode2(str, defaultEncoder, charset, kind, format2) {\n      if (str.length === 0) {\n        return str;\n      }\n      var string = str;\n      if (typeof str === \"symbol\") {\n        string = Symbol.prototype.toString.call(str);\n      } else if (typeof str !== \"string\") {\n        string = String(str);\n      }\n      if (charset === \"iso-8859-1\") {\n        return escape(string).replace(/%u[0-9a-f]{4}/gi, function($0) {\n          return \"%26%23\" + parseInt($0.slice(2), 16) + \"%3B\";\n        });\n      }\n      var out = \"\";\n      for (var j = 0; j < string.length; j += limit) {\n        var segment = string.length >= limit ? string.slice(j, j + limit) : string;\n        var arr = [];\n        for (var i = 0; i < segment.length; ++i) {\n          var c = segment.charCodeAt(i);\n          if (c === 45 || c === 46 || c === 95 || c === 126 || c >= 48 && c <= 57 || c >= 65 && c <= 90 || c >= 97 && c <= 122 || format2 === formats.RFC1738 && (c === 40 || c === 41)) {\n            arr[arr.length] = segment.charAt(i);\n            continue;\n          }\n          if (c < 128) {\n            arr[arr.length] = hexTable[c];\n            continue;\n          }\n          if (c < 2048) {\n            arr[arr.length] = hexTable[192 | c >> 6] + hexTable[128 | c & 63];\n            continue;\n          }\n          if (c < 55296 || c >= 57344) {\n            arr[arr.length] = hexTable[224 | c >> 12] + hexTable[128 | c >> 6 & 63] + hexTable[128 | c & 63];\n            continue;\n          }\n          i += 1;\n          c = 65536 + ((c & 1023) << 10 | segment.charCodeAt(i) & 1023);\n          arr[arr.length] = hexTable[240 | c >> 18] + hexTable[128 | c >> 12 & 63] + hexTable[128 | c >> 6 & 63] + hexTable[128 | c & 63];\n        }\n        out += arr.join(\"\");\n      }\n      return out;\n    };\n    var compact = function compact2(value) {\n      var queue = [{ obj: { o: value }, prop: \"o\" }];\n      var refs = [];\n      for (var i = 0; i < queue.length; ++i) {\n        var item = queue[i];\n        var obj = item.obj[item.prop];\n        var keys = Object.keys(obj);\n        for (var j = 0; j < keys.length; ++j) {\n          var key = keys[j];\n          var val = obj[key];\n          if (typeof val === \"object\" && val !== null && refs.indexOf(val) === -1) {\n            queue[queue.length] = { obj, prop: key };\n            refs[refs.length] = val;\n          }\n        }\n      }\n      compactQueue(queue);\n      return value;\n    };\n    var isRegExp = function isRegExp2(obj) {\n      return Object.prototype.toString.call(obj) === \"[object RegExp]\";\n    };\n    var isBuffer = function isBuffer2(obj) {\n      if (!obj || typeof obj !== \"object\") {\n        return false;\n      }\n      return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj));\n    };\n    var combine = function combine2(a, b, arrayLimit, plainObjects) {\n      if (isOverflow(a)) {\n        var newIndex = getMaxIndex(a) + 1;\n        a[newIndex] = b;\n        setMaxIndex(a, newIndex);\n        return a;\n      }\n      var result = [].concat(a, b);\n      if (result.length > arrayLimit) {\n        return markOverflow(arrayToObject(result, { plainObjects }), result.length - 1);\n      }\n      return result;\n    };\n    var maybeMap = function maybeMap2(val, fn) {\n      if (isArray(val)) {\n        var mapped = [];\n        for (var i = 0; i < val.length; i += 1) {\n          mapped[mapped.length] = fn(val[i]);\n        }\n        return mapped;\n      }\n      return fn(val);\n    };\n    module2.exports = {\n      arrayToObject,\n      assign,\n      combine,\n      compact,\n      decode,\n      encode,\n      isBuffer,\n      isOverflow,\n      isRegExp,\n      markOverflow,\n      maybeMap,\n      merge\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/qs@6.15.0/node_modules/qs/lib/stringify.js\nvar require_stringify = __commonJS({\n  \"../../node_modules/.pnpm/qs@6.15.0/node_modules/qs/lib/stringify.js\"(exports2, module2) {\n    \"use strict\";\n    var getSideChannel = require_side_channel();\n    var utils = require_utils();\n    var formats = require_formats();\n    var has = Object.prototype.hasOwnProperty;\n    var arrayPrefixGenerators = {\n      brackets: function brackets(prefix) {\n        return prefix + \"[]\";\n      },\n      comma: \"comma\",\n      indices: function indices(prefix, key) {\n        return prefix + \"[\" + key + \"]\";\n      },\n      repeat: function repeat(prefix) {\n        return prefix;\n      }\n    };\n    var isArray = Array.isArray;\n    var push = Array.prototype.push;\n    var pushToArray = function(arr, valueOrArray) {\n      push.apply(arr, isArray(valueOrArray) ? valueOrArray : [valueOrArray]);\n    };\n    var toISO = Date.prototype.toISOString;\n    var defaultFormat = formats[\"default\"];\n    var defaults = {\n      addQueryPrefix: false,\n      allowDots: false,\n      allowEmptyArrays: false,\n      arrayFormat: \"indices\",\n      charset: \"utf-8\",\n      charsetSentinel: false,\n      commaRoundTrip: false,\n      delimiter: \"&\",\n      encode: true,\n      encodeDotInKeys: false,\n      encoder: utils.encode,\n      encodeValuesOnly: false,\n      filter: void 0,\n      format: defaultFormat,\n      formatter: formats.formatters[defaultFormat],\n      // deprecated\n      indices: false,\n      serializeDate: function serializeDate(date) {\n        return toISO.call(date);\n      },\n      skipNulls: false,\n      strictNullHandling: false\n    };\n    var isNonNullishPrimitive = function isNonNullishPrimitive2(v) {\n      return typeof v === \"string\" || typeof v === \"number\" || typeof v === \"boolean\" || typeof v === \"symbol\" || typeof v === \"bigint\";\n    };\n    var sentinel = {};\n    var stringify = function stringify2(object, prefix, generateArrayPrefix, commaRoundTrip, allowEmptyArrays, strictNullHandling, skipNulls, encodeDotInKeys, encoder, filter2, sort, allowDots, serializeDate, format2, formatter, encodeValuesOnly, charset, sideChannel) {\n      var obj = object;\n      var tmpSc = sideChannel;\n      var step = 0;\n      var findFlag = false;\n      while ((tmpSc = tmpSc.get(sentinel)) !== void 0 && !findFlag) {\n        var pos = tmpSc.get(object);\n        step += 1;\n        if (typeof pos !== \"undefined\") {\n          if (pos === step) {\n            throw new RangeError(\"Cyclic object value\");\n          } else {\n            findFlag = true;\n          }\n        }\n        if (typeof tmpSc.get(sentinel) === \"undefined\") {\n          step = 0;\n        }\n      }\n      if (typeof filter2 === \"function\") {\n        obj = filter2(prefix, obj);\n      } else if (obj instanceof Date) {\n        obj = serializeDate(obj);\n      } else if (generateArrayPrefix === \"comma\" && isArray(obj)) {\n        obj = utils.maybeMap(obj, function(value2) {\n          if (value2 instanceof Date) {\n            return serializeDate(value2);\n          }\n          return value2;\n        });\n      }\n      if (obj === null) {\n        if (strictNullHandling) {\n          return encoder && !encodeValuesOnly ? encoder(prefix, defaults.encoder, charset, \"key\", format2) : prefix;\n        }\n        obj = \"\";\n      }\n      if (isNonNullishPrimitive(obj) || utils.isBuffer(obj)) {\n        if (encoder) {\n          var keyValue = encodeValuesOnly ? prefix : encoder(prefix, defaults.encoder, charset, \"key\", format2);\n          return [formatter(keyValue) + \"=\" + formatter(encoder(obj, defaults.encoder, charset, \"value\", format2))];\n        }\n        return [formatter(prefix) + \"=\" + formatter(String(obj))];\n      }\n      var values = [];\n      if (typeof obj === \"undefined\") {\n        return values;\n      }\n      var objKeys;\n      if (generateArrayPrefix === \"comma\" && isArray(obj)) {\n        if (encodeValuesOnly && encoder) {\n          obj = utils.maybeMap(obj, encoder);\n        }\n        objKeys = [{ value: obj.length > 0 ? obj.join(\",\") || null : void 0 }];\n      } else if (isArray(filter2)) {\n        objKeys = filter2;\n      } else {\n        var keys = Object.keys(obj);\n        objKeys = sort ? keys.sort(sort) : keys;\n      }\n      var encodedPrefix = encodeDotInKeys ? String(prefix).replace(/\\./g, \"%2E\") : String(prefix);\n      var adjustedPrefix = commaRoundTrip && isArray(obj) && obj.length === 1 ? encodedPrefix + \"[]\" : encodedPrefix;\n      if (allowEmptyArrays && isArray(obj) && obj.length === 0) {\n        return adjustedPrefix + \"[]\";\n      }\n      for (var j = 0; j < objKeys.length; ++j) {\n        var key = objKeys[j];\n        var value = typeof key === \"object\" && key && typeof key.value !== \"undefined\" ? key.value : obj[key];\n        if (skipNulls && value === null) {\n          continue;\n        }\n        var encodedKey = allowDots && encodeDotInKeys ? String(key).replace(/\\./g, \"%2E\") : String(key);\n        var keyPrefix = isArray(obj) ? typeof generateArrayPrefix === \"function\" ? generateArrayPrefix(adjustedPrefix, encodedKey) : adjustedPrefix : adjustedPrefix + (allowDots ? \".\" + encodedKey : \"[\" + encodedKey + \"]\");\n        sideChannel.set(object, step);\n        var valueSideChannel = getSideChannel();\n        valueSideChannel.set(sentinel, sideChannel);\n        pushToArray(values, stringify2(\n          value,\n          keyPrefix,\n          generateArrayPrefix,\n          commaRoundTrip,\n          allowEmptyArrays,\n          strictNullHandling,\n          skipNulls,\n          encodeDotInKeys,\n          generateArrayPrefix === \"comma\" && encodeValuesOnly && isArray(obj) ? null : encoder,\n          filter2,\n          sort,\n          allowDots,\n          serializeDate,\n          format2,\n          formatter,\n          encodeValuesOnly,\n          charset,\n          valueSideChannel\n        ));\n      }\n      return values;\n    };\n    var normalizeStringifyOptions = function normalizeStringifyOptions2(opts) {\n      if (!opts) {\n        return defaults;\n      }\n      if (typeof opts.allowEmptyArrays !== \"undefined\" && typeof opts.allowEmptyArrays !== \"boolean\") {\n        throw new TypeError(\"`allowEmptyArrays` option can only be `true` or `false`, when provided\");\n      }\n      if (typeof opts.encodeDotInKeys !== \"undefined\" && typeof opts.encodeDotInKeys !== \"boolean\") {\n        throw new TypeError(\"`encodeDotInKeys` option can only be `true` or `false`, when provided\");\n      }\n      if (opts.encoder !== null && typeof opts.encoder !== \"undefined\" && typeof opts.encoder !== \"function\") {\n        throw new TypeError(\"Encoder has to be a function.\");\n      }\n      var charset = opts.charset || defaults.charset;\n      if (typeof opts.charset !== \"undefined\" && opts.charset !== \"utf-8\" && opts.charset !== \"iso-8859-1\") {\n        throw new TypeError(\"The charset option must be either utf-8, iso-8859-1, or undefined\");\n      }\n      var format2 = formats[\"default\"];\n      if (typeof opts.format !== \"undefined\") {\n        if (!has.call(formats.formatters, opts.format)) {\n          throw new TypeError(\"Unknown format option provided.\");\n        }\n        format2 = opts.format;\n      }\n      var formatter = formats.formatters[format2];\n      var filter2 = defaults.filter;\n      if (typeof opts.filter === \"function\" || isArray(opts.filter)) {\n        filter2 = opts.filter;\n      }\n      var arrayFormat;\n      if (opts.arrayFormat in arrayPrefixGenerators) {\n        arrayFormat = opts.arrayFormat;\n      } else if (\"indices\" in opts) {\n        arrayFormat = opts.indices ? \"indices\" : \"repeat\";\n      } else {\n        arrayFormat = defaults.arrayFormat;\n      }\n      if (\"commaRoundTrip\" in opts && typeof opts.commaRoundTrip !== \"boolean\") {\n        throw new TypeError(\"`commaRoundTrip` must be a boolean, or absent\");\n      }\n      var allowDots = typeof opts.allowDots === \"undefined\" ? opts.encodeDotInKeys === true ? true : defaults.allowDots : !!opts.allowDots;\n      return {\n        addQueryPrefix: typeof opts.addQueryPrefix === \"boolean\" ? opts.addQueryPrefix : defaults.addQueryPrefix,\n        allowDots,\n        allowEmptyArrays: typeof opts.allowEmptyArrays === \"boolean\" ? !!opts.allowEmptyArrays : defaults.allowEmptyArrays,\n        arrayFormat,\n        charset,\n        charsetSentinel: typeof opts.charsetSentinel === \"boolean\" ? opts.charsetSentinel : defaults.charsetSentinel,\n        commaRoundTrip: !!opts.commaRoundTrip,\n        delimiter: typeof opts.delimiter === \"undefined\" ? defaults.delimiter : opts.delimiter,\n        encode: typeof opts.encode === \"boolean\" ? opts.encode : defaults.encode,\n        encodeDotInKeys: typeof opts.encodeDotInKeys === \"boolean\" ? opts.encodeDotInKeys : defaults.encodeDotInKeys,\n        encoder: typeof opts.encoder === \"function\" ? opts.encoder : defaults.encoder,\n        encodeValuesOnly: typeof opts.encodeValuesOnly === \"boolean\" ? opts.encodeValuesOnly : defaults.encodeValuesOnly,\n        filter: filter2,\n        format: format2,\n        formatter,\n        serializeDate: typeof opts.serializeDate === \"function\" ? opts.serializeDate : defaults.serializeDate,\n        skipNulls: typeof opts.skipNulls === \"boolean\" ? opts.skipNulls : defaults.skipNulls,\n        sort: typeof opts.sort === \"function\" ? opts.sort : null,\n        strictNullHandling: typeof opts.strictNullHandling === \"boolean\" ? opts.strictNullHandling : defaults.strictNullHandling\n      };\n    };\n    module2.exports = function(object, opts) {\n      var obj = object;\n      var options = normalizeStringifyOptions(opts);\n      var objKeys;\n      var filter2;\n      if (typeof options.filter === \"function\") {\n        filter2 = options.filter;\n        obj = filter2(\"\", obj);\n      } else if (isArray(options.filter)) {\n        filter2 = options.filter;\n        objKeys = filter2;\n      }\n      var keys = [];\n      if (typeof obj !== \"object\" || obj === null) {\n        return \"\";\n      }\n      var generateArrayPrefix = arrayPrefixGenerators[options.arrayFormat];\n      var commaRoundTrip = generateArrayPrefix === \"comma\" && options.commaRoundTrip;\n      if (!objKeys) {\n        objKeys = Object.keys(obj);\n      }\n      if (options.sort) {\n        objKeys.sort(options.sort);\n      }\n      var sideChannel = getSideChannel();\n      for (var i = 0; i < objKeys.length; ++i) {\n        var key = objKeys[i];\n        var value = obj[key];\n        if (options.skipNulls && value === null) {\n          continue;\n        }\n        pushToArray(keys, stringify(\n          value,\n          key,\n          generateArrayPrefix,\n          commaRoundTrip,\n          options.allowEmptyArrays,\n          options.strictNullHandling,\n          options.skipNulls,\n          options.encodeDotInKeys,\n          options.encode ? options.encoder : null,\n          options.filter,\n          options.sort,\n          options.allowDots,\n          options.serializeDate,\n          options.format,\n          options.formatter,\n          options.encodeValuesOnly,\n          options.charset,\n          sideChannel\n        ));\n      }\n      var joined = keys.join(options.delimiter);\n      var prefix = options.addQueryPrefix === true ? \"?\" : \"\";\n      if (options.charsetSentinel) {\n        if (options.charset === \"iso-8859-1\") {\n          prefix += \"utf8=%26%2310003%3B&\";\n        } else {\n          prefix += \"utf8=%E2%9C%93&\";\n        }\n      }\n      return joined.length > 0 ? prefix + joined : \"\";\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/qs@6.15.0/node_modules/qs/lib/parse.js\nvar require_parse = __commonJS({\n  \"../../node_modules/.pnpm/qs@6.15.0/node_modules/qs/lib/parse.js\"(exports2, module2) {\n    \"use strict\";\n    var utils = require_utils();\n    var has = Object.prototype.hasOwnProperty;\n    var isArray = Array.isArray;\n    var defaults = {\n      allowDots: false,\n      allowEmptyArrays: false,\n      allowPrototypes: false,\n      allowSparse: false,\n      arrayLimit: 20,\n      charset: \"utf-8\",\n      charsetSentinel: false,\n      comma: false,\n      decodeDotInKeys: false,\n      decoder: utils.decode,\n      delimiter: \"&\",\n      depth: 5,\n      duplicates: \"combine\",\n      ignoreQueryPrefix: false,\n      interpretNumericEntities: false,\n      parameterLimit: 1e3,\n      parseArrays: true,\n      plainObjects: false,\n      strictDepth: false,\n      strictMerge: true,\n      strictNullHandling: false,\n      throwOnLimitExceeded: false\n    };\n    var interpretNumericEntities = function(str) {\n      return str.replace(/&#(\\d+);/g, function($0, numberStr) {\n        return String.fromCharCode(parseInt(numberStr, 10));\n      });\n    };\n    var parseArrayValue = function(val, options, currentArrayLength) {\n      if (val && typeof val === \"string\" && options.comma && val.indexOf(\",\") > -1) {\n        return val.split(\",\");\n      }\n      if (options.throwOnLimitExceeded && currentArrayLength >= options.arrayLimit) {\n        throw new RangeError(\"Array limit exceeded. Only \" + options.arrayLimit + \" element\" + (options.arrayLimit === 1 ? \"\" : \"s\") + \" allowed in an array.\");\n      }\n      return val;\n    };\n    var isoSentinel = \"utf8=%26%2310003%3B\";\n    var charsetSentinel = \"utf8=%E2%9C%93\";\n    var parseValues = function parseQueryStringValues(str, options) {\n      var obj = { __proto__: null };\n      var cleanStr = options.ignoreQueryPrefix ? str.replace(/^\\?/, \"\") : str;\n      cleanStr = cleanStr.replace(/%5B/gi, \"[\").replace(/%5D/gi, \"]\");\n      var limit = options.parameterLimit === Infinity ? void 0 : options.parameterLimit;\n      var parts = cleanStr.split(\n        options.delimiter,\n        options.throwOnLimitExceeded ? limit + 1 : limit\n      );\n      if (options.throwOnLimitExceeded && parts.length > limit) {\n        throw new RangeError(\"Parameter limit exceeded. Only \" + limit + \" parameter\" + (limit === 1 ? \"\" : \"s\") + \" allowed.\");\n      }\n      var skipIndex = -1;\n      var i;\n      var charset = options.charset;\n      if (options.charsetSentinel) {\n        for (i = 0; i < parts.length; ++i) {\n          if (parts[i].indexOf(\"utf8=\") === 0) {\n            if (parts[i] === charsetSentinel) {\n              charset = \"utf-8\";\n            } else if (parts[i] === isoSentinel) {\n              charset = \"iso-8859-1\";\n            }\n            skipIndex = i;\n            i = parts.length;\n          }\n        }\n      }\n      for (i = 0; i < parts.length; ++i) {\n        if (i === skipIndex) {\n          continue;\n        }\n        var part = parts[i];\n        var bracketEqualsPos = part.indexOf(\"]=\");\n        var pos = bracketEqualsPos === -1 ? part.indexOf(\"=\") : bracketEqualsPos + 1;\n        var key;\n        var val;\n        if (pos === -1) {\n          key = options.decoder(part, defaults.decoder, charset, \"key\");\n          val = options.strictNullHandling ? null : \"\";\n        } else {\n          key = options.decoder(part.slice(0, pos), defaults.decoder, charset, \"key\");\n          if (key !== null) {\n            val = utils.maybeMap(\n              parseArrayValue(\n                part.slice(pos + 1),\n                options,\n                isArray(obj[key]) ? obj[key].length : 0\n              ),\n              function(encodedVal) {\n                return options.decoder(encodedVal, defaults.decoder, charset, \"value\");\n              }\n            );\n          }\n        }\n        if (val && options.interpretNumericEntities && charset === \"iso-8859-1\") {\n          val = interpretNumericEntities(String(val));\n        }\n        if (part.indexOf(\"[]=\") > -1) {\n          val = isArray(val) ? [val] : val;\n        }\n        if (options.comma && isArray(val) && val.length > options.arrayLimit) {\n          if (options.throwOnLimitExceeded) {\n            throw new RangeError(\"Array limit exceeded. Only \" + options.arrayLimit + \" element\" + (options.arrayLimit === 1 ? \"\" : \"s\") + \" allowed in an array.\");\n          }\n          val = utils.combine([], val, options.arrayLimit, options.plainObjects);\n        }\n        if (key !== null) {\n          var existing = has.call(obj, key);\n          if (existing && (options.duplicates === \"combine\" || part.indexOf(\"[]=\") > -1)) {\n            obj[key] = utils.combine(\n              obj[key],\n              val,\n              options.arrayLimit,\n              options.plainObjects\n            );\n          } else if (!existing || options.duplicates === \"last\") {\n            obj[key] = val;\n          }\n        }\n      }\n      return obj;\n    };\n    var parseObject = function(chain, val, options, valuesParsed) {\n      var currentArrayLength = 0;\n      if (chain.length > 0 && chain[chain.length - 1] === \"[]\") {\n        var parentKey = chain.slice(0, -1).join(\"\");\n        currentArrayLength = Array.isArray(val) && val[parentKey] ? val[parentKey].length : 0;\n      }\n      var leaf = valuesParsed ? val : parseArrayValue(val, options, currentArrayLength);\n      for (var i = chain.length - 1; i >= 0; --i) {\n        var obj;\n        var root = chain[i];\n        if (root === \"[]\" && options.parseArrays) {\n          if (utils.isOverflow(leaf)) {\n            obj = leaf;\n          } else {\n            obj = options.allowEmptyArrays && (leaf === \"\" || options.strictNullHandling && leaf === null) ? [] : utils.combine(\n              [],\n              leaf,\n              options.arrayLimit,\n              options.plainObjects\n            );\n          }\n        } else {\n          obj = options.plainObjects ? { __proto__: null } : {};\n          var cleanRoot = root.charAt(0) === \"[\" && root.charAt(root.length - 1) === \"]\" ? root.slice(1, -1) : root;\n          var decodedRoot = options.decodeDotInKeys ? cleanRoot.replace(/%2E/g, \".\") : cleanRoot;\n          var index = parseInt(decodedRoot, 10);\n          var isValidArrayIndex = !isNaN(index) && root !== decodedRoot && String(index) === decodedRoot && index >= 0 && options.parseArrays;\n          if (!options.parseArrays && decodedRoot === \"\") {\n            obj = { 0: leaf };\n          } else if (isValidArrayIndex && index < options.arrayLimit) {\n            obj = [];\n            obj[index] = leaf;\n          } else if (isValidArrayIndex && options.throwOnLimitExceeded) {\n            throw new RangeError(\"Array limit exceeded. Only \" + options.arrayLimit + \" element\" + (options.arrayLimit === 1 ? \"\" : \"s\") + \" allowed in an array.\");\n          } else if (isValidArrayIndex) {\n            obj[index] = leaf;\n            utils.markOverflow(obj, index);\n          } else if (decodedRoot !== \"__proto__\") {\n            obj[decodedRoot] = leaf;\n          }\n        }\n        leaf = obj;\n      }\n      return leaf;\n    };\n    var splitKeyIntoSegments = function splitKeyIntoSegments2(givenKey, options) {\n      var key = options.allowDots ? givenKey.replace(/\\.([^.[]+)/g, \"[$1]\") : givenKey;\n      if (options.depth <= 0) {\n        if (!options.plainObjects && has.call(Object.prototype, key)) {\n          if (!options.allowPrototypes) {\n            return;\n          }\n        }\n        return [key];\n      }\n      var brackets = /(\\[[^[\\]]*])/;\n      var child = /(\\[[^[\\]]*])/g;\n      var segment = brackets.exec(key);\n      var parent = segment ? key.slice(0, segment.index) : key;\n      var keys = [];\n      if (parent) {\n        if (!options.plainObjects && has.call(Object.prototype, parent)) {\n          if (!options.allowPrototypes) {\n            return;\n          }\n        }\n        keys[keys.length] = parent;\n      }\n      var i = 0;\n      while ((segment = child.exec(key)) !== null && i < options.depth) {\n        i += 1;\n        var segmentContent = segment[1].slice(1, -1);\n        if (!options.plainObjects && has.call(Object.prototype, segmentContent)) {\n          if (!options.allowPrototypes) {\n            return;\n          }\n        }\n        keys[keys.length] = segment[1];\n      }\n      if (segment) {\n        if (options.strictDepth === true) {\n          throw new RangeError(\"Input depth exceeded depth option of \" + options.depth + \" and strictDepth is true\");\n        }\n        keys[keys.length] = \"[\" + key.slice(segment.index) + \"]\";\n      }\n      return keys;\n    };\n    var parseKeys = function parseQueryStringKeys(givenKey, val, options, valuesParsed) {\n      if (!givenKey) {\n        return;\n      }\n      var keys = splitKeyIntoSegments(givenKey, options);\n      if (!keys) {\n        return;\n      }\n      return parseObject(keys, val, options, valuesParsed);\n    };\n    var normalizeParseOptions = function normalizeParseOptions2(opts) {\n      if (!opts) {\n        return defaults;\n      }\n      if (typeof opts.allowEmptyArrays !== \"undefined\" && typeof opts.allowEmptyArrays !== \"boolean\") {\n        throw new TypeError(\"`allowEmptyArrays` option can only be `true` or `false`, when provided\");\n      }\n      if (typeof opts.decodeDotInKeys !== \"undefined\" && typeof opts.decodeDotInKeys !== \"boolean\") {\n        throw new TypeError(\"`decodeDotInKeys` option can only be `true` or `false`, when provided\");\n      }\n      if (opts.decoder !== null && typeof opts.decoder !== \"undefined\" && typeof opts.decoder !== \"function\") {\n        throw new TypeError(\"Decoder has to be a function.\");\n      }\n      if (typeof opts.charset !== \"undefined\" && opts.charset !== \"utf-8\" && opts.charset !== \"iso-8859-1\") {\n        throw new TypeError(\"The charset option must be either utf-8, iso-8859-1, or undefined\");\n      }\n      if (typeof opts.throwOnLimitExceeded !== \"undefined\" && typeof opts.throwOnLimitExceeded !== \"boolean\") {\n        throw new TypeError(\"`throwOnLimitExceeded` option must be a boolean\");\n      }\n      var charset = typeof opts.charset === \"undefined\" ? defaults.charset : opts.charset;\n      var duplicates = typeof opts.duplicates === \"undefined\" ? defaults.duplicates : opts.duplicates;\n      if (duplicates !== \"combine\" && duplicates !== \"first\" && duplicates !== \"last\") {\n        throw new TypeError(\"The duplicates option must be either combine, first, or last\");\n      }\n      var allowDots = typeof opts.allowDots === \"undefined\" ? opts.decodeDotInKeys === true ? true : defaults.allowDots : !!opts.allowDots;\n      return {\n        allowDots,\n        allowEmptyArrays: typeof opts.allowEmptyArrays === \"boolean\" ? !!opts.allowEmptyArrays : defaults.allowEmptyArrays,\n        allowPrototypes: typeof opts.allowPrototypes === \"boolean\" ? opts.allowPrototypes : defaults.allowPrototypes,\n        allowSparse: typeof opts.allowSparse === \"boolean\" ? opts.allowSparse : defaults.allowSparse,\n        arrayLimit: typeof opts.arrayLimit === \"number\" ? opts.arrayLimit : defaults.arrayLimit,\n        charset,\n        charsetSentinel: typeof opts.charsetSentinel === \"boolean\" ? opts.charsetSentinel : defaults.charsetSentinel,\n        comma: typeof opts.comma === \"boolean\" ? opts.comma : defaults.comma,\n        decodeDotInKeys: typeof opts.decodeDotInKeys === \"boolean\" ? opts.decodeDotInKeys : defaults.decodeDotInKeys,\n        decoder: typeof opts.decoder === \"function\" ? opts.decoder : defaults.decoder,\n        delimiter: typeof opts.delimiter === \"string\" || utils.isRegExp(opts.delimiter) ? opts.delimiter : defaults.delimiter,\n        // eslint-disable-next-line no-implicit-coercion, no-extra-parens\n        depth: typeof opts.depth === \"number\" || opts.depth === false ? +opts.depth : defaults.depth,\n        duplicates,\n        ignoreQueryPrefix: opts.ignoreQueryPrefix === true,\n        interpretNumericEntities: typeof opts.interpretNumericEntities === \"boolean\" ? opts.interpretNumericEntities : defaults.interpretNumericEntities,\n        parameterLimit: typeof opts.parameterLimit === \"number\" ? opts.parameterLimit : defaults.parameterLimit,\n        parseArrays: opts.parseArrays !== false,\n        plainObjects: typeof opts.plainObjects === \"boolean\" ? opts.plainObjects : defaults.plainObjects,\n        strictDepth: typeof opts.strictDepth === \"boolean\" ? !!opts.strictDepth : defaults.strictDepth,\n        strictMerge: typeof opts.strictMerge === \"boolean\" ? !!opts.strictMerge : defaults.strictMerge,\n        strictNullHandling: typeof opts.strictNullHandling === \"boolean\" ? opts.strictNullHandling : defaults.strictNullHandling,\n        throwOnLimitExceeded: typeof opts.throwOnLimitExceeded === \"boolean\" ? opts.throwOnLimitExceeded : false\n      };\n    };\n    module2.exports = function(str, opts) {\n      var options = normalizeParseOptions(opts);\n      if (str === \"\" || str === null || typeof str === \"undefined\") {\n        return options.plainObjects ? { __proto__: null } : {};\n      }\n      var tempObj = typeof str === \"string\" ? parseValues(str, options) : str;\n      var obj = options.plainObjects ? { __proto__: null } : {};\n      var keys = Object.keys(tempObj);\n      for (var i = 0; i < keys.length; ++i) {\n        var key = keys[i];\n        var newObj = parseKeys(key, tempObj[key], options, typeof str === \"string\");\n        obj = utils.merge(obj, newObj, options);\n      }\n      if (options.allowSparse === true) {\n        return obj;\n      }\n      return utils.compact(obj);\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/qs@6.15.0/node_modules/qs/lib/index.js\nvar require_lib = __commonJS({\n  \"../../node_modules/.pnpm/qs@6.15.0/node_modules/qs/lib/index.js\"(exports2, module2) {\n    \"use strict\";\n    var stringify = require_stringify();\n    var parse2 = require_parse();\n    var formats = require_formats();\n    module2.exports = {\n      formats,\n      parse: parse2,\n      stringify\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/node-stdlib-browser@1.3.1/node_modules/node-stdlib-browser/esm/proxy/url.js\nvar url_exports = {};\n__export(url_exports, {\n  URL: () => URL,\n  URLSearchParams: () => URLSearchParams,\n  Url: () => UrlImport,\n  default: () => api,\n  domainToASCII: () => domainToASCII,\n  domainToUnicode: () => domainToUnicode,\n  fileURLToPath: () => fileURLToPath,\n  format: () => formatImportWithOverloads,\n  parse: () => parseImport,\n  pathToFileURL: () => pathToFileURL,\n  resolve: () => resolveImport,\n  resolveObject: () => resolveObject\n});\nfunction Url() {\n  this.protocol = null;\n  this.slashes = null;\n  this.auth = null;\n  this.host = null;\n  this.port = null;\n  this.hostname = null;\n  this.hash = null;\n  this.search = null;\n  this.query = null;\n  this.pathname = null;\n  this.path = null;\n  this.href = null;\n}\nfunction urlParse(url, parseQueryString, slashesDenoteHost) {\n  if (url && typeof url === \"object\" && url instanceof Url) {\n    return url;\n  }\n  var u = new Url();\n  u.parse(url, parseQueryString, slashesDenoteHost);\n  return u;\n}\nfunction urlFormat(obj) {\n  if (typeof obj === \"string\") {\n    obj = urlParse(obj);\n  }\n  if (!(obj instanceof Url)) {\n    return Url.prototype.format.call(obj);\n  }\n  return obj.format();\n}\nfunction urlResolve(source, relative) {\n  return urlParse(source, false, true).resolve(relative);\n}\nfunction urlResolveObject(source, relative) {\n  if (!source) {\n    return relative;\n  }\n  return urlParse(source, false, true).resolveObject(relative);\n}\nfunction normalizeArray(parts, allowAboveRoot) {\n  var up = 0;\n  for (var i = parts.length - 1; i >= 0; i--) {\n    var last = parts[i];\n    if (last === \".\") {\n      parts.splice(i, 1);\n    } else if (last === \"..\") {\n      parts.splice(i, 1);\n      up++;\n    } else if (up) {\n      parts.splice(i, 1);\n      up--;\n    }\n  }\n  if (allowAboveRoot) {\n    for (; up--; up) {\n      parts.unshift(\"..\");\n    }\n  }\n  return parts;\n}\nfunction resolve() {\n  var resolvedPath = \"\", resolvedAbsolute = false;\n  for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n    var path2 = i >= 0 ? arguments[i] : \"/\";\n    if (typeof path2 !== \"string\") {\n      throw new TypeError(\"Arguments to path.resolve must be strings\");\n    } else if (!path2) {\n      continue;\n    }\n    resolvedPath = path2 + \"/\" + resolvedPath;\n    resolvedAbsolute = path2.charAt(0) === \"/\";\n  }\n  resolvedPath = normalizeArray(filter(resolvedPath.split(\"/\"), function(p) {\n    return !!p;\n  }), !resolvedAbsolute).join(\"/\");\n  return (resolvedAbsolute ? \"/\" : \"\") + resolvedPath || \".\";\n}\nfunction filter(xs, f) {\n  if (xs.filter) return xs.filter(f);\n  var res = [];\n  for (var i = 0; i < xs.length; i++) {\n    if (f(xs[i], i, xs)) res.push(xs[i]);\n  }\n  return res;\n}\nfunction isURLInstance(instance) {\n  var resolved2 = (\n    /** @type {URL|null} */\n    instance != null ? instance : null\n  );\n  return Boolean(resolved2 !== null && (resolved2 == null ? void 0 : resolved2.href) && (resolved2 == null ? void 0 : resolved2.origin));\n}\nfunction getPathFromURLPosix(url) {\n  if (url.hostname !== \"\") {\n    throw new TypeError('File URL host must be \"localhost\" or empty on browser');\n  }\n  var pathname = url.pathname;\n  for (var n = 0; n < pathname.length; n++) {\n    if (pathname[n] === \"%\") {\n      var third = pathname.codePointAt(n + 2) | 32;\n      if (pathname[n + 1] === \"2\" && third === 102) {\n        throw new TypeError(\"File URL path must not include encoded / characters\");\n      }\n    }\n  }\n  return decodeURIComponent(pathname);\n}\nfunction encodePathChars(filepath) {\n  if (filepath.includes(\"%\")) {\n    filepath = filepath.replace(percentRegEx, \"%25\");\n  }\n  if (filepath.includes(\"\\\\\")) {\n    filepath = filepath.replace(backslashRegEx, \"%5C\");\n  }\n  if (filepath.includes(\"\\n\")) {\n    filepath = filepath.replace(newlineRegEx, \"%0A\");\n  }\n  if (filepath.includes(\"\\r\")) {\n    filepath = filepath.replace(carriageReturnRegEx, \"%0D\");\n  }\n  if (filepath.includes(\"\t\")) {\n    filepath = filepath.replace(tabRegEx, \"%09\");\n  }\n  return filepath;\n}\nvar import_punycode, import_qs, punycode, protocolPattern, portPattern, simplePathPattern, delims, unwise, autoEscape, nonHostChars, hostEndingChars, hostnameMaxLen, hostnamePartPattern, hostnamePartStart, unsafeProtocol, hostlessProtocol, slashedProtocol, querystring, parse, resolve$1, resolveObject, format, Url_1, _globalThis, formatImport, parseImport, resolveImport, UrlImport, URL, URLSearchParams, percentRegEx, backslashRegEx, newlineRegEx, carriageReturnRegEx, tabRegEx, CHAR_FORWARD_SLASH, domainToASCII, domainToUnicode, pathToFileURL, fileURLToPath, formatImportWithOverloads, api;\nvar init_url = __esm({\n  \"../../node_modules/.pnpm/node-stdlib-browser@1.3.1/node_modules/node-stdlib-browser/esm/proxy/url.js\"() {\n    import_punycode = __toESM(require_punycode(), 1);\n    import_qs = __toESM(require_lib(), 1);\n    punycode = import_punycode.default;\n    protocolPattern = /^([a-z0-9.+-]+:)/i;\n    portPattern = /:[0-9]*$/;\n    simplePathPattern = /^(\\/\\/?(?!\\/)[^?\\s]*)(\\?[^\\s]*)?$/;\n    delims = [\n      \"<\",\n      \">\",\n      '\"',\n      \"`\",\n      \" \",\n      \"\\r\",\n      \"\\n\",\n      \"\t\"\n    ];\n    unwise = [\n      \"{\",\n      \"}\",\n      \"|\",\n      \"\\\\\",\n      \"^\",\n      \"`\"\n    ].concat(delims);\n    autoEscape = [\"'\"].concat(unwise);\n    nonHostChars = [\n      \"%\",\n      \"/\",\n      \"?\",\n      \";\",\n      \"#\"\n    ].concat(autoEscape);\n    hostEndingChars = [\n      \"/\",\n      \"?\",\n      \"#\"\n    ];\n    hostnameMaxLen = 255;\n    hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/;\n    hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/;\n    unsafeProtocol = {\n      javascript: true,\n      \"javascript:\": true\n    };\n    hostlessProtocol = {\n      javascript: true,\n      \"javascript:\": true\n    };\n    slashedProtocol = {\n      http: true,\n      https: true,\n      ftp: true,\n      gopher: true,\n      file: true,\n      \"http:\": true,\n      \"https:\": true,\n      \"ftp:\": true,\n      \"gopher:\": true,\n      \"file:\": true\n    };\n    querystring = import_qs.default;\n    Url.prototype.parse = function(url, parseQueryString, slashesDenoteHost) {\n      if (typeof url !== \"string\") {\n        throw new TypeError(\"Parameter 'url' must be a string, not \" + typeof url);\n      }\n      var queryIndex = url.indexOf(\"?\"), splitter = queryIndex !== -1 && queryIndex < url.indexOf(\"#\") ? \"?\" : \"#\", uSplit = url.split(splitter), slashRegex = /\\\\/g;\n      uSplit[0] = uSplit[0].replace(slashRegex, \"/\");\n      url = uSplit.join(splitter);\n      var rest = url;\n      rest = rest.trim();\n      if (!slashesDenoteHost && url.split(\"#\").length === 1) {\n        var simplePath = simplePathPattern.exec(rest);\n        if (simplePath) {\n          this.path = rest;\n          this.href = rest;\n          this.pathname = simplePath[1];\n          if (simplePath[2]) {\n            this.search = simplePath[2];\n            if (parseQueryString) {\n              this.query = querystring.parse(this.search.substr(1));\n            } else {\n              this.query = this.search.substr(1);\n            }\n          } else if (parseQueryString) {\n            this.search = \"\";\n            this.query = {};\n          }\n          return this;\n        }\n      }\n      var proto = protocolPattern.exec(rest);\n      if (proto) {\n        proto = proto[0];\n        var lowerProto = proto.toLowerCase();\n        this.protocol = lowerProto;\n        rest = rest.substr(proto.length);\n      }\n      if (slashesDenoteHost || proto || rest.match(/^\\/\\/[^@/]+@[^@/]+/)) {\n        var slashes = rest.substr(0, 2) === \"//\";\n        if (slashes && !(proto && hostlessProtocol[proto])) {\n          rest = rest.substr(2);\n          this.slashes = true;\n        }\n      }\n      if (!hostlessProtocol[proto] && (slashes || proto && !slashedProtocol[proto])) {\n        var hostEnd = -1;\n        for (var i = 0; i < hostEndingChars.length; i++) {\n          var hec = rest.indexOf(hostEndingChars[i]);\n          if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) {\n            hostEnd = hec;\n          }\n        }\n        var auth, atSign;\n        if (hostEnd === -1) {\n          atSign = rest.lastIndexOf(\"@\");\n        } else {\n          atSign = rest.lastIndexOf(\"@\", hostEnd);\n        }\n        if (atSign !== -1) {\n          auth = rest.slice(0, atSign);\n          rest = rest.slice(atSign + 1);\n          this.auth = decodeURIComponent(auth);\n        }\n        hostEnd = -1;\n        for (var i = 0; i < nonHostChars.length; i++) {\n          var hec = rest.indexOf(nonHostChars[i]);\n          if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) {\n            hostEnd = hec;\n          }\n        }\n        if (hostEnd === -1) {\n          hostEnd = rest.length;\n        }\n        this.host = rest.slice(0, hostEnd);\n        rest = rest.slice(hostEnd);\n        this.parseHost();\n        this.hostname = this.hostname || \"\";\n        var ipv6Hostname = this.hostname[0] === \"[\" && this.hostname[this.hostname.length - 1] === \"]\";\n        if (!ipv6Hostname) {\n          var hostparts = this.hostname.split(/\\./);\n          for (var i = 0, l = hostparts.length; i < l; i++) {\n            var part = hostparts[i];\n            if (!part) {\n              continue;\n            }\n            if (!part.match(hostnamePartPattern)) {\n              var newpart = \"\";\n              for (var j = 0, k = part.length; j < k; j++) {\n                if (part.charCodeAt(j) > 127) {\n                  newpart += \"x\";\n                } else {\n                  newpart += part[j];\n                }\n              }\n              if (!newpart.match(hostnamePartPattern)) {\n                var validParts = hostparts.slice(0, i);\n                var notHost = hostparts.slice(i + 1);\n                var bit = part.match(hostnamePartStart);\n                if (bit) {\n                  validParts.push(bit[1]);\n                  notHost.unshift(bit[2]);\n                }\n                if (notHost.length) {\n                  rest = \"/\" + notHost.join(\".\") + rest;\n                }\n                this.hostname = validParts.join(\".\");\n                break;\n              }\n            }\n          }\n        }\n        if (this.hostname.length > hostnameMaxLen) {\n          this.hostname = \"\";\n        } else {\n          this.hostname = this.hostname.toLowerCase();\n        }\n        if (!ipv6Hostname) {\n          this.hostname = punycode.toASCII(this.hostname);\n        }\n        var p = this.port ? \":\" + this.port : \"\";\n        var h = this.hostname || \"\";\n        this.host = h + p;\n        this.href += this.host;\n        if (ipv6Hostname) {\n          this.hostname = this.hostname.substr(1, this.hostname.length - 2);\n          if (rest[0] !== \"/\") {\n            rest = \"/\" + rest;\n          }\n        }\n      }\n      if (!unsafeProtocol[lowerProto]) {\n        for (var i = 0, l = autoEscape.length; i < l; i++) {\n          var ae = autoEscape[i];\n          if (rest.indexOf(ae) === -1) {\n            continue;\n          }\n          var esc = encodeURIComponent(ae);\n          if (esc === ae) {\n            esc = escape(ae);\n          }\n          rest = rest.split(ae).join(esc);\n        }\n      }\n      var hash = rest.indexOf(\"#\");\n      if (hash !== -1) {\n        this.hash = rest.substr(hash);\n        rest = rest.slice(0, hash);\n      }\n      var qm = rest.indexOf(\"?\");\n      if (qm !== -1) {\n        this.search = rest.substr(qm);\n        this.query = rest.substr(qm + 1);\n        if (parseQueryString) {\n          this.query = querystring.parse(this.query);\n        }\n        rest = rest.slice(0, qm);\n      } else if (parseQueryString) {\n        this.search = \"\";\n        this.query = {};\n      }\n      if (rest) {\n        this.pathname = rest;\n      }\n      if (slashedProtocol[lowerProto] && this.hostname && !this.pathname) {\n        this.pathname = \"/\";\n      }\n      if (this.pathname || this.search) {\n        var p = this.pathname || \"\";\n        var s = this.search || \"\";\n        this.path = p + s;\n      }\n      this.href = this.format();\n      return this;\n    };\n    Url.prototype.format = function() {\n      var auth = this.auth || \"\";\n      if (auth) {\n        auth = encodeURIComponent(auth);\n        auth = auth.replace(/%3A/i, \":\");\n        auth += \"@\";\n      }\n      var protocol = this.protocol || \"\", pathname = this.pathname || \"\", hash = this.hash || \"\", host = false, query = \"\";\n      if (this.host) {\n        host = auth + this.host;\n      } else if (this.hostname) {\n        host = auth + (this.hostname.indexOf(\":\") === -1 ? this.hostname : \"[\" + this.hostname + \"]\");\n        if (this.port) {\n          host += \":\" + this.port;\n        }\n      }\n      if (this.query && typeof this.query === \"object\" && Object.keys(this.query).length) {\n        query = querystring.stringify(this.query, {\n          arrayFormat: \"repeat\",\n          addQueryPrefix: false\n        });\n      }\n      var search = this.search || query && \"?\" + query || \"\";\n      if (protocol && protocol.substr(-1) !== \":\") {\n        protocol += \":\";\n      }\n      if (this.slashes || (!protocol || slashedProtocol[protocol]) && host !== false) {\n        host = \"//\" + (host || \"\");\n        if (pathname && pathname.charAt(0) !== \"/\") {\n          pathname = \"/\" + pathname;\n        }\n      } else if (!host) {\n        host = \"\";\n      }\n      if (hash && hash.charAt(0) !== \"#\") {\n        hash = \"#\" + hash;\n      }\n      if (search && search.charAt(0) !== \"?\") {\n        search = \"?\" + search;\n      }\n      pathname = pathname.replace(/[?#]/g, function(match) {\n        return encodeURIComponent(match);\n      });\n      search = search.replace(\"#\", \"%23\");\n      return protocol + host + pathname + search + hash;\n    };\n    Url.prototype.resolve = function(relative) {\n      return this.resolveObject(urlParse(relative, false, true)).format();\n    };\n    Url.prototype.resolveObject = function(relative) {\n      if (typeof relative === \"string\") {\n        var rel = new Url();\n        rel.parse(relative, false, true);\n        relative = rel;\n      }\n      var result = new Url();\n      var tkeys = Object.keys(this);\n      for (var tk = 0; tk < tkeys.length; tk++) {\n        var tkey = tkeys[tk];\n        result[tkey] = this[tkey];\n      }\n      result.hash = relative.hash;\n      if (relative.href === \"\") {\n        result.href = result.format();\n        return result;\n      }\n      if (relative.slashes && !relative.protocol) {\n        var rkeys = Object.keys(relative);\n        for (var rk = 0; rk < rkeys.length; rk++) {\n          var rkey = rkeys[rk];\n          if (rkey !== \"protocol\") {\n            result[rkey] = relative[rkey];\n          }\n        }\n        if (slashedProtocol[result.protocol] && result.hostname && !result.pathname) {\n          result.pathname = \"/\";\n          result.path = result.pathname;\n        }\n        result.href = result.format();\n        return result;\n      }\n      if (relative.protocol && relative.protocol !== result.protocol) {\n        if (!slashedProtocol[relative.protocol]) {\n          var keys = Object.keys(relative);\n          for (var v = 0; v < keys.length; v++) {\n            var k = keys[v];\n            result[k] = relative[k];\n          }\n          result.href = result.format();\n          return result;\n        }\n        result.protocol = relative.protocol;\n        if (!relative.host && !hostlessProtocol[relative.protocol]) {\n          var relPath = (relative.pathname || \"\").split(\"/\");\n          while (relPath.length && !(relative.host = relPath.shift())) {\n          }\n          if (!relative.host) {\n            relative.host = \"\";\n          }\n          if (!relative.hostname) {\n            relative.hostname = \"\";\n          }\n          if (relPath[0] !== \"\") {\n            relPath.unshift(\"\");\n          }\n          if (relPath.length < 2) {\n            relPath.unshift(\"\");\n          }\n          result.pathname = relPath.join(\"/\");\n        } else {\n          result.pathname = relative.pathname;\n        }\n        result.search = relative.search;\n        result.query = relative.query;\n        result.host = relative.host || \"\";\n        result.auth = relative.auth;\n        result.hostname = relative.hostname || relative.host;\n        result.port = relative.port;\n        if (result.pathname || result.search) {\n          var p = result.pathname || \"\";\n          var s = result.search || \"\";\n          result.path = p + s;\n        }\n        result.slashes = result.slashes || relative.slashes;\n        result.href = result.format();\n        return result;\n      }\n      var isSourceAbs = result.pathname && result.pathname.charAt(0) === \"/\", isRelAbs = relative.host || relative.pathname && relative.pathname.charAt(0) === \"/\", mustEndAbs = isRelAbs || isSourceAbs || result.host && relative.pathname, removeAllDots = mustEndAbs, srcPath = result.pathname && result.pathname.split(\"/\") || [], relPath = relative.pathname && relative.pathname.split(\"/\") || [], psychotic = result.protocol && !slashedProtocol[result.protocol];\n      if (psychotic) {\n        result.hostname = \"\";\n        result.port = null;\n        if (result.host) {\n          if (srcPath[0] === \"\") {\n            srcPath[0] = result.host;\n          } else {\n            srcPath.unshift(result.host);\n          }\n        }\n        result.host = \"\";\n        if (relative.protocol) {\n          relative.hostname = null;\n          relative.port = null;\n          if (relative.host) {\n            if (relPath[0] === \"\") {\n              relPath[0] = relative.host;\n            } else {\n              relPath.unshift(relative.host);\n            }\n          }\n          relative.host = null;\n        }\n        mustEndAbs = mustEndAbs && (relPath[0] === \"\" || srcPath[0] === \"\");\n      }\n      if (isRelAbs) {\n        result.host = relative.host || relative.host === \"\" ? relative.host : result.host;\n        result.hostname = relative.hostname || relative.hostname === \"\" ? relative.hostname : result.hostname;\n        result.search = relative.search;\n        result.query = relative.query;\n        srcPath = relPath;\n      } else if (relPath.length) {\n        if (!srcPath) {\n          srcPath = [];\n        }\n        srcPath.pop();\n        srcPath = srcPath.concat(relPath);\n        result.search = relative.search;\n        result.query = relative.query;\n      } else if (relative.search != null) {\n        if (psychotic) {\n          result.host = srcPath.shift();\n          result.hostname = result.host;\n          var authInHost = result.host && result.host.indexOf(\"@\") > 0 ? result.host.split(\"@\") : false;\n          if (authInHost) {\n            result.auth = authInHost.shift();\n            result.hostname = authInHost.shift();\n            result.host = result.hostname;\n          }\n        }\n        result.search = relative.search;\n        result.query = relative.query;\n        if (result.pathname !== null || result.search !== null) {\n          result.path = (result.pathname ? result.pathname : \"\") + (result.search ? result.search : \"\");\n        }\n        result.href = result.format();\n        return result;\n      }\n      if (!srcPath.length) {\n        result.pathname = null;\n        if (result.search) {\n          result.path = \"/\" + result.search;\n        } else {\n          result.path = null;\n        }\n        result.href = result.format();\n        return result;\n      }\n      var last = srcPath.slice(-1)[0];\n      var hasTrailingSlash = (result.host || relative.host || srcPath.length > 1) && (last === \".\" || last === \"..\") || last === \"\";\n      var up = 0;\n      for (var i = srcPath.length; i >= 0; i--) {\n        last = srcPath[i];\n        if (last === \".\") {\n          srcPath.splice(i, 1);\n        } else if (last === \"..\") {\n          srcPath.splice(i, 1);\n          up++;\n        } else if (up) {\n          srcPath.splice(i, 1);\n          up--;\n        }\n      }\n      if (!mustEndAbs && !removeAllDots) {\n        for (; up--; up) {\n          srcPath.unshift(\"..\");\n        }\n      }\n      if (mustEndAbs && srcPath[0] !== \"\" && (!srcPath[0] || srcPath[0].charAt(0) !== \"/\")) {\n        srcPath.unshift(\"\");\n      }\n      if (hasTrailingSlash && srcPath.join(\"/\").substr(-1) !== \"/\") {\n        srcPath.push(\"\");\n      }\n      var isAbsolute = srcPath[0] === \"\" || srcPath[0] && srcPath[0].charAt(0) === \"/\";\n      if (psychotic) {\n        result.hostname = isAbsolute ? \"\" : srcPath.length ? srcPath.shift() : \"\";\n        result.host = result.hostname;\n        var authInHost = result.host && result.host.indexOf(\"@\") > 0 ? result.host.split(\"@\") : false;\n        if (authInHost) {\n          result.auth = authInHost.shift();\n          result.hostname = authInHost.shift();\n          result.host = result.hostname;\n        }\n      }\n      mustEndAbs = mustEndAbs || result.host && srcPath.length;\n      if (mustEndAbs && !isAbsolute) {\n        srcPath.unshift(\"\");\n      }\n      if (srcPath.length > 0) {\n        result.pathname = srcPath.join(\"/\");\n      } else {\n        result.pathname = null;\n        result.path = null;\n      }\n      if (result.pathname !== null || result.search !== null) {\n        result.path = (result.pathname ? result.pathname : \"\") + (result.search ? result.search : \"\");\n      }\n      result.auth = relative.auth || result.auth;\n      result.slashes = result.slashes || relative.slashes;\n      result.href = result.format();\n      return result;\n    };\n    Url.prototype.parseHost = function() {\n      var host = this.host;\n      var port = portPattern.exec(host);\n      if (port) {\n        port = port[0];\n        if (port !== \":\") {\n          this.port = port.substr(1);\n        }\n        host = host.substr(0, host.length - port.length);\n      }\n      if (host) {\n        this.hostname = host;\n      }\n    };\n    parse = urlParse;\n    resolve$1 = urlResolve;\n    resolveObject = urlResolveObject;\n    format = urlFormat;\n    Url_1 = Url;\n    _globalThis = (function(Object2) {\n      function get() {\n        var _global2 = this || self;\n        delete Object2.prototype.__magic__;\n        return _global2;\n      }\n      if (typeof globalThis === \"object\") {\n        return globalThis;\n      }\n      if (this) {\n        return get();\n      } else {\n        Object2.defineProperty(Object2.prototype, \"__magic__\", {\n          configurable: true,\n          get\n        });\n        var _global = __magic__;\n        return _global;\n      }\n    })(Object);\n    formatImport = /** @type {formatImport}*/\n    format;\n    parseImport = /** @type {parseImport}*/\n    parse;\n    resolveImport = /** @type {resolveImport}*/\n    resolve$1;\n    UrlImport = /** @type {UrlImport}*/\n    Url_1;\n    URL = _globalThis.URL;\n    URLSearchParams = _globalThis.URLSearchParams;\n    percentRegEx = /%/g;\n    backslashRegEx = /\\\\/g;\n    newlineRegEx = /\\n/g;\n    carriageReturnRegEx = /\\r/g;\n    tabRegEx = /\\t/g;\n    CHAR_FORWARD_SLASH = 47;\n    domainToASCII = /**\n     * @type {domainToASCII}\n     */\n    function domainToASCII2(domain) {\n      if (typeof domain === \"undefined\") {\n        throw new TypeError('The \"domain\" argument must be specified');\n      }\n      return new URL(\"http://\" + domain).hostname;\n    };\n    domainToUnicode = /**\n     * @type {domainToUnicode}\n     */\n    function domainToUnicode2(domain) {\n      if (typeof domain === \"undefined\") {\n        throw new TypeError('The \"domain\" argument must be specified');\n      }\n      return new URL(\"http://\" + domain).hostname;\n    };\n    pathToFileURL = /**\n     * @type {(url: string) => URL}\n     */\n    function pathToFileURL2(filepath) {\n      var outURL = new URL(\"file://\");\n      var resolved2 = resolve(filepath);\n      var filePathLast = filepath.charCodeAt(filepath.length - 1);\n      if (filePathLast === CHAR_FORWARD_SLASH && resolved2[resolved2.length - 1] !== \"/\") {\n        resolved2 += \"/\";\n      }\n      outURL.pathname = encodePathChars(resolved2);\n      return outURL;\n    };\n    fileURLToPath = /**\n     * @type {fileURLToPath & ((path: string | URL) => string)}\n     */\n    function fileURLToPath2(path2) {\n      if (!isURLInstance(path2) && typeof path2 !== \"string\") {\n        throw new TypeError('The \"path\" argument must be of type string or an instance of URL. Received type ' + typeof path2 + \" (\" + path2 + \")\");\n      }\n      var resolved2 = new URL(path2);\n      if (resolved2.protocol !== \"file:\") {\n        throw new TypeError(\"The URL must be of scheme file\");\n      }\n      return getPathFromURLPosix(resolved2);\n    };\n    formatImportWithOverloads = /**\n     * @type {(\n     *   ((urlObject: URL, options?: URLFormatOptions) => string) &\n     *   ((urlObject: UrlObject | string, options?: never) => string)\n     * )}\n     */\n    function formatImportWithOverloads2(urlObject, options) {\n      var _options$auth, _options$fragment, _options$search, _options$unicode;\n      if (options === void 0) {\n        options = {};\n      }\n      if (!(urlObject instanceof URL)) {\n        return formatImport(urlObject);\n      }\n      if (typeof options !== \"object\" || options === null) {\n        throw new TypeError('The \"options\" argument must be of type object.');\n      }\n      var auth = (_options$auth = options.auth) != null ? _options$auth : true;\n      var fragment = (_options$fragment = options.fragment) != null ? _options$fragment : true;\n      var search = (_options$search = options.search) != null ? _options$search : true;\n      (_options$unicode = options.unicode) != null ? _options$unicode : false;\n      var parsed = new URL(urlObject.toString());\n      if (!auth) {\n        parsed.username = \"\";\n        parsed.password = \"\";\n      }\n      if (!fragment) {\n        parsed.hash = \"\";\n      }\n      if (!search) {\n        parsed.search = \"\";\n      }\n      return parsed.toString();\n    };\n    api = {\n      format: formatImportWithOverloads,\n      parse: parseImport,\n      resolve: resolveImport,\n      resolveObject,\n      Url: UrlImport,\n      URL,\n      URLSearchParams,\n      domainToASCII,\n      domainToUnicode,\n      pathToFileURL,\n      fileURLToPath\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/path-browserify@1.0.1/node_modules/path-browserify/index.js\nvar require_path_browserify = __commonJS({\n  \"../../node_modules/.pnpm/path-browserify@1.0.1/node_modules/path-browserify/index.js\"(exports2, module2) {\n    \"use strict\";\n    function assertPath(path2) {\n      if (typeof path2 !== \"string\") {\n        throw new TypeError(\"Path must be a string. Received \" + JSON.stringify(path2));\n      }\n    }\n    function normalizeStringPosix(path2, allowAboveRoot) {\n      var res = \"\";\n      var lastSegmentLength = 0;\n      var lastSlash = -1;\n      var dots = 0;\n      var code;\n      for (var i = 0; i <= path2.length; ++i) {\n        if (i < path2.length)\n          code = path2.charCodeAt(i);\n        else if (code === 47)\n          break;\n        else\n          code = 47;\n        if (code === 47) {\n          if (lastSlash === i - 1 || dots === 1) {\n          } else if (lastSlash !== i - 1 && dots === 2) {\n            if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 || res.charCodeAt(res.length - 2) !== 46) {\n              if (res.length > 2) {\n                var lastSlashIndex = res.lastIndexOf(\"/\");\n                if (lastSlashIndex !== res.length - 1) {\n                  if (lastSlashIndex === -1) {\n                    res = \"\";\n                    lastSegmentLength = 0;\n                  } else {\n                    res = res.slice(0, lastSlashIndex);\n                    lastSegmentLength = res.length - 1 - res.lastIndexOf(\"/\");\n                  }\n                  lastSlash = i;\n                  dots = 0;\n                  continue;\n                }\n              } else if (res.length === 2 || res.length === 1) {\n                res = \"\";\n                lastSegmentLength = 0;\n                lastSlash = i;\n                dots = 0;\n                continue;\n              }\n            }\n            if (allowAboveRoot) {\n              if (res.length > 0)\n                res += \"/..\";\n              else\n                res = \"..\";\n              lastSegmentLength = 2;\n            }\n          } else {\n            if (res.length > 0)\n              res += \"/\" + path2.slice(lastSlash + 1, i);\n            else\n              res = path2.slice(lastSlash + 1, i);\n            lastSegmentLength = i - lastSlash - 1;\n          }\n          lastSlash = i;\n          dots = 0;\n        } else if (code === 46 && dots !== -1) {\n          ++dots;\n        } else {\n          dots = -1;\n        }\n      }\n      return res;\n    }\n    function _format(sep, pathObject) {\n      var dir = pathObject.dir || pathObject.root;\n      var base = pathObject.base || (pathObject.name || \"\") + (pathObject.ext || \"\");\n      if (!dir) {\n        return base;\n      }\n      if (dir === pathObject.root) {\n        return dir + base;\n      }\n      return dir + sep + base;\n    }\n    var posix = {\n      // path.resolve([from ...], to)\n      resolve: function resolve2() {\n        var resolvedPath = \"\";\n        var resolvedAbsolute = false;\n        var cwd;\n        for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n          var path2;\n          if (i >= 0)\n            path2 = arguments[i];\n          else {\n            if (cwd === void 0)\n              cwd = process.cwd();\n            path2 = cwd;\n          }\n          assertPath(path2);\n          if (path2.length === 0) {\n            continue;\n          }\n          resolvedPath = path2 + \"/\" + resolvedPath;\n          resolvedAbsolute = path2.charCodeAt(0) === 47;\n        }\n        resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);\n        if (resolvedAbsolute) {\n          if (resolvedPath.length > 0)\n            return \"/\" + resolvedPath;\n          else\n            return \"/\";\n        } else if (resolvedPath.length > 0) {\n          return resolvedPath;\n        } else {\n          return \".\";\n        }\n      },\n      normalize: function normalize(path2) {\n        assertPath(path2);\n        if (path2.length === 0) return \".\";\n        var isAbsolute = path2.charCodeAt(0) === 47;\n        var trailingSeparator = path2.charCodeAt(path2.length - 1) === 47;\n        path2 = normalizeStringPosix(path2, !isAbsolute);\n        if (path2.length === 0 && !isAbsolute) path2 = \".\";\n        if (path2.length > 0 && trailingSeparator) path2 += \"/\";\n        if (isAbsolute) return \"/\" + path2;\n        return path2;\n      },\n      isAbsolute: function isAbsolute(path2) {\n        assertPath(path2);\n        return path2.length > 0 && path2.charCodeAt(0) === 47;\n      },\n      join: function join() {\n        if (arguments.length === 0)\n          return \".\";\n        var joined;\n        for (var i = 0; i < arguments.length; ++i) {\n          var arg = arguments[i];\n          assertPath(arg);\n          if (arg.length > 0) {\n            if (joined === void 0)\n              joined = arg;\n            else\n              joined += \"/\" + arg;\n          }\n        }\n        if (joined === void 0)\n          return \".\";\n        return posix.normalize(joined);\n      },\n      relative: function relative(from, to) {\n        assertPath(from);\n        assertPath(to);\n        if (from === to) return \"\";\n        from = posix.resolve(from);\n        to = posix.resolve(to);\n        if (from === to) return \"\";\n        var fromStart = 1;\n        for (; fromStart < from.length; ++fromStart) {\n          if (from.charCodeAt(fromStart) !== 47)\n            break;\n        }\n        var fromEnd = from.length;\n        var fromLen = fromEnd - fromStart;\n        var toStart = 1;\n        for (; toStart < to.length; ++toStart) {\n          if (to.charCodeAt(toStart) !== 47)\n            break;\n        }\n        var toEnd = to.length;\n        var toLen = toEnd - toStart;\n        var length = fromLen < toLen ? fromLen : toLen;\n        var lastCommonSep = -1;\n        var i = 0;\n        for (; i <= length; ++i) {\n          if (i === length) {\n            if (toLen > length) {\n              if (to.charCodeAt(toStart + i) === 47) {\n                return to.slice(toStart + i + 1);\n              } else if (i === 0) {\n                return to.slice(toStart + i);\n              }\n            } else if (fromLen > length) {\n              if (from.charCodeAt(fromStart + i) === 47) {\n                lastCommonSep = i;\n              } else if (i === 0) {\n                lastCommonSep = 0;\n              }\n            }\n            break;\n          }\n          var fromCode = from.charCodeAt(fromStart + i);\n          var toCode = to.charCodeAt(toStart + i);\n          if (fromCode !== toCode)\n            break;\n          else if (fromCode === 47)\n            lastCommonSep = i;\n        }\n        var out = \"\";\n        for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {\n          if (i === fromEnd || from.charCodeAt(i) === 47) {\n            if (out.length === 0)\n              out += \"..\";\n            else\n              out += \"/..\";\n          }\n        }\n        if (out.length > 0)\n          return out + to.slice(toStart + lastCommonSep);\n        else {\n          toStart += lastCommonSep;\n          if (to.charCodeAt(toStart) === 47)\n            ++toStart;\n          return to.slice(toStart);\n        }\n      },\n      _makeLong: function _makeLong(path2) {\n        return path2;\n      },\n      dirname: function dirname(path2) {\n        assertPath(path2);\n        if (path2.length === 0) return \".\";\n        var code = path2.charCodeAt(0);\n        var hasRoot = code === 47;\n        var end = -1;\n        var matchedSlash = true;\n        for (var i = path2.length - 1; i >= 1; --i) {\n          code = path2.charCodeAt(i);\n          if (code === 47) {\n            if (!matchedSlash) {\n              end = i;\n              break;\n            }\n          } else {\n            matchedSlash = false;\n          }\n        }\n        if (end === -1) return hasRoot ? \"/\" : \".\";\n        if (hasRoot && end === 1) return \"//\";\n        return path2.slice(0, end);\n      },\n      basename: function basename(path2, ext) {\n        if (ext !== void 0 && typeof ext !== \"string\") throw new TypeError('\"ext\" argument must be a string');\n        assertPath(path2);\n        var start = 0;\n        var end = -1;\n        var matchedSlash = true;\n        var i;\n        if (ext !== void 0 && ext.length > 0 && ext.length <= path2.length) {\n          if (ext.length === path2.length && ext === path2) return \"\";\n          var extIdx = ext.length - 1;\n          var firstNonSlashEnd = -1;\n          for (i = path2.length - 1; i >= 0; --i) {\n            var code = path2.charCodeAt(i);\n            if (code === 47) {\n              if (!matchedSlash) {\n                start = i + 1;\n                break;\n              }\n            } else {\n              if (firstNonSlashEnd === -1) {\n                matchedSlash = false;\n                firstNonSlashEnd = i + 1;\n              }\n              if (extIdx >= 0) {\n                if (code === ext.charCodeAt(extIdx)) {\n                  if (--extIdx === -1) {\n                    end = i;\n                  }\n                } else {\n                  extIdx = -1;\n                  end = firstNonSlashEnd;\n                }\n              }\n            }\n          }\n          if (start === end) end = firstNonSlashEnd;\n          else if (end === -1) end = path2.length;\n          return path2.slice(start, end);\n        } else {\n          for (i = path2.length - 1; i >= 0; --i) {\n            if (path2.charCodeAt(i) === 47) {\n              if (!matchedSlash) {\n                start = i + 1;\n                break;\n              }\n            } else if (end === -1) {\n              matchedSlash = false;\n              end = i + 1;\n            }\n          }\n          if (end === -1) return \"\";\n          return path2.slice(start, end);\n        }\n      },\n      extname: function extname(path2) {\n        assertPath(path2);\n        var startDot = -1;\n        var startPart = 0;\n        var end = -1;\n        var matchedSlash = true;\n        var preDotState = 0;\n        for (var i = path2.length - 1; i >= 0; --i) {\n          var code = path2.charCodeAt(i);\n          if (code === 47) {\n            if (!matchedSlash) {\n              startPart = i + 1;\n              break;\n            }\n            continue;\n          }\n          if (end === -1) {\n            matchedSlash = false;\n            end = i + 1;\n          }\n          if (code === 46) {\n            if (startDot === -1)\n              startDot = i;\n            else if (preDotState !== 1)\n              preDotState = 1;\n          } else if (startDot !== -1) {\n            preDotState = -1;\n          }\n        }\n        if (startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot\n        preDotState === 0 || // The (right-most) trimmed path component is exactly '..'\n        preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {\n          return \"\";\n        }\n        return path2.slice(startDot, end);\n      },\n      format: function format2(pathObject) {\n        if (pathObject === null || typeof pathObject !== \"object\") {\n          throw new TypeError('The \"pathObject\" argument must be of type Object. Received type ' + typeof pathObject);\n        }\n        return _format(\"/\", pathObject);\n      },\n      parse: function parse2(path2) {\n        assertPath(path2);\n        var ret = { root: \"\", dir: \"\", base: \"\", ext: \"\", name: \"\" };\n        if (path2.length === 0) return ret;\n        var code = path2.charCodeAt(0);\n        var isAbsolute = code === 47;\n        var start;\n        if (isAbsolute) {\n          ret.root = \"/\";\n          start = 1;\n        } else {\n          start = 0;\n        }\n        var startDot = -1;\n        var startPart = 0;\n        var end = -1;\n        var matchedSlash = true;\n        var i = path2.length - 1;\n        var preDotState = 0;\n        for (; i >= start; --i) {\n          code = path2.charCodeAt(i);\n          if (code === 47) {\n            if (!matchedSlash) {\n              startPart = i + 1;\n              break;\n            }\n            continue;\n          }\n          if (end === -1) {\n            matchedSlash = false;\n            end = i + 1;\n          }\n          if (code === 46) {\n            if (startDot === -1) startDot = i;\n            else if (preDotState !== 1) preDotState = 1;\n          } else if (startDot !== -1) {\n            preDotState = -1;\n          }\n        }\n        if (startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot\n        preDotState === 0 || // The (right-most) trimmed path component is exactly '..'\n        preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {\n          if (end !== -1) {\n            if (startPart === 0 && isAbsolute) ret.base = ret.name = path2.slice(1, end);\n            else ret.base = ret.name = path2.slice(startPart, end);\n          }\n        } else {\n          if (startPart === 0 && isAbsolute) {\n            ret.name = path2.slice(1, startDot);\n            ret.base = path2.slice(1, end);\n          } else {\n            ret.name = path2.slice(startPart, startDot);\n            ret.base = path2.slice(startPart, end);\n          }\n          ret.ext = path2.slice(startDot, end);\n        }\n        if (startPart > 0) ret.dir = path2.slice(0, startPart - 1);\n        else if (isAbsolute) ret.dir = \"/\";\n        return ret;\n      },\n      sep: \"/\",\n      delimiter: \":\",\n      win32: null,\n      posix: null\n    };\n    posix.posix = posix;\n    module2.exports = posix;\n  }\n});\n\n// <stdin>\nvar imported = (init_url(), __toCommonJS(url_exports));\nvar resolved = imported.default ?? imported;\nvar path = require_path_browserify();\nvar punycode2 = require_punycode();\nresolved.URL = globalThis.URL;\nresolved.URLSearchParams = globalThis.URLSearchParams;\nresolved.domainToASCII = punycode2.toASCII;\nresolved.domainToUnicode = punycode2.toUnicode;\nresolved.fileURLToPath = (input) => {\n  const url = input instanceof globalThis.URL ? input : new globalThis.URL(input);\n  if (url.protocol !== \"file:\") throw new TypeError(\"The URL must be of scheme file\");\n  if (url.host && url.host !== \"localhost\") throw new TypeError(\"File URL host must be empty or localhost\");\n  if (/%2f/i.test(url.pathname)) throw new TypeError(\"File URL path must not include encoded / characters\");\n  return decodeURIComponent(url.pathname);\n};\nresolved.pathToFileURL = (input) => {\n  const absolute = path.posix.resolve(String(input || \"/\"));\n  const encoded = encodeURI(absolute).replaceAll(\"#\", \"%23\").replaceAll(\"?\", \"%3F\");\n  return new globalThis.URL(`file://${encoded.startsWith(\"/\") ? encoded : `/${encoded}`}`);\n};\nmodule.exports = resolved;\n/*! Bundled license information:\n\npunycode/punycode.js:\n  (*! https://mths.be/punycode v1.4.1 by @mathias *)\n*/\n\nif (module.exports && module.exports.default == null) module.exports.default = module.exports;\n";
diff --git a/packages/runtime-browser/src/runtime.ts b/packages/runtime-browser/src/runtime.ts
index ec8072c87b..66d2870106 100644
--- a/packages/runtime-browser/src/runtime.ts
+++ b/packages/runtime-browser/src/runtime.ts
@@ -1,5 +1,13 @@
 import { guestEncodingBootstrapCode } from "./encoding.js";
 import { BROWSER_BUFFER_POLYFILL_CODE } from "./generated/buffer-polyfill.js";
+import {
+	BROWSER_ASSERT_POLYFILL_CODE,
+	BROWSER_EVENTS_POLYFILL_CODE,
+	BROWSER_QUERYSTRING_POLYFILL_CODE,
+	BROWSER_STREAM_POLYFILL_CODE,
+	BROWSER_STRING_DECODER_POLYFILL_CODE,
+	BROWSER_URL_POLYFILL_CODE,
+} from "./generated/node-polyfills.js";
 import { BROWSER_PATH_POLYFILL_CODE } from "./generated/path-polyfill.js";
 import { BROWSER_UTIL_POLYFILL_CODE } from "./generated/util-polyfill.js";
 import {
@@ -1176,67 +1184,7 @@ export const POLYFILL_CODE_MAP: Record<string, string> = {
 		module.exports.default = module.exports;
 	`,
 	"node:module": "module.exports = require('module');",
-	// node:stream — a minimal but functional stream set. The ACP connection itself
-	// uses WHATWG Readable/WritableStream (worker globals); guest programs use these
-	// node streams for buffering (e.g. pi's bufferedStdin PassThrough). Readable.toWeb
-	// / Writable.toWeb bridge to the WHATWG streams the ACP codec consumes.
-	stream: `
-		class EventEmitterLike {
-			constructor() { this._listeners = Object.create(null); }
-			on(event, fn) { (this._listeners[event] = this._listeners[event] || []).push(fn); if (event === "data" && typeof this.resume === "function") this.resume(); return this; }
-			addListener(event, fn) { return this.on(event, fn); }
-			once(event, fn) { const w = (...a) => { this.off(event, w); fn(...a); }; w._origin = fn; return this.on(event, w); }
-			off(event, fn) { if (this._listeners[event]) this._listeners[event] = this._listeners[event].filter((x) => x !== fn && x._origin !== fn); return this; }
-			removeListener(event, fn) { return this.off(event, fn); }
-			removeAllListeners(event) { if (event) delete this._listeners[event]; else this._listeners = Object.create(null); return this; }
-			emit(event, ...args) { const ls = (this._listeners[event] || []).slice(); if (ls.length === 0 && event === "error") throw (args[0] instanceof Error ? args[0] : new Error(String(args[0]))); for (const fn of ls) fn(...args); return ls.length > 0; }
-			listenerCount(event) { return (this._listeners[event] || []).length; }
-		}
-		const chunkLength = (chunk) => typeof chunk === "string" ? new TextEncoder().encode(chunk).length : Number(chunk && chunk.byteLength) || 1;
-		const streamError = (code, message) => { const error = new Error(message); error.code = code; return error; };
-		class Readable extends EventEmitterLike {
-			constructor(options) { super(); this.readable = true; this.readableEnded = false; this.destroyed = false; this.paused = true; this._buffer = []; this._bufferedBytes = 0; this._highWaterMark = Number(options && options.highWaterMark) || 16384; this._readableOptions = options || {}; this._readableAutoDestroy = this._readableOptions.autoDestroy !== false; if (this._readableOptions.read) this._read = this._readableOptions.read; }
-			_finishReadable() { if (this.readableEnded) return; this.readableEnded = true; this.readable = false; this.emit("end"); if (this._readableAutoDestroy && !this._closeScheduled) { this._closeScheduled = true; queueMicrotask(() => this.destroy()); } }
-			_flush() { while (!this.paused && this._buffer.length > 0) { const chunk = this._buffer.shift(); this._bufferedBytes -= chunkLength(chunk); this.emit("data", chunk); } if (!this.paused && this._ended && this._buffer.length === 0) this._finishReadable(); }
-			resume() { if (this.destroyed) return this; const changed = this.paused; this.paused = false; if (changed) this.emit("resume"); this._flush(); return this; }
-			pause() { this.paused = true; this.emit("pause"); return this; }
-			setEncoding() { return this; }
-			read() { const chunk = this._buffer.shift() ?? null; if (chunk != null) this._bufferedBytes -= chunkLength(chunk); if (chunk == null && this._ended) this._finishReadable(); return chunk; }
-			push(chunk) { if (this.destroyed || this._ended) return false; if (chunk == null) { this._ended = true; this._flush(); return false; } this._buffer.push(chunk); this._bufferedBytes += chunkLength(chunk); this._flush(); return this._bufferedBytes < this._highWaterMark; }
-			pipe(dest) { this.on("data", (chunk) => { if (dest.write && dest.write(chunk) === false) { this.pause(); dest.once && dest.once("drain", () => this.resume()); } }); this.once("end", () => dest.end && dest.end()); this.once("error", (error) => dest.destroy ? dest.destroy(error) : dest.emit && dest.emit("error", error)); return dest; }
-			destroy(error) { if (this.destroyed) return this; this.destroyed = true; this.readable = false; this._buffer.length = 0; this._bufferedBytes = 0; if (error) this.emit("error", error); this.emit("close"); return this; }
-		}
-		Readable.toWeb = (stream) => new ReadableStream({ start(controller) { stream.once("end", () => controller.close()); stream.once("error", (error) => controller.error(error)); stream.on("data", (chunk) => { controller.enqueue(chunk); if ((controller.desiredSize ?? 1) <= 0) stream.pause && stream.pause(); }); }, pull() { stream.resume && stream.resume(); }, cancel(reason) { stream.destroy && stream.destroy(reason instanceof Error ? reason : undefined); } });
-		class Writable extends EventEmitterLike {
-			constructor(options) { super(); this.writable = true; this.writableEnded = false; this.writableFinished = false; this.destroyed = false; this._pendingWrites = 0; this._writableBufferedBytes = 0; this._writableNeedDrain = false; this._writableHighWaterMark = Number(options && options.highWaterMark) || 16384; this._writableOptions = options || {}; this._writableAutoDestroy = this._writableOptions.autoDestroy !== false; if (this._writableOptions.write) this._writeImpl = this._writableOptions.write; }
-			_finishIfReady() { if (this.writableEnded && this._pendingWrites === 0 && !this.writableFinished && !this.destroyed) { this.writableFinished = true; this.writable = false; this.emit("finish"); if (this._endCallback) { const callback = this._endCallback; this._endCallback = null; callback(); } if (this._writableAutoDestroy && !this._closeScheduled) { this._closeScheduled = true; queueMicrotask(() => this.destroy()); } } }
-			write(chunk, encoding, cb) { if (typeof encoding === "function") { cb = encoding; encoding = undefined; } if (this.destroyed || this.writableEnded) { const error = streamError("ERR_STREAM_WRITE_AFTER_END", "write after end"); queueMicrotask(() => { if (cb) cb(error); else this.emit("error", error); }); return false; } const size = chunkLength(chunk); this._pendingWrites += 1; this._writableBufferedBytes += size; const accepted = this._writableBufferedBytes < this._writableHighWaterMark; if (!accepted) this._writableNeedDrain = true; let completed = false; const done = (error) => { if (completed) return; completed = true; queueMicrotask(() => { this._pendingWrites -= 1; this._writableBufferedBytes = Math.max(0, this._writableBufferedBytes - size); if (error) { if (cb) cb(error); this.destroy(error); return; } if (cb) cb(); if (this._writableNeedDrain && this._writableBufferedBytes < this._writableHighWaterMark) { this._writableNeedDrain = false; this.emit("drain"); } this._finishIfReady(); }); }; try { if (this._writeImpl) this._writeImpl(chunk, encoding, done); else { this.emit("data", chunk); done(); } } catch (error) { done(error); } return accepted; }
-			end(chunk, encoding, cb) { const done = typeof chunk === "function" ? chunk : typeof encoding === "function" ? encoding : cb; if (this.writableEnded) { const error = streamError("ERR_STREAM_ALREADY_FINISHED", "end called after stream finished"); queueMicrotask(() => done ? done(error) : this.emit("error", error)); return this; } if (chunk != null && typeof chunk !== "function") this.write(chunk, typeof encoding === "string" ? encoding : undefined); this.writableEnded = true; this._endCallback = done || null; this._finishIfReady(); return this; }
-			destroy(error) { if (this.destroyed) return this; this.destroyed = true; this.writable = false; if (error) this.emit("error", error); this.emit("close"); return this; }
-		}
-		Writable.toWeb = (stream) => new WritableStream({ start(controller) { stream.on("error", (error) => controller.error(error)); }, write(chunk) { return new Promise((resolve, reject) => stream.write(chunk, undefined, (error) => error ? reject(error) : resolve())); }, close() { return new Promise((resolve, reject) => stream.end((error) => error ? reject(error) : resolve())); }, abort(reason) { stream.destroy && stream.destroy(reason instanceof Error ? reason : new Error(String(reason))); } });
-		class Duplex extends Readable { constructor(options) { super(options); this.writable = true; this.writableEnded = false; this.writableFinished = false; this._pendingWrites = 0; this._writableBufferedBytes = 0; this._writableNeedDrain = false; this._writableHighWaterMark = Number(options && options.highWaterMark) || 16384; this._writableOptions = options || {}; this._writableAutoDestroy = this._writableOptions.autoDestroy !== false; this._writeImpl = options && options.write; } write(...args) { return Writable.prototype.write.apply(this, args); } end(...args) { return Writable.prototype.end.apply(this, args); } _finishIfReady() { return Writable.prototype._finishIfReady.call(this); } destroy(error) { if (this.destroyed) return this; this.writable = false; return Readable.prototype.destroy.call(this, error); } }
-		class Transform extends Duplex {}
-		class PassThrough extends Transform { constructor(options) { super(options); this._writeImpl = (chunk, _encoding, callback) => { this.push(chunk); callback(); }; } end(chunk, encoding, cb) { const done = typeof chunk === "function" ? chunk : typeof encoding === "function" ? encoding : cb; if (chunk != null && typeof chunk !== "function") this.write(chunk, typeof encoding === "string" ? encoding : undefined); this.push(null); return Writable.prototype.end.call(this, done); } }
-		function finished(stream, optsOrCb, maybeCb) {
-			const cb = typeof optsOrCb === "function" ? optsOrCb : maybeCb;
-			if (stream && stream.on) { let done = false; const fire = (e) => { if (done) return; done = true; if (cb) cb(e || null); }; stream.on("end", () => fire()); stream.on("finish", () => fire()); stream.on("close", () => fire()); stream.on("error", (e) => fire(e)); }
-			return () => {};
-		}
-		function pipeline(...args) {
-			const cb = typeof args[args.length - 1] === "function" ? args.pop() : null;
-			const streams = args.flat();
-			for (let i = 0; i < streams.length - 1; i++) { if (streams[i] && streams[i].pipe) streams[i].pipe(streams[i + 1]); }
-			const last = streams[streams.length - 1];
-			if (last && last.on) { last.on("finish", () => cb && cb(null)); last.on("end", () => cb && cb(null)); last.on("error", (e) => cb && cb(e)); }
-			return last;
-		}
-		const Stream = EventEmitterLike;
-		Stream.Readable = Readable; Stream.Writable = Writable; Stream.Duplex = Duplex; Stream.Transform = Transform; Stream.PassThrough = PassThrough;
-		module.exports = { Stream, Readable, Writable, Duplex, Transform, PassThrough, finished, pipeline };
-		module.exports.promises = { finished: (s) => new Promise((res, rej) => finished(s, (e) => (e ? rej(e) : res()))), pipeline: (...a) => new Promise((res, rej) => pipeline(...a, (e) => (e ? rej(e) : res()))) };
-		module.exports.default = module.exports;
-	`,
+	stream: BROWSER_STREAM_POLYFILL_CODE,
 	"node:stream": "module.exports = require('stream');",
 	"stream/promises": "module.exports = require('stream').promises;",
 	"node:stream/promises": "module.exports = require('stream').promises;",
@@ -1255,91 +1203,18 @@ export const POLYFILL_CODE_MAP: Record<string, string> = {
 		module.exports.default = module.exports;
 	`,
 	"node:constants": "module.exports = require('constants');",
-	// node:events — EventEmitter (a complete-enough implementation for guest libraries).
-	events: `
-		class EventEmitter {
-			constructor() { this._events = Object.create(null); this._max = 10; }
-			setMaxListeners(n) { this._max = n; return this; }
-			getMaxListeners() { return this._max; }
-			on(type, fn) { (this._events[type] = this._events[type] || []).push(fn); this.emit("newListener", type, fn); return this; }
-			addListener(type, fn) { return this.on(type, fn); }
-			prependListener(type, fn) { (this._events[type] = this._events[type] || []).unshift(fn); return this; }
-			once(type, fn) { const w = (...a) => { this.off(type, w); fn(...a); }; w.listener = fn; return this.on(type, w); }
-			prependOnceListener(type, fn) { const w = (...a) => { this.off(type, w); fn(...a); }; w.listener = fn; return this.prependListener(type, w); }
-			off(type, fn) { const l = this._events[type]; if (l) { this._events[type] = l.filter((x) => x !== fn && x.listener !== fn); if (this._events[type].length === 0) delete this._events[type]; } return this; }
-			removeListener(type, fn) { return this.off(type, fn); }
-			removeAllListeners(type) { if (type) delete this._events[type]; else this._events = Object.create(null); return this; }
-			emit(type, ...args) { const l = this._events[type]; if (!l || l.length === 0) { if (type === "error") throw args[0] instanceof Error ? args[0] : new Error("Unhandled error"); return false; } for (const fn of l.slice()) fn.apply(this, args); return true; }
-			listeners(type) { return (this._events[type] || []).slice(); }
-			rawListeners(type) { return (this._events[type] || []).slice(); }
-			listenerCount(type) { return (this._events[type] || []).length; }
-			eventNames() { return Object.keys(this._events); }
-		}
-		EventEmitter.EventEmitter = EventEmitter;
-		EventEmitter.once = (emitter, name) => new Promise((resolve, reject) => {
-			const ok = (...a) => { emitter.off("error", err); resolve(a); };
-			const err = (e) => { emitter.off(name, ok); reject(e); };
-			emitter.once(name, ok); emitter.once("error", err);
-		});
-		EventEmitter.defaultMaxListeners = 10;
-		module.exports = EventEmitter;
-		module.exports.default = EventEmitter;
-	`,
+	events: BROWSER_EVENTS_POLYFILL_CODE,
 	"node:events": "module.exports = require('events');",
-	// node:assert — the common assertion surface.
-	assert: `
-		function AssertionError(message) { const e = new Error(message); e.name = "AssertionError"; return e; }
-		function assert(value, message) { if (!value) throw AssertionError(message || "assertion failed"); }
-		assert.ok = assert;
-		assert.equal = (a, b, m) => { if (a != b) throw AssertionError(m || (a + " != " + b)); };
-		assert.strictEqual = (a, b, m) => { if (a !== b) throw AssertionError(m || (a + " !== " + b)); };
-		assert.notEqual = (a, b, m) => { if (a == b) throw AssertionError(m); };
-		assert.notStrictEqual = (a, b, m) => { if (a === b) throw AssertionError(m); };
-		assert.deepEqual = (a, b, m) => { if (JSON.stringify(a) !== JSON.stringify(b)) throw AssertionError(m); };
-		assert.deepStrictEqual = assert.deepEqual;
-		assert.fail = (m) => { throw AssertionError(m || "failed"); };
-		assert.throws = (fn, m) => { try { fn(); } catch (e) { return; } throw AssertionError(m || "missing expected exception"); };
-		assert.AssertionError = AssertionError;
-		module.exports = assert;
-		module.exports.default = assert;
-	`,
+	assert: BROWSER_ASSERT_POLYFILL_CODE,
 	"node:assert": "module.exports = require('assert');",
-	// node:url — WHATWG URL globals + the legacy parse/format surface.
-	url: `
-		module.exports = {
-			URL: globalThis.URL,
-			URLSearchParams: globalThis.URLSearchParams,
-			parse(input) { try { const u = new URL(input); return { href: u.href, protocol: u.protocol, host: u.host, hostname: u.hostname, port: u.port, pathname: u.pathname, search: u.search, hash: u.hash, query: u.search.replace(/^\\?/, ""), path: u.pathname + u.search }; } catch (e) { return { href: input, pathname: input }; } },
-			format(u) { if (typeof u === "string") return u; const proto = u.protocol ? (u.protocol.endsWith(":") ? u.protocol : u.protocol + ":") : ""; return proto + "//" + (u.host || u.hostname || "") + (u.pathname || "") + (u.search || (u.query ? "?" + u.query : "")) + (u.hash || ""); },
-			resolve(from, to) { try { return new URL(to, from).href; } catch (e) { return to; } },
-			fileURLToPath(u) { const s = typeof u === "string" ? u : u.href; return s.replace(/^file:\\/\\//, ""); },
-			pathToFileURL(p) { return new URL("file://" + (p.startsWith("/") ? p : "/" + p)); },
-			domainToASCII: (d) => d,
-			domainToUnicode: (d) => d,
-		};
-		module.exports.default = module.exports;
-	`,
+	"assert/strict":
+		"module.exports = require('assert').strict || require('assert');",
+	"node:assert/strict": "module.exports = require('assert/strict');",
+	url: BROWSER_URL_POLYFILL_CODE,
 	"node:url": "module.exports = require('url');",
-	// node:string_decoder — UTF-8 incremental decoder (TextDecoder-backed).
-	string_decoder: `
-		class StringDecoder {
-			constructor(encoding) { this.encoding = encoding || "utf8"; this._decoder = new TextDecoder(this.encoding === "utf8" ? "utf-8" : this.encoding); }
-			write(buf) { const bytes = buf instanceof Uint8Array ? buf : new Uint8Array(buf); return this._decoder.decode(bytes, { stream: true }); }
-			end(buf) { const head = buf ? this.write(buf) : ""; return head + this._decoder.decode(); }
-		}
-		module.exports = { StringDecoder };
-		module.exports.default = module.exports;
-	`,
+	string_decoder: BROWSER_STRING_DECODER_POLYFILL_CODE,
 	"node:string_decoder": "module.exports = require('string_decoder');",
-	// node:querystring — legacy query parsing/serialization.
-	querystring: `
-		module.exports = {
-			parse(str) { const out = Object.create(null); if (!str) return out; for (const pair of String(str).split("&")) { if (!pair) continue; const i = pair.indexOf("="); const k = decodeURIComponent(i < 0 ? pair : pair.slice(0, i)); const v = i < 0 ? "" : decodeURIComponent(pair.slice(i + 1)); if (k in out) { if (Array.isArray(out[k])) out[k].push(v); else out[k] = [out[k], v]; } else out[k] = v; } return out; },
-			stringify(obj) { if (!obj) return ""; const parts = []; for (const k of Object.keys(obj)) { const v = obj[k]; if (Array.isArray(v)) for (const item of v) parts.push(encodeURIComponent(k) + "=" + encodeURIComponent(item)); else parts.push(encodeURIComponent(k) + "=" + encodeURIComponent(v)); } return parts.join("&"); },
-			escape: encodeURIComponent, unescape: decodeURIComponent,
-		};
-		module.exports.default = module.exports;
-	`,
+	querystring: BROWSER_QUERYSTRING_POLYFILL_CODE,
 	"node:querystring": "module.exports = require('querystring');",
 	// node:tty — reflects ExecOptions.stdioPty for stdio fds.
 	tty: `
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index da4abfde05..b1073bfb38 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -2749,9 +2749,15 @@ importers:
       '@bare-ts/tools':
         specifier: 0.15.0
         version: 0.15.0(@bare-ts/lib@0.4.0)
+      '@exodus/bytes':
+        specifier: 1.15.1
+        version: 1.15.1(@noble/hashes@2.2.0)
       esbuild:
         specifier: ^0.27.4
         version: 0.27.4
+      fetch-blob:
+        specifier: 4.0.0
+        version: 4.0.0
       node-stdlib-browser:
         specifier: ^1.3.1
         version: 1.3.1
@@ -2759,11 +2765,14 @@ importers:
         specifier: 4.7.0
         version: 4.7.0
       undici:
-        specifier: ^7.24.6
+        specifier: 7.24.6
         version: 7.24.6
       web-streams-polyfill:
-        specifier: ^3.3.3
-        version: 3.3.3
+        specifier: 4.3.0
+        version: 4.3.0
+      whatwg-url:
+        specifier: 15.1.0
+        version: 15.1.0
       ws:
         specifier: 8.21.0
         version: 8.21.0(bufferutil@4.1.0)
@@ -6421,6 +6430,15 @@ packages:
     cpu: [x64]
     os: [win32]
 
+  '@exodus/bytes@1.15.1':
+    resolution: {integrity: sha512-S6mL0yNB/Abt9Ei4tq8gDhcczc4S3+vQ4ra7vxnAf+YHC02srtqxKKZghx2Dq6p0e66THKwR6r8N6P95wEty7Q==}
+    engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0}
+    peerDependencies:
+      '@noble/hashes': ^1.8.0 || ^2.0.0
+    peerDependenciesMeta:
+      '@noble/hashes':
+        optional: true
+
   '@floating-ui/core@1.8.0':
     resolution: {integrity: sha512-0CIZ5itps/8x7BG8dEIhs53BvCUH2PCoogtakwRTut+Arm58sJooJ0AuZhLw2HJYIR5cMLNPBSS728sPho2khQ==}
 
@@ -10943,6 +10961,10 @@ packages:
     resolution: {integrity: sha512-7yAQpD2UMJzLi1Dqv7qFYnPbaPx7ZfFK6PiIxQ4PfkGPyNyl2Ugx+a/umUonmKqjhM4DnfbMvdX6otXq83soQQ==}
     engines: {node: ^12.20 || >= 14.13}
 
+  fetch-blob@4.0.0:
+    resolution: {integrity: sha512-nPmnhRmpNMjYWnp9EBMGs6z5lq9RXed5W1vuZcECrsDVQInM8AMQSooVb3X183Aole60adzjWbH9qlRFWzDDTA==}
+    engines: {node: '>=16.7'}
+
   fetch-cookie@3.2.0:
     resolution: {integrity: sha512-n61pQIxP25C6DRhcJxn7BDzgHP/+S56Urowb5WFxtcRMpU6drqXD90xjyAsVQYsNSNNVbaCcYY1DuHsdkZLuiA==}
 
@@ -13981,6 +14003,10 @@ packages:
   tr46@0.0.3:
     resolution: {integrity: sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==}
 
+  tr46@6.0.0:
+    resolution: {integrity: sha512-bLVMLPtstlZ4iMQHpFHTR7GAGj2jxi8Dg0s2h2MafAE4uSWF98FC/3MomU51iQAMf8/qDUbKWf5GxuvvVcXEhw==}
+    engines: {node: '>=20'}
+
   tree-kill@1.2.2:
     resolution: {integrity: sha512-L0Orpi8qGpRG//Nd+H90vFB+3iHnue1zSSGmNOOCh1GLJ7rUKVwV2HvijphGQS2UmhUZewS9VgvxYIdgr+fG1A==}
     hasBin: true
@@ -14651,6 +14677,14 @@ packages:
   webidl-conversions@3.0.1:
     resolution: {integrity: sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==}
 
+  webidl-conversions@8.0.1:
+    resolution: {integrity: sha512-BMhLD/Sw+GbJC21C/UgyaZX41nPt8bUTg+jWyDeg7e7YN4xOM05YPSIXceACnXVtqyEw/LMClUQMtMZ+PGGpqQ==}
+    engines: {node: '>=20'}
+
+  whatwg-url@15.1.0:
+    resolution: {integrity: sha512-2ytDk0kiEj/yu90JOAp44PVPUkO9+jVhyf+SybKlRHSDlvOOZhdPIrr7xTH64l4WixO2cP+wQIcgujkGBPPz6g==}
+    engines: {node: '>=20'}
+
   whatwg-url@5.0.0:
     resolution: {integrity: sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==}
 
@@ -17068,6 +17102,10 @@ snapshots:
   '@esbuild/win32-x64@0.28.1':
     optional: true
 
+  '@exodus/bytes@1.15.1(@noble/hashes@2.2.0)':
+    optionalDependencies:
+      '@noble/hashes': 2.2.0
+
   '@floating-ui/core@1.8.0':
     dependencies:
       '@floating-ui/utils': 0.2.12
@@ -23081,6 +23119,10 @@ snapshots:
       node-domexception: 1.0.0
       web-streams-polyfill: 3.3.3
 
+  fetch-blob@4.0.0:
+    dependencies:
+      node-domexception: 1.0.0
+
   fetch-cookie@3.2.0:
     dependencies:
       set-cookie-parser: 2.7.2
@@ -26875,6 +26917,10 @@ snapshots:
 
   tr46@0.0.3: {}
 
+  tr46@6.0.0:
+    dependencies:
+      punycode: 2.3.1
+
   tree-kill@1.2.2: {}
 
   trim-lines@3.0.1: {}
@@ -27522,6 +27568,13 @@ snapshots:
 
   webidl-conversions@3.0.1: {}
 
+  webidl-conversions@8.0.1: {}
+
+  whatwg-url@15.1.0:
+    dependencies:
+      tr46: 6.0.0
+      webidl-conversions: 8.0.1
+
   whatwg-url@5.0.0:
     dependencies:
       tr46: 0.0.3