@ubean/server 0.1.13 → 0.2.0

package/dist/sse-Ct72zhic.d.ts

@@ -0,0 +1,95 @@
+import { Context, MiddlewareHandler } from "hono";
+import { UbeanEnv } from "@ubean/shared";
+//#region src/websocket.d.ts
+interface Peer {
+  readonly id: string;
+  readonly url: string;
+  readonly headers: Headers;
+  readonly readyState: number;
+  send(data: string | ArrayBuffer | Uint8Array): void;
+  publish(topic: string, data: string | ArrayBuffer | Uint8Array): void;
+  subscribe(topic: string): void;
+  unsubscribe(topic: string): void;
+  close(code?: number, reason?: string): void;
+  getData<T = unknown>(): T | undefined;
+  setData<T>(data: T): void;
+}
+interface WebSocketRoom {
+  readonly name: string;
+  readonly peers: Set<Peer>;
+  broadcast(data: string | ArrayBuffer | Uint8Array, options?: {
+    except?: Peer;
+  }): void;
+  add(peer: Peer): void;
+  remove(peer: Peer): void;
+}
+interface WebSocketHooks {
+  open?: (peer: Peer) => void | Promise<void>;
+  message?: (peer: Peer, message: string | ArrayBuffer) => void | Promise<void>;
+  close?: (peer: Peer, code: number, reason: string) => void | Promise<void>;
+  error?: (peer: Peer, error: Error) => void | Promise<void>;
+}
+interface WebSocketDefinition {
+  path?: string;
+  hooks?: WebSocketHooks;
+  topics?: string[];
+  rooms?: string[];
+}
+declare function createRoom(name: string): WebSocketRoom;
+declare function defineWebSocket(def: WebSocketDefinition): WebSocketDefinition;
+declare function defineRoom(name: string): WebSocketRoom;
+declare function getRoom(name: string): WebSocketRoom | undefined;
+declare function getRooms(): Map<string, WebSocketRoom>;
+declare function broadcast(topic: string, data: string | ArrayBuffer | Uint8Array): void;
+declare function registerWebSocket(path: string, def: WebSocketDefinition): void;
+declare function getWebSocketDefinitions(): Map<string, WebSocketDefinition>;
+interface UpgradeResult {
+  response: Response;
+  peer: Peer;
+}
+declare function handleUpgrade(c: Context<UbeanEnv>, options: {
+  send: (data: string | ArrayBuffer | Uint8Array) => void;
+  close: (code?: number, reason?: string) => void;
+  raw?: unknown;
+}): UpgradeResult;
+declare function handleMessage(peer: Peer, message: string | ArrayBuffer): void;
+declare function handleClose(peer: Peer, code?: number, reason?: string): void;
+declare function handleError(peer: Peer, error: Error): void;
+declare function createWebSocketMiddleware(): MiddlewareHandler<UbeanEnv>;
+declare function clearWebSocketState(): void;
+//#endregion
+//#region src/sse.d.ts
+interface SSEMessage {
+  data?: string | object;
+  event?: string;
+  id?: string;
+  retry?: number;
+  comment?: string;
+}
+interface SSEConnection {
+  readonly id: string;
+  send(message: SSEMessage): void;
+  sendData(data: string | object, event?: string): void;
+  comment(text: string): void;
+  close(): void;
+  readonly closed: boolean;
+}
+interface SSEHandler {
+  onConnect?: (connection: SSEConnection) => void | Promise<void>;
+  onClose?: (connection: SSEConnection) => void | Promise<void>;
+}
+interface SSEOptions {
+  headers?: Record<string, string>;
+  retry?: number;
+  keepAlive?: boolean | number;
+}
+declare function formatSSEMessage(msg: SSEMessage): string;
+declare function createSSEStream(c: Context<UbeanEnv>, handler: SSEHandler, options?: SSEOptions): Response;
+declare function defineSSE(handler: SSEHandler, options?: SSEOptions): MiddlewareHandler<UbeanEnv>;
+declare function getSSEConnections(): Map<string, SSEConnection>;
+declare function broadcastSSE(event: string, data: string | object, filter?: (conn: SSEConnection) => boolean): void;
+declare function closeAllSSE(): void;
+declare function sseHeaders(): Record<string, string>;
+declare function clearSSEState(): void;
+//#endregion
+export { handleUpgrade as A, defineWebSocket as C, handleClose as D, getWebSocketDefinitions as E, handleError as O, defineRoom as S, getRooms as T, WebSocketRoom as _, broadcastSSE as a, createRoom as b, createSSEStream as c, getSSEConnections as d, sseHeaders as f, WebSocketHooks as g, WebSocketDefinition as h, SSEOptions as i, registerWebSocket as j, handleMessage as k, defineSSE as l, UpgradeResult as m, SSEHandler as n, clearSSEState as o, Peer as p, SSEMessage as r, closeAllSSE as s, SSEConnection as t, formatSSEMessage as u, broadcast as v, getRoom as w, createWebSocketMiddleware as x, clearWebSocketState as y };

package/dist/sse-a6Ky9Vcl.js

@@ -0,0 +1,310 @@
+//#region src/websocket.ts
+const rooms = /* @__PURE__ */ new Map();
+const topicSubscribers = /* @__PURE__ */ new Map();
+const definitions = /* @__PURE__ */ new Map();
+const peerIdSeed = { value: 0 };
+var RoomImpl = class {
+	name;
+	peers = /* @__PURE__ */ new Set();
+	constructor(name) {
+		this.name = name;
+	}
+	broadcast(msg, options) {
+		for (const peer of this.peers) {
+			if (options?.except && peer === options.except) continue;
+			if (peer.readyState === 1) try {
+				peer.send(msg);
+			} catch {}
+		}
+	}
+	add(peer) {
+		this.peers.add(peer);
+		peer._rooms.add(this.name);
+	}
+	remove(peer) {
+		this.peers.delete(peer);
+		peer._rooms.delete(this.name);
+		if (this.peers.size === 0) rooms.delete(this.name);
+	}
+};
+function generateId$1() {
+	peerIdSeed.value++;
+	return `peer_${Date.now().toString(36)}_${peerIdSeed.value.toString(36)}`;
+}
+function createPeer(options) {
+	const subscriptions = /* @__PURE__ */ new Set();
+	const peerRooms = /* @__PURE__ */ new Set();
+	let data = void 0;
+	const peer = {
+		id: options.id,
+		url: options.url,
+		headers: options.headers,
+		get readyState() {
+			return 1;
+		},
+		_subscriptions: subscriptions,
+		_rooms: peerRooms,
+		_raw: options.raw,
+		send: options.send,
+		close: options.close,
+		publish(topic, msg) {
+			const topicPeers = topicSubscribers.get(topic);
+			if (topicPeers) {
+				for (const p of topicPeers) if (p !== peer && p.readyState === 1) try {
+					p.send(msg);
+				} catch {}
+			}
+		},
+		subscribe(topic) {
+			subscriptions.add(topic);
+			let set = topicSubscribers.get(topic);
+			if (!set) {
+				set = /* @__PURE__ */ new Set();
+				topicSubscribers.set(topic, set);
+			}
+			set.add(peer);
+		},
+		unsubscribe(topic) {
+			subscriptions.delete(topic);
+			topicSubscribers.get(topic)?.delete(peer);
+		},
+		getData() {
+			return data;
+		},
+		setData(value) {
+			data = value;
+		}
+	};
+	return peer;
+}
+function createRoom(name) {
+	const existing = rooms.get(name);
+	if (existing) return existing;
+	const room = new RoomImpl(name);
+	rooms.set(name, room);
+	return room;
+}
+function defineWebSocket(def) {
+	return def;
+}
+function defineRoom(name) {
+	return createRoom(name);
+}
+function getRoom(name) {
+	return rooms.get(name);
+}
+function getRooms() {
+	return rooms;
+}
+function broadcast(topic, data) {
+	const peers = topicSubscribers.get(topic);
+	if (!peers) return;
+	for (const peer of peers) if (peer.readyState === 1) try {
+		peer.send(data);
+	} catch {}
+}
+function registerWebSocket(path, def) {
+	definitions.set(path, def);
+}
+function getWebSocketDefinitions() {
+	return definitions;
+}
+function handleUpgrade(c, options) {
+	const path = new URL(c.req.url).pathname;
+	const def = definitions.get(path) || definitions.get("/*");
+	const peer = createPeer({
+		id: generateId$1(),
+		url: c.req.url,
+		headers: c.req.raw.headers,
+		send: options.send,
+		close: options.close,
+		raw: options.raw
+	});
+	if (def?.topics) for (const topic of def.topics) peer.subscribe(topic);
+	if (def?.rooms) for (const roomName of def.rooms) createRoom(roomName).add(peer);
+	if (def?.hooks?.open) queueMicrotask(() => {
+		Promise.resolve(def.hooks.open(peer)).catch(() => {});
+	});
+	return {
+		response: new Response(null, {
+			status: 200,
+			headers: {
+				Upgrade: "websocket",
+				Connection: "Upgrade"
+			}
+		}),
+		peer
+	};
+}
+function handleMessage(peer, message) {
+	const path = new URL(peer.url).pathname;
+	const def = definitions.get(path) || definitions.get("/*");
+	if (def?.hooks?.message) Promise.resolve(def.hooks.message(peer, message)).catch(() => {});
+}
+function handleClose(peer, code = 1e3, reason = "") {
+	const path = new URL(peer.url).pathname;
+	const def = definitions.get(path) || definitions.get("/*");
+	const internal = peer;
+	for (const topic of internal._subscriptions) topicSubscribers.get(topic)?.delete(peer);
+	for (const roomName of internal._rooms) rooms.get(roomName)?.remove(peer);
+	internal._subscriptions.clear();
+	if (def?.hooks?.close) Promise.resolve(def.hooks.close(peer, code, reason)).catch(() => {});
+}
+function handleError(peer, error) {
+	const path = new URL(peer.url).pathname;
+	const def = definitions.get(path) || definitions.get("/*");
+	if (def?.hooks?.error) Promise.resolve(def.hooks.error(peer, error)).catch(() => {});
+}
+function createWebSocketMiddleware() {
+	return async function wsMiddleware(c, next) {
+		if (c.req.header("upgrade")?.toLowerCase() !== "websocket") {
+			await next();
+			return;
+		}
+		const path = new URL(c.req.url).pathname;
+		if (!definitions.get(path)) {
+			await next();
+			return;
+		}
+		return new Response("WebSocket upgrade requires platform-specific handler", { status: 426 });
+	};
+}
+function clearWebSocketState() {
+	rooms.clear();
+	topicSubscribers.clear();
+	definitions.clear();
+	peerIdSeed.value = 0;
+}
+//#endregion
+//#region src/sse.ts
+const connections = /* @__PURE__ */ new Map();
+let idSeed = 0;
+function generateId() {
+	idSeed++;
+	return `sse_${Date.now().toString(36)}_${idSeed.toString(36)}`;
+}
+function formatSSEMessage(msg) {
+	const lines = [];
+	if (msg.comment) for (const line of msg.comment.split("\n")) lines.push(`: ${line}`);
+	if (msg.id != null) lines.push(`id: ${msg.id}`);
+	if (msg.event) lines.push(`event: ${msg.event}`);
+	if (msg.retry != null) lines.push(`retry: ${msg.retry}`);
+	if (msg.data != null) {
+		const data = typeof msg.data === "string" ? msg.data : JSON.stringify(msg.data);
+		for (const line of data.split("\n")) lines.push(`data: ${line}`);
+	}
+	return `${lines.join("\n")}\n\n`;
+}
+var SSEConnectionImpl = class {
+	id;
+	writer = null;
+	encoder = new TextEncoder();
+	_closed = false;
+	keepAliveTimer = null;
+	onCloseCb;
+	constructor(writer, options = {}, onClose) {
+		this.id = generateId();
+		this.writer = writer;
+		this.onCloseCb = onClose;
+		if (options.keepAlive !== false) {
+			const interval = typeof options.keepAlive === "number" ? options.keepAlive : 3e4;
+			this.keepAliveTimer = setInterval(() => {
+				if (!this._closed) this.comment("keep-alive");
+			}, interval);
+		}
+		connections.set(this.id, this);
+	}
+	get closed() {
+		return this._closed;
+	}
+	send(msg) {
+		if (this._closed || !this.writer) return;
+		const raw = formatSSEMessage(msg);
+		this.writer.write(this.encoder.encode(raw)).catch(() => this._cleanup());
+	}
+	sendData(data, event) {
+		this.send({
+			data,
+			event
+		});
+	}
+	comment(text) {
+		if (this._closed || !this.writer) return;
+		try {
+			const raw = `: ${text}\n\n`;
+			this.writer.write(this.encoder.encode(raw)).catch(() => this._cleanup());
+		} catch {
+			this._cleanup();
+		}
+	}
+	close() {
+		this._cleanup();
+	}
+	_cleanup() {
+		if (this._closed) return;
+		this._closed = true;
+		if (this.keepAliveTimer) {
+			clearInterval(this.keepAliveTimer);
+			this.keepAliveTimer = null;
+		}
+		if (this.writer) {
+			try {
+				this.writer.close();
+			} catch {}
+			this.writer = null;
+		}
+		connections.delete(this.id);
+		if (this.onCloseCb) {
+			try {
+				Promise.resolve(this.onCloseCb(this)).catch(() => {});
+			} catch {}
+			this.onCloseCb = void 0;
+		}
+	}
+};
+function createSSEStream(c, handler, options = {}) {
+	const { readable, writable } = new TransformStream();
+	const writer = writable.getWriter();
+	const headers = {
+		"Content-Type": "text/event-stream",
+		"Cache-Control": "no-cache, no-transform",
+		Connection: "keep-alive",
+		"X-Accel-Buffering": "no",
+		...options.headers
+	};
+	const connection = new SSEConnectionImpl(writer, options, handler.onClose);
+	if (options.retry != null) connection.send({ retry: options.retry });
+	queueMicrotask(() => {
+		Promise.resolve(handler.onConnect?.(connection)).catch(() => {});
+	});
+	return new Response(readable, { headers });
+}
+function defineSSE(handler, options) {
+	return (async (c) => {
+		return createSSEStream(c, handler, options);
+	});
+}
+function getSSEConnections() {
+	return connections;
+}
+function broadcastSSE(event, data, filter) {
+	for (const conn of connections.values()) if (!conn.closed && (!filter || filter(conn))) conn.sendData(data, event);
+}
+function closeAllSSE() {
+	for (const conn of Array.from(connections.values())) conn.close();
+	connections.clear();
+}
+function sseHeaders() {
+	return {
+		"Content-Type": "text/event-stream",
+		"Cache-Control": "no-cache, no-transform",
+		Connection: "keep-alive",
+		"X-Accel-Buffering": "no"
+	};
+}
+function clearSSEState() {
+	closeAllSSE();
+	idSeed = 0;
+}
+//#endregion
+export { registerWebSocket as S, getWebSocketDefinitions as _, defineSSE as a, handleMessage as b, sseHeaders as c, createRoom as d, createWebSocketMiddleware as f, getRooms as g, getRoom as h, createSSEStream as i, broadcast as l, defineWebSocket as m, clearSSEState as n, formatSSEMessage as o, defineRoom as p, closeAllSSE as r, getSSEConnections as s, broadcastSSE as t, clearWebSocketState as u, handleClose as v, handleUpgrade as x, handleError as y };

package/dist/static-DPHaovQe.js

@@ -0,0 +1,90 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { extname, join } from "pathe";
+//#region src/static.ts
+const MIME_TYPES = {
+	".html": "text/html; charset=utf-8",
+	".htm": "text/html; charset=utf-8",
+	".css": "text/css; charset=utf-8",
+	".js": "application/javascript; charset=utf-8",
+	".mjs": "application/javascript; charset=utf-8",
+	".json": "application/json; charset=utf-8",
+	".svg": "image/svg+xml",
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".gif": "image/gif",
+	".webp": "image/webp",
+	".ico": "image/x-icon",
+	".avif": "image/avif",
+	".woff": "font/woff",
+	".woff2": "font/woff2",
+	".ttf": "font/ttf",
+	".otf": "font/otf",
+	".eot": "application/vnd.ms-fontobject",
+	".txt": "text/plain; charset=utf-8",
+	".xml": "application/xml; charset=utf-8",
+	".pdf": "application/pdf",
+	".zip": "application/zip",
+	".gz": "application/gzip",
+	".mp3": "audio/mpeg",
+	".mp4": "video/mp4",
+	".webm": "video/webm",
+	".wasm": "application/wasm",
+	".map": "application/json; charset=utf-8"
+};
+function getMimeType(filePath) {
+	const ext = extname(filePath).toLowerCase();
+	return MIME_TYPES[ext] || "application/octet-stream";
+}
+function serveStatic(options) {
+	const { publicDir, indexFiles = ["index.html"], maxAge = 3600 } = options;
+	return async (c, next) => {
+		const path = decodeURIComponent(c.req.path);
+		if (path.startsWith("/_") || path.startsWith("/api/")) return next();
+		let filePath = join(publicDir, path);
+		try {
+			if (!existsSync(filePath)) {
+				if (path.endsWith("/")) for (const indexFile of indexFiles) {
+					const indexPath = join(filePath, indexFile);
+					if (existsSync(indexPath) && statSync(indexPath).isFile()) {
+						filePath = indexPath;
+						break;
+					}
+				}
+				if (!existsSync(filePath) || !statSync(filePath).isFile()) return next();
+			}
+			if (statSync(filePath).isDirectory()) for (const indexFile of indexFiles) {
+				const indexPath = join(filePath, indexFile);
+				if (existsSync(indexPath) && statSync(indexPath).isFile()) {
+					filePath = indexPath;
+					break;
+				}
+			}
+			if (!existsSync(filePath) || statSync(filePath).isDirectory()) return next();
+			const finalStat = statSync(filePath);
+			const mimeType = getMimeType(filePath);
+			const body = readFileSync(filePath);
+			const headers = {
+				"Content-Type": mimeType,
+				"Content-Length": String(body.length),
+				"Cache-Control": `public, max-age=${maxAge}`,
+				"X-Content-Type-Options": "nosniff"
+			};
+			const ifNoneMatch = c.req.header("If-None-Match");
+			const etag = `"${finalStat.size.toString(16)}-${finalStat.mtimeMs.toString(16)}"`;
+			if (ifNoneMatch === etag) return new Response(null, {
+				status: 304,
+				headers
+			});
+			headers.ETag = etag;
+			return new Response(body, {
+				status: 200,
+				headers
+			});
+		} catch {
+			return next();
+		}
+	};
+}
+//#endregion
+export { serveStatic as t };

package/dist/static-K2dRvjpS.d.ts

@@ -0,0 +1,11 @@
+import { MiddlewareHandler } from "hono";
+import { UbeanEnv } from "@ubean/shared";
+//#region src/static.d.ts
+interface ServeStaticOptions {
+  publicDir: string;
+  indexFiles?: string[];
+  maxAge?: number;
+}
+declare function serveStatic(options: ServeStaticOptions): MiddlewareHandler<UbeanEnv>;
+//#endregion
+export { serveStatic as n, ServeStaticOptions as t };

package/dist/static.d.ts

@@ -0,0 +1,2 @@
+import { n as serveStatic, t as ServeStaticOptions } from "./static-K2dRvjpS.js";
+export { ServeStaticOptions, serveStatic };

package/dist/static.js

@@ -0,0 +1,2 @@
+import { t as serveStatic } from "./static-DPHaovQe.js";
+export { serveStatic };

package/dist/storage-BZLMaqHr.js

@@ -0,0 +1,162 @@
+//#region src/storage.ts
+function createMemoryDriver() {
+	const store = /* @__PURE__ */ new Map();
+	return {
+		async getItemRaw(key) {
+			return store.get(key);
+		},
+		async setItemRaw(key, value) {
+			store.set(key, value);
+		},
+		async removeItem(key) {
+			store.delete(key);
+		},
+		async getKeys(base) {
+			const prefix = base || "";
+			return Array.from(store.keys()).filter((k) => k.startsWith(prefix));
+		},
+		async clear(base) {
+			if (!base) {
+				store.clear();
+				return;
+			}
+			for (const key of Array.from(store.keys())) if (key.startsWith(base)) store.delete(key);
+		},
+		async hasItem(key) {
+			return store.has(key);
+		}
+	};
+}
+function createStorage(options = {}) {
+	const mounts = /* @__PURE__ */ new Map();
+	const rootDriver = options.driver || createMemoryDriver();
+	const rootBase = options.base ? `${options.base.replace(/\/$/, "")}:` : "";
+	function resolveKey(key) {
+		const fullKey = rootBase + key;
+		let bestMatch = "";
+		let bestDriver = rootDriver;
+		for (const [base, driver] of mounts) if (fullKey.startsWith(`${base}:`) && base.length > bestMatch.length) {
+			bestMatch = base;
+			bestDriver = driver;
+		}
+		const relativeKey = bestMatch ? fullKey.slice(bestMatch.length + 1) : fullKey;
+		return {
+			driver: bestDriver,
+			relativeKey
+		};
+	}
+	async function getEntry(key) {
+		const { driver, relativeKey } = resolveKey(key);
+		const raw = await driver.getItemRaw(relativeKey);
+		if (raw === void 0 || raw === null) return null;
+		const entry = raw;
+		if (entry.expiresAt && Date.now() > entry.expiresAt) {
+			await driver.removeItem(relativeKey);
+			return null;
+		}
+		return entry;
+	}
+	return {
+		async get(key) {
+			const entry = await getEntry(key);
+			return entry ? entry.value : null;
+		},
+		async set(key, value, ttl) {
+			const { driver, relativeKey } = resolveKey(key);
+			const entry = {
+				value,
+				createdAt: Date.now(),
+				expiresAt: ttl ? Date.now() + ttl * 1e3 : void 0
+			};
+			await driver.setItemRaw(relativeKey, entry);
+		},
+		async remove(key) {
+			const { driver, relativeKey } = resolveKey(key);
+			await driver.removeItem(relativeKey);
+		},
+		async keys(base) {
+			const prefix = base || "";
+			const rootPrefix = rootBase;
+			const results = /* @__PURE__ */ new Set();
+			const rootKeys = await rootDriver.getKeys(rootPrefix);
+			for (const k of rootKeys) {
+				const stripped = k.slice(rootPrefix.length);
+				if (!prefix || stripped.startsWith(prefix)) results.add(stripped);
+			}
+			return Array.from(results);
+		},
+		async clear(base) {
+			const rootPrefix = rootBase + (base || "");
+			const rootKeys = await rootDriver.getKeys(rootPrefix);
+			for (const k of rootKeys) await rootDriver.removeItem(k);
+		},
+		async has(key) {
+			return await getEntry(key) !== null;
+		},
+		async getMeta(key) {
+			const entry = await getEntry(key);
+			if (!entry) return null;
+			return {
+				ttl: entry.expiresAt ? Math.max(0, Math.floor((entry.expiresAt - Date.now()) / 1e3)) : void 0,
+				createdAt: entry.createdAt,
+				expiresAt: entry.expiresAt
+			};
+		},
+		mount(base, driver) {
+			mounts.set(rootBase + base.replace(/\/$/, ""), driver);
+		}
+	};
+}
+let globalStorage = null;
+function useStorage(storage) {
+	if (storage) {
+		globalStorage = storage;
+		return storage;
+	}
+	if (!globalStorage) globalStorage = createStorage();
+	return globalStorage;
+}
+function clearGlobalStorage() {
+	globalStorage = null;
+}
+function createKV(options = {}) {
+	const storage = useStorage();
+	const prefix = options.prefix || "kv:default";
+	const serialize = options.serialize || ((v) => JSON.stringify(v));
+	const deserialize = options.deserialize || ((raw) => JSON.parse(raw));
+	const fullKey = (key) => `${prefix}:${key}`;
+	return {
+		async get(key) {
+			const raw = await storage.get(fullKey(key));
+			if (raw === null) return null;
+			return deserialize(raw);
+		},
+		async set(key, value, ttl) {
+			await storage.set(fullKey(key), serialize(value), ttl ?? options.ttl);
+		},
+		async remove(key) {
+			await storage.remove(fullKey(key));
+		},
+		async keys() {
+			return (await storage.keys(prefix)).map((k) => k.slice(prefix.length + 1)).filter((k) => k.length > 0);
+		},
+		async has(key) {
+			return storage.has(fullKey(key));
+		},
+		async clear() {
+			await storage.clear(prefix);
+		}
+	};
+}
+const namespaces = /* @__PURE__ */ new Map();
+function useKV(name = "default", options) {
+	if (namespaces.has(name)) return namespaces.get(name);
+	const ns = createKV({
+		...options,
+		prefix: `kv:${name}`
+	});
+	namespaces.set(name, ns);
+	return ns;
+}
+//#endregion
+export { useKV as a, createStorage as i, createKV as n, useStorage as o, createMemoryDriver as r, clearGlobalStorage as t };