@wooksjs/event-http 0.4.9 → 0.4.11

package/dist/index.cjs

@@ -6,1102 +6,1056 @@ var stream = require('stream');
 var wooks = require('wooks');
 var http = require('http');
 
-function createHttpContext(data, options) {
-    return eventCore.createEventContext({
-        event: Object.assign(Object.assign({}, data), { type: 'HTTP' }),
-        options,
-    });
-}
-/**
- * Wrapper on useEventContext with HTTP event types
- * @returns set of hooks { getCtx, restoreCtx, clearCtx, hookStore, getStore, setStore }
- */
-function useHttpContext() {
-    return eventCore.useEventContext('HTTP');
+function createHttpContext(data, options) {
+    return eventCore.createEventContext({
+        event: {
+            ...data,
+            type: 'HTTP',
+        },
+        options,
+    });
+}
+/**
+ * Wrapper on useEventContext with HTTP event types
+ * @returns set of hooks { getCtx, restoreCtx, clearCtx, hookStore, getStore, setStore }
+ */
+function useHttpContext() {
+    return eventCore.useEventContext('HTTP');
 }
 
-const xForwardedFor = 'x-forwarded-for';
-function useRequest() {
-    const { store } = useHttpContext();
-    const { init } = store('request');
-    const event = store('event');
-    const { req } = event.value;
-    const rawBody = () => init('rawBody', () => {
-        return new Promise((resolve, reject) => {
-            let body = Buffer.from('');
-            req.on('data', function (chunk) {
-                body = Buffer.concat([body, chunk]);
-            });
-            req.on('error', function (err) {
-                reject(err);
-            });
-            req.on('end', function () {
-                resolve(body);
-            });
-        });
-    });
-    const reqId = eventCore.useEventId().getId;
-    const forwardedIp = () => init('forwardedIp', () => {
-        var _a;
-        if (typeof req.headers[xForwardedFor] === 'string' &&
-            req.headers[xForwardedFor]) {
-            return (_a = req.headers[xForwardedFor]
-                .split(',')
-                .shift()) === null || _a === void 0 ? void 0 : _a.trim();
-        }
-        else {
-            return '';
-        }
-    });
-    const remoteIp = () => init('remoteIp', () => { var _a, _b; return ((_a = req.socket) === null || _a === void 0 ? void 0 : _a.remoteAddress) || ((_b = req.connection) === null || _b === void 0 ? void 0 : _b.remoteAddress) || ''; });
-    function getIp(options) {
-        if (options === null || options === void 0 ? void 0 : options.trustProxy) {
-            return forwardedIp() || getIp();
-        }
-        else {
-            return remoteIp();
-        }
-    }
-    const getIpList = () => init('ipList', () => {
-        var _a, _b;
-        return {
-            remoteIp: ((_a = req.socket) === null || _a === void 0 ? void 0 : _a.remoteAddress) ||
-                ((_b = req.connection) === null || _b === void 0 ? void 0 : _b.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 xForwardedFor = 'x-forwarded-for';
+function useRequest() {
+    const { store } = useHttpContext();
+    const { init } = store('request');
+    const event = store('event');
+    const { req } = event.value;
+    const rawBody = () => init('rawBody', () => {
+        return new Promise((resolve, reject) => {
+            let body = Buffer.from('');
+            req.on('data', function (chunk) {
+                body = Buffer.concat([body, chunk]);
+            });
+            req.on('error', function (err) {
+                reject(err);
+            });
+            req.on('end', function () {
+                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', () => {
+        return {
+            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,
+    };
 }
 
-function useHeaders() {
-    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,
-    };
-}
-function useSetHeader(name) {
-    const { store } = useHttpContext();
-    const { hook } = store('setHeader');
-    return hook(name);
+function useHeaders() {
+    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,
+    };
+}
+function useSetHeader(name) {
+    const { store } = useHttpContext();
+    const { hook } = store('setHeader');
+    return hook(name);
 }
 
-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.indexOf(mime) >= 0)));
-        }
-        return get(mime);
-    };
-    return {
-        accept,
-        accepts,
-        acceptsJson: () => accepts('application/json'),
-        acceptsXml: () => accepts('application/xml'),
-        acceptsText: () => accepts('text/plain'),
-        acceptsHtml: () => accepts('text/html'),
-    };
+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.indexOf(mime) >= 0)));
+        }
+        return get(mime);
+    };
+    return {
+        accept,
+        accepts,
+        acceptsJson: () => accepts('application/json'),
+        acceptsXml: () => accepts('application/xml'),
+        acceptsText: () => accepts('text/plain'),
+        acceptsHtml: () => accepts('text/html'),
+    };
 }
 
-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: () => { var _a; return ((_a = authType()) === null || _a === void 0 ? void 0 : _a.toLocaleLowerCase()) === 'basic'; },
-        isBearer: () => { var _a; return ((_a = authType()) === null || _a === void 0 ? void 0 : _a.toLocaleLowerCase()) === 'bearer'; },
-        basicCredentials: () => init('basicCredentials', () => {
-            if (authorization) {
-                const type = authType();
-                if ((type === null || type === void 0 ? void 0 : type.toLocaleLowerCase()) === 'basic') {
-                    const creds = Buffer.from(authRawCredentials() || '', 'base64').toString('ascii');
-                    const [username, password] = creds.split(':');
-                    return { username, password };
-                }
-            }
-            return null;
-        }),
-    };
+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;
+        }),
+    };
 }
 
-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];
-}
-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,
+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];
+}
+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,
 };
 
-function renderCacheControl(data) {
-    let attrs = '';
-    for (const [a, v] of Object.entries(data)) {
-        if (typeof v === 'undefined')
-            continue;
-        const func = cacheControlFunc[a];
-        if (typeof func === 'function') {
-            const val = func(v);
-            if (val) {
-                attrs += attrs ? ', ' + val : val;
-            }
-        }
-        else {
-            throw new Error('Unknown Cache-Control attribute ' + a);
-        }
-    }
-    return attrs;
-}
-// rfc7234#section-5.2.2
-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(),
+function renderCacheControl(data) {
+    let attrs = '';
+    for (const [a, v] of Object.entries(data)) {
+        if (typeof v === 'undefined')
+            continue;
+        const func = cacheControlFunc[a];
+        if (typeof func === 'function') {
+            const val = func(v);
+            if (val) {
+                attrs += attrs ? ', ' + val : val;
+            }
+        }
+        else {
+            throw new Error('Unknown Cache-Control attribute ' + a);
+        }
+    }
+    return attrs;
+}
+// rfc7234#section-5.2.2
+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(),
 };
 
-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' : '');
-// rfc7234#section-5.2.2
-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 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' : '');
+// rfc7234#section-5.2.2
+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,
+    };
 }
 
-function useResponse() {
-    const { store } = useHttpContext();
-    const event = store('event');
-    const { res } = event.value;
-    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),
-        }),
-    };
-}
-function useStatus() {
-    const { store } = useHttpContext();
-    return store('status').hook('code');
+function useResponse() {
+    const { store } = useHttpContext();
+    const event = store('event');
+    const { res } = event.value;
+    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),
+        }),
+    };
+}
+function useStatus() {
+    const { store } = useHttpContext();
+    return store('status').hook('code');
 }
 
-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 Error('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') : '',
+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 Error('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') : '',
 };
 
-function escapeRegex(s) {
-    return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
-}
-function safeDecode(f, v) {
-    try {
-        return f(v);
-    }
-    catch (e) {
-        return v;
-    }
-}
-function safeDecodeURIComponent(uri) {
-    if (uri.indexOf('%') < 0)
-        return uri;
-    return safeDecode(decodeURIComponent, uri);
+function escapeRegex(s) {
+    return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
 }
-
-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 && 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,
-    };
-}
-function useSetCookie(name) {
-    const { setCookie, getCookie } = useSetCookies();
-    const valueHook = eventCore.attachHook({
-        name,
-        type: 'cookie',
-    }, {
-        get: () => { var _a; return (_a = getCookie(name)) === null || _a === void 0 ? void 0 : _a.value; },
-        set: (value) => { var _a; return setCookie(name, value, (_a = getCookie(name)) === null || _a === void 0 ? void 0 : _a.attrs); },
-    });
-    return eventCore.attachHook(valueHook, {
-        get: () => { var _a; return (_a = getCookie(name)) === null || _a === void 0 ? void 0 : _a.attrs; },
-        set: (attrs) => { var _a; return setCookie(name, ((_a = getCookie(name)) === null || _a === void 0 ? void 0 : _a.value) || '', attrs); },
-    }, 'attrs');
+function safeDecode(f, v) {
+    try {
+        return f(v);
+    }
+    catch (e) {
+        return v;
+    }
+}
+function safeDecodeURIComponent(uri) {
+    if (uri.indexOf('%') < 0)
+        return uri;
+    return safeDecode(decodeURIComponent, uri);
 }
 
-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;
-    }
-}
-function isArrayParam(name) {
-    return name.endsWith('[]');
+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 && 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,
+    };
+}
+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');
 }
 
-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(),
-    };
+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;
+    }
+}
+function isArrayParam(name) {
+    return name.endsWith('[]');
 }
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-
-function __values(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-}
-
-function __asyncValues(o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+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(),
+    };
 }
 
-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 (typeof 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 + '"');
-    }
+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 (typeof 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 + '"');
+    }
 }
 
-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',
-};
-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";
+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',
+};
+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 = {}));
 
-const defaultStatus = {
-    GET: exports.EHttpStatusCode.OK,
-    POST: exports.EHttpStatusCode.Created,
-    PUT: exports.EHttpStatusCode.Created,
-    PATCH: exports.EHttpStatusCode.Accepted,
-    DELETE: exports.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 = Object.assign(Object.assign({}, headers()), this._headers);
-        const setCookie = [...newCookies, ...cookies()];
-        if (setCookie && setCookie.length) {
-            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;
-    }
-    respond() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { rawResponse, hasResponded } = useResponse();
-            const { method, rawRequest } = useRequest();
-            const logger = eventCore.useEventLogger('http-response');
-            if (hasResponded()) {
-                this.panic('The response was already sent.', logger);
-            }
-            this.mergeHeaders();
-            const res = rawResponse();
-            if (this.body instanceof stream.Readable) {
-                // responding with readable stream
-                const stream = this.body;
-                this.mergeStatus('ok');
-                res.writeHead(this.status, Object.assign({}, 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 /* Fetch 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, Object.assign(Object.assign({}, additionalHeaders), this._headers));
-                    yield respondWithFetch(this.body.body, res);
-                }
-            }
-            else {
-                const renderedBody = this.renderer.render(this);
-                this.mergeStatus(renderedBody);
-                res.writeHead(this.status, Object.assign({ 'content-length': Buffer.byteLength(renderedBody) }, this._headers)).end(method !== 'HEAD' ? renderedBody : '');
-            }
-        });
-    }
-}
-function respondWithFetch(fetchBody, res) {
-    var _a, e_1, _b, _c;
-    return __awaiter(this, void 0, void 0, function* () {
-        if (fetchBody) {
-            try {
-                try {
-                    for (var _d = true, _e = __asyncValues(fetchBody), _f; _f = yield _e.next(), _a = _f.done, !_a;) {
-                        _c = _f.value;
-                        _d = false;
-                        try {
-                            const chunk = _c;
-                            res.write(chunk);
-                        }
-                        finally {
-                            _d = true;
-                        }
-                    }
-                }
-                catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                finally {
-                    try {
-                        if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
-                    }
-                    finally { if (e_1) throw e_1.error; }
-                }
-            }
-            catch (e) {
-                // ?
-            }
-        }
-        res.end();
-    });
+const defaultStatus = {
+    GET: exports.EHttpStatusCode.OK,
+    POST: exports.EHttpStatusCode.Created,
+    PUT: exports.EHttpStatusCode.Created,
+    PATCH: exports.EHttpStatusCode.Accepted,
+    DELETE: exports.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 && setCookie.length) {
+            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');
+        if (hasResponded()) {
+            this.panic('The response was already sent.', logger);
+        }
+        this.mergeHeaders();
+        const res = rawResponse();
+        if (this.body instanceof stream.Readable) {
+            // responding with readable stream
+            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 /* Fetch 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 (e) {
+            // ?
+        }
+    }
+    res.end();
 }
 
-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.4.9"} </center>` +
-            `${keys.length
-                ? `<pre style="${preStyles}">${JSON.stringify(Object.assign(Object.assign({}, 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
-                ? `${JSON.stringify(Object.assign(Object.assign({}, 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
-                ? ',' +
-                    keys
-                        .map((k) => `"${escapeQuotes(k)}":${JSON.stringify(data[k])}`)
-                        .join(',')
-                : ''}}`);
-    }
-    render(response) {
-        var _a;
-        const { acceptsJson, acceptsText, acceptsHtml } = useAccept();
-        response.status = ((_a = response.body) === null || _a === void 0 ? void 0 : _a.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, '\\"');
+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.4.11"} </center>` +
+            `${keys.length
+                ? `<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
+                ? `${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
+                ? ',' +
+                    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, '\\"');
 }
 
-class HttpError extends Error {
-    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],
-            }
-            : Object.assign(Object.assign({}, this._body), { statusCode: this.code, message: this.message, error: httpStatusCodes[this.code] });
-    }
-    attachRenderer(renderer) {
-        this.renderer = renderer;
-    }
-    getRenderer() {
-        return this.renderer;
-    }
+class HttpError extends Error {
+    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],
+            };
+    }
+    attachRenderer(renderer) {
+        this.renderer = renderer;
+    }
+    getRenderer() {
+        return this.renderer;
+    }
 }
 
-function createWooksResponder(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-renderer = new BaseHttpResponseRenderer(), 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-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) => { var _a; return (_a = createResponse(data)) === null || _a === void 0 ? void 0 : _a.respond(); },
-    };
+function createWooksResponder(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+renderer = new BaseHttpResponseRenderer(), 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+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(),
+    };
 }
 
-class WooksHttp extends wooks.WooksAdapterBase {
-    constructor(opts, wooks) {
-        super(wooks, opts === null || opts === void 0 ? void 0 : opts.logger, opts === null || opts === void 0 ? void 0 : opts.router);
-        this.opts = opts;
-        this.responder = createWooksResponder();
-        this.logger = (opts === null || opts === void 0 ? void 0 : 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);
-    }
-    /**
-     * Starts the http(s) server.
-     *
-     * Use this only if you rely on Wooks server.
-     */
-    listen(...args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const server = (this.server = http.createServer(this.getServerCb()));
-            return new Promise((resolve, reject) => {
-                server.once('listening', resolve);
-                server.once('error', reject);
-                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 === null || srv === void 0 ? void 0 : srv.close((err) => {
-                if (err)
-                    return reject(err);
-                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;
-    }
-    respond(data) {
-        var _a;
-        void ((_a = this.responder.respond(data)) === null || _a === void 0 ? void 0 : _a.catch((e) => {
-            this.logger.error('Uncought 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) => __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c;
-            const { restoreCtx, clearCtx } = createHttpContext({ req, res }, this.mergeEventOptions((_a = this.opts) === null || _a === void 0 ? void 0 : _a.eventOptions));
-            const { handlers } = this.wooks.lookup(req.method, req.url);
-            if (handlers || ((_b = this.opts) === null || _b === void 0 ? void 0 : _b.onNotFound)) {
-                try {
-                    yield this.processHandlers(handlers || [(_c = this.opts) === null || _c === void 0 ? void 0 : _c.onNotFound]);
-                }
-                catch (e) {
-                    this.logger.error('Internal error, please report', e);
-                    restoreCtx();
-                    this.respond(e);
-                    clearCtx();
-                }
-            }
-            else {
-                // not found
-                this.logger.debug(`404 Not found (${req.method})${req.url}`);
-                this.respond(new HttpError(404));
-                clearCtx();
-            }
-        });
-    }
-    processHandlers(handlers) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { restoreCtx, clearCtx, store } = useHttpContext();
-            for (const [i, handler] of handlers.entries()) {
-                const isLastHandler = handlers.length === i + 1;
-                try {
-                    restoreCtx();
-                    const promise = handler();
-                    clearCtx();
-                    const result = yield promise;
-                    // even if the returned value is an Error instance
-                    // we still want to process it as a response
-                    restoreCtx();
-                    this.respond(result);
-                    clearCtx();
-                    break;
-                }
-                catch (e) {
-                    this.logger.error(`Uncought route handler exception: ${store('event').get('req').url || ''}`, e);
-                    if (isLastHandler) {
-                        restoreCtx();
-                        this.respond(e);
-                        clearCtx();
-                    }
-                }
-            }
-        });
-    }
-}
-/**
- * Factory for WooksHttp App
- * @param opts TWooksHttpOptions
- * @param wooks Wooks | WooksAdapterBase
- * @returns WooksHttp
- */
-function createHttpApp(opts, wooks) {
-    return new WooksHttp(opts, wooks);
+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);
+    }
+    /**
+     * Starts the http(s) server.
+     *
+     * Use this only if you rely on Wooks server.
+     */
+    async listen(...args) {
+        const server = (this.server = http.createServer(this.getServerCb()));
+        return new Promise((resolve, reject) => {
+            server.once('listening', resolve);
+            server.once('error', reject);
+            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)
+                    return reject(err);
+                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;
+    }
+    respond(data) {
+        void this.responder.respond(data)?.catch((e) => {
+            this.logger.error('Uncought 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 async (req, res) => {
+            const { restoreCtx, clearCtx } = createHttpContext({ req, res }, this.mergeEventOptions(this.opts?.eventOptions));
+            const { handlers } = this.wooks.lookup(req.method, req.url);
+            if (handlers || this.opts?.onNotFound) {
+                try {
+                    await this.processHandlers(handlers || [this.opts?.onNotFound]);
+                }
+                catch (e) {
+                    this.logger.error('Internal error, please report', e);
+                    restoreCtx();
+                    this.respond(e);
+                    clearCtx();
+                }
+            }
+            else {
+                // not found
+                this.logger.debug(`404 Not found (${req.method})${req.url}`);
+                this.respond(new HttpError(404));
+                clearCtx();
+            }
+        };
+    }
+    async processHandlers(handlers) {
+        const { restoreCtx, clearCtx, store } = useHttpContext();
+        for (const [i, handler] of handlers.entries()) {
+            const isLastHandler = handlers.length === i + 1;
+            try {
+                restoreCtx();
+                const promise = handler();
+                clearCtx();
+                const result = await promise;
+                // even if the returned value is an Error instance
+                // we still want to process it as a response
+                restoreCtx();
+                this.respond(result);
+                clearCtx();
+                break;
+            }
+            catch (e) {
+                this.logger.error(`Uncought route handler exception: ${store('event').get('req').url || ''}`, e);
+                if (isLastHandler) {
+                    restoreCtx();
+                    this.respond(e);
+                    clearCtx();
+                }
+            }
+        }
+    }
+}
+/**
+ * Factory for WooksHttp App
+ * @param opts TWooksHttpOptions
+ * @param wooks Wooks | WooksAdapterBase
+ * @returns WooksHttp
+ */
+function createHttpApp(opts, wooks) {
+    return new WooksHttp(opts, wooks);
 }
 
 exports.BaseHttpResponse = BaseHttpResponse;