tezx 2.0.11 → 3.0.0

package/cjs/core/server.js

@@ -1,234 +1,115 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TezX = void 0;
-const colors_js_1 = require("../utils/colors.js");
-const httpStatusMap_js_1 = require("../utils/httpStatusMap.js");
-const regexRouter_js_1 = require("../utils/regexRouter.js");
+const RadixRouter_js_1 = require("../registry/RadixRouter.js");
+const response_js_1 = require("../utils/response.js");
+const url_js_1 = require("../utils/url.js");
 const config_js_1 = require("./config.js");
 const context_js_1 = require("./context.js");
+const error_js_1 = require("./error.js");
 const router_js_1 = require("./router.js");
 class TezX extends router_js_1.Router {
-    #onPathResolve;
-    constructor({ basePath = "/", env = {}, debugMode = false, onPathResolve, allowDuplicateMw = false, overwriteMethod = true, } = {}) {
-        config_js_1.GlobalConfig.allowDuplicateMw = allowDuplicateMw;
-        config_js_1.GlobalConfig.overwriteMethod = overwriteMethod;
+    #pathResolver;
+    #notFound = response_js_1.notFoundResponse;
+    #errorHandler = response_js_1.handleErrorResponse;
+    constructor({ basePath = "/", env = {}, debugMode = false, onPathResolve, routeRegistry = new RadixRouter_js_1.RadixRouter(), } = {}) {
         if (debugMode) {
             config_js_1.GlobalConfig.debugMode = debugMode;
         }
         super({ basePath, env });
-        this.#onPathResolve = onPathResolve;
+        if (!routeRegistry) {
+            throw new Error("routeRegistry is required for TezX initialization");
+        }
+        this.router = routeRegistry;
+        this.#pathResolver = onPathResolve;
         this.serve = this.serve.bind(this);
     }
-    #regexRouter(method, pathname) {
-        for (let pattern of this.routers.values()) {
-            const handler = pattern?.get(method) || pattern?.get("ALL");
-            const { success, params } = (0, regexRouter_js_1.regexMatchRoute)(handler?.regex, pathname, handler?.paramNames || []);
-            if (success && handler) {
-                return {
-                    callback: handler.callback,
-                    middlewares: handler.middlewares,
-                    params: params,
-                };
-            }
-        }
-        return null;
+    notFound(callback) {
+        this.#notFound = callback;
+        return this;
     }
-    #triRouter(method, pathname, priority = "static") {
-        const parts = pathname.split("/").filter(Boolean);
-        const params = {};
-        let node = this.triRouter;
-        if (priority == "static") {
-            for (let part of parts) {
-                if (node.children.has(part)) {
-                    node = node.children.get(part);
-                }
-                else if (node.children.has(":")) {
-                    node = node.children.get(":");
-                    if (node.paramName)
-                        params[node.paramName] = part;
-                }
-                else {
-                    return null;
-                }
-            }
-        }
-        else {
-            for (let part of parts) {
-                if (node.children.has(":")) {
-                    node = node.children.get(":");
-                    if (node.paramName)
-                        params[node.paramName] = part;
-                }
-                else if (node.children.has(part)) {
-                    node = node.children.get(part);
-                }
-                else {
-                    return null;
-                }
-            }
-        }
-        if (node?.handlers?.size && node?.pathname) {
-            const handlers = node.handlers.get(method) || node.handlers.get("ALL");
-            if (handlers) {
-                return {
-                    middlewares: handlers.middlewares,
-                    callback: handlers.callback,
-                    params: params,
-                };
-            }
-            return null;
-        }
-        return null;
-    }
-    findRoute(method, pathname) {
-        const route = this.#triRouter(method, pathname) ||
-            this.#regexRouter(method, pathname) ||
-            this.#triRouter(method, pathname, "param");
-        if (route) {
-            return {
-                ...route,
-                middlewares: [...route.middlewares],
-            };
-        }
-        return null;
+    onError(callback) {
+        this.#errorHandler = callback;
+        return this;
     }
-    #createHandler(middlewares) {
-        return async (ctx) => {
-            let index = 0;
-            let response = undefined;
-            const next = async () => {
-                if (index >= middlewares.length) {
-                    return;
+    async #chain(ctx, mLen, middlewares, hLen, handlers) {
+        let index = -1;
+        let res;
+        async function dispatch(i) {
+            if (i <= index)
+                throw new error_js_1.TezXError("next() called multiple times");
+            index = i;
+            if (i < mLen) {
+                const fn = middlewares[i];
+                if (typeof fn !== "function")
+                    throw new TypeError(`Middleware[${i}] must be a function`);
+                res = (await fn(ctx, () => dispatch(i + 1)));
+                if (res !== undefined) {
+                    ctx.res = res;
                 }
-                const currentMiddleware = middlewares[index++];
-                try {
-                    const result = await currentMiddleware(ctx, next);
-                    if (result instanceof Response) {
-                        ctx.res = result;
-                    }
-                    if (result !== undefined) {
-                        response = result;
-                    }
-                    return response;
-                }
-                catch (err) {
-                    ctx.body = err;
-                    throw err;
-                }
-            };
-            let res = await next();
-            if (res instanceof Response) {
-                return res;
-            }
-            if (typeof res == "function" && ctx.wsProtocol) {
-                return res;
-            }
-            if (!res && !ctx.body) {
-                throw new Error(`Handler failed: Middleware chain incomplete or response missing. Did you forget ${(0, colors_js_1.colorText)(" await next() ", "bgRed")} or to return a response? ${(0, colors_js_1.colorText)(` Path: ${ctx.pathname}, Method: ${ctx.method} `, "bgCyan")}`);
-            }
-            const resBody = res || ctx.body;
-            const toJson = {};
-            for (const [key, value] of ctx.headers.entries()) {
-                toJson[key] = value;
-            }
-            return ctx.send(resBody, toJson);
-        };
-    }
-    #findMiddleware(pathname) {
-        const parts = pathname.split("/").filter(Boolean);
-        let middlewares = [];
-        let node = this.triMiddlewares;
-        for (let part of parts) {
-            if (node.children.has(part)) {
-                node = node.children.get(part);
-            }
-            else if (node.children.has("*")) {
-                node = node.children.get("*");
+                return ctx.res;
             }
-            else if (node.children.has(":")) {
-                node = node.children.get(":");
-            }
-            else {
-                break;
+            const hi = i - mLen;
+            if (hi < hLen) {
+                const fn = handlers[hi];
+                if (typeof fn !== "function")
+                    throw new TypeError(`Handler[${hi}] must be a function`);
+                res = (await fn(ctx, () => dispatch(i + 1)));
+                if (res !== undefined) {
+                    ctx.res = res;
+                }
+                return ctx.res;
             }
-            middlewares.push(...node.middlewares);
-        }
-        return middlewares;
-    }
-    async #resolvePath(pathname) {
-        let resolvePath = pathname;
-        if (this.#onPathResolve) {
-            resolvePath = await this.#onPathResolve(pathname);
-            config_js_1.GlobalConfig.debugging.warn(`${(0, colors_js_1.colorText)(" PATH RESOLVE ", "white")} ${(0, colors_js_1.colorText)(pathname, "red")} ➞ ${(0, colors_js_1.colorText)(resolvePath, "cyan")}`);
         }
-        if (typeof resolvePath !== "string") {
-            throw new Error(`Path resolution failed: expected a string, got ${typeof resolvePath}`);
-        }
-        return resolvePath;
+        await dispatch(0);
+        return (ctx.res ??
+            (ctx.body !== undefined ? ctx.send(ctx.body) : this.#notFound(ctx)));
     }
-    async #handleRequest(req, options) {
-        let ctx = new context_js_1.Context(req, options);
-        const urlRef = ctx.req.urlRef;
-        const { pathname } = urlRef;
-        let resolvePath = await this.#resolvePath(pathname);
-        let middlewares = this.#findMiddleware(resolvePath);
-        ctx.env = this.env;
+    async #handleRequest(req, method, args) {
+        if (!(req instanceof Request))
+            throw new error_js_1.TezXError("Invalid request object provided to tezX server.");
+        const rawPath = (0, url_js_1.getPathname)(req.url);
+        const pathname = this.#pathResolver
+            ? await this.#pathResolver(rawPath)
+            : rawPath;
+        const ctx = new context_js_1.Context(req, pathname, method, this.env, args);
         try {
-            let combine = [...this.triMiddlewares.middlewares, ...middlewares];
-            const find = this.findRoute(ctx.req.method, resolvePath);
-            if (find?.callback) {
-                ctx.params = find.params;
-                const callback = find.callback;
-                let routeMiddlewares = find.middlewares || [];
-                combine.push(...routeMiddlewares, callback);
+            const staticHandler = this.staticFile?.[`${method} ${pathname}`];
+            if (staticHandler) {
+                return staticHandler(ctx);
             }
-            else {
-                ctx.setStatus = 404;
-                combine.push(config_js_1.GlobalConfig.notFound);
+            const route = this.router?.search(method, pathname);
+            const mLen = route?.middlewares?.length;
+            const hLen = route?.handlers?.length;
+            if (!route || (hLen === 0 && mLen === 0)) {
+                return this.#notFound(ctx);
             }
-            let response = await this.#createHandler(combine)(ctx);
-            if (ctx.wsProtocol) {
-                if (typeof response == "function") {
-                    return {
-                        websocket: response,
-                        ctx: ctx,
-                    };
-                }
-                return response;
+            ctx.params = route.params;
+            if (hLen === 1 && mLen === 0) {
+                return ((await route.handlers[0](ctx)) ??
+                    (ctx.body !== undefined ? ctx.send(ctx.body) : this.#notFound(ctx)));
             }
-            let finalResponse = () => {
-                return (ctx) => {
-                    let headers = response?.headers;
-                    for (const [key, value] of headers.entries()) {
-                        ctx.headers.set(key, value);
-                    }
-                    const statusText = response?.statusText || httpStatusMap_js_1.httpStatusMap[response?.status] || "";
-                    const status = response.status || ctx.getStatus;
-                    return new Response(response.body, {
-                        status,
-                        statusText,
-                        headers: ctx.headers,
-                    });
-                };
-            };
-            return finalResponse()(ctx);
+            return await this.#chain(ctx, mLen, route.middlewares, hLen, route.handlers);
         }
         catch (err) {
-            return this.#handleError(err, ctx);
+            return this.#errorHandler?.((0, error_js_1.TezXErrorParse)(err), ctx);
         }
     }
-    async #handleError(err, ctx) {
-        let error = err;
-        if (err instanceof Error) {
-            error = err.stack;
+    async serve(req, ...args) {
+        const method = (req.method ?? "GET").toUpperCase();
+        if (method === "HEAD") {
+            const getRequest = new Request(req.url, { ...req, method: "GET" });
+            const headResponse = await this.#handleRequest(getRequest, method, args);
+            return new Response(null, {
+                status: headResponse.status,
+                statusText: headResponse.statusText,
+                headers: headResponse.headers,
+            });
         }
-        config_js_1.GlobalConfig.debugging.error(`${(0, colors_js_1.colorText)(` ${ctx.pathname}, Method: ${ctx.method} `, "bgRed")}`, `${httpStatusMap_js_1.httpStatusMap[500]}: ${error} `);
-        let res = await config_js_1.GlobalConfig.onError(error, ctx);
-        ctx.setStatus = res.status;
-        return res;
-    }
-    async serve(req, options) {
-        return this.#handleRequest(req, options);
+        return this.#handleRequest(req, method, args);
     }
 }
 exports.TezX = TezX;
+if (!globalThis.TezX) {
+    globalThis.TezX = TezX;
+}

package/cjs/deno/env.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadEnv = loadEnv;
-const environment_js_1 = require("../core/environment.js");
+const runtime_js_1 = require("../utils/runtime.js");
 const colors_js_1 = require("../utils/colors.js");
+const error_js_1 = require("../core/error.js");
 function parseEnvFile(filePath, result) {
     try {
-        let runtime = environment_js_1.Environment.getEnvironment;
-        if (runtime !== "deno") {
-            throw new Error(`Please use ${(0, colors_js_1.colorText)(`import {loadEnv} from "tezx/${runtime}"`, "bgRed")} environment`);
+        if (runtime_js_1.runtime !== "deno") {
+            throw new error_js_1.TezXError(`Please use ${(0, colors_js_1.colorText)(`import {loadEnv} from "tezx/${runtime_js_1.runtime}"`, "bgRed")} environment`);
         }
         let fileExists = false;
         try {

package/cjs/deno/getConnInfo.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConnInfo = getConnInfo;
+function getConnInfo() {
+    return (ctx, next) => {
+        let connInfo = ctx.args?.[0];
+        if (connInfo && connInfo.remoteAddr) {
+            let remoteAddr = connInfo.remoteAddr;
+            ctx.req.remoteAddress = {
+                port: remoteAddr?.port,
+                address: remoteAddr?.hostname,
+                transport: remoteAddr?.transport,
+                family: remoteAddr?.family,
+            };
+        }
+        return next();
+    };
+}

package/cjs/deno/index.js

@@ -1,24 +1,17 @@
 "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 __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const adpater_js_1 = require("./adpater.js");
+exports.upgradeWebSocket = exports.serveStatic = exports.loadEnv = exports.getConnInfo = void 0;
 const env_js_1 = require("./env.js");
-__exportStar(require("./adpater.js"), exports);
-__exportStar(require("./env.js"), exports);
+Object.defineProperty(exports, "loadEnv", { enumerable: true, get: function () { return env_js_1.loadEnv; } });
+const getConnInfo_js_1 = require("./getConnInfo.js");
+Object.defineProperty(exports, "getConnInfo", { enumerable: true, get: function () { return getConnInfo_js_1.getConnInfo; } });
+const serveStatic_js_1 = require("./serveStatic.js");
+Object.defineProperty(exports, "serveStatic", { enumerable: true, get: function () { return serveStatic_js_1.serveStatic; } });
+const ws_js_1 = require("./ws.js");
+Object.defineProperty(exports, "upgradeWebSocket", { enumerable: true, get: function () { return ws_js_1.upgradeWebSocket; } });
 exports.default = {
-    denoAdapter: adpater_js_1.denoAdapter,
+    serveStatic: serveStatic_js_1.serveStatic,
+    getConnInfo: getConnInfo_js_1.getConnInfo,
     loadEnv: env_js_1.loadEnv,
+    upgradeWebSocket: ws_js_1.upgradeWebSocket,
 };

package/cjs/deno/serveStatic.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serveStatic = serveStatic;
+exports.getFiles = getFiles;
+const error_js_1 = require("../core/error.js");
+const low_level_js_1 = require("../utils/low-level.js");
+function serveStatic(...args) {
+    let route = "";
+    let dir;
+    let options = {};
+    switch (args.length) {
+        case 3:
+            [route, dir, options] = args;
+            break;
+        case 2:
+            if (typeof args[1] === "object") {
+                [dir, options] = args;
+            }
+            else {
+                [route, dir] = args;
+            }
+            break;
+        case 1:
+            [dir] = args;
+            break;
+        default:
+            throw new error_js_1.TezXError(`\x1b[1;31m404 Not Found\x1b[0m \x1b[1;32mInvalid arguments\x1b[0m`);
+    }
+    return {
+        files: getFiles(dir, route, options),
+        options,
+    };
+}
+function getFiles(dir, basePath = "/", option = {}) {
+    const files = [];
+    for (const entry of Deno.readDirSync(dir)) {
+        const path = `${dir}/${entry.name}`;
+        if (entry.isDirectory) {
+            files.push(...getFiles(path, `${basePath}/${entry.name}`, option));
+        }
+        else {
+            const ext = (0, low_level_js_1.extensionExtract)(entry.name);
+            if (option?.extensions?.length && !option.extensions.includes(ext)) {
+                continue;
+            }
+            files.push({
+                fileSource: path,
+                route: `/${(0, low_level_js_1.sanitizePathSplitBasePath)(basePath, entry.name).join("/")}`,
+            });
+        }
+    }
+    return files;
+}

package/cjs/deno/ws.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.upgradeWebSocket = upgradeWebSocket;
+const error_js_1 = require("../core/error.js");
+function upgradeWebSocket(callback, options = {}) {
+    const { onUpgradeError = (error, ctx) => {
+        ctx.setStatus = 401;
+        return ctx.text(error.message);
+    }, } = options;
+    return async (ctx, next) => {
+        const upgrade = ctx.req.header("upgrade")?.toLowerCase();
+        const connection = ctx.req.header("connection")?.toLowerCase();
+        const key = ctx.req.header("sec-websocket-key");
+        if (upgrade !== "websocket" || !connection?.includes("upgrade") || !key) {
+            ctx.setStatus = 401;
+            const error = new error_js_1.TezXError("Invalid WebSocket upgrade request.", 401);
+            return next ? next() : onUpgradeError(error, ctx);
+        }
+        ctx.wsProtocol = ctx.url?.startsWith("https") ? "wss" : "ws";
+        try {
+            if (typeof callback !== "function") {
+                throw new error_js_1.TezXError("Missing or invalid WebSocket callback handler.");
+            }
+            const { socket, response } = Deno.upgradeWebSocket(ctx.rawRequest, {
+                protocol: options.protocol,
+                idleTimeout: options.idleTimeout,
+            });
+            const event = callback(ctx);
+            socket.onopen = () => event.open?.(socket, ctx);
+            socket.onmessage = (e) => event.message?.(socket, e.data);
+            socket.onclose = (e) => event.close?.(socket, { code: e.code, reason: e.reason });
+            socket.onerror = (err) => event.error?.(socket, err);
+            return response;
+        }
+        catch (err) {
+            return onUpgradeError((0, error_js_1.TezXErrorParse)(err, 426), ctx);
+        }
+    };
+}

package/cjs/helper/index.js

@@ -1,20 +1,56 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sanitizePathSplit = exports.GlobalConfig = exports.generateID = exports.Environment = exports.colorText = void 0;
+exports.useFormData = exports.setCookie = exports.sanitized = exports.sanitizePathSplitBasePath = exports.sanitizePathSplit = exports.runtime = exports.readStream = exports.normalizeHeaderKey = exports.httpStatusMap = exports.getFileBuffer = exports.getCookie = exports.generateUUID = exports.generateRandomBase64 = exports.generateID = exports.fileSize = exports.fileExists = exports.extensionExtract = exports.deleteCookie = exports.colorText = exports.allCookies = exports.GlobalConfig = void 0;
 const config_js_1 = require("../core/config.js");
 Object.defineProperty(exports, "GlobalConfig", { enumerable: true, get: function () { return config_js_1.GlobalConfig; } });
-const environment_js_1 = require("../core/environment.js");
-Object.defineProperty(exports, "Environment", { enumerable: true, get: function () { return environment_js_1.Environment; } });
 const colors_js_1 = require("../utils/colors.js");
 Object.defineProperty(exports, "colorText", { enumerable: true, get: function () { return colors_js_1.colorText; } });
-const url_js_1 = require("../utils/url.js");
-Object.defineProperty(exports, "sanitizePathSplit", { enumerable: true, get: function () { return url_js_1.sanitizePathSplit; } });
-const common_js_1 = require("./common.js");
-Object.defineProperty(exports, "generateID", { enumerable: true, get: function () { return common_js_1.generateID; } });
+const cookie_js_1 = require("../utils/cookie.js");
+Object.defineProperty(exports, "allCookies", { enumerable: true, get: function () { return cookie_js_1.allCookies; } });
+Object.defineProperty(exports, "deleteCookie", { enumerable: true, get: function () { return cookie_js_1.deleteCookie; } });
+Object.defineProperty(exports, "getCookie", { enumerable: true, get: function () { return cookie_js_1.getCookie; } });
+Object.defineProperty(exports, "setCookie", { enumerable: true, get: function () { return cookie_js_1.setCookie; } });
+const file_js_1 = require("../utils/file.js");
+Object.defineProperty(exports, "fileExists", { enumerable: true, get: function () { return file_js_1.fileExists; } });
+Object.defineProperty(exports, "fileSize", { enumerable: true, get: function () { return file_js_1.fileSize; } });
+Object.defineProperty(exports, "getFileBuffer", { enumerable: true, get: function () { return file_js_1.getFileBuffer; } });
+Object.defineProperty(exports, "readStream", { enumerable: true, get: function () { return file_js_1.readStream; } });
+const formData_js_1 = require("../utils/formData.js");
+Object.defineProperty(exports, "useFormData", { enumerable: true, get: function () { return formData_js_1.useFormData; } });
+const generateID_js_1 = require("../utils/generateID.js");
+Object.defineProperty(exports, "generateID", { enumerable: true, get: function () { return generateID_js_1.generateID; } });
+Object.defineProperty(exports, "generateRandomBase64", { enumerable: true, get: function () { return generateID_js_1.generateRandomBase64; } });
+Object.defineProperty(exports, "generateUUID", { enumerable: true, get: function () { return generateID_js_1.generateUUID; } });
+const httpStatusMap_js_1 = require("../utils/httpStatusMap.js");
+Object.defineProperty(exports, "httpStatusMap", { enumerable: true, get: function () { return httpStatusMap_js_1.httpStatusMap; } });
+const low_level_js_1 = require("../utils/low-level.js");
+Object.defineProperty(exports, "extensionExtract", { enumerable: true, get: function () { return low_level_js_1.extensionExtract; } });
+Object.defineProperty(exports, "normalizeHeaderKey", { enumerable: true, get: function () { return low_level_js_1.normalizeHeaderKey; } });
+Object.defineProperty(exports, "sanitizePathSplit", { enumerable: true, get: function () { return low_level_js_1.sanitizePathSplit; } });
+Object.defineProperty(exports, "sanitizePathSplitBasePath", { enumerable: true, get: function () { return low_level_js_1.sanitizePathSplitBasePath; } });
+Object.defineProperty(exports, "sanitized", { enumerable: true, get: function () { return low_level_js_1.sanitized; } });
+const runtime_js_1 = require("../utils/runtime.js");
+Object.defineProperty(exports, "runtime", { enumerable: true, get: function () { return runtime_js_1.runtime; } });
 exports.default = {
-    Environment: environment_js_1.Environment,
+    useFormData: formData_js_1.useFormData,
+    generateRandomBase64: generateID_js_1.generateRandomBase64,
+    runtime: runtime_js_1.runtime,
+    extensionExtract: low_level_js_1.extensionExtract,
+    normalizeHeaderKey: low_level_js_1.normalizeHeaderKey,
+    sanitizePathSplit: low_level_js_1.sanitizePathSplit,
+    sanitizePathSplitBasePath: low_level_js_1.sanitizePathSplitBasePath,
+    sanitized: low_level_js_1.sanitized,
+    allCookies: cookie_js_1.allCookies,
+    deleteCookie: cookie_js_1.deleteCookie,
+    getCookie: cookie_js_1.getCookie,
+    setCookie: cookie_js_1.setCookie,
+    fileExists: file_js_1.fileExists,
+    fileSize: file_js_1.fileSize,
+    getFileBuffer: file_js_1.getFileBuffer,
+    readStream: file_js_1.readStream,
+    generateID: generateID_js_1.generateID,
+    generateUUID: generateID_js_1.generateUUID,
+    httpStatusMap: httpStatusMap_js_1.httpStatusMap,
     colorText: colors_js_1.colorText,
     GlobalConfig: config_js_1.GlobalConfig,
-    sanitizePathSplit: url_js_1.sanitizePathSplit,
-    generateID: common_js_1.generateID,
 };

package/cjs/index.js

@@ -1,18 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.version = exports.TezX = exports.Router = exports.regexMatchRoute = exports.compileRegexRoute = void 0;
+exports.version = exports.TezXError = exports.TezX = exports.Router = void 0;
+const error_js_1 = require("./core/error.js");
+Object.defineProperty(exports, "TezXError", { enumerable: true, get: function () { return error_js_1.TezXError; } });
 const router_js_1 = require("./core/router.js");
 Object.defineProperty(exports, "Router", { enumerable: true, get: function () { return router_js_1.Router; } });
 const server_js_1 = require("./core/server.js");
 Object.defineProperty(exports, "TezX", { enumerable: true, get: function () { return server_js_1.TezX; } });
-const regexRouter_js_1 = require("./utils/regexRouter.js");
-Object.defineProperty(exports, "compileRegexRoute", { enumerable: true, get: function () { return regexRouter_js_1.compileRegexRoute; } });
-Object.defineProperty(exports, "regexMatchRoute", { enumerable: true, get: function () { return regexRouter_js_1.regexMatchRoute; } });
-exports.version = "2.0.11";
+exports.version = "3.0.0";
 exports.default = {
     Router: router_js_1.Router,
-    regexMatchRoute: regexRouter_js_1.regexMatchRoute,
-    compileRegexRoute: regexRouter_js_1.compileRegexRoute,
     TezX: server_js_1.TezX,
     version: exports.version,
+    TezXError: error_js_1.TezXError,
 };