tezx 2.0.11 → 3.0.0

package/middleware/lazyLoadModules.js

@@ -1,69 +0,0 @@
-import { GlobalConfig } from "../core/config.js";
-export const lazyLoadModules = (options) => {
-    const { moduleKey = (ctx) => ctx.req.params[queryKeyModule] || ctx.req.query[queryKeyModule], getModuleLoader, queryKeyModule = "module", moduleContextKey = "module", cacheTTL = 3600000, enableCache = true, cacheStorage, lifecycleHooks = {}, validateModule, } = options;
-    let storage = cacheStorage;
-    if (enableCache && !cacheStorage) {
-        storage = new Map();
-    }
-    return async function lazyLoadModules(ctx, next) {
-        let moduleName = moduleKey(ctx) ||
-            ctx.req.params[queryKeyModule] ||
-            ctx.req.query[queryKeyModule];
-        if (!moduleName) {
-            GlobalConfig.debugging.warn("No module specified for lazy loading.");
-            return await next();
-        }
-        try {
-            if (enableCache) {
-                const cached = storage.get(moduleName);
-                if (cached) {
-                    if (cached.expiresAt < Date.now()) {
-                        storage.delete(moduleName);
-                    }
-                    else {
-                        GlobalConfig.debugging.info(`Using cached module: ${moduleName}`);
-                        ctx[moduleContextKey] = cached?.module;
-                        lifecycleHooks.onCacheHit?.(moduleName, ctx[moduleContextKey], ctx);
-                        lifecycleHooks.onComplete?.(moduleName, ctx[moduleContextKey], ctx);
-                        return await next();
-                    }
-                }
-            }
-            if (!getModuleLoader) {
-                throw new Error(`No module loader found for module: ${moduleName}`);
-            }
-            const moduleLoader = await getModuleLoader(ctx);
-            if (!moduleLoader) {
-                throw new Error(`No loader found for module: ${moduleName}`);
-            }
-            lifecycleHooks.onLoad?.(moduleName, ctx);
-            const module = await moduleLoader();
-            if (validateModule && !validateModule(module)) {
-                throw new Error(`Module validation failed for: ${moduleName}`);
-            }
-            if (enableCache) {
-                storage.set(moduleName, {
-                    module,
-                    expiresAt: Date.now() + cacheTTL,
-                });
-                lifecycleHooks.onCacheSet?.(moduleName, module, ctx);
-            }
-            ctx[moduleContextKey] = module;
-            if (module.init && typeof module.init === "function") {
-                const initResult = await module.init(ctx);
-                if (initResult) {
-                    return initResult;
-                }
-            }
-            lifecycleHooks.onComplete?.(moduleName, module, ctx);
-            GlobalConfig.debugging.success(`Successfully loaded module: ${moduleName}`);
-        }
-        catch (error) {
-            GlobalConfig.debugging.error(`Error loading module: ${moduleName}`, error);
-            lifecycleHooks.onError?.(moduleName, error, ctx);
-            ctx.setStatus = 500;
-            throw error;
-        }
-        return await next();
-    };
-};

package/middleware/rateLimiter.js

@@ -1,20 +0,0 @@
-import { createRateLimitDefaultStorage, isRateLimit } from "./detectBot.js";
-export const rateLimiter = (options) => {
-    const { maxRequests, windowMs, keyGenerator = (ctx) => `${ctx.req.remoteAddress.address}:${ctx.req.remoteAddress.port}`, storage = createRateLimitDefaultStorage(), onError = (ctx, retryAfter, error) => {
-        ctx.setStatus = 429;
-        throw new Error(`Rate limit exceeded. Try again in ${retryAfter} seconds.`);
-    }, } = options;
-    return async function rateLimiter(ctx, next) {
-        const key = keyGenerator(ctx);
-        const { check, entry } = isRateLimit(ctx, key, storage, maxRequests, windowMs);
-        if (check) {
-            const retryAfter = Math.ceil((entry.resetTime - Date.now()) / 1000);
-            ctx.headers.set("Retry-After", retryAfter.toString());
-            return onError(ctx, retryAfter, new Error(`Rate limit exceeded. Retry after ${retryAfter} seconds.`));
-        }
-        ctx.headers.set("X-RateLimit-Limit", maxRequests.toString());
-        ctx.headers.set("X-RateLimit-Remaining", (maxRequests - entry.count).toString());
-        ctx.headers.set("X-RateLimit-Reset", entry.resetTime.toString());
-        return await next();
-    };
-};

package/middleware/requestTimeout.d.ts

@@ -1,25 +0,0 @@
-import { Context } from "../core/context.js";
-import { CallbackReturn, Middleware } from "../types/index.js";
-export type TimeoutOptions = {
-    /**
-     * ⏳ Function to dynamically determine the timeout duration (in milliseconds).
-     */
-    getTimeout: (ctx: Context) => number;
-    /**
-     * 🚫 Custom function to handle timeout errors.
-     */
-    onTimeout?: (ctx: Context, error: Error) => CallbackReturn;
-    /**
-     * 📝 Logging function for timeout events.
-     */
-    logTimeoutEvent?: (ctx: Context, error: Error) => void;
-    /**
-     * 🛠️ Custom function to clean up resources after a timeout.
-     */
-    cleanup?: (ctx: Context) => void;
-};
-/**
- * Middleware to enforce fully dynamic request timeouts.
- * @param options - Custom options for dynamic timeout handling.
- */
-export declare const requestTimeout: (options: TimeoutOptions) => Middleware;

package/middleware/requestTimeout.js

@@ -1,38 +0,0 @@
-import { GlobalConfig } from "../core/config.js";
-export const requestTimeout = (options) => {
-    const { getTimeout, onTimeout = (ctx) => {
-        ctx.setStatus = 504;
-        ctx.body = { error: "Request timed out." };
-    }, logTimeoutEvent = (ctx, error) => {
-        GlobalConfig.debugging.warn(`[TIMEOUT] ${error.message}: ${ctx.method} ${ctx.path}`);
-    }, cleanup = () => {
-    }, } = options;
-    return async function requestTimeout(ctx, next) {
-        let timeoutId = null;
-        try {
-            const timeout = getTimeout(ctx);
-            const timeoutPromise = new Promise((_, reject) => {
-                timeoutId = setTimeout(() => {
-                    const timeoutError = new Error("Request timed out.");
-                    logTimeoutEvent(ctx, timeoutError);
-                    reject(timeoutError);
-                }, timeout);
-            });
-            return await Promise.race([next(), timeoutPromise]);
-        }
-        catch (error) {
-            if (error.message === "Request timed out.") {
-                onTimeout(ctx, error);
-            }
-            else {
-                throw error;
-            }
-        }
-        finally {
-            if (timeoutId) {
-                clearTimeout(timeoutId);
-            }
-            cleanup(ctx);
-        }
-    };
-};

package/middleware/sanitizeHeader.js

@@ -1,47 +0,0 @@
-import { GlobalConfig } from "../core/config.js";
-export const sanitizeHeaders = (options = {}) => {
-    const { whitelist = [], blacklist = [], normalizeKeys = true, allowUnsafeCharacters = false, } = options;
-    return async function sanitizeHeaders(ctx, next) {
-        const sanitizedHeaders = new Map();
-        for (const [key, values] of ctx.headers.entries()) {
-            if (!Array.isArray(values) || values.length === 0) {
-                continue;
-            }
-            const normalizedKey = normalizeKeys ? key.toLowerCase() : key;
-            if (whitelist.length > 0 &&
-                !whitelist.some((r) => r?.toLowerCase() === normalizedKey)) {
-                GlobalConfig.debugging.warn(`🚫 Header "${normalizedKey}" not in whitelist - removed`);
-                continue;
-            }
-            if (blacklist.some((r) => r.toLowerCase() === normalizedKey)) {
-                GlobalConfig.debugging.warn(`🚫 Header "${normalizedKey}" in blacklist - removed`);
-                continue;
-            }
-            if (!isValidHeaderName(normalizedKey)) {
-                GlobalConfig.debugging.warn(`⚠️ Invalid header name: "${normalizedKey}" - removed`);
-                continue;
-            }
-            const sanitizedValues = values
-                .map((value) => sanitizeHeaderValue(value, allowUnsafeCharacters))
-                .filter(Boolean);
-            if (sanitizedValues.length === 0) {
-                GlobalConfig.debugging.warn(`⚠️ All values for "${normalizedKey}" invalid - removed`);
-                continue;
-            }
-            sanitizedHeaders.set(normalizedKey, sanitizedValues?.join(", "));
-        }
-        ctx.headers = new Headers(sanitizedHeaders);
-        return await next();
-    };
-};
-const isValidHeaderName = (name) => {
-    const HEADER_NAME_REGEX = /^[a-zA-Z0-9\-_]+$/;
-    return HEADER_NAME_REGEX.test(name);
-};
-const sanitizeHeaderValue = (value, allowUnsafeCharacters) => {
-    let sanitized = value.trim();
-    if (!allowUnsafeCharacters) {
-        sanitized = sanitized.replace(/[\x00-\x1F\x7F]/g, "");
-    }
-    return sanitized;
-};

package/middleware/secureHeaders.d.ts

@@ -1,78 +0,0 @@
-import { Context } from "../core/context.js";
-import { Middleware } from "../types/index.js";
-export type DynamicHeaderValue = string | ((ctx: Context) => string | undefined);
-export type SecurityHeaderOptions = {
-    /**
-     * 🔵 Content Security Policy header value
-     * @default "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline';"
-     * @example
-     * contentSecurityPolicy: "default-src 'none'; script-src 'self' https://trusted.cdn.com"
-     * contentSecurityPolicy: (ctx) => ctx.isAdmin ? "default-src 'self'" : "default-src 'none'"
-     */
-    contentSecurityPolicy?: DynamicHeaderValue;
-    /**
-     * 🟢 Whether to set X-Frame-Options header (clickjacking protection)
-     * @default true
-     * @example
-     * frameGuard: true // Always enable
-     * frameGuard: (ctx) => !ctx.pathname.startsWith('/embed/') // Disable for embed routes
-     */
-    frameGuard?: boolean | ((ctx: Context) => boolean);
-    /**
-     * 🟣 HTTP Strict Transport Security (HSTS) header
-     * @default true
-     * @example
-     * hsts: true // Enable with 2 year duration
-     * hsts: (ctx) => ctx.secure // Enable only for HTTPS
-     */
-    hsts?: boolean | ((ctx: Context) => boolean);
-    /**
-     * 🟠 XSS Protection header
-     * @default true
-     * @example
-     * xssProtection: false // Disable legacy XSS filter
-     */
-    xssProtection?: boolean | ((ctx: Context) => boolean);
-    /**
-     * 🟡 X-Content-Type-Options header (MIME sniffing prevention)
-     * @default true
-     * @example
-     * noSniff: false // Only disable if you have specific needs
-     */
-    noSniff?: boolean | ((ctx: Context) => boolean);
-    /**
-     * 🔴 Referrer Policy header
-     * @default "no-referrer"
-     * @example
-     * referrerPolicy: "strict-origin-when-cross-origin"
-     */
-    referrerPolicy?: DynamicHeaderValue;
-    /**
-     * 🟤 Permissions Policy header (formerly Feature Policy)
-     * @default "geolocation=(), microphone=(), camera=()"
-     * @example
-     * permissionsPolicy: "geolocation=(self 'https://example.com')"
-     */
-    permissionsPolicy?: DynamicHeaderValue;
-};
-/**
- * 🛡️ Comprehensive security headers middleware
- *
- * Sets multiple security-related HTTP headers with dynamic configuration.
- * All headers can be configured per-request using functions.
- *
- * @param {SecurityHeaderOptions} [options={}] - Configuration options
- * @returns {Middleware} Middleware function
- *
- * @example
- * // Basic usage with defaults
- * app.use(secureHeaders());
- *
- * // Custom configuration
- * app.use(secureHeaders({
- *   contentSecurityPolicy: "default-src 'self'",
- *   frameGuard: (ctx) => !ctx.isEmbedded,
- *   referrerPolicy: "strict-origin-when-cross-origin"
- * }));
- */
-export declare const secureHeaders: (options?: SecurityHeaderOptions) => Middleware;

package/middleware/secureHeaders.js

@@ -1,38 +0,0 @@
-export const secureHeaders = (options = {}) => {
-    return async function secureHeaders(ctx, next) {
-        const resolveValue = (value) => {
-            return typeof value === "function" ? value(ctx) : value;
-        };
-        const contentSecurityPolicy = resolveValue(options.contentSecurityPolicy) ||
-            "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline';";
-        const frameGuard = resolveValue(options.frameGuard) ?? true;
-        const hsts = resolveValue(options.hsts) ?? true;
-        const xssProtection = resolveValue(options.xssProtection) ?? true;
-        const noSniff = resolveValue(options.noSniff) ?? true;
-        const referrerPolicy = resolveValue(options.referrerPolicy) || "no-referrer";
-        const permissionsPolicy = resolveValue(options.permissionsPolicy) ||
-            "geolocation=(), microphone=(), camera=()";
-        if (contentSecurityPolicy) {
-            ctx.headers.set("Content-Security-Policy", contentSecurityPolicy);
-        }
-        if (frameGuard) {
-            ctx.headers.set("X-Frame-Options", "DENY");
-        }
-        if (hsts) {
-            ctx.headers.set("Strict-Transport-Security", "max-age=63072000; includeSubDomains");
-        }
-        if (xssProtection) {
-            ctx.headers.set("X-XSS-Protection", "1; mode=block");
-        }
-        if (noSniff) {
-            ctx.headers.set("X-Content-Type-Options", "nosniff");
-        }
-        if (referrerPolicy) {
-            ctx.headers.set("Referrer-Policy", referrerPolicy);
-        }
-        if (permissionsPolicy) {
-            ctx.headers.set("Permissions-Policy", permissionsPolicy);
-        }
-        return await next();
-    };
-};

package/middleware/xssProtection.js

@@ -1,22 +0,0 @@
-import { GlobalConfig } from "../core/config.js";
-export const xssProtection = (options = {}) => {
-    const { enabled = true, mode = "block", fallbackCSP = "default-src 'self'; script-src 'self';", } = options;
-    return async function xssProtection(ctx, next) {
-        const isEnabled = typeof enabled === "function" ? enabled(ctx) : enabled;
-        if (!isEnabled) {
-            GlobalConfig.debugging.warn("🟠 XSS protection is disabled.");
-            return await next();
-        }
-        const xssHeaderValue = mode === "block" ? "1; mode=block" : "1";
-        ctx.headers.set("X-XSS-Protection", xssHeaderValue);
-        GlobalConfig.debugging.warn(`🟢 X-XSS-Protection set to: ${xssHeaderValue}`);
-        if (fallbackCSP) {
-            const existingCSP = ctx.req.headers.get("Content-Security-Policy");
-            if (!existingCSP) {
-                ctx.headers.set("Content-Security-Policy", fallbackCSP);
-                GlobalConfig.debugging.warn(`🟣 Fallback CSP set to: ${fallbackCSP}`);
-            }
-        }
-        return await next();
-    };
-};

package/node/adapter.d.ts

@@ -1,46 +0,0 @@
-import type { ServerOptions } from "node:http";
-import type { TlsOptions } from "node:tls";
-import { TezX } from "../core/server.js";
-export type UnixSocketOptions = ServerOptions & {
-    unix?: string;
-    enableSSL?: false;
-};
-export type SSLOptions = ServerOptions & TlsOptions & {
-    enableSSL: true;
-};
-export type TezXServerOptions = UnixSocketOptions | SSLOptions;
-/**
- * Starts the TezX server using Node.js native `http` or `https` module based on the `enableSSL` flag.
- * - If `enableSSL` is true and valid TLS options are provided, it uses `https.createServer`.
- * - Otherwise, falls back to `http.createServer`.
- * - Optionally supports binding to a Unix domain socket via `options.unix`.
- *
- * ### Usage:
- *
- * ```ts
- * // Start with default HTTP
- * nodeAdapter(app).listen(3000, () => {
- *   console.log("Server is running");
- * });
- *
- * // Start with HTTPS
- * nodeAdapter(app, {
- *   enableSSL: true,
- *   key: fs.readFileSync("key.pem"),
- *   cert: fs.readFileSync("cert.pem")
- * }).listen(443);
- *
- * // Start with Unix socket
- * nodeAdapter(app, { unix: "/tmp/tezx.sock" }).listen();
- * ```
- * @param {number} [port] - The port number to listen on (ignored if `unix` is provided).
- * @param {() => void} [callback] - Callback invoked after the server starts listening.
- * @returns {void} Nothing is returned directly; server instance is stored in GlobalConfig.
- */
-export declare function nodeAdapter<T extends Record<string, any> = {}>(TezX: TezX<T>, options?: TezXServerOptions): {
-    listen: {
-        (callback?: () => void): any;
-        (port?: number): any;
-        (port?: number, callback?: () => void): any;
-    };
-};

package/node/adapter.js

@@ -1,102 +0,0 @@
-import { Buffer } from "node:buffer";
-import { createServer } from "node:http";
-import { createServer as sslCreateServer } from "node:https";
-import { GlobalConfig } from "../core/config.js";
-import { Context } from "../core/context.js";
-export function nodeAdapter(TezX, options = {}) {
-    function listen(...arg) {
-        let ssl = options?.enableSSL;
-        let createServerFn = ssl ? sslCreateServer : createServer;
-        GlobalConfig.adapter = "node";
-        let server = createServerFn(options, async (req, res) => {
-            let address = {};
-            if (req.socket) {
-                address = {
-                    remoteAddr: {
-                        family: req.socket.remoteFamily,
-                        address: req.socket.remoteAddress,
-                        port: req.socket.remotePort,
-                    },
-                    localAddr: {
-                        address: req.socket.localAddress,
-                        port: req.socket.localPort,
-                        family: req.socket.localFamily,
-                    },
-                };
-            }
-            let options = {
-                connInfo: address,
-            };
-            const response = await TezX.serve(req, options);
-            if (typeof response?.websocket === "function" &&
-                response.ctx instanceof Context &&
-                response.ctx.wsProtocol) {
-                response.websocket(response.ctx, server);
-                return res.end();
-            }
-            const statusText = response?.statusText;
-            if (!(response instanceof Response)) {
-                throw new Error("Invalid response from TezX.serve");
-            }
-            if (statusText) {
-                res.statusMessage = statusText;
-            }
-            res.writeHead(response.status, [...response.headers.entries()]);
-            const { Readable } = await import("node:stream");
-            const body = response.body;
-            if (response.headers.get("Content-Type") === "text/event-stream") {
-                req.socket.setTimeout(0);
-            }
-            if (body instanceof Readable) {
-                return body.pipe(res);
-            }
-            else if (body?.pipeTo || body?.getReader) {
-                try {
-                    return Readable.fromWeb(body).pipe(res);
-                }
-                catch (err) {
-                    GlobalConfig.debugging.warn("Failed to stream web body:", err);
-                    return res.end();
-                }
-            }
-            else if (typeof body?.[Symbol.asyncIterator] === "function") {
-                const readable = Readable.from(body);
-                return readable.pipe(res);
-            }
-            else {
-                try {
-                    const buffer = await response.arrayBuffer?.();
-                    if (buffer && buffer.byteLength > 0) {
-                        return res.end(Buffer.from(buffer));
-                    }
-                    else {
-                        return res.end();
-                    }
-                }
-                catch (err) {
-                    GlobalConfig.debugging.warn("Body extraction failed, trying text fallback...");
-                    const text = await response.text?.();
-                    return res.end(text ?? "");
-                }
-            }
-        });
-        const port = typeof arg[0] === "function" ? undefined : arg[0];
-        const callback = typeof arg[0] === "function" ? arg[0] : arg[1];
-        server.listen(options?.unix || port || 0, () => {
-            const protocol = ssl ? "\x1b[1;35mhttps\x1b[0m" : "\x1b[1;34mhttp\x1b[0m";
-            const address = server.address();
-            const message = typeof address === "string"
-                ? `\x1b[1mNodeJS TezX Server running at unix://${address}\x1b[0m`
-                : `\x1b[1mNodeJS TezX Server running at ${protocol}://localhost:${address?.port}/\x1b[0m`;
-            GlobalConfig.server = server;
-            GlobalConfig.debugging.success(message);
-            if (typeof callback == "function")
-                callback();
-            return server;
-        });
-        return server;
-    }
-    return {
-        listen,
-    };
-}

package/utils/regexRouter.d.ts

@@ -1,66 +0,0 @@
-/**
- * Compiles a route string or segment array into a regular expression for matching URL paths.
- * Supports dynamic `:param`, optional `:param?`, and wildcard `*param` segments.
- *
- * @param {string | string[]} seg - The route pattern, either as a string (`'/user/:id'`)
- *   or an array of segments (`['user', ':id']`).
- *
- * @returns {{
-*   regex: RegExp,
-*   paramNames: string[]
-* }}
-* @example
-* const { regex, paramNames } = compileRegexRoute('/user/:id/post/:slug?');
-* // regex: /^\/user\/([^\/]+)\/(?:([^\/]+))?\/?$/
-* // paramNames: ['id', 'slug']
-*
-* regex.test('/user/123/post/hello'); // ✅ true
-* regex.test('/user/123/post');       // ✅ true (because :slug? is optional)
-*
-* @example
-* const { regex, paramNames } = compileRegexRoute('/files/*path');
-* // regex: /^\/files\/(.+)\/?$/
-* // paramNames: ['path']
-*
-* regex.test('/files/images/cat.jpg'); // ✅ true
-*/
-export declare function compileRegexRoute(seg: string | string[]): {
-    regex: RegExp;
-    paramNames: string[];
-};
-/**
- * Combines a base path with a route regex pattern.
- *
- * @param basePath - The base path to prepend (e.g., '/api/v1')
- * @param routeRegex - The original route regex (e.g., /^\/users\/([^/]+?)$/)
- * @returns A new regex that includes the base path
- */
-export declare function addBaseToRegex(basePath: string, routeRegex: RegExp): RegExp;
-/**
- * Matches a given URL against a provided regular expression and extracts named parameters.
- *
- * @param {RegExp} regex - The regular expression to match against the URL.
- *   It should include capturing groups for each parameter.
- *   Example: /^\/user\/(\d+)\/post\/(\w+)$/
- *
- * @param {string} url - The URL string to match.
- *   Example: "/user/123/post/abc"
- *
- * @param {string[]} paramNames - An array of parameter names corresponding to the capturing groups in the regex.
- *   Example: ["userId", "postId"]
- *
- * @returns {{ success: boolean, params: Record<string, string | null> }} An object indicating:
- *   - `success`: whether the URL matched the regex.
- *   - `params`: an object mapping parameter names to their matched values, or `null` if not found.
- *
- * @example
- * const regex = /^\/user\/(\d+)\/post\/(\w+)$/;
- * const url = "/user/123/post/abc";
- * const paramNames = ["userId", "postId"];
- * const result = regexMatchRoute(regex, url, paramNames);
- * // result = { success: true, params: { userId: "123", postId: "abc" } }
- */
-export declare function regexMatchRoute(regex: RegExp, url: string, paramNames?: string[]): {
-    params: Record<string, string | null>;
-    success: boolean;
-};

package/utils/regexRouter.js

@@ -1,53 +0,0 @@
-import { sanitizePathSplit } from "./url.js";
-export function compileRegexRoute(seg) {
-    const segments = typeof seg == 'string' ? seg.split("/").filter(Boolean) : seg;
-    let regexStr = "^";
-    const paramNames = [];
-    for (let seg of segments) {
-        if (seg.startsWith(":")) {
-            const isOptional = seg.endsWith("?");
-            const name = seg.replace(":", "").replace("?", "");
-            paramNames.push(name);
-            regexStr += isOptional
-                ? `(?:\\/([^\\/]+))?`
-                : `\\/([^\\/]+)`;
-        }
-        else if (seg.startsWith("*")) {
-            const name = seg.slice(1) || "*";
-            paramNames.push(name);
-            regexStr += `\\/(.+)`;
-        }
-        else {
-            regexStr += `\\/${seg}`;
-        }
-    }
-    regexStr += "\\/?$";
-    return {
-        regex: new RegExp(regexStr),
-        paramNames,
-    };
-}
-export function addBaseToRegex(basePath, routeRegex) {
-    basePath = "/" + sanitizePathSplit("/", basePath)?.join("/");
-    if (basePath === "/")
-        basePath = "";
-    let body = routeRegex.source.replace(/^(\^)/, '').replace(/(\$)$/, '');
-    body = body.replace(/\\\//g, "/");
-    if (body.startsWith("/")) {
-        body = body.slice(1);
-    }
-    const cleaned = body.replace(/^\/+|\/+$/g, "").replace(/\/?\?$/, "");
-    const combined = basePath + "/" + cleaned + "/?";
-    const finalRegex = new RegExp(`^${combined}$`);
-    return finalRegex;
-}
-export function regexMatchRoute(regex, url, paramNames = []) {
-    const match = url.match(regex);
-    if (!match)
-        return { success: false, params: {} };
-    const params = {};
-    paramNames.forEach((name, idx) => {
-        params[name] = match[idx + 1] ?? null;
-    });
-    return { params, success: true };
-}

package/utils/state.d.ts

@@ -1,50 +0,0 @@
-/**
- * A simple key-value storage class using Map.
- */
-export declare class State {
-    private state;
-    constructor();
-    /**
-     * Store a value with a specific key.
-     * @param key - The key for the value.
-     * @param value - The value to be stored.
-     */
-    set(key: string, value: any): void;
-    /**
-     * Retrieve a value by key.
-     * @param key - The key of the value to retrieve.
-     * @returns The stored value or undefined if not found.
-     */
-    get(key: string): any | undefined;
-    /**
-     * Delete a key from storage.
-     * @param key - The key to remove.
-     * @returns True if the key was deleted, false otherwise.
-     */
-    delete(key: string): boolean;
-    /**
-     * Check if a key exists in the storage.
-     * @param key - The key to check.
-     * @returns True if the key exists, false otherwise.
-     */
-    has(key: string): boolean;
-    /**
-     * Get an array of all stored keys.
-     * @returns An array of keys.
-     */
-    keys(): string[];
-    /**
-     * Get an array of all stored values.
-     * @returns An array of values.
-     */
-    values(): any[];
-    /**
-     * Get an array of all key-value pairs.
-     * @returns An array of [key, value] tuples.
-     */
-    entries(): [string, any][];
-    /**
-     * Remove all entries from storage.
-     */
-    clear(): void;
-}