tezx 3.0.9-beta → 3.0.11-beta

package/middleware/sanitize-headers.d.ts

@@ -1,4 +1,4 @@
-import { Middleware } from "../types/index.js";
+import { Middleware, ResHeaderKey } from "../types/index.js";
 export type SanitizeHeadersOptions = {
     /**
      * 🟢 Whitelist of allowed headers (case-insensitive)
@@ -6,22 +6,14 @@ export type SanitizeHeadersOptions = {
      * @example
      * whitelist: ['content-type', 'authorization'] // Only allow these headers
      */
-    whitelist?: string[];
+    whitelist?: ResHeaderKey[];
     /**
      * 🔴 Blacklist of disallowed headers (case-insensitive)
      * @default [] (block none if empty)
      * @example
      * blacklist: ['x-powered-by', 'server'] // Block server info headers
      */
-    blacklist?: string[];
-    /**
-     * 🟠 Allow potentially unsafe characters in header values
-     * @default false
-     * @warning Enabling this may reduce security
-     * @example
-     * allowUnsafeCharacters: true // Allow CR/LF in headers
-     */
-    allowUnsafeCharacters?: boolean;
+    blacklist?: ResHeaderKey[];
 };
 /**
  * 🧼 Middleware to sanitize HTTP headers for security and compliance

package/middleware/sanitize-headers.js

@@ -1,50 +1,18 @@
-import { GlobalConfig } from "../core/config.js";
 const sanitizeHeaders = (options = {}) => {
-    const { whitelist = [], blacklist = [], allowUnsafeCharacters = false, } = options;
+    const { whitelist = [], blacklist = [], } = options;
     const normalizedWhitelist = whitelist.map((h) => h.toLowerCase());
     const normalizedBlacklist = blacklist.map((h) => h.toLowerCase());
+    let lWhite = normalizedWhitelist.length;
     return async function sanitizeHeaders(ctx, next) {
-        const sanitizedHeaders = {};
-        for (const key in ctx.header()) {
-            let value = ctx.header(key);
-            const normalizedKey = key.toLowerCase();
-            if (normalizedWhitelist.length > 0 &&
-                !normalizedWhitelist.includes(normalizedKey)) {
-                GlobalConfig.debugging.warn(`🚫 Header "${key}" not in whitelist - removed`);
-                continue;
+        await next();
+        for (const key of ctx.headers.keys()) {
+            if (lWhite > 0 && !normalizedWhitelist.includes(key)) {
+                ctx.headers.delete(key);
             }
-            if (normalizedBlacklist.includes(normalizedKey)) {
-                GlobalConfig.debugging.warn(`🚫 Header "${key}" in blacklist - removed`);
-                continue;
+            if (normalizedBlacklist.includes(key)) {
+                ctx.headers.delete(key);
             }
-            if (!isValidHeaderName(normalizedKey)) {
-                GlobalConfig.debugging.warn(`⚠️ Invalid header name: "${normalizedKey}" - removed`);
-                continue;
-            }
-            const sanitizedValue = sanitizeHeaderValue(value, allowUnsafeCharacters);
-            if (!sanitizedValue) {
-                GlobalConfig.debugging.warn(`⚠️ Header "${key}" has invalid/empty value - removed`);
-                continue;
-            }
-            sanitizedHeaders[normalizedKey] = sanitizedValue;
-        }
-        for (const k in sanitizedHeaders) {
-            let v = sanitizedHeaders[k];
-            ctx.setHeader(k, v);
         }
-        ctx.clearHeader = 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;
-};
 export { sanitizeHeaders as default, sanitizeHeaders };

package/middleware/xss-protection.d.ts

@@ -41,4 +41,4 @@ export type XSSProtectionOptions = {
  * }));
  */
 declare const xssProtection: (options?: XSSProtectionOptions) => (ctx: Context, next: NextCallback) => Promise<void>;
-export { xssProtection, xssProtection as default };
+export { xssProtection as default, xssProtection };

package/middleware/xss-protection.js

@@ -1,23 +1,19 @@
-import { GlobalConfig } from "../core/config.js";
 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.setHeader("X-XSS-Protection", xssHeaderValue);
-        GlobalConfig.debugging.warn(`🟢 X-XSS-Protection set to: ${xssHeaderValue}`);
         if (fallbackCSP) {
             const existingCSP = ctx.req.header("content-security-policy");
             if (!existingCSP) {
                 ctx.setHeader("Content-Security-Policy", fallbackCSP);
-                GlobalConfig.debugging.warn(`🟣 Fallback CSP set to: ${fallbackCSP}`);
             }
         }
         return await next();
     };
 };
-export { xssProtection, xssProtection as default };
+export { xssProtection as default, xssProtection };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tezx",
-  "version": "3.0.9-beta",
+  "version": "3.0.11-beta",
   "description": "TezX is a high-performance, lightweight JavaScript framework designed for speed, scalability, and flexibility. It enables efficient routing, middleware management, and static file serving with minimal configuration. Fully compatible with Node.js, Deno, and Bun.",
   "type": "module",
   "main": "cjs/index.js",
@@ -47,6 +47,11 @@
       "require": "./cjs/registry/index.js",
       "types": "./registry/index.d.ts"
     },
+    "./middleware": {
+      "import": "./middleware/index.js",
+      "require": "./cjs/middleware/index.js",
+      "types": "./middleware/index.d.ts"
+    },
     "./middleware/*": {
       "import": "./middleware/*.js",
       "require": "./cjs/middleware/*.js",

package/registry/RadixRouter.js

@@ -36,20 +36,18 @@ export class RadixRouter {
     search(method, path) {
         let params = {};
         let middlewares = [];
-        const { success, node } = this._match(method, this.root, sanitizePathSplit(path), 0, params, middlewares, new Set());
+        const { success, node } = this._match(method, this.root, path?.split("/")?.filter(Boolean), 0, params, middlewares);
         if (success && node) {
             const handlers = node.handlers?.[method] ?? [];
             return { method, params, handlers, middlewares };
         }
         return { method, params: {}, handlers: [], middlewares };
     }
-    _match(method, node, segments, index, params, middlewares, seen) {
-        if (node.handlers?.ALL) {
-            for (const mw of node.handlers.ALL) {
-                if (!seen.has(mw)) {
-                    seen.add(mw);
-                    middlewares.push(mw);
-                }
+    _match(method, node, segments, index, params, middlewares) {
+        if (node?.handlers?.ALL) {
+            const mw = node.handlers?.ALL;
+            for (let i = 0; i < mw.length; i++) {
+                middlewares.push(mw[i]);
             }
         }
         if (index === segments.length) {
@@ -58,40 +56,59 @@ export class RadixRouter {
             const opt = node.children[":"];
             if (opt?.isOptional) {
                 params[opt.paramName] = null;
-                return this._match(method, opt, segments, index, params, middlewares, seen);
+                return this._match(method, opt, segments, index, params, middlewares);
             }
             return { success: false, node: node };
         }
         const wc = node.children["*"];
-        if (wc?.handlers?.ALL) {
-            for (const mw of wc.handlers.ALL) {
-                if (!seen.has(mw)) {
-                    seen.add(mw);
-                    middlewares.push(mw);
-                }
-            }
-        }
         const seg = segments[index];
         if (node.children[seg]) {
-            const res = this._match(method, node.children[seg], segments, index + 1, params, middlewares, seen);
-            if (res.success)
+            const res = this._match(method, node.children[seg], segments, index + 1, params, middlewares);
+            if (res.success) {
+                if (wc?.handlers?.ALL) {
+                    const mw = wc.handlers?.ALL;
+                    for (let i = 0; i < mw.length; i++) {
+                        middlewares.push(mw[i]);
+                    }
+                }
                 return res;
+            }
         }
         const dyn = node.children[":"];
         if (dyn) {
             params[dyn.paramName] = seg;
-            const res = this._match(method, dyn, segments, index + 1, params, middlewares, seen);
-            if (res.success)
+            const res = this._match(method, dyn, segments, index + 1, params, middlewares);
+            if (res.success) {
+                if (wc?.handlers?.ALL) {
+                    const mw = wc.handlers?.ALL;
+                    for (let i = 0; i < mw.length; i++) {
+                        middlewares.push(mw[i]);
+                    }
+                }
                 return res;
+            }
             if (dyn.isOptional) {
                 params[dyn.paramName] = null;
-                const skip = this._match(method, dyn, segments, index, params, middlewares, seen);
-                if (skip.success)
+                const skip = this._match(method, dyn, segments, index, params, middlewares);
+                if (skip.success) {
+                    if (wc?.handlers?.ALL) {
+                        const mw = wc.handlers?.ALL;
+                        for (let i = 0; i < mw.length; i++) {
+                            middlewares.push(mw[i]);
+                        }
+                    }
                     return skip;
+                }
             }
         }
         if (wc) {
             let wildcard = segments.slice(index).join("/");
+            if (wc?.handlers?.ALL) {
+                const mw = wc.handlers?.ALL;
+                for (let i = 0; i < mw.length; i++) {
+                    middlewares.push(mw[i]);
+                }
+            }
             if (wildcard) {
                 params[wc.paramName] = wildcard;
                 return { node: wc, success: true };
@@ -124,3 +141,35 @@ export class RadixRouter {
         return result;
     }
 }
+const routes = [
+    "/",
+    "/users",
+    "/users/:id",
+    "/users/:id/profile",
+    "/posts/:postId?",
+    "/files/*",
+    "/admin/settings",
+    "/search/:term?",
+    "/categories/:categoryId/products/:productId",
+    "/about",
+];
+const testPaths = [
+    "/",
+    "/users",
+    "/users/123",
+    "/users/123/profile",
+    "/posts",
+    "/posts/456",
+    "/files/path/to/file.txt",
+    "/admin/settings",
+    "/search",
+    "/search/nodejs",
+    "/categories/12/products/999",
+    "/notfound",
+];
+const router = new RadixRouter();
+let x = function xx() {
+    return {
+        body: "3453455",
+    };
+};

package/types/index.d.ts

@@ -128,6 +128,7 @@ export interface CookieOptions {
  */
 export type Runtime = "bun" | "deno" | "node";
 import { Context } from "../core/context.js";
+import { TezXError } from "../core/error.js";
 import { RequestHeader, ResponseHeader } from "./headers.js";
 /**
  * Options to customize static file serving behavior.
@@ -233,7 +234,7 @@ export type Middleware<T extends Record<string, any> = {}, Path extends string =
  * @param ctx - The context object where the error occurred.
  * @returns An HTTP response or a promise that resolves to an HTTP response.
  */
-export type ErrorHandler<T extends Record<string, any> = {}> = (err: Error, ctx: Ctx<T>) => HttpBaseResponse;
+export type ErrorHandler<T extends Record<string, any> = {}> = (err: TezXError, ctx: Ctx<T>) => HttpBaseResponse;
 /**
  * Configuration options for parsing and validating multipart/form-data.
  */

package/utils/cookie.js

@@ -28,7 +28,7 @@ export function allCookies(ctx) {
     return cookies;
 }
 export function setCookie(ctx, name, value, options) {
-    ctx.setHeader("Set-Cookie", `${name}=${value}; ${serializeOptions(options || {})}`);
+    ctx.setHeader("Set-Cookie", `${name}=${value}; ${serializeOptions(options ?? {})}`);
 }
 export function deleteCookie(ctx, name, options) {
     ctx.setHeader("Set-Cookie", `${name}=; ${serializeOptions({ ...options, maxAge: 0, expires: new Date(0) })}`);

package/utils/rateLimit.d.ts

@@ -1,4 +1,3 @@
-import { Context } from "..";
 export declare function createRateLimitDefaultStorage(): {
     get: (key: string) => {
         count: number;
@@ -13,7 +12,7 @@ export declare function createRateLimitDefaultStorage(): {
     }>;
     clearExpired: () => void;
 };
-export declare function isRateLimit(ctx: Context, key: string, store: any, maxRequests: number, windowMs: number): {
+export declare function isRateLimit(key: string, store: any, maxRequests: number, windowMs: number): {
     check: boolean;
     entry: any;
 };

package/utils/rateLimit.js

@@ -13,8 +13,8 @@ export function createRateLimitDefaultStorage() {
         },
     };
 }
-export function isRateLimit(ctx, key, store, maxRequests, windowMs) {
-    store.clearExpired();
+export function isRateLimit(key, store, maxRequests, windowMs) {
+    store?.clearExpired();
     const now = Date.now();
     let entry = store.get(key) || { count: 0, resetTime: now + windowMs };
     if (now < entry.resetTime) {

package/utils/regexRouter.js

@@ -14,6 +14,7 @@ export function compileRegexRoute(seg) {
             const name = seg.slice(1) || "*";
             paramNames.push(name);
             regexStr += `\\/(.+)`;
+            break;
         }
         else {
             regexStr += `\\/${seg}`;

package/utils/response.d.ts

@@ -1,20 +1,18 @@
 import { Context } from "../core/context.js";
-import { HttpBaseResponse, ResponseHeaders, ResponseInit } from "../types/index.js";
+import { TezXError } from "../core/error.js";
+import { HttpBaseResponse } from "../types/index.js";
 export declare let notFoundResponse: (ctx: Context) => HttpBaseResponse;
-export declare function handleErrorResponse(message: Error | undefined, ctx: Context): Promise<HttpBaseResponse>;
+export declare function handleErrorResponse(err: TezXError | undefined, ctx: Context): Promise<HttpBaseResponse>;
+/**
+ * Converts a template literal array and values into a single string.
+ * If a plain string is passed, it returns the string itself.
+ *
+ * @param input - A string or a template literal array.
+ * @param values - Values for template literal placeholders.
+ * @returns Concatenated string.
+ */
+export declare function toString(input: string | readonly string[], values: any[]): string;
 export declare function determineContentTypeBody(body: any): {
     type: string;
     body: any;
 };
-/**
- * Creates a Response object with minimal GC overhead.
- * Merges only once and supports a forced Content-Type.
- *
- * @param {BodyInit} body - The body content.
- * @param {string} type - The Content-Type header.
- * @param {ResponseInit} init - Optional ResponseInit.
- * @param {ResponseHeader} baseHeaders - Default headers from the class.
- * @param {number} defaultStatus - Default status from the class.
- * @returns {Response}
- */
-export declare function newResponse(body: BodyInit | null, type: string, init: ResponseInit | undefined, baseHeaders: ResponseHeaders, defaultStatus: number): Response;

package/utils/response.js

@@ -1,17 +1,29 @@
+import { GlobalConfig } from "../core/config.js";
+import { TezXError } from "../core/error.js";
 export let notFoundResponse = (ctx) => {
     const { method, pathname } = ctx;
     return ctx.text(`${method}: '${pathname}' could not find\n`, {
         status: 404,
     });
 };
-export async function handleErrorResponse(message = new Error("Internal Server Error"), ctx) {
-    let error = message;
-    if (message instanceof Error) {
-        error = message.stack;
+export async function handleErrorResponse(err = TezXError.internal(), ctx) {
+    if (err instanceof TezXError) {
+        GlobalConfig.debugging.error(err.details ?? err?.message);
+        return ctx.status(err.statusCode ?? 500).send(err.details ?? err?.message ?? "Internal Server Error");
     }
-    return ctx.text(error, {
-        status: 500,
-    });
+    return await handleErrorResponse(TezXError.internal(), ctx);
+}
+export function toString(input, values) {
+    if (typeof input === "string") {
+        return input;
+    }
+    let result = "";
+    for (let i = 0; i < input.length; i++) {
+        result += input[i];
+        if (i < values.length)
+            result += values[i];
+    }
+    return result;
 }
 export function determineContentTypeBody(body) {
     if (typeof body === "string" ||
@@ -31,7 +43,7 @@ export function determineContentTypeBody(body) {
     if (typeof Blob !== "undefined" && body instanceof Blob) {
         return { type: body.type || "application/octet-stream", body };
     }
-    if (typeof body === "object" && typeof body.pipe === "function") {
+    if (typeof body === "object" && typeof body?.pipe === "function") {
         return { type: "application/octet-stream", body };
     }
     if (typeof body === "object") {
@@ -42,24 +54,3 @@ export function determineContentTypeBody(body) {
     }
     return { type: "text/plain; charset=utf-8", body: String(body ?? "") };
 }
-export function newResponse(body, type, init = {}, baseHeaders, defaultStatus) {
-    let headers;
-    if (init.headers) {
-        headers = {
-            "Content-Type": type,
-            ...baseHeaders,
-            ...init.headers,
-        };
-    }
-    else {
-        headers = {
-            "Content-Type": type,
-            ...baseHeaders,
-        };
-    }
-    return new Response(body, {
-        status: init.status || defaultStatus,
-        statusText: init.statusText,
-        headers,
-    });
-}

package/cjs/middleware/cache-control.js

@@ -1,93 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = exports.cacheControl = void 0;
-const config_js_1 = require("../core/config.js");
-const cacheControl = (options) => {
-    const { defaultSettings, useWeakETag = false, rules = [], onError = (error, ctx) => {
-        ctx.setStatus = 500;
-        ctx.body = { error: "Failed to set cache headers." };
-    }, logEvent = (event, ctx, error) => {
-        if (event === "error") {
-            config_js_1.GlobalConfig.debugging.error(`[CACHE] ${event.toUpperCase()}: ${error?.message}`);
-        }
-        else {
-            config_js_1.GlobalConfig.debugging.success(`[CACHE] ${event.toUpperCase()} for ${ctx.method} ${ctx.pathname}`);
-        }
-    }, } = options;
-    return async function cacheControl(ctx, next) {
-        if (!["GET", "HEAD"].includes(ctx.method)) {
-            return await next();
-        }
-        try {
-            await next();
-            const matchedRule = rules.find((rule) => rule.condition(ctx)) || null;
-            const { maxAge, scope, enableETag, vary } = matchedRule || defaultSettings;
-            const cacheControlValue = `${scope}, max-age=${maxAge}`;
-            ctx.setHeader("Cache-Control", cacheControlValue);
-            const expiresDate = new Date(Date.now() + maxAge * 1000).toUTCString();
-            ctx.setHeader("Expires", expiresDate);
-            if (vary?.length) {
-                ctx.setHeader("Vary", vary.join(", "));
-            }
-            if (enableETag) {
-                const responseBody = typeof ctx.resBody === "string"
-                    ? ctx.resBody
-                    : JSON.stringify(ctx.resBody ?? "");
-                const etag = await generateETag(responseBody, useWeakETag);
-                const ifNoneMatch = ctx.req.header("if-none-match");
-                if (ifNoneMatch === etag) {
-                    ctx.setStatus = 304;
-                    ctx.body = null;
-                    logEvent("cached", ctx);
-                    return;
-                }
-                ctx.setHeader("ETag", etag);
-            }
-            logEvent("cached", ctx);
-        }
-        catch (error) {
-            logEvent("error", ctx, error);
-            return onError?.(error, ctx);
-        }
-    };
-};
-exports.cacheControl = cacheControl;
-exports.default = cacheControl;
-const generateETag = async (content, weak = false) => {
-    const crypto = await Promise.resolve().then(() => __importStar(require("node:crypto")));
-    const hash = crypto.createHash("md5").update(content).digest("hex");
-    return weak ? `W/"${hash}"` : `"${hash}"`;
-};

package/cjs/middleware/detect-bot.js

@@ -1,66 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.detectBot = void 0;
-const config_js_1 = require("../core/config.js");
-const rateLimit_js_1 = require("../utils/rateLimit.js");
-const detectBot = (options = {}) => {
-    const { botUserAgents = ["bot", "spider", "crawl", "slurp"], maxRequests = 30, windowMs = 60000, isBlacklisted = async () => false, queryKeyBot = "bot", onBotDetected = "block", enableRateLimiting = false, customBotDetector = async () => false, customBlockedResponse = (ctx, { reason }) => {
-        ctx.setStatus = 403;
-        return ctx.json({ error: `Bot detected: ${reason}` });
-    }, storage, confidenceThreshold = 0.5, } = options;
-    let store = storage;
-    if (enableRateLimiting) {
-        store = (0, rateLimit_js_1.createRateLimitDefaultStorage)();
-    }
-    return async function detectBot(ctx, next) {
-        const detectionResult = {
-            isBot: false,
-            indicators: [],
-        };
-        const userAgent = ctx.header("user-agent")?.toLowerCase() || "";
-        const remoteAddress = `${ctx.req.remoteAddress?.address}:${ctx.req.remoteAddress?.port}` ||
-            "unknown";
-        const isBotQuery = ctx.req.query[queryKeyBot] === "true";
-        if (botUserAgents.some((agent) => userAgent.includes(agent))) {
-            detectionResult.indicators.push("User-Agent");
-        }
-        if (await isBlacklisted(ctx, remoteAddress)) {
-            detectionResult.indicators.push("Blacklisted IP");
-        }
-        if (isBotQuery) {
-            detectionResult.indicators.push("Query Parameter");
-        }
-        const key = `${ctx.req.remoteAddress.address}:${ctx.req.remoteAddress.port}`;
-        if (enableRateLimiting &&
-            (0, rateLimit_js_1.isRateLimit)(ctx, key, store, maxRequests, windowMs).check) {
-            detectionResult.indicators.push("Rate Limiting");
-        }
-        if (await customBotDetector(ctx)) {
-            detectionResult.indicators.push("Custom Detector");
-        }
-        detectionResult.isBot = detectionResult.indicators.length > 0;
-        if (detectionResult.indicators.length > 1) {
-            detectionResult.reason = "Multiple Indicators";
-            const confidence = Math.min(0.3 * detectionResult.indicators.length, 1);
-            detectionResult.isBot = confidence >= confidenceThreshold;
-        }
-        else if (detectionResult.indicators.length === 1) {
-            detectionResult.reason = detectionResult.indicators[0];
-        }
-        if (detectionResult.isBot) {
-            config_js_1.GlobalConfig.debugging.warn(`Bot detected: ${detectionResult.reason}`, {
-                ip: remoteAddress,
-                userAgent,
-                indicators: detectionResult.indicators,
-            });
-            if (onBotDetected === "block") {
-                return customBlockedResponse(ctx, detectionResult);
-            }
-            else if (typeof onBotDetected === "function") {
-                return onBotDetected(ctx, detectionResult);
-            }
-        }
-        return await next();
-    };
-};
-exports.detectBot = detectBot;

package/cjs/middleware/detect-locale.js

@@ -1,45 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = exports.detectLocale = void 0;
-const config_js_1 = require("../core/config.js");
-const cookie_js_1 = require("../utils/cookie.js");
-const detectLocale = (options) => {
-    const { supportedLocales, defaultLocale = "en", queryKeyLocale = "lang", cookieKeyLocale = "locale", localeContextKey = "locale", customLocaleDetector, } = options;
-    return async function detectLocale(ctx, next) {
-        let detectedLocale;
-        const queryLocale = ctx.req.query[queryKeyLocale];
-        if (queryLocale && supportedLocales.includes(queryLocale)) {
-            detectedLocale = queryLocale;
-        }
-        if (!detectedLocale) {
-            const cookieLocale = (0, cookie_js_1.getCookie)(ctx, cookieKeyLocale);
-            if (cookieLocale && supportedLocales.includes(cookieLocale)) {
-                detectedLocale = cookieLocale;
-            }
-        }
-        if (!detectedLocale) {
-            const acceptLanguage = ctx.req.header("accept-language");
-            if (acceptLanguage) {
-                const preferredLocales = acceptLanguage
-                    .split(",")
-                    .map((lang) => lang.split(";")[0].trim())
-                    .filter((lang) => supportedLocales.includes(lang));
-                detectedLocale = preferredLocales[0];
-            }
-        }
-        if (!detectedLocale && customLocaleDetector) {
-            const customLocale = customLocaleDetector(ctx);
-            if (customLocale && supportedLocales.includes(customLocale)) {
-                detectedLocale = customLocale;
-            }
-        }
-        if (!detectedLocale) {
-            detectedLocale = defaultLocale;
-        }
-        ctx[localeContextKey] = detectedLocale;
-        config_js_1.GlobalConfig.debugging.success(`Detected locale: ${detectedLocale}`);
-        return await next();
-    };
-};
-exports.detectLocale = detectLocale;
-exports.default = detectLocale;