@wooksjs/event-http 0.5.20 → 0.5.25

package/dist/index.cjs

@@ -1,1034 +1,1031 @@
-'use strict';
+"use strict";
+//#region rolldown:runtime
+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 __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 eventCore = require('@wooksjs/event-core');
-var url = require('url');
-var http = require('http');
-var wooks = require('wooks');
-var stream = require('stream');
+//#endregion
+const __wooksjs_event_core = __toESM(require("@wooksjs/event-core"));
+const buffer = __toESM(require("buffer"));
+const url = __toESM(require("url"));
+const http = __toESM(require("http"));
+const wooks = __toESM(require("wooks"));
+const stream = __toESM(require("stream"));
 
+//#region packages/event-http/src/event-http.ts
 function createHttpContext(data, options) {
-    return eventCore.createAsyncEventContext({
-        event: {
-            ...data,
-            type: 'HTTP',
-        },
-        options,
-    });
+	return (0, __wooksjs_event_core.createAsyncEventContext)({
+		event: {
+			...data,
+			type: "HTTP"
+		},
+		options
+	});
 }
 function useHttpContext() {
-    return eventCore.useAsyncEventContext('HTTP');
+	return (0, __wooksjs_event_core.useAsyncEventContext)("HTTP");
 }
 
+//#endregion
+//#region packages/event-http/src/utils/helpers.ts
 function escapeRegex(s) {
-    return s.replace(/[$()*+./?[\\\]^{|}-]/g, '\\$&');
+	return s.replace(/[$()*+\-./?[\\\]^{|}]/gu, "\\$&");
 }
 function safeDecode(f, v) {
-    try {
-        return f(v);
-    }
-    catch (error) {
-        return v;
-    }
+	try {
+		return f(v);
+	} catch (error) {
+		return v;
+	}
 }
 function safeDecodeURIComponent(uri) {
-    if (!uri.includes('%')) {
-        return uri;
-    }
-    return safeDecode(decodeURIComponent, uri);
+	if (!uri.includes("%")) return uri;
+	return safeDecode(decodeURIComponent, uri);
 }
 
-function convertTime(time, unit = 'ms') {
-    if (typeof time === 'number') {
-        return time / units[unit];
-    }
-    const rg = /(\d+)(\w+)/g;
-    let t = 0;
-    let r;
-    while ((r = rg.exec(time))) {
-        t += Number(r[1]) * (units[r[2]] || 0);
-    }
-    return t / units[unit];
+//#endregion
+//#region packages/event-http/src/utils/time.ts
+function convertTime(time, unit = "ms") {
+	if (typeof time === "number") return time / units[unit];
+	const rg = /(\d+)(\w+)/gu;
+	let t = 0;
+	let r;
+	while (r = rg.exec(time)) t += Number(r[1]) * (units[r[2]] || 0);
+	return t / units[unit];
 }
 const units = {
-    ms: 1,
-    s: 1000,
-    m: 1000 * 60,
-    h: 1000 * 60 * 60,
-    d: 1000 * 60 * 60 * 24,
-    w: 1000 * 60 * 60 * 24 * 7,
-    M: 1000 * 60 * 60 * 24 * 30,
-    Y: 1000 * 60 * 60 * 24 * 365,
+	ms: 1,
+	s: 1e3,
+	m: 6e4,
+	h: 36e5,
+	d: 864e5,
+	w: 6048e5,
+	M: 2592e6,
+	Y: 31536e6
 };
 
+//#endregion
+//#region packages/event-http/src/utils/set-cookie.ts
 function renderCookie(key, data) {
-    let attrs = '';
-    for (const [a, v] of Object.entries(data.attrs)) {
-        const func = cookieAttrFunc[a];
-        if (typeof func === 'function') {
-            const val = func(v);
-            attrs += val ? `; ${val}` : '';
-        }
-        else {
-            throw new TypeError(`Unknown Set-Cookie attribute ${a}`);
-        }
-    }
-    return `${key}=${encodeURIComponent(data.value)}${attrs}`;
+	let attrs = "";
+	for (const [a, v] of Object.entries(data.attrs)) {
+		const func = cookieAttrFunc[a];
+		if (typeof func === "function") {
+			const val = func(v);
+			attrs += val ? `; ${val}` : "";
+		} else throw new TypeError(`Unknown Set-Cookie attribute ${a}`);
+	}
+	return `${key}=${encodeURIComponent(data.value)}${attrs}`;
 }
 const cookieAttrFunc = {
-    expires: (v) => `Expires=${typeof v === 'string' || typeof v === 'number' ? new Date(v).toUTCString() : v.toUTCString()}`,
-    maxAge: (v) => `Max-Age=${convertTime(v, 's').toString()}`,
-    domain: (v) => `Domain=${v}`,
-    path: (v) => `Path=${v}`,
-    secure: (v) => (v ? 'Secure' : ''),
-    httpOnly: (v) => (v ? 'HttpOnly' : ''),
-    sameSite: (v) => v ? `SameSite=${typeof v === 'string' ? v : 'Strict'}` : '',
+	expires: (v) => `Expires=${typeof v === "string" || typeof v === "number" ? new Date(v).toUTCString() : v.toUTCString()}`,
+	maxAge: (v) => `Max-Age=${convertTime(v, "s").toString()}`,
+	domain: (v) => `Domain=${v}`,
+	path: (v) => `Path=${v}`,
+	secure: (v) => v ? "Secure" : "",
+	httpOnly: (v) => v ? "HttpOnly" : "",
+	sameSite: (v) => v ? `SameSite=${typeof v === "string" ? v : "Strict"}` : ""
 };
 
-const xForwardedFor = 'x-forwarded-for';
+//#endregion
+//#region packages/event-http/src/composables/request.ts
+const xForwardedFor = "x-forwarded-for";
 function useRequest() {
-    const { store } = useHttpContext();
-    const { init } = store('request');
-    const event = store('event');
-    const req = event.get('req');
-    const rawBody = () => init('rawBody', () => new Promise((resolve, reject) => {
-        let body = Buffer.from('');
-        req.on('data', chunk => {
-            body = Buffer.concat([body, chunk]);
-        });
-        req.on('error', err => {
-            reject(err);
-        });
-        req.on('end', () => {
-            resolve(body);
-        });
-    }));
-    const reqId = eventCore.useEventId().getId;
-    const forwardedIp = () => init('forwardedIp', () => {
-        if (typeof req.headers[xForwardedFor] === 'string' && req.headers[xForwardedFor]) {
-            return req.headers[xForwardedFor].split(',').shift()?.trim();
-        }
-        else {
-            return '';
-        }
-    });
-    const remoteIp = () => init('remoteIp', () => req.socket.remoteAddress || req.connection.remoteAddress || '');
-    function getIp(options) {
-        if (options?.trustProxy) {
-            return forwardedIp() || getIp();
-        }
-        else {
-            return remoteIp();
-        }
-    }
-    const getIpList = () => init('ipList', () => ({
-        remoteIp: req.socket.remoteAddress || req.connection.remoteAddress || '',
-        forwarded: (req.headers[xForwardedFor] || '').split(',').map(s => s.trim()),
-    }));
-    return {
-        rawRequest: req,
-        url: req.url,
-        method: req.method,
-        headers: req.headers,
-        rawBody,
-        reqId,
-        getIp,
-        getIpList,
-    };
+	const { store } = useHttpContext();
+	const { init } = store("request");
+	const event = store("event");
+	const req = event.get("req");
+	const rawBody = () => init("rawBody", () => new Promise((resolve, reject) => {
+		let body = buffer.Buffer.from("");
+		req.on("data", (chunk) => {
+			body = buffer.Buffer.concat([body, chunk]);
+		});
+		req.on("error", (err) => {
+			reject(err);
+		});
+		req.on("end", () => {
+			resolve(body);
+		});
+	}));
+	const reqId = (0, __wooksjs_event_core.useEventId)().getId;
+	const forwardedIp = () => init("forwardedIp", () => {
+		if (typeof req.headers[xForwardedFor] === "string" && req.headers[xForwardedFor]) return req.headers[xForwardedFor].split(",").shift()?.trim();
+else return "";
+	});
+	const remoteIp = () => init("remoteIp", () => req.socket.remoteAddress || req.connection.remoteAddress || "");
+	function getIp(options) {
+		if (options?.trustProxy) return forwardedIp() || getIp();
+else return remoteIp();
+	}
+	const getIpList = () => init("ipList", () => ({
+		remoteIp: req.socket.remoteAddress || req.connection.remoteAddress || "",
+		forwarded: (req.headers[xForwardedFor] || "").split(",").map((s) => s.trim())
+	}));
+	return {
+		rawRequest: req,
+		url: req.url,
+		method: req.method,
+		headers: req.headers,
+		rawBody,
+		reqId,
+		getIp,
+		getIpList
+	};
 }
 
+//#endregion
+//#region packages/event-http/src/composables/headers.ts
 function useHeaders() {
-    return useRequest().headers;
+	return useRequest().headers;
 }
 function useSetHeaders() {
-    const { store } = useHttpContext();
-    const setHeaderStore = store('setHeader');
-    function setHeader(name, value) {
-        setHeaderStore.set(name, value.toString());
-    }
-    function setContentType(value) {
-        setHeader('content-type', value);
-    }
-    function enableCors(origin = '*') {
-        setHeader('access-control-allow-origin', origin);
-    }
-    return {
-        setHeader,
-        getHeader: setHeaderStore.get,
-        removeHeader: setHeaderStore.del,
-        setContentType,
-        headers: () => setHeaderStore.value || {},
-        enableCors,
-    };
+	const { store } = useHttpContext();
+	const setHeaderStore = store("setHeader");
+	function setHeader(name, value) {
+		setHeaderStore.set(name, value.toString());
+	}
+	function setContentType(value) {
+		setHeader("content-type", value);
+	}
+	function enableCors(origin = "*") {
+		setHeader("access-control-allow-origin", origin);
+	}
+	return {
+		setHeader,
+		getHeader: setHeaderStore.get,
+		removeHeader: setHeaderStore.del,
+		setContentType,
+		headers: () => setHeaderStore.value || {},
+		enableCors
+	};
 }
 function useSetHeader(name) {
-    const { store } = useHttpContext();
-    const { hook } = store('setHeader');
-    return hook(name);
+	const { store } = useHttpContext();
+	const { hook } = store("setHeader");
+	return hook(name);
 }
 
+//#endregion
+//#region packages/event-http/src/composables/cookies.ts
 function useCookies() {
-    const { store } = useHttpContext();
-    const { cookie } = useHeaders();
-    const { init } = store('cookies');
-    const getCookie = (name) => init(name, () => {
-        if (cookie) {
-            const result = new RegExp(`(?:^|; )${escapeRegex(name)}=(.*?)(?:;?$|; )`, 'i').exec(cookie);
-            return result?.[1] ? safeDecodeURIComponent(result[1]) : null;
-        }
-        else {
-            return null;
-        }
-    });
-    return {
-        rawCookies: cookie,
-        getCookie,
-    };
+	const { store } = useHttpContext();
+	const { cookie } = useHeaders();
+	const { init } = store("cookies");
+	const getCookie = (name) => init(name, () => {
+		if (cookie) {
+			const result = new RegExp(`(?:^|; )${escapeRegex(name)}=(.*?)(?:;?$|; )`, "i").exec(cookie);
+			return result?.[1] ? safeDecodeURIComponent(result[1]) : null;
+		} else return null;
+	});
+	return {
+		rawCookies: cookie,
+		getCookie
+	};
 }
 function useSetCookies() {
-    const { store } = useHttpContext();
-    const cookiesStore = store('setCookies');
-    function setCookie(name, value, attrs) {
-        cookiesStore.set(name, {
-            value,
-            attrs: attrs || {},
-        });
-    }
-    function cookies() {
-        return cookiesStore
-            .entries()
-            .filter(a => !!a[1])
-            .map(([key, value]) => renderCookie(key, value));
-    }
-    return {
-        setCookie,
-        getCookie: cookiesStore.get,
-        removeCookie: cookiesStore.del,
-        clearCookies: cookiesStore.clear,
-        cookies,
-    };
+	const { store } = useHttpContext();
+	const cookiesStore = store("setCookies");
+	function setCookie(name, value, attrs) {
+		cookiesStore.set(name, {
+			value,
+			attrs: attrs || {}
+		});
+	}
+	function cookies() {
+		return cookiesStore.entries().filter((a) => !!a[1]).map(([key, value]) => renderCookie(key, value));
+	}
+	return {
+		setCookie,
+		getCookie: cookiesStore.get,
+		removeCookie: cookiesStore.del,
+		clearCookies: cookiesStore.clear,
+		cookies
+	};
 }
 function useSetCookie(name) {
-    const { setCookie, getCookie } = useSetCookies();
-    const valueHook = eventCore.attachHook({
-        name,
-        type: 'cookie',
-    }, {
-        get: () => getCookie(name)?.value,
-        set: (value) => {
-            setCookie(name, value, getCookie(name)?.attrs);
-        },
-    });
-    return eventCore.attachHook(valueHook, {
-        get: () => getCookie(name)?.attrs,
-        set: (attrs) => {
-            setCookie(name, getCookie(name)?.value || '', attrs);
-        },
-    }, 'attrs');
+	const { setCookie, getCookie } = useSetCookies();
+	const valueHook = (0, __wooksjs_event_core.attachHook)({
+		name,
+		type: "cookie"
+	}, {
+		get: () => getCookie(name)?.value,
+		set: (value) => {
+			setCookie(name, value, getCookie(name)?.attrs);
+		}
+	});
+	return (0, __wooksjs_event_core.attachHook)(valueHook, {
+		get: () => getCookie(name)?.attrs,
+		set: (attrs) => {
+			setCookie(name, getCookie(name)?.value || "", attrs);
+		}
+	}, "attrs");
 }
 
+//#endregion
+//#region packages/event-http/src/composables/header-accept.ts
 function useAccept() {
-    const { store } = useHttpContext();
-    const { accept } = useHeaders();
-    const accepts = (mime) => {
-        const { set, get, has } = store('accept');
-        if (!has(mime)) {
-            return set(mime, !!(accept && (accept === '*/*' || accept.includes(mime))));
-        }
-        return get(mime);
-    };
-    return {
-        accept,
-        accepts,
-        acceptsJson: () => accepts('application/json'),
-        acceptsXml: () => accepts('application/xml'),
-        acceptsText: () => accepts('text/plain'),
-        acceptsHtml: () => accepts('text/html'),
-    };
+	const { store } = useHttpContext();
+	const { accept } = useHeaders();
+	const accepts = (mime) => {
+		const { set, get, has } = store("accept");
+		if (!has(mime)) return set(mime, !!(accept && (accept === "*/*" || accept.includes(mime))));
+		return get(mime);
+	};
+	return {
+		accept,
+		accepts,
+		acceptsJson: () => accepts("application/json"),
+		acceptsXml: () => accepts("application/xml"),
+		acceptsText: () => accepts("text/plain"),
+		acceptsHtml: () => accepts("text/html")
+	};
 }
 
+//#endregion
+//#region packages/event-http/src/composables/header-authorization.ts
 function useAuthorization() {
-    const { store } = useHttpContext();
-    const { authorization } = useHeaders();
-    const { init } = store('authorization');
-    const authType = () => init('type', () => {
-        if (authorization) {
-            const space = authorization.indexOf(' ');
-            return authorization.slice(0, space);
-        }
-        return null;
-    });
-    const authRawCredentials = () => init('credentials', () => {
-        if (authorization) {
-            const space = authorization.indexOf(' ');
-            return authorization.slice(space + 1);
-        }
-        return null;
-    });
-    return {
-        authorization,
-        authType,
-        authRawCredentials,
-        isBasic: () => authType()?.toLocaleLowerCase() === 'basic',
-        isBearer: () => authType()?.toLocaleLowerCase() === 'bearer',
-        basicCredentials: () => init('basicCredentials', () => {
-            if (authorization) {
-                const type = authType();
-                if (type?.toLocaleLowerCase() === 'basic') {
-                    const creds = Buffer.from(authRawCredentials() || '', 'base64').toString('ascii');
-                    const [username, password] = creds.split(':');
-                    return { username, password };
-                }
-            }
-            return null;
-        }),
-    };
+	const { store } = useHttpContext();
+	const { authorization } = useHeaders();
+	const { init } = store("authorization");
+	const authType = () => init("type", () => {
+		if (authorization) {
+			const space = authorization.indexOf(" ");
+			return authorization.slice(0, space);
+		}
+		return null;
+	});
+	const authRawCredentials = () => init("credentials", () => {
+		if (authorization) {
+			const space = authorization.indexOf(" ");
+			return authorization.slice(space + 1);
+		}
+		return null;
+	});
+	return {
+		authorization,
+		authType,
+		authRawCredentials,
+		isBasic: () => authType()?.toLocaleLowerCase() === "basic",
+		isBearer: () => authType()?.toLocaleLowerCase() === "bearer",
+		basicCredentials: () => init("basicCredentials", () => {
+			if (authorization) {
+				const type = authType();
+				if (type?.toLocaleLowerCase() === "basic") {
+					const creds = buffer.Buffer.from(authRawCredentials() || "", "base64").toString("ascii");
+					const [username, password] = creds.split(":");
+					return {
+						username,
+						password
+					};
+				}
+			}
+			return null;
+		})
+	};
 }
 
+//#endregion
+//#region packages/event-http/src/utils/cache-control.ts
 function renderCacheControl(data) {
-    let attrs = '';
-    for (const [a, v] of Object.entries(data)) {
-        if (v === undefined) {
-            continue;
-        }
-        const func = cacheControlFunc[a];
-        if (typeof func === 'function') {
-            const val = func(v);
-            if (val) {
-                attrs += attrs ? `, ${val}` : val;
-            }
-        }
-        else {
-            throw new TypeError(`Unknown Cache-Control attribute ${a}`);
-        }
-    }
-    return attrs;
+	let attrs = "";
+	for (const [a, v] of Object.entries(data)) {
+		if (v === undefined) continue;
+		const func = cacheControlFunc[a];
+		if (typeof func === "function") {
+			const val = func(v);
+			if (val) attrs += attrs ? `, ${val}` : val;
+		} else throw new TypeError(`Unknown Cache-Control attribute ${a}`);
+	}
+	return attrs;
 }
 const cacheControlFunc = {
-    mustRevalidate: (v) => (v ? 'must-revalidate' : ''),
-    noCache: (v) => v ? (typeof v === 'string' ? `no-cache="${v}"` : 'no-cache') : '',
-    noStore: (v) => (v ? 'no-store' : ''),
-    noTransform: (v) => (v ? 'no-transform' : ''),
-    public: (v) => (v ? 'public' : ''),
-    private: (v) => v ? (typeof v === 'string' ? `private="${v}"` : 'private') : '',
-    proxyRevalidate: (v) => (v ? 'proxy-revalidate' : ''),
-    maxAge: (v) => `max-age=${convertTime(v, 's').toString()}`,
-    sMaxage: (v) => `s-maxage=${convertTime(v, 's').toString()}`,
+	mustRevalidate: (v) => v ? "must-revalidate" : "",
+	noCache: (v) => v ? typeof v === "string" ? `no-cache="${v}"` : "no-cache" : "",
+	noStore: (v) => v ? "no-store" : "",
+	noTransform: (v) => v ? "no-transform" : "",
+	public: (v) => v ? "public" : "",
+	private: (v) => v ? typeof v === "string" ? `private="${v}"` : "private" : "",
+	proxyRevalidate: (v) => v ? "proxy-revalidate" : "",
+	maxAge: (v) => `max-age=${convertTime(v, "s").toString()}`,
+	sMaxage: (v) => `s-maxage=${convertTime(v, "s").toString()}`
 };
 
-const renderAge = (v) => convertTime(v, 's').toString();
-const renderExpires = (v) => typeof v === 'string' || typeof v === 'number' ? new Date(v).toUTCString() : v.toUTCString();
-const renderPragmaNoCache = (v) => (v ? 'no-cache' : '');
+//#endregion
+//#region packages/event-http/src/composables/header-set-cache-control.ts
+const renderAge = (v) => convertTime(v, "s").toString();
+const renderExpires = (v) => typeof v === "string" || typeof v === "number" ? new Date(v).toUTCString() : v.toUTCString();
+const renderPragmaNoCache = (v) => v ? "no-cache" : "";
 function useSetCacheControl() {
-    const { setHeader } = useSetHeaders();
-    const setAge = (value) => {
-        setHeader('age', renderAge(value));
-    };
-    const setExpires = (value) => {
-        setHeader('expires', renderExpires(value));
-    };
-    const setPragmaNoCache = (value = true) => {
-        setHeader('pragma', renderPragmaNoCache(value));
-    };
-    const setCacheControl = (data) => {
-        setHeader('cache-control', renderCacheControl(data));
-    };
-    return {
-        setExpires,
-        setAge,
-        setPragmaNoCache,
-        setCacheControl,
-    };
+	const { setHeader } = useSetHeaders();
+	const setAge = (value) => {
+		setHeader("age", renderAge(value));
+	};
+	const setExpires = (value) => {
+		setHeader("expires", renderExpires(value));
+	};
+	const setPragmaNoCache = (value = true) => {
+		setHeader("pragma", renderPragmaNoCache(value));
+	};
+	const setCacheControl = (data) => {
+		setHeader("cache-control", renderCacheControl(data));
+	};
+	return {
+		setExpires,
+		setAge,
+		setPragmaNoCache,
+		setCacheControl
+	};
 }
 
+//#endregion
+//#region packages/event-http/src/composables/response.ts
 function useResponse() {
-    const { store } = useHttpContext();
-    const event = store('event');
-    const res = event.get('res');
-    const responded = store('response').hook('responded');
-    const statusCode = store('status').hook('code');
-    function status(code) {
-        return (statusCode.value = code ? code : statusCode.value);
-    }
-    const rawResponse = (options) => {
-        if (!options || !options.passthrough) {
-            responded.value = true;
-        }
-        return res;
-    };
-    return {
-        rawResponse,
-        hasResponded: () => responded.value || !res.writable || res.writableEnded,
-        status: eventCore.attachHook(status, {
-            get: () => statusCode.value,
-            set: (code) => (statusCode.value = code),
-        }),
-    };
+	const { store } = useHttpContext();
+	const event = store("event");
+	const res = event.get("res");
+	const responded = store("response").hook("responded");
+	const statusCode = store("status").hook("code");
+	function status(code) {
+		return statusCode.value = code ? code : statusCode.value;
+	}
+	const rawResponse = (options) => {
+		if (!options || !options.passthrough) responded.value = true;
+		return res;
+	};
+	return {
+		rawResponse,
+		hasResponded: () => responded.value || !res.writable || res.writableEnded,
+		status: (0, __wooksjs_event_core.attachHook)(status, {
+			get: () => statusCode.value,
+			set: (code) => statusCode.value = code
+		})
+	};
 }
 function useStatus() {
-    const { store } = useHttpContext();
-    return store('status').hook('code');
+	const { store } = useHttpContext();
+	return store("status").hook("code");
 }
 
-class WooksURLSearchParams extends url.URLSearchParams {
-    toJson() {
-        const json = {};
-        for (const [key, value] of this.entries()) {
-            if (isArrayParam(key)) {
-                const a = (json[key] = (json[key] || []));
-                a.push(value);
-            }
-            else {
-                json[key] = value;
-            }
-        }
-        return json;
-    }
-}
+//#endregion
+//#region packages/event-http/src/utils/url-search-params.ts
+var WooksURLSearchParams = class extends url.URLSearchParams {
+	toJson() {
+		const json = {};
+		for (const [key, value] of this.entries()) if (isArrayParam(key)) {
+			const a = json[key] = json[key] || [];
+			a.push(value);
+		} else json[key] = value;
+		return json;
+	}
+};
 function isArrayParam(name) {
-    return name.endsWith('[]');
+	return name.endsWith("[]");
 }
 
+//#endregion
+//#region packages/event-http/src/composables/search-params.ts
 function useSearchParams() {
-    const { store } = useHttpContext();
-    const url = useRequest().url || '';
-    const { init } = store('searchParams');
-    const rawSearchParams = () => init('raw', () => {
-        const i = url.indexOf('?');
-        return i >= 0 ? url.slice(i) : '';
-    });
-    const urlSearchParams = () => init('urlSearchParams', () => new WooksURLSearchParams(rawSearchParams()));
-    return {
-        rawSearchParams,
-        urlSearchParams,
-        jsonSearchParams: () => urlSearchParams().toJson(),
-    };
+	const { store } = useHttpContext();
+	const url$1 = useRequest().url || "";
+	const { init } = store("searchParams");
+	const rawSearchParams = () => init("raw", () => {
+		const i = url$1.indexOf("?");
+		return i >= 0 ? url$1.slice(i) : "";
+	});
+	const urlSearchParams = () => init("urlSearchParams", () => new WooksURLSearchParams(rawSearchParams()));
+	return {
+		rawSearchParams,
+		urlSearchParams,
+		jsonSearchParams: () => urlSearchParams().toJson()
+	};
 }
 
-class BaseHttpResponseRenderer {
-    render(response) {
-        if (typeof response.body === 'string' ||
-            typeof response.body === 'boolean' ||
-            typeof response.body === 'number') {
-            if (!response.getContentType()) {
-                response.setContentType('text/plain');
-            }
-            return response.body.toString();
-        }
-        if (response.body === undefined) {
-            return '';
-        }
-        if (response.body instanceof Uint8Array) {
-            return response.body;
-        }
-        if (typeof response.body === 'object') {
-            if (!response.getContentType()) {
-                response.setContentType('application/json');
-            }
-            return JSON.stringify(response.body);
-        }
-        throw new Error(`Unsupported body format "${typeof response.body}"`);
-    }
-}
+//#endregion
+//#region packages/event-http/src/response/renderer.ts
+var BaseHttpResponseRenderer = class {
+	render(response) {
+		if (typeof response.body === "string" || typeof response.body === "boolean" || typeof response.body === "number") {
+			if (!response.getContentType()) response.setContentType("text/plain");
+			return response.body.toString();
+		}
+		if (response.body === undefined) return "";
+		if (response.body instanceof Uint8Array) return response.body;
+		if (typeof response.body === "object") {
+			if (!response.getContentType()) response.setContentType("application/json");
+			return JSON.stringify(response.body);
+		}
+		throw new Error(`Unsupported body format "${typeof response.body}"`);
+	}
+};
 
+//#endregion
+//#region packages/event-http/src/utils/status-codes.ts
 const httpStatusCodes = {
-    100: 'Continue',
-    101: 'Switching protocols',
-    102: 'Processing',
-    103: 'Early Hints',
-    200: 'OK',
-    201: 'Created',
-    202: 'Accepted',
-    203: 'Non-Authoritative Information',
-    204: 'No Content',
-    205: 'Reset Content',
-    206: 'Partial Content',
-    207: 'Multi-Status',
-    208: 'Already Reported',
-    226: 'IM Used',
-    300: 'Multiple Choices',
-    301: 'Moved Permanently',
-    302: 'Found (Previously "Moved Temporarily")',
-    303: 'See Other',
-    304: 'Not Modified',
-    305: 'Use Proxy',
-    306: 'Switch Proxy',
-    307: 'Temporary Redirect',
-    308: 'Permanent Redirect',
-    400: 'Bad Request',
-    401: 'Unauthorized',
-    402: 'Payment Required',
-    403: 'Forbidden',
-    404: 'Not Found',
-    405: 'Method Not Allowed',
-    406: 'Not Acceptable',
-    407: 'Proxy Authentication Required',
-    408: 'Request Timeout',
-    409: 'Conflict',
-    410: 'Gone',
-    411: 'Length Required',
-    412: 'Precondition Failed',
-    413: 'Payload Too Large',
-    414: 'URI Too Long',
-    415: 'Unsupported Media Type',
-    416: 'Range Not Satisfiable',
-    417: 'Expectation Failed',
-    418: "I'm a Teapot",
-    421: 'Misdirected Request',
-    422: 'Unprocessable Entity',
-    423: 'Locked',
-    424: 'Failed Dependency',
-    425: 'Too Early',
-    426: 'Upgrade Required',
-    428: 'Precondition Required',
-    429: 'Too Many Requests',
-    431: 'Request Header Fields Too Large',
-    451: 'Unavailable For Legal Reasons',
-    500: 'Internal Server Error',
-    501: 'Not Implemented',
-    502: 'Bad Gateway',
-    503: 'Service Unavailable',
-    504: 'Gateway Timeout',
-    505: 'HTTP Version Not Supported',
-    506: 'Variant Also Negotiates',
-    507: 'Insufficient Storage',
-    508: 'Loop Detected',
-    510: 'Not Extended',
-    511: 'Network Authentication Required',
+	100: "Continue",
+	101: "Switching protocols",
+	102: "Processing",
+	103: "Early Hints",
+	200: "OK",
+	201: "Created",
+	202: "Accepted",
+	203: "Non-Authoritative Information",
+	204: "No Content",
+	205: "Reset Content",
+	206: "Partial Content",
+	207: "Multi-Status",
+	208: "Already Reported",
+	226: "IM Used",
+	300: "Multiple Choices",
+	301: "Moved Permanently",
+	302: "Found (Previously \"Moved Temporarily\")",
+	303: "See Other",
+	304: "Not Modified",
+	305: "Use Proxy",
+	306: "Switch Proxy",
+	307: "Temporary Redirect",
+	308: "Permanent Redirect",
+	400: "Bad Request",
+	401: "Unauthorized",
+	402: "Payment Required",
+	403: "Forbidden",
+	404: "Not Found",
+	405: "Method Not Allowed",
+	406: "Not Acceptable",
+	407: "Proxy Authentication Required",
+	408: "Request Timeout",
+	409: "Conflict",
+	410: "Gone",
+	411: "Length Required",
+	412: "Precondition Failed",
+	413: "Payload Too Large",
+	414: "URI Too Long",
+	415: "Unsupported Media Type",
+	416: "Range Not Satisfiable",
+	417: "Expectation Failed",
+	418: "I'm a Teapot",
+	421: "Misdirected Request",
+	422: "Unprocessable Entity",
+	423: "Locked",
+	424: "Failed Dependency",
+	425: "Too Early",
+	426: "Upgrade Required",
+	428: "Precondition Required",
+	429: "Too Many Requests",
+	431: "Request Header Fields Too Large",
+	451: "Unavailable For Legal Reasons",
+	500: "Internal Server Error",
+	501: "Not Implemented",
+	502: "Bad Gateway",
+	503: "Service Unavailable",
+	504: "Gateway Timeout",
+	505: "HTTP Version Not Supported",
+	506: "Variant Also Negotiates",
+	507: "Insufficient Storage",
+	508: "Loop Detected",
+	510: "Not Extended",
+	511: "Network Authentication Required"
 };
-exports.EHttpStatusCode = void 0;
-(function (EHttpStatusCode) {
-    EHttpStatusCode[EHttpStatusCode["Continue"] = 100] = "Continue";
-    EHttpStatusCode[EHttpStatusCode["SwitchingProtocols"] = 101] = "SwitchingProtocols";
-    EHttpStatusCode[EHttpStatusCode["Processing"] = 102] = "Processing";
-    EHttpStatusCode[EHttpStatusCode["EarlyHints"] = 103] = "EarlyHints";
-    EHttpStatusCode[EHttpStatusCode["OK"] = 200] = "OK";
-    EHttpStatusCode[EHttpStatusCode["Created"] = 201] = "Created";
-    EHttpStatusCode[EHttpStatusCode["Accepted"] = 202] = "Accepted";
-    EHttpStatusCode[EHttpStatusCode["NonAuthoritativeInformation"] = 203] = "NonAuthoritativeInformation";
-    EHttpStatusCode[EHttpStatusCode["NoContent"] = 204] = "NoContent";
-    EHttpStatusCode[EHttpStatusCode["ResetContent"] = 205] = "ResetContent";
-    EHttpStatusCode[EHttpStatusCode["PartialContent"] = 206] = "PartialContent";
-    EHttpStatusCode[EHttpStatusCode["MultiStatus"] = 207] = "MultiStatus";
-    EHttpStatusCode[EHttpStatusCode["AlreadyReported"] = 208] = "AlreadyReported";
-    EHttpStatusCode[EHttpStatusCode["IMUsed"] = 226] = "IMUsed";
-    EHttpStatusCode[EHttpStatusCode["MultipleChoices"] = 300] = "MultipleChoices";
-    EHttpStatusCode[EHttpStatusCode["MovedPermanently"] = 301] = "MovedPermanently";
-    EHttpStatusCode[EHttpStatusCode["Found"] = 302] = "Found";
-    EHttpStatusCode[EHttpStatusCode["SeeOther"] = 303] = "SeeOther";
-    EHttpStatusCode[EHttpStatusCode["NotModified"] = 304] = "NotModified";
-    EHttpStatusCode[EHttpStatusCode["UseProxy"] = 305] = "UseProxy";
-    EHttpStatusCode[EHttpStatusCode["SwitchProxy"] = 306] = "SwitchProxy";
-    EHttpStatusCode[EHttpStatusCode["TemporaryRedirect"] = 307] = "TemporaryRedirect";
-    EHttpStatusCode[EHttpStatusCode["PermanentRedirect"] = 308] = "PermanentRedirect";
-    EHttpStatusCode[EHttpStatusCode["BadRequest"] = 400] = "BadRequest";
-    EHttpStatusCode[EHttpStatusCode["Unauthorized"] = 401] = "Unauthorized";
-    EHttpStatusCode[EHttpStatusCode["PaymentRequired"] = 402] = "PaymentRequired";
-    EHttpStatusCode[EHttpStatusCode["Forbidden"] = 403] = "Forbidden";
-    EHttpStatusCode[EHttpStatusCode["NotFound"] = 404] = "NotFound";
-    EHttpStatusCode[EHttpStatusCode["MethodNotAllowed"] = 405] = "MethodNotAllowed";
-    EHttpStatusCode[EHttpStatusCode["NotAcceptable"] = 406] = "NotAcceptable";
-    EHttpStatusCode[EHttpStatusCode["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired";
-    EHttpStatusCode[EHttpStatusCode["RequestTimeout"] = 408] = "RequestTimeout";
-    EHttpStatusCode[EHttpStatusCode["Conflict"] = 409] = "Conflict";
-    EHttpStatusCode[EHttpStatusCode["Gone"] = 410] = "Gone";
-    EHttpStatusCode[EHttpStatusCode["LengthRequired"] = 411] = "LengthRequired";
-    EHttpStatusCode[EHttpStatusCode["PreconditionFailed"] = 412] = "PreconditionFailed";
-    EHttpStatusCode[EHttpStatusCode["PayloadTooLarge"] = 413] = "PayloadTooLarge";
-    EHttpStatusCode[EHttpStatusCode["URITooLong"] = 414] = "URITooLong";
-    EHttpStatusCode[EHttpStatusCode["UnsupportedMediaType"] = 415] = "UnsupportedMediaType";
-    EHttpStatusCode[EHttpStatusCode["RangeNotSatisfiable"] = 416] = "RangeNotSatisfiable";
-    EHttpStatusCode[EHttpStatusCode["ExpectationFailed"] = 417] = "ExpectationFailed";
-    EHttpStatusCode[EHttpStatusCode["ImATeapot"] = 418] = "ImATeapot";
-    EHttpStatusCode[EHttpStatusCode["MisdirectedRequest"] = 421] = "MisdirectedRequest";
-    EHttpStatusCode[EHttpStatusCode["UnprocessableEntity"] = 422] = "UnprocessableEntity";
-    EHttpStatusCode[EHttpStatusCode["Locked"] = 423] = "Locked";
-    EHttpStatusCode[EHttpStatusCode["FailedDependency"] = 424] = "FailedDependency";
-    EHttpStatusCode[EHttpStatusCode["TooEarly"] = 425] = "TooEarly";
-    EHttpStatusCode[EHttpStatusCode["UpgradeRequired"] = 426] = "UpgradeRequired";
-    EHttpStatusCode[EHttpStatusCode["PreconditionRequired"] = 428] = "PreconditionRequired";
-    EHttpStatusCode[EHttpStatusCode["TooManyRequests"] = 429] = "TooManyRequests";
-    EHttpStatusCode[EHttpStatusCode["RequestHeaderFieldsTooLarge"] = 431] = "RequestHeaderFieldsTooLarge";
-    EHttpStatusCode[EHttpStatusCode["UnavailableForLegalReasons"] = 451] = "UnavailableForLegalReasons";
-    EHttpStatusCode[EHttpStatusCode["InternalServerError"] = 500] = "InternalServerError";
-    EHttpStatusCode[EHttpStatusCode["NotImplemented"] = 501] = "NotImplemented";
-    EHttpStatusCode[EHttpStatusCode["BadGateway"] = 502] = "BadGateway";
-    EHttpStatusCode[EHttpStatusCode["ServiceUnavailable"] = 503] = "ServiceUnavailable";
-    EHttpStatusCode[EHttpStatusCode["GatewayTimeout"] = 504] = "GatewayTimeout";
-    EHttpStatusCode[EHttpStatusCode["HTTPVersionNotSupported"] = 505] = "HTTPVersionNotSupported";
-    EHttpStatusCode[EHttpStatusCode["VariantAlsoNegotiates"] = 506] = "VariantAlsoNegotiates";
-    EHttpStatusCode[EHttpStatusCode["InsufficientStorage"] = 507] = "InsufficientStorage";
-    EHttpStatusCode[EHttpStatusCode["LoopDetected"] = 508] = "LoopDetected";
-    EHttpStatusCode[EHttpStatusCode["NotExtended"] = 510] = "NotExtended";
-    EHttpStatusCode[EHttpStatusCode["NetworkAuthenticationRequired"] = 511] = "NetworkAuthenticationRequired";
-})(exports.EHttpStatusCode || (exports.EHttpStatusCode = {}));
+let EHttpStatusCode = function(EHttpStatusCode$1) {
+	EHttpStatusCode$1[EHttpStatusCode$1["Continue"] = 100] = "Continue";
+	EHttpStatusCode$1[EHttpStatusCode$1["SwitchingProtocols"] = 101] = "SwitchingProtocols";
+	EHttpStatusCode$1[EHttpStatusCode$1["Processing"] = 102] = "Processing";
+	EHttpStatusCode$1[EHttpStatusCode$1["EarlyHints"] = 103] = "EarlyHints";
+	EHttpStatusCode$1[EHttpStatusCode$1["OK"] = 200] = "OK";
+	EHttpStatusCode$1[EHttpStatusCode$1["Created"] = 201] = "Created";
+	EHttpStatusCode$1[EHttpStatusCode$1["Accepted"] = 202] = "Accepted";
+	EHttpStatusCode$1[EHttpStatusCode$1["NonAuthoritativeInformation"] = 203] = "NonAuthoritativeInformation";
+	EHttpStatusCode$1[EHttpStatusCode$1["NoContent"] = 204] = "NoContent";
+	EHttpStatusCode$1[EHttpStatusCode$1["ResetContent"] = 205] = "ResetContent";
+	EHttpStatusCode$1[EHttpStatusCode$1["PartialContent"] = 206] = "PartialContent";
+	EHttpStatusCode$1[EHttpStatusCode$1["MultiStatus"] = 207] = "MultiStatus";
+	EHttpStatusCode$1[EHttpStatusCode$1["AlreadyReported"] = 208] = "AlreadyReported";
+	EHttpStatusCode$1[EHttpStatusCode$1["IMUsed"] = 226] = "IMUsed";
+	EHttpStatusCode$1[EHttpStatusCode$1["MultipleChoices"] = 300] = "MultipleChoices";
+	EHttpStatusCode$1[EHttpStatusCode$1["MovedPermanently"] = 301] = "MovedPermanently";
+	EHttpStatusCode$1[EHttpStatusCode$1["Found"] = 302] = "Found";
+	EHttpStatusCode$1[EHttpStatusCode$1["SeeOther"] = 303] = "SeeOther";
+	EHttpStatusCode$1[EHttpStatusCode$1["NotModified"] = 304] = "NotModified";
+	EHttpStatusCode$1[EHttpStatusCode$1["UseProxy"] = 305] = "UseProxy";
+	EHttpStatusCode$1[EHttpStatusCode$1["SwitchProxy"] = 306] = "SwitchProxy";
+	EHttpStatusCode$1[EHttpStatusCode$1["TemporaryRedirect"] = 307] = "TemporaryRedirect";
+	EHttpStatusCode$1[EHttpStatusCode$1["PermanentRedirect"] = 308] = "PermanentRedirect";
+	EHttpStatusCode$1[EHttpStatusCode$1["BadRequest"] = 400] = "BadRequest";
+	EHttpStatusCode$1[EHttpStatusCode$1["Unauthorized"] = 401] = "Unauthorized";
+	EHttpStatusCode$1[EHttpStatusCode$1["PaymentRequired"] = 402] = "PaymentRequired";
+	EHttpStatusCode$1[EHttpStatusCode$1["Forbidden"] = 403] = "Forbidden";
+	EHttpStatusCode$1[EHttpStatusCode$1["NotFound"] = 404] = "NotFound";
+	EHttpStatusCode$1[EHttpStatusCode$1["MethodNotAllowed"] = 405] = "MethodNotAllowed";
+	EHttpStatusCode$1[EHttpStatusCode$1["NotAcceptable"] = 406] = "NotAcceptable";
+	EHttpStatusCode$1[EHttpStatusCode$1["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired";
+	EHttpStatusCode$1[EHttpStatusCode$1["RequestTimeout"] = 408] = "RequestTimeout";
+	EHttpStatusCode$1[EHttpStatusCode$1["Conflict"] = 409] = "Conflict";
+	EHttpStatusCode$1[EHttpStatusCode$1["Gone"] = 410] = "Gone";
+	EHttpStatusCode$1[EHttpStatusCode$1["LengthRequired"] = 411] = "LengthRequired";
+	EHttpStatusCode$1[EHttpStatusCode$1["PreconditionFailed"] = 412] = "PreconditionFailed";
+	EHttpStatusCode$1[EHttpStatusCode$1["PayloadTooLarge"] = 413] = "PayloadTooLarge";
+	EHttpStatusCode$1[EHttpStatusCode$1["URITooLong"] = 414] = "URITooLong";
+	EHttpStatusCode$1[EHttpStatusCode$1["UnsupportedMediaType"] = 415] = "UnsupportedMediaType";
+	EHttpStatusCode$1[EHttpStatusCode$1["RangeNotSatisfiable"] = 416] = "RangeNotSatisfiable";
+	EHttpStatusCode$1[EHttpStatusCode$1["ExpectationFailed"] = 417] = "ExpectationFailed";
+	EHttpStatusCode$1[EHttpStatusCode$1["ImATeapot"] = 418] = "ImATeapot";
+	EHttpStatusCode$1[EHttpStatusCode$1["MisdirectedRequest"] = 421] = "MisdirectedRequest";
+	EHttpStatusCode$1[EHttpStatusCode$1["UnprocessableEntity"] = 422] = "UnprocessableEntity";
+	EHttpStatusCode$1[EHttpStatusCode$1["Locked"] = 423] = "Locked";
+	EHttpStatusCode$1[EHttpStatusCode$1["FailedDependency"] = 424] = "FailedDependency";
+	EHttpStatusCode$1[EHttpStatusCode$1["TooEarly"] = 425] = "TooEarly";
+	EHttpStatusCode$1[EHttpStatusCode$1["UpgradeRequired"] = 426] = "UpgradeRequired";
+	EHttpStatusCode$1[EHttpStatusCode$1["PreconditionRequired"] = 428] = "PreconditionRequired";
+	EHttpStatusCode$1[EHttpStatusCode$1["TooManyRequests"] = 429] = "TooManyRequests";
+	EHttpStatusCode$1[EHttpStatusCode$1["RequestHeaderFieldsTooLarge"] = 431] = "RequestHeaderFieldsTooLarge";
+	EHttpStatusCode$1[EHttpStatusCode$1["UnavailableForLegalReasons"] = 451] = "UnavailableForLegalReasons";
+	EHttpStatusCode$1[EHttpStatusCode$1["InternalServerError"] = 500] = "InternalServerError";
+	EHttpStatusCode$1[EHttpStatusCode$1["NotImplemented"] = 501] = "NotImplemented";
+	EHttpStatusCode$1[EHttpStatusCode$1["BadGateway"] = 502] = "BadGateway";
+	EHttpStatusCode$1[EHttpStatusCode$1["ServiceUnavailable"] = 503] = "ServiceUnavailable";
+	EHttpStatusCode$1[EHttpStatusCode$1["GatewayTimeout"] = 504] = "GatewayTimeout";
+	EHttpStatusCode$1[EHttpStatusCode$1["HTTPVersionNotSupported"] = 505] = "HTTPVersionNotSupported";
+	EHttpStatusCode$1[EHttpStatusCode$1["VariantAlsoNegotiates"] = 506] = "VariantAlsoNegotiates";
+	EHttpStatusCode$1[EHttpStatusCode$1["InsufficientStorage"] = 507] = "InsufficientStorage";
+	EHttpStatusCode$1[EHttpStatusCode$1["LoopDetected"] = 508] = "LoopDetected";
+	EHttpStatusCode$1[EHttpStatusCode$1["NotExtended"] = 510] = "NotExtended";
+	EHttpStatusCode$1[EHttpStatusCode$1["NetworkAuthenticationRequired"] = 511] = "NetworkAuthenticationRequired";
+	return EHttpStatusCode$1;
+}({});
 
-const preStyles = 'font-family: monospace;' +
-    'width: 100%;' +
-    'max-width: 900px;' +
-    'padding: 10px;' +
-    'margin: 20px auto;' +
-    'border-radius: 8px;' +
-    'background-color: #494949;' +
-    'box-shadow: 0px 0px 3px 2px rgb(255 255 255 / 20%);';
-class HttpErrorRenderer extends BaseHttpResponseRenderer {
-    renderHtml(response) {
-        const data = response.body || {};
-        response.setContentType('text/html');
-        const keys = Object.keys(data).filter(key => !['statusCode', 'error', 'message'].includes(key));
-        return ('<html style="background-color: #333; color: #bbb;">' +
-            `<head><title>${data.statusCode} ${httpStatusCodes[data.statusCode]}</title></head>` +
-            `<body><center><h1>${data.statusCode} ${httpStatusCodes[data.statusCode]}</h1></center>` +
-            `<center><h4>${data.message}</h1></center><hr color="#666">` +
-            `<center style="color: #666;"> Wooks v${"0.5.20"} </center>` +
-            `${keys.length > 0
-                ? `<pre style="${preStyles}">${JSON.stringify({
-                    ...data,
-                    statusCode: undefined,
-                    message: undefined,
-                    error: undefined,
-                }, null, '  ')}</pre>`
-                : ''}` +
-            '</body></html>');
-    }
-    renderText(response) {
-        const data = response.body || {};
-        response.setContentType('text/plain');
-        const keys = Object.keys(data).filter(key => !['statusCode', 'error', 'message'].includes(key));
-        return (`${data.statusCode} ${httpStatusCodes[data.statusCode]}\n${data.message}` +
-            `\n\n${keys.length > 0
-                ? `${JSON.stringify({
-                    ...data,
-                    statusCode: undefined,
-                    message: undefined,
-                    error: undefined,
-                }, null, '  ')}`
-                : ''}`);
-    }
-    renderJson(response) {
-        const data = response.body || {};
-        response.setContentType('application/json');
-        const keys = Object.keys(data).filter(key => !['statusCode', 'error', 'message'].includes(key));
-        return (`{"statusCode":${escapeQuotes(data.statusCode)},` +
-            `"error":"${escapeQuotes(data.error)}",` +
-            `"message":"${escapeQuotes(data.message)}"` +
-            `${keys.length > 0
-                ? `,${keys.map(k => `"${escapeQuotes(k)}":${JSON.stringify(data[k])}`).join(',')}`
-                : ''}}`);
-    }
-    render(response) {
-        const { acceptsJson, acceptsText, acceptsHtml } = useAccept();
-        response.status = response.body?.statusCode || 500;
-        if (acceptsJson()) {
-            return this.renderJson(response);
-        }
-        else if (acceptsHtml()) {
-            return this.renderHtml(response);
-        }
-        else if (acceptsText()) {
-            return this.renderText(response);
-        }
-        else {
-            return this.renderJson(response);
-        }
-    }
-}
+//#endregion
+//#region packages/event-http/src/errors/error-renderer.ts
+const preStyles = "font-family: monospace;width: 100%;max-width: 900px;padding: 10px;margin: 20px auto;border-radius: 8px;background-color: #494949;box-shadow: 0px 0px 3px 2px rgb(255 255 255 / 20%);";
+var HttpErrorRenderer = class extends BaseHttpResponseRenderer {
+	renderHtml(response) {
+		const data = response.body || {};
+		response.setContentType("text/html");
+		const keys = Object.keys(data).filter((key) => ![
+			"statusCode",
+			"error",
+			"message"
+		].includes(key));
+		return "<html style=\"background-color: #333; color: #bbb;\">" + `<head><title>${data.statusCode} ${httpStatusCodes[data.statusCode]}</title></head>` + `<body><center><h1>${data.statusCode} ${httpStatusCodes[data.statusCode]}</h1></center>` + `<center><h4>${data.message}</h1></center><hr color="#666">` + `<center style="color: #666;"> Wooks v${"0.5.24"} </center>` + `${keys.length > 0 ? `<pre style="${preStyles}">${JSON.stringify({
+			...data,
+			statusCode: undefined,
+			message: undefined,
+			error: undefined
+		}, null, "  ")}</pre>` : ""}` + "</body></html>";
+	}
+	renderText(response) {
+		const data = response.body || {};
+		response.setContentType("text/plain");
+		const keys = Object.keys(data).filter((key) => ![
+			"statusCode",
+			"error",
+			"message"
+		].includes(key));
+		return `${data.statusCode} ${httpStatusCodes[data.statusCode]}\n${data.message}` + `\n\n${keys.length > 0 ? `${JSON.stringify({
+			...data,
+			statusCode: undefined,
+			message: undefined,
+			error: undefined
+		}, null, "  ")}` : ""}`;
+	}
+	renderJson(response) {
+		const data = response.body || {};
+		response.setContentType("application/json");
+		const keys = Object.keys(data).filter((key) => ![
+			"statusCode",
+			"error",
+			"message"
+		].includes(key));
+		return `{"statusCode":${escapeQuotes(data.statusCode)},` + `"error":"${escapeQuotes(data.error)}",` + `"message":"${escapeQuotes(data.message)}"` + `${keys.length > 0 ? `,${keys.map((k) => `"${escapeQuotes(k)}":${JSON.stringify(data[k])}`).join(",")}` : ""}}`;
+	}
+	render(response) {
+		const { acceptsJson, acceptsText, acceptsHtml } = useAccept();
+		response.status = response.body?.statusCode || 500;
+		if (acceptsJson()) return this.renderJson(response);
+else if (acceptsHtml()) return this.renderHtml(response);
+else if (acceptsText()) return this.renderText(response);
+else return this.renderJson(response);
+	}
+};
 function escapeQuotes(s) {
-    return (typeof s === 'number' ? s : s || '').toString().replace(/"/g, '\\"');
+	return (typeof s === "number" ? s : s || "").toString().replace(/"/gu, "\\\"");
 }
 
-class HttpError extends Error {
-    constructor(code = 500, _body = '') {
-        super(typeof _body === 'string' ? _body : _body.message);
-        this.code = code;
-        this._body = _body;
-        this.name = 'HttpError';
-    }
-    get body() {
-        return typeof this._body === 'string'
-            ? {
-                statusCode: this.code,
-                message: this.message,
-                error: httpStatusCodes[this.code],
-            }
-            : {
-                ...this._body,
-                statusCode: this.code,
-                message: this.message,
-                error: httpStatusCodes[this.code],
-            };
-    }
-    attachRenderer(renderer) {
-        this.renderer = renderer;
-    }
-    getRenderer() {
-        return this.renderer;
-    }
-}
+//#endregion
+//#region packages/event-http/src/errors/http-error.ts
+var HttpError = class extends Error {
+	name = "HttpError";
+	constructor(code = 500, _body = "") {
+		super(typeof _body === "string" ? _body : _body.message);
+		this.code = code;
+		this._body = _body;
+	}
+	get body() {
+		return typeof this._body === "string" ? {
+			statusCode: this.code,
+			message: this.message,
+			error: httpStatusCodes[this.code]
+		} : {
+			...this._body,
+			statusCode: this.code,
+			message: this.message,
+			error: httpStatusCodes[this.code]
+		};
+	}
+	renderer;
+	attachRenderer(renderer) {
+		this.renderer = renderer;
+	}
+	getRenderer() {
+		return this.renderer;
+	}
+};
 
+//#endregion
+//#region packages/event-http/src/response/core.ts
 const defaultStatus = {
-    GET: exports.EHttpStatusCode.OK,
-    POST: exports.EHttpStatusCode.Created,
-    PUT: exports.EHttpStatusCode.Created,
-    PATCH: exports.EHttpStatusCode.Accepted,
-    DELETE: exports.EHttpStatusCode.Accepted,
+	GET: EHttpStatusCode.OK,
+	POST: EHttpStatusCode.Created,
+	PUT: EHttpStatusCode.Created,
+	PATCH: EHttpStatusCode.Accepted,
+	DELETE: EHttpStatusCode.Accepted
 };
 const baseRenderer = new BaseHttpResponseRenderer();
-class BaseHttpResponse {
-    constructor(renderer = baseRenderer) {
-        this.renderer = renderer;
-        this._status = 0;
-        this._headers = {};
-    }
-    get status() {
-        return this._status;
-    }
-    set status(value) {
-        this._status = value;
-    }
-    get body() {
-        return this._body;
-    }
-    set body(value) {
-        this._body = value;
-    }
-    setStatus(value) {
-        this.status = value;
-        return this;
-    }
-    setBody(value) {
-        this.body = value;
-        return this;
-    }
-    getContentType() {
-        return this._headers['content-type'];
-    }
-    setContentType(value) {
-        this._headers['content-type'] = value;
-        return this;
-    }
-    enableCors(origin = '*') {
-        this._headers['Access-Control-Allow-Origin'] = origin;
-        return this;
-    }
-    setCookie(name, value, attrs) {
-        const cookies = (this._headers['set-cookie'] = (this._headers['set-cookie'] || []));
-        cookies.push(renderCookie(name, { value, attrs: attrs || {} }));
-        return this;
-    }
-    setCacheControl(data) {
-        this.setHeader('cache-control', renderCacheControl(data));
-    }
-    setCookieRaw(rawValue) {
-        const cookies = (this._headers['set-cookie'] = (this._headers['set-cookie'] || []));
-        cookies.push(rawValue);
-        return this;
-    }
-    header(name, value) {
-        this._headers[name] = value;
-        return this;
-    }
-    setHeader(name, value) {
-        return this.header(name, value);
-    }
-    getHeader(name) {
-        return this._headers[name];
-    }
-    mergeHeaders() {
-        const { headers } = useSetHeaders();
-        const { cookies, removeCookie } = useSetCookies();
-        const newCookies = this._headers['set-cookie'] || [];
-        for (const cookie of newCookies) {
-            removeCookie(cookie.slice(0, cookie.indexOf('=')));
-        }
-        this._headers = {
-            ...headers(),
-            ...this._headers,
-        };
-        const setCookie = [...newCookies, ...cookies()];
-        if (setCookie.length > 0) {
-            this._headers['set-cookie'] = setCookie;
-        }
-        return this;
-    }
-    mergeStatus(renderedBody) {
-        this.status = this.status || useResponse().status();
-        if (!this.status) {
-            const { method } = useRequest();
-            this.status = renderedBody
-                ? defaultStatus[method] || exports.EHttpStatusCode.OK
-                : exports.EHttpStatusCode.NoContent;
-        }
-        return this;
-    }
-    mergeFetchStatus(fetchStatus) {
-        this.status = this.status || useResponse().status() || fetchStatus;
-    }
-    panic(text, logger) {
-        const error = new Error(text);
-        logger.error(error);
-        throw error;
-    }
-    async respond() {
-        const { rawResponse, hasResponded } = useResponse();
-        const { method, rawRequest } = useRequest();
-        const logger = eventCore.useEventLogger('http-response') || console;
-        if (hasResponded()) {
-            this.panic('The response was already sent.', logger);
-        }
-        this.mergeHeaders();
-        const res = rawResponse();
-        if (this.body instanceof stream.Readable) {
-            const stream = this.body;
-            this.mergeStatus('ok');
-            res.writeHead(this.status, {
-                ...this._headers,
-            });
-            rawRequest.once('close', () => {
-                stream.destroy();
-            });
-            if (method === 'HEAD') {
-                stream.destroy();
-                res.end();
-            }
-            else {
-                return new Promise((resolve, reject) => {
-                    stream.on('error', e => {
-                        stream.destroy();
-                        res.end();
-                        reject(e);
-                    });
-                    stream.on('close', () => {
-                        stream.destroy();
-                        resolve(undefined);
-                    });
-                    stream.pipe(res);
-                });
-            }
-        }
-        else if (globalThis.Response && this.body instanceof Response) {
-            this.mergeFetchStatus(this.body.status);
-            if (method === 'HEAD') {
-                res.end();
-            }
-            else {
-                const additionalHeaders = {};
-                if (this.body.headers.get('content-length')) {
-                    additionalHeaders['content-length'] = this.body.headers.get('content-length');
-                }
-                if (this.body.headers.get('content-type')) {
-                    additionalHeaders['content-type'] = this.body.headers.get('content-type');
-                }
-                res.writeHead(this.status, {
-                    ...additionalHeaders,
-                    ...this._headers,
-                });
-                await respondWithFetch(this.body.body, res);
-            }
-        }
-        else {
-            const renderedBody = this.renderer.render(this);
-            this.mergeStatus(renderedBody);
-            res
-                .writeHead(this.status, {
-                'content-length': Buffer.byteLength(renderedBody),
-                ...this._headers,
-            })
-                .end(method === 'HEAD' ? '' : renderedBody);
-        }
-    }
-}
+var BaseHttpResponse = class {
+	constructor(renderer = baseRenderer) {
+		this.renderer = renderer;
+	}
+	_status = 0;
+	_body;
+	_headers = {};
+	get status() {
+		return this._status;
+	}
+	set status(value) {
+		this._status = value;
+	}
+	get body() {
+		return this._body;
+	}
+	set body(value) {
+		this._body = value;
+	}
+	setStatus(value) {
+		this.status = value;
+		return this;
+	}
+	setBody(value) {
+		this.body = value;
+		return this;
+	}
+	getContentType() {
+		return this._headers["content-type"];
+	}
+	setContentType(value) {
+		this._headers["content-type"] = value;
+		return this;
+	}
+	enableCors(origin = "*") {
+		this._headers["Access-Control-Allow-Origin"] = origin;
+		return this;
+	}
+	setCookie(name, value, attrs) {
+		const cookies = this._headers["set-cookie"] = this._headers["set-cookie"] || [];
+		cookies.push(renderCookie(name, {
+			value,
+			attrs: attrs || {}
+		}));
+		return this;
+	}
+	setCacheControl(data) {
+		this.setHeader("cache-control", renderCacheControl(data));
+	}
+	setCookieRaw(rawValue) {
+		const cookies = this._headers["set-cookie"] = this._headers["set-cookie"] || [];
+		cookies.push(rawValue);
+		return this;
+	}
+	header(name, value) {
+		this._headers[name] = value;
+		return this;
+	}
+	setHeader(name, value) {
+		return this.header(name, value);
+	}
+	getHeader(name) {
+		return this._headers[name];
+	}
+	mergeHeaders() {
+		const { headers } = useSetHeaders();
+		const { cookies, removeCookie } = useSetCookies();
+		const newCookies = this._headers["set-cookie"] || [];
+		for (const cookie of newCookies) removeCookie(cookie.slice(0, cookie.indexOf("=")));
+		this._headers = {
+			...headers(),
+			...this._headers
+		};
+		const setCookie = [...newCookies, ...cookies()];
+		if (setCookie.length > 0) this._headers["set-cookie"] = setCookie;
+		return this;
+	}
+	mergeStatus(renderedBody) {
+		this.status = this.status || useResponse().status();
+		if (!this.status) {
+			const { method } = useRequest();
+			this.status = renderedBody ? defaultStatus[method] || EHttpStatusCode.OK : EHttpStatusCode.NoContent;
+		}
+		return this;
+	}
+	mergeFetchStatus(fetchStatus) {
+		this.status = this.status || useResponse().status() || fetchStatus;
+	}
+	panic(text, logger) {
+		const error = new Error(text);
+		logger.error(error);
+		throw error;
+	}
+	async respond() {
+		const { rawResponse, hasResponded } = useResponse();
+		const { method, rawRequest } = useRequest();
+		const logger = (0, __wooksjs_event_core.useEventLogger)("http-response") || console;
+		if (hasResponded()) this.panic("The response was already sent.", logger);
+		this.mergeHeaders();
+		const res = rawResponse();
+		if (this.body instanceof stream.Readable) {
+			const stream$1 = this.body;
+			this.mergeStatus("ok");
+			res.writeHead(this.status, { ...this._headers });
+			rawRequest.once("close", () => {
+				stream$1.destroy();
+			});
+			if (method === "HEAD") {
+				stream$1.destroy();
+				res.end();
+			} else return new Promise((resolve, reject) => {
+				stream$1.on("error", (e) => {
+					stream$1.destroy();
+					res.end();
+					reject(e);
+				});
+				stream$1.on("close", () => {
+					stream$1.destroy();
+					resolve(undefined);
+				});
+				stream$1.pipe(res);
+			});
+		} else if (globalThis.Response && this.body instanceof Response) {
+			this.mergeFetchStatus(this.body.status);
+			if (method === "HEAD") res.end();
+else {
+				const additionalHeaders = {};
+				if (this.body.headers.get("content-length")) additionalHeaders["content-length"] = this.body.headers.get("content-length");
+				if (this.body.headers.get("content-type")) additionalHeaders["content-type"] = this.body.headers.get("content-type");
+				res.writeHead(this.status, {
+					...additionalHeaders,
+					...this._headers
+				});
+				await respondWithFetch(this.body.body, res);
+			}
+		} else {
+			const renderedBody = this.renderer.render(this);
+			this.mergeStatus(renderedBody);
+			res.writeHead(this.status, {
+				"content-length": Buffer.byteLength(renderedBody),
+				...this._headers
+			}).end(method === "HEAD" ? "" : renderedBody);
+		}
+	}
+};
 async function respondWithFetch(fetchBody, res) {
-    if (fetchBody) {
-        try {
-            for await (const chunk of fetchBody) {
-                res.write(chunk);
-            }
-        }
-        catch (error) {
-        }
-    }
-    res.end();
+	if (fetchBody) try {
+		for await (const chunk of fetchBody) res.write(chunk);
+	} catch (error) {}
+	res.end();
 }
 
+//#endregion
+//#region packages/event-http/src/response/factory.ts
 function createWooksResponder(renderer = new BaseHttpResponseRenderer(), errorRenderer = new HttpErrorRenderer()) {
-    function createResponse(data) {
-        const { hasResponded } = useResponse();
-        if (hasResponded()) {
-            return null;
-        }
-        if (data instanceof Error) {
-            const r = new BaseHttpResponse(errorRenderer);
-            let httpError;
-            if (data instanceof HttpError) {
-                httpError = data;
-            }
-            else {
-                httpError = new HttpError(500, data.message);
-            }
-            r.setBody(httpError.body);
-            return r;
-        }
-        else if (data instanceof BaseHttpResponse) {
-            return data;
-        }
-        else {
-            return new BaseHttpResponse(renderer).setBody(data);
-        }
-    }
-    return {
-        createResponse,
-        respond: (data) => createResponse(data)?.respond(),
-    };
+	function createResponse(data) {
+		const { hasResponded } = useResponse();
+		if (hasResponded()) return null;
+		if (data instanceof Error) {
+			const r = new BaseHttpResponse(errorRenderer);
+			let httpError;
+			if (data instanceof HttpError) httpError = data;
+else httpError = new HttpError(500, data.message);
+			r.setBody(httpError.body);
+			return r;
+		} else if (data instanceof BaseHttpResponse) return data;
+else return new BaseHttpResponse(renderer).setBody(data);
+	}
+	return {
+		createResponse,
+		respond: (data) => createResponse(data)?.respond()
+	};
 }
 
-class WooksHttp extends wooks.WooksAdapterBase {
-    constructor(opts, wooks) {
-        super(wooks, opts?.logger, opts?.router);
-        this.opts = opts;
-        this.responder = createWooksResponder();
-        this.logger = opts?.logger || this.getLogger(`${''}[wooks-http]`);
-    }
-    all(path, handler) {
-        return this.on('*', path, handler);
-    }
-    get(path, handler) {
-        return this.on('GET', path, handler);
-    }
-    post(path, handler) {
-        return this.on('POST', path, handler);
-    }
-    put(path, handler) {
-        return this.on('PUT', path, handler);
-    }
-    patch(path, handler) {
-        return this.on('PATCH', path, handler);
-    }
-    delete(path, handler) {
-        return this.on('DELETE', path, handler);
-    }
-    head(path, handler) {
-        return this.on('HEAD', path, handler);
-    }
-    options(path, handler) {
-        return this.on('OPTIONS', path, handler);
-    }
-    async listen(port, hostname, backlog, listeningListener) {
-        const server = (this.server = http.createServer(this.getServerCb()));
-        return new Promise((resolve, reject) => {
-            server.once('listening', resolve);
-            server.once('error', reject);
-            let args = [port, hostname, backlog, listeningListener];
-            const ui = args.indexOf(undefined);
-            if (ui >= 0) {
-                args = args.slice(0, ui);
-            }
-            server.listen(...args);
-        });
-    }
-    close(server) {
-        const srv = server || this.server;
-        return new Promise((resolve, reject) => {
-            srv?.close(err => {
-                if (err) {
-                    reject(err);
-                    return;
-                }
-                resolve(srv);
-            });
-        });
-    }
-    getServer() {
-        return this.server;
-    }
-    attachServer(server) {
-        this.server = server;
-    }
-    respond(data) {
-        void this.responder.respond(data)?.catch(e => {
-            this.logger.error('Uncaught response exception', e);
-        });
-    }
-    getServerCb() {
-        return (req, res) => {
-            const runInContext = createHttpContext({ req, res }, this.mergeEventOptions(this.opts?.eventOptions));
-            runInContext(async () => {
-                const { handlers } = this.wooks.lookup(req.method, req.url);
-                if (handlers || this.opts?.onNotFound) {
-                    try {
-                        return await this.processHandlers(handlers || [this.opts?.onNotFound]);
-                    }
-                    catch (error) {
-                        this.logger.error('Internal error, please report', error);
-                        this.respond(error);
-                        return error;
-                    }
-                }
-                else {
-                    this.logger.debug(`404 Not found (${req.method})${req.url}`);
-                    const error = new HttpError(404);
-                    this.respond(error);
-                    return error;
-                }
-            });
-        };
-    }
-    async processHandlers(handlers) {
-        const { store } = useHttpContext();
-        for (const [i, handler] of handlers.entries()) {
-            const isLastHandler = handlers.length === i + 1;
-            try {
-                const promise = handler();
-                const result = await promise;
-                this.respond(result);
-                return result;
-            }
-            catch (error) {
-                if (error instanceof HttpError) ;
-                else {
-                    this.logger.error(`Uncaught route handler exception: ${store('event').get('req')?.url || ''}`, error);
-                }
-                if (isLastHandler) {
-                    this.respond(error);
-                    return error;
-                }
-            }
-        }
-    }
-}
-function createHttpApp(opts, wooks) {
-    return new WooksHttp(opts, wooks);
+//#endregion
+//#region packages/event-http/src/http-adapter.ts
+var WooksHttp = class extends wooks.WooksAdapterBase {
+	logger;
+	constructor(opts, wooks$1) {
+		super(wooks$1, opts?.logger, opts?.router);
+		this.opts = opts;
+		this.logger = opts?.logger || this.getLogger(`${"\x1B[96m"}[wooks-http]`);
+	}
+	all(path, handler) {
+		return this.on("*", path, handler);
+	}
+	get(path, handler) {
+		return this.on("GET", path, handler);
+	}
+	post(path, handler) {
+		return this.on("POST", path, handler);
+	}
+	put(path, handler) {
+		return this.on("PUT", path, handler);
+	}
+	patch(path, handler) {
+		return this.on("PATCH", path, handler);
+	}
+	delete(path, handler) {
+		return this.on("DELETE", path, handler);
+	}
+	head(path, handler) {
+		return this.on("HEAD", path, handler);
+	}
+	options(path, handler) {
+		return this.on("OPTIONS", path, handler);
+	}
+	server;
+	async listen(port, hostname, backlog, listeningListener) {
+		const server = this.server = http.default.createServer(this.getServerCb());
+		return new Promise((resolve, reject) => {
+			server.once("listening", resolve);
+			server.once("error", reject);
+			let args = [
+				port,
+				hostname,
+				backlog,
+				listeningListener
+			];
+			const ui = args.indexOf(undefined);
+			if (ui >= 0) args = args.slice(0, ui);
+			server.listen(...args);
+		});
+	}
+	/**
+	* Stops the server if it was attached or passed via argument
+	* @param server
+	*/
+	close(server) {
+		const srv = server || this.server;
+		return new Promise((resolve, reject) => {
+			srv?.close((err) => {
+				if (err) {
+					reject(err);
+					return;
+				}
+				resolve(srv);
+			});
+		});
+	}
+	/**
+	* Returns http(s) server that was attached to Wooks
+	*
+	* See attachServer method docs
+	* @returns Server
+	*/
+	getServer() {
+		return this.server;
+	}
+	/**
+	* Attaches http(s) server instance
+	* to Wooks.
+	*
+	* Use it only if you want to `close` method to stop the server.
+	* @param server Server
+	*/
+	attachServer(server) {
+		this.server = server;
+	}
+	responder = createWooksResponder();
+	respond(data) {
+		void this.responder.respond(data)?.catch((e) => {
+			this.logger.error("Uncaught response exception", e);
+		});
+	}
+	/**
+	* Returns server callback function
+	* that can be passed to any node server:
+	* ```js
+	* import { createHttpApp } from '@wooksjs/event-http'
+	* import http from 'http'
+	*
+	* const app = createHttpApp()
+	* const server = http.createServer(app.getServerCb())
+	* server.listen(3000)
+	* ```
+	*/
+	getServerCb() {
+		return (req, res) => {
+			const runInContext = createHttpContext({
+				req,
+				res
+			}, this.mergeEventOptions(this.opts?.eventOptions));
+			runInContext(async () => {
+				const { handlers } = this.wooks.lookup(req.method, req.url);
+				if (handlers || this.opts?.onNotFound) try {
+					return await this.processHandlers(handlers || [this.opts?.onNotFound]);
+				} catch (error) {
+					this.logger.error("Internal error, please report", error);
+					this.respond(error);
+					return error;
+				}
+else {
+					this.logger.debug(`404 Not found (${req.method})${req.url}`);
+					const error = new HttpError(404);
+					this.respond(error);
+					return error;
+				}
+			});
+		};
+	}
+	async processHandlers(handlers) {
+		const { store } = useHttpContext();
+		for (const [i, handler] of handlers.entries()) {
+			const isLastHandler = handlers.length === i + 1;
+			try {
+				const promise = handler();
+				const result = await promise;
+				this.respond(result);
+				return result;
+			} catch (error) {
+				if (error instanceof HttpError) {} else this.logger.error(`Uncaught route handler exception: ${store("event").get("req")?.url || ""}`, error);
+				if (isLastHandler) {
+					this.respond(error);
+					return error;
+				}
+			}
+		}
+	}
+};
+function createHttpApp(opts, wooks$1) {
+	return new WooksHttp(opts, wooks$1);
 }
 
-Object.defineProperty(exports, "useEventLogger", {
+//#endregion
+exports.BaseHttpResponse = BaseHttpResponse
+exports.BaseHttpResponseRenderer = BaseHttpResponseRenderer
+exports.EHttpStatusCode = EHttpStatusCode
+exports.HttpError = HttpError
+exports.HttpErrorRenderer = HttpErrorRenderer
+exports.WooksHttp = WooksHttp
+exports.WooksURLSearchParams = WooksURLSearchParams
+exports.createHttpApp = createHttpApp
+exports.createHttpContext = createHttpContext
+exports.createWooksResponder = createWooksResponder
+exports.httpStatusCodes = httpStatusCodes
+exports.renderCacheControl = renderCacheControl
+exports.useAccept = useAccept
+exports.useAuthorization = useAuthorization
+exports.useCookies = useCookies
+Object.defineProperty(exports, 'useEventLogger', {
   enumerable: true,
-  get: function () { return eventCore.useEventLogger; }
+  get: function () {
+    return __wooksjs_event_core.useEventLogger;
+  }
 });
-Object.defineProperty(exports, "useRouteParams", {
+exports.useHeaders = useHeaders
+exports.useHttpContext = useHttpContext
+exports.useRequest = useRequest
+exports.useResponse = useResponse
+Object.defineProperty(exports, 'useRouteParams', {
   enumerable: true,
-  get: function () { return eventCore.useRouteParams; }
+  get: function () {
+    return __wooksjs_event_core.useRouteParams;
+  }
 });
-exports.BaseHttpResponse = BaseHttpResponse;
-exports.BaseHttpResponseRenderer = BaseHttpResponseRenderer;
-exports.HttpError = HttpError;
-exports.HttpErrorRenderer = HttpErrorRenderer;
-exports.WooksHttp = WooksHttp;
-exports.WooksURLSearchParams = WooksURLSearchParams;
-exports.createHttpApp = createHttpApp;
-exports.createHttpContext = createHttpContext;
-exports.createWooksResponder = createWooksResponder;
-exports.httpStatusCodes = httpStatusCodes;
-exports.renderCacheControl = renderCacheControl;
-exports.useAccept = useAccept;
-exports.useAuthorization = useAuthorization;
-exports.useCookies = useCookies;
-exports.useHeaders = useHeaders;
-exports.useHttpContext = useHttpContext;
-exports.useRequest = useRequest;
-exports.useResponse = useResponse;
-exports.useSearchParams = useSearchParams;
-exports.useSetCacheControl = useSetCacheControl;
-exports.useSetCookie = useSetCookie;
-exports.useSetCookies = useSetCookies;
-exports.useSetHeader = useSetHeader;
-exports.useSetHeaders = useSetHeaders;
-exports.useStatus = useStatus;
+exports.useSearchParams = useSearchParams
+exports.useSetCacheControl = useSetCacheControl
+exports.useSetCookie = useSetCookie
+exports.useSetCookies = useSetCookies
+exports.useSetHeader = useSetHeader
+exports.useSetHeaders = useSetHeaders
+exports.useStatus = useStatus