crossws 0.4.6 → 0.4.8

package/dist/index.mjs

@@ -1,10 +1,11 @@
 import { defineHooks, defineWebSocketAdapter } from "./_chunks/adapter.mjs";
+import runtimeWebSocket from "crossws/websocket";
 const DEFAULT_MAX_BUFFER_SIZE = 1024 * 1024;
 const DEFAULT_CONNECT_TIMEOUT = 1e4;
 const TOKEN_RE = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
 function createWebSocketProxy(target) {
 	const options = typeof target === "string" || target instanceof URL || typeof target === "function" ? { target } : target;
-	const WebSocketCtor = options.WebSocket ?? globalThis.WebSocket;
+	const WebSocketCtor = options.WebSocket ?? runtimeWebSocket;
 	if (typeof WebSocketCtor !== "function") throw new TypeError("createWebSocketProxy requires a `WebSocket` constructor. Pass one via the `WebSocket` option, or use a runtime that provides a global `WebSocket` (Node.js >= 22, Bun, Deno, Cloudflare Workers, browsers).");
 	const upstreams = /* @__PURE__ */ new Map();
 	return {
@@ -16,19 +17,8 @@ function createWebSocketProxy(target) {
 			return { headers: { "sec-websocket-protocol": accepted } };
 		},
 		open(peer) {
-			let ws;
-			try {
-				const url = _resolveTarget(options.target, peer);
-				const protocols = _resolveProtocols(peer, options.forwardProtocol);
-				const wsOptions = _resolveWsOptions(options.headers, peer);
-				ws = wsOptions ? new WebSocketCtor(url, protocols, wsOptions) : new WebSocketCtor(url, protocols);
-				ws.binaryType = "arraybuffer";
-			} catch {
-				_safeClose(peer, 1011, "Upstream setup failed");
-				return;
-			}
 			const state = {
-				ws,
+				ws: void 0,
 				buffer: [],
 				bufferSize: 0,
 				open: false,
@@ -41,26 +31,20 @@ function createWebSocketProxy(target) {
 				_cleanupState(upstreams, peer.id, state);
 				_safeClose(peer, 1011, "Upstream connect timeout");
 			}, timeoutMs);
-			ws.addEventListener("open", () => {
-				_clearTimeout(state);
-				state.open = true;
-				for (const data of state.buffer) ws.send(data);
-				state.buffer.length = 0;
-				state.bufferSize = 0;
-			});
-			ws.addEventListener("message", (event) => {
-				_safeSend(peer, event.data);
-			});
-			ws.addEventListener("close", (event) => {
-				if (upstreams.get(peer.id) !== state) return;
+			let resolved;
+			try {
+				resolved = _resolveTarget(options.target, peer);
+			} catch {
 				_cleanupState(upstreams, peer.id, state);
-				_safeClose(peer, _remapIncomingCode(event.code), event.reason);
-			});
-			ws.addEventListener("error", () => {
+				_safeClose(peer, 1011, "Upstream setup failed");
+				return;
+			}
+			if (resolved instanceof Promise) resolved.then((url) => _dialUpstream(upstreams, peer, state, url, options, WebSocketCtor), () => {
 				if (upstreams.get(peer.id) !== state) return;
 				_cleanupState(upstreams, peer.id, state);
-				_safeClose(peer, 1011, "Upstream error");
+				_safeClose(peer, 1011, "Upstream setup failed");
 			});
+			else _dialUpstream(upstreams, peer, state, resolved, options, WebSocketCtor);
 		},
 		message(peer, message) {
 			const state = upstreams.get(peer.id);
@@ -68,7 +52,7 @@ function createWebSocketProxy(target) {
 			const raw = typeof message.rawData === "string" ? message.rawData : message.uint8Array();
 			if (state.open) {
 				try {
-					state.ws.send(raw);
+					state.ws?.send(raw);
 				} catch {}
 				return;
 			}
@@ -88,7 +72,7 @@ function createWebSocketProxy(target) {
 			_clearTimeout(state);
 			upstreams.delete(peer.id);
 			try {
-				state.ws.close(_normalizeOutgoingCode(details.code), _truncateReason(details.reason));
+				state.ws?.close(_normalizeOutgoingCode(details.code), _truncateReason(details.reason));
 			} catch {}
 		},
 		error(peer) {
@@ -97,16 +81,56 @@ function createWebSocketProxy(target) {
 			_clearTimeout(state);
 			upstreams.delete(peer.id);
 			try {
-				state.ws.close(1011, "Peer error");
+				state.ws?.close(1011, "Peer error");
 			} catch {}
 		}
 	};
 }
+function _dialUpstream(upstreams, peer, state, url, options, WebSocketCtor) {
+	if (upstreams.get(peer.id) !== state) return;
+	let ws;
+	try {
+		const protocols = _resolveProtocols(peer, options.forwardProtocol);
+		const wsOptions = _resolveWsOptions(options, peer);
+		ws = wsOptions ? new WebSocketCtor(url, protocols, wsOptions) : new WebSocketCtor(url, protocols);
+		ws.binaryType = "arraybuffer";
+	} catch {
+		_cleanupState(upstreams, peer.id, state);
+		_safeClose(peer, 1011, "Upstream setup failed");
+		return;
+	}
+	state.ws = ws;
+	ws.addEventListener("open", () => {
+		if (upstreams.get(peer.id) !== state) return;
+		_clearTimeout(state);
+		state.open = true;
+		try {
+			for (const data of state.buffer) ws.send(data);
+		} catch {} finally {
+			state.buffer.length = 0;
+			state.bufferSize = 0;
+		}
+	});
+	ws.addEventListener("message", (event) => {
+		if (upstreams.get(peer.id) !== state) return;
+		_safeSend(peer, event.data);
+	});
+	ws.addEventListener("close", (event) => {
+		if (upstreams.get(peer.id) !== state) return;
+		_cleanupState(upstreams, peer.id, state);
+		_safeClose(peer, _remapIncomingCode(event.code), event.reason);
+	});
+	ws.addEventListener("error", () => {
+		if (upstreams.get(peer.id) !== state) return;
+		_cleanupState(upstreams, peer.id, state);
+		_safeClose(peer, 1011, "Upstream error");
+	});
+}
 function _cleanupState(upstreams, id, state) {
 	_clearTimeout(state);
 	upstreams.delete(id);
 	try {
-		state.ws.close();
+		state.ws?.close();
 	} catch {}
 }
 function _clearTimeout(state) {
@@ -117,13 +141,20 @@ function _clearTimeout(state) {
 }
 function _resolveTarget(target, peer) {
 	const raw = typeof target === "function" ? target(peer) : target;
+	if (_isThenable(raw)) return Promise.resolve(raw).then((value) => value instanceof URL ? value : new URL(value));
 	return raw instanceof URL ? raw : new URL(raw);
 }
-function _resolveWsOptions(headers, peer) {
-	if (!headers) return;
-	const resolved = typeof headers === "function" ? headers(peer) : headers;
-	if (!resolved) return;
-	return { headers: resolved };
+function _isThenable(value) {
+	return value != null && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+}
+function _resolveWsOptions(options, peer) {
+	const { headers, webSocketOptions } = options;
+	const extra = typeof webSocketOptions === "function" ? webSocketOptions(peer) : webSocketOptions;
+	const resolvedHeaders = typeof headers === "function" ? headers(peer) : headers;
+	if (!extra && !resolvedHeaders) return;
+	const merged = { ...extra };
+	if (resolvedHeaders) merged.headers = resolvedHeaders;
+	return merged;
 }
 function _resolveProtocols(peer, forwardProtocol) {
 	if (forwardProtocol === false) return;

package/dist/sync.d.mts

@@ -0,0 +1,2 @@
+import { PostgresClientLike, RedisClientLike, SyncAdapter, SyncDriver, SyncDriverName, SyncDriverOptions, SyncMessage, broadcastChannel, cluster, decodeEnvelope, encodeEnvelope, pgsql, redis, setupPrimaryCluster, syncDrivers } from "./_chunks/adapter.mjs";
+export { type PostgresClientLike, type RedisClientLike, type SyncAdapter, type SyncDriver, SyncDriverName, SyncDriverOptions, type SyncMessage, broadcastChannel, cluster, decodeEnvelope, encodeEnvelope, pgsql, redis, setupPrimaryCluster, syncDrivers };

package/dist/sync.mjs

@@ -0,0 +1,200 @@
+function broadcastChannel(opts) {
+	return ({ id }) => {
+		const channel = new BroadcastChannel(opts.channel);
+		return {
+			subscribe(deliver) {
+				channel.addEventListener("message", (event) => {
+					const envelope = event.data;
+					const msg = envelope?.msg;
+					if (!envelope || envelope.id === id || typeof msg?.topic !== "string" || typeof msg.namespace !== "string" || !(typeof msg.data === "string" || msg.data instanceof Uint8Array)) return;
+					deliver(msg);
+				});
+			},
+			publish(msg) {
+				channel.postMessage({
+					id,
+					msg
+				});
+			},
+			close() {
+				channel.close();
+			}
+		};
+	};
+}
+function encodeEnvelope(id, msg) {
+	const binary = msg.data instanceof Uint8Array;
+	return JSON.stringify({
+		id,
+		msg: {
+			namespace: msg.namespace,
+			topic: msg.topic,
+			binary,
+			data: binary ? toBase64(msg.data) : msg.data
+		}
+	});
+}
+function decodeEnvelope(raw) {
+	try {
+		const parsed = JSON.parse(raw);
+		if (!parsed || typeof parsed.id !== "string" || !parsed.msg || typeof parsed.msg.topic !== "string" || typeof parsed.msg.namespace !== "string" || typeof parsed.msg.data !== "string") return;
+		return {
+			id: parsed.id,
+			msg: {
+				namespace: parsed.msg.namespace,
+				topic: parsed.msg.topic,
+				data: parsed.msg.binary ? fromBase64(parsed.msg.data) : parsed.msg.data
+			}
+		};
+	} catch {
+		return;
+	}
+}
+function toBase64(data) {
+	let binary = "";
+	for (const byte of data) binary += String.fromCharCode(byte);
+	return btoa(binary);
+}
+function fromBase64(data) {
+	const binary = atob(data);
+	const out = new Uint8Array(binary.length);
+	for (let i = 0; i < binary.length; i++) out[i] = binary.charCodeAt(i);
+	return out;
+}
+function redis(opts) {
+	const channel = opts.channel;
+	const isNodeRedis = opts.connector === void 0 ? typeof opts.client.pSubscribe === "function" : opts.connector === "node-redis";
+	return ({ id }) => {
+		const subscriber = opts.client.duplicate();
+		let started = false;
+		let onMessage;
+		return {
+			async subscribe(deliver) {
+				started = true;
+				const handle = (raw) => {
+					const envelope = decodeEnvelope(raw);
+					if (!envelope || envelope.id === id) return;
+					deliver(envelope.msg);
+				};
+				if (isNodeRedis) {
+					await subscriber.connect?.();
+					await subscriber.subscribe(channel, (raw) => handle(raw));
+				} else {
+					onMessage = (ch, raw) => {
+						if (ch === channel) handle(raw);
+					};
+					subscriber.on?.("message", onMessage);
+					await subscriber.subscribe(channel);
+				}
+			},
+			async publish(msg) {
+				await opts.client.publish(channel, encodeEnvelope(id, msg));
+			},
+			async close() {
+				if (!started) return;
+				if (onMessage) {
+					subscriber.off?.("message", onMessage);
+					onMessage = void 0;
+				}
+				try {
+					await subscriber.quit?.();
+				} catch (error) {
+					console.error("[crossws] sync redis close failed:", error);
+				}
+			}
+		};
+	};
+}
+function pgsql(opts) {
+	const channel = opts.channel;
+	if (new TextEncoder().encode(channel).length > 63) throw new Error(`[crossws] pgsql sync channel name must be at most 63 bytes (got ${channel.length} chars): ${channel}`);
+	const isPostgresJs = opts.connector === void 0 ? typeof opts.client.listen === "function" : opts.connector === "postgres.js";
+	if (!isPostgresJs && "idleCount" in opts.client && "totalCount" in opts.client && typeof opts.client.query === "function") throw new Error("[crossws] pgsql sync requires a dedicated `Client`, not a `Pool` (pool connections rotate, so LISTEN/NOTIFY can't deliver). Pass `new Client()` (node-postgres) or a `postgres()` instance (postgres.js).");
+	const quotedChannel = `"${channel.replace(/"/g, "\"\"")}"`;
+	return ({ id }) => {
+		let unlisten;
+		let onNotification;
+		return {
+			async subscribe(deliver) {
+				const handle = (raw) => {
+					const envelope = decodeEnvelope(raw);
+					if (!envelope || envelope.id === id) return;
+					deliver(envelope.msg);
+				};
+				if (isPostgresJs) unlisten = (await opts.client.listen(channel, (payload) => handle(payload)))?.unlisten;
+				else {
+					onNotification = (msg) => {
+						if (msg.channel === channel && msg.payload !== void 0) handle(msg.payload);
+					};
+					opts.client.on("notification", onNotification);
+					await opts.client.query(`LISTEN ${quotedChannel}`);
+				}
+			},
+			async publish(msg) {
+				const payload = encodeEnvelope(id, msg);
+				if (isPostgresJs) await opts.client.notify(channel, payload);
+				else await opts.client.query("SELECT pg_notify($1, $2)", [channel, payload]);
+			},
+			async close() {
+				if (isPostgresJs) await unlisten?.();
+				else if (onNotification) {
+					opts.client.removeListener?.("notification", onNotification);
+					onNotification = void 0;
+					await opts.client.query?.(`UNLISTEN ${quotedChannel}`);
+				}
+			}
+		};
+	};
+}
+const CLUSTER_MESSAGE = "crossws:sync";
+function isClusterEnvelope(message) {
+	return typeof message === "object" && message !== null && typeof message[CLUSTER_MESSAGE] === "string" && typeof message.env === "string";
+}
+let relayInstalled = false;
+async function setupPrimaryCluster() {
+	const cluster = (await import("node:cluster")).default;
+	if (!cluster.isPrimary || relayInstalled) return;
+	relayInstalled = true;
+	cluster.on("message", (_worker, message) => {
+		if (!isClusterEnvelope(message)) return;
+		for (const id in cluster.workers) cluster.workers[id]?.send(message);
+	});
+}
+function cluster(opts) {
+	const channel = opts.channel;
+	return ({ id }) => {
+		const proc = globalThis.process;
+		let onMessage;
+		return {
+			subscribe(deliver) {
+				if (typeof proc?.send !== "function") throw new Error("[crossws] cluster sync must run in a worker forked by node:cluster (process.send is unavailable). Call setupPrimaryCluster() in the primary process and start your server in the workers.");
+				onMessage = (message) => {
+					if (!isClusterEnvelope(message) || message[CLUSTER_MESSAGE] !== channel) return;
+					const envelope = decodeEnvelope(message.env);
+					if (!envelope || envelope.id === id) return;
+					deliver(envelope.msg);
+				};
+				proc.on("message", onMessage);
+			},
+			publish(msg) {
+				proc?.send?.({
+					[CLUSTER_MESSAGE]: channel,
+					env: encodeEnvelope(id, msg)
+				});
+			},
+			close() {
+				if (onMessage) {
+					proc?.off?.("message", onMessage);
+					onMessage = void 0;
+				}
+			}
+		};
+	};
+}
+const syncDrivers = [
+	"broadcastChannel",
+	"redis",
+	"pgsql",
+	"cluster"
+];
+export { broadcastChannel, cluster, decodeEnvelope, encodeEnvelope, pgsql, redis, setupPrimaryCluster, syncDrivers };

package/dist/websocket/bun.d.mts

@@ -0,0 +1,2 @@
+declare const _default: typeof globalThis.WebSocket;
+export { _default as default };

package/dist/websocket/bun.mjs

@@ -0,0 +1,13 @@
+const _WebSocket = globalThis.WebSocket;
+var BunWebSocket = class extends _WebSocket {
+	constructor(url, protocols, options) {
+		if (!options) {
+			super(url, protocols);
+			return;
+		}
+		const opts = { ...options };
+		if (protocols !== void 0) opts.protocols = protocols;
+		super(url, opts);
+	}
+};
+export { BunWebSocket as default };

package/dist/websocket/deno.d.mts

@@ -0,0 +1,2 @@
+declare const _default: typeof globalThis.WebSocket;
+export { _default as default };

package/dist/websocket/deno.mjs

@@ -0,0 +1,37 @@
+const _WebSocket = globalThis.WebSocket;
+var DenoWebSocket = class extends _WebSocket {
+	constructor(url, protocols, options) {
+		const href = typeof url === "string" ? url : url.href;
+		const isUnix = href.startsWith("ws+unix:");
+		if (!isUnix && !options) {
+			super(url, protocols);
+			return;
+		}
+		const opts = { ...options };
+		if (protocols !== void 0) opts.protocols = protocols;
+		if (isUnix) {
+			const { socketPath, path } = _parseUnixTarget(href);
+			opts.client ??= Deno.createHttpClient({ proxy: {
+				transport: "unix",
+				path: socketPath
+			} });
+			super(`ws://localhost${path}`, opts);
+			return;
+		}
+		super(url, opts);
+	}
+};
+function _parseUnixTarget(href) {
+	const { pathname, search } = new URL(href);
+	const raw = pathname + search;
+	const colon = raw.indexOf(":");
+	if (colon === -1) return {
+		socketPath: raw,
+		path: "/"
+	};
+	return {
+		socketPath: raw.slice(0, colon),
+		path: raw.slice(colon + 1) || "/"
+	};
+}
+export { DenoWebSocket as default };

package/dist/websocket/node.d.mts

@@ -1,2 +1,2 @@
-declare const Websocket: typeof globalThis.WebSocket;
-export { Websocket as default };
+declare const NodeWebSocket: typeof globalThis.WebSocket;
+export { NodeWebSocket as default };

package/dist/websocket/node.mjs

@@ -1,3 +1,8 @@
 import { import_websocket } from "../_chunks/libs/ws.mjs";
-const Websocket = globalThis.WebSocket || import_websocket.default;
-export { Websocket as default };
+const _global = globalThis.WebSocket;
+const NodeWebSocket = _global ? new Proxy(_global, { construct(target, args) {
+	const url = args[0];
+	const Ctor = (typeof url === "string" ? url : url?.href ?? "").startsWith("ws+unix:") || args[2] != null ? import_websocket.default : target;
+	return Reflect.construct(Ctor, args);
+} }) : import_websocket.default;
+export { NodeWebSocket as default };

package/package.json

@@ -1,24 +1,15 @@
 {
   "name": "crossws",
-  "version": "0.4.6",
+  "version": "0.4.8",
   "description": "Cross-platform WebSocket Servers for Node.js, Deno, Bun and Cloudflare Workers",
   "homepage": "https://crossws.h3.dev",
-  "license": "MIT",
   "repository": "h3js/crossws",
-  "files": [
-    "dist",
-    "adapters",
-    "websocket",
-    "server",
-    "*.d.ts"
-  ],
-  "type": "module",
+  "license": "MIT",
   "sideEffects": false,
-  "main": "./dist/index.mjs",
-  "module": "./dist/index.mjs",
-  "types": "./dist/index.d.mts",
+  "type": "module",
   "exports": {
     ".": "./dist/index.mjs",
+    "./sync": "./dist/sync.mjs",
     "./adapters/bun": "./dist/adapters/bun.mjs",
     "./adapters/bunny": "./dist/adapters/bunny.mjs",
     "./adapters/deno": "./dist/adapters/deno.mjs",
@@ -42,19 +33,30 @@
     "./websocket": {
       "browser": "./dist/websocket/native.mjs",
       "worker": "./dist/websocket/native.mjs",
-      "bun": "./dist/websocket/native.mjs",
-      "deno": "./dist/websocket/native.mjs",
+      "bun": "./dist/websocket/bun.mjs",
+      "deno": "./dist/websocket/deno.mjs",
       "edge-light": "./dist/websocket/native.mjs",
       "workerd": "./dist/websocket/native.mjs",
       "node": "./dist/websocket/node.mjs",
       "default": "./dist/websocket/native.mjs"
     }
   },
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist",
+    "adapters",
+    "websocket",
+    "server",
+    "*.d.ts"
+  ],
   "scripts": {
+    "prepare": "obuild --stub",
     "build": "obuild",
     "dev": "vitest",
-    "lint": "oxlint . && oxfmt --check src test",
     "fmt": "oxlint . --fix && oxfmt src test",
+    "lint": "oxlint . && oxfmt --check src test",
     "prepack": "pnpm run build",
     "play:bun": "bun --watch test/fixture/bun.ts",
     "play:cf": "wrangler dev --port 3001 -c test/fixture/wrangler.toml",
@@ -67,15 +69,18 @@
     "test": "pnpm lint && pnpm typecheck && vitest run --coverage",
     "typecheck": "tsgo --noEmit --skipLibCheck"
   },
+  "resolutions": {
+    "crossws": "workspace:*"
+  },
   "devDependencies": {
-    "@cloudflare/workers-types": "^4.20260608.1",
+    "@cloudflare/workers-types": "^4.20260701.1",
     "@types/bun": "^1.3.14",
     "@types/deno": "^2.7.0",
-    "@types/node": "^25.9.2",
-    "@types/web": "^0.0.350",
+    "@types/node": "^26.1.0",
+    "@types/web": "^0.0.352",
     "@types/ws": "^8.18.1",
-    "@typescript/native-preview": "7.0.0-dev.20260608.1",
-    "@vitest/coverage-v8": "^4.1.8",
+    "@typescript/native-preview": "^7.0.0-dev.20260701.1",
+    "@vitest/coverage-v8": "^4.1.9",
     "automd": "^0.4.3",
     "changelogen": "^0.6.2",
     "consola": "^3.4.2",
@@ -86,16 +91,16 @@
     "h3": "2.0.1-rc.22",
     "jiti": "^2.7.0",
     "listhen": "^1.10.0",
-    "obuild": "^0.4.36",
-    "oxfmt": "^0.53.0",
-    "oxlint": "^1.68.0",
-    "srvx": "^0.11.16",
+    "obuild": "^0.4.37",
+    "oxfmt": "^0.57.0",
+    "oxlint": "^1.72.0",
+    "srvx": "^0.11.18",
     "typescript": "^6.0.3",
     "uWebSockets.js": "github:uNetworking/uWebSockets.js#v20.57.0",
     "unbuild": "^3.6.1",
-    "undici": "^8.4.1",
-    "vitest": "^4.1.8",
-    "wrangler": "^4.98.0",
+    "undici": "^8.5.0",
+    "vitest": "^4.1.9",
+    "wrangler": "^4.106.0",
     "ws": "^8.21.0"
   },
   "peerDependencies": {
@@ -106,22 +111,5 @@
       "optional": true
     }
   },
-  "resolutions": {
-    "crossws": "workspace:*"
-  },
-  "packageManager": "pnpm@11.5.2",
-  "pnpm": {
-    "ignoredBuiltDependencies": [
-      "@parcel/watcher",
-      "esbuild",
-      "sharp",
-      "workerd"
-    ],
-    "onlyBuiltDependencies": [
-      "@parcel/watcher",
-      "esbuild",
-      "sharp",
-      "workerd"
-    ]
-  }
+  "packageManager": "pnpm@11.7.0"
 }

package/sync.d.ts

@@ -0,0 +1,2 @@
+export * from "./dist/sync.mjs";
+export { default } from "./dist/sync.mjs";

package/dist/_chunks/rolldown-runtime.mjs

@@ -1,24 +0,0 @@
-import { createRequire } from "node:module";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-export { __commonJSMin, __require, __toESM };