.

This reverts commit 945832b6c28f5cbdb808d2b5168333bab4074c09.

.gitignore

@@ -0,0 +1,2 @@
+node_modules
+package-lock.json

README.md

@@ -1,42 +0,0 @@
-# flummpress
-
-## Usage Example
-```javascript
-import path from "path";
-import flummpress, { router, views } from "flummpress";
-
-(async () => {
-  const port = 8080;
-  (await new flummpress())
-    .listen(port)
-    .on("listening", () => {
-      console.log(`flummpress is listening on port ${port}`);
-
-      // new route GET
-      router.get(/^\/$/, (req, res) => {
-        res.reply({
-          body: "hello world!"
-        });
-      });
-
-      // new route POST
-      router.post(/^\/$/, async (req, res) => {
-        const postdata = await req.post;
-        console.log(postdata);
-        res.reply({
-          body: "hello post!"
-        });
-      });
-
-      // public folder
-      router.static({
-        dir: path.resolve() + "/public",
-        route: /^\/public/
-      });
-    });
-})();
-```
-
-## documentation
-
-coming soon

dist/container.d.ts

@@ -0,0 +1,5 @@
+export default class Container {
+    private services;
+    set<T>(type: new (...args: any[]) => T, instance: T): void;
+    get<T>(type: new (...args: any[]) => T): T;
+}

dist/container.js

@@ -0,0 +1,14 @@
+export default class Container {
+    constructor() {
+        this.services = new Map();
+    }
+    set(type, instance) {
+        this.services.set(type, instance);
+    }
+    get(type) {
+        const instance = this.services.get(type);
+        if (!instance)
+            throw new Error(`Service of type "${type.name}" not found.`);
+        return instance;
+    }
+}

dist/index.d.ts

@@ -0,0 +1,15 @@
+import Router, { Request, Response, Handler } from "./router.js";
+import Tpl from "./template.js";
+export { Router, Tpl, Request, Response, Handler };
+export default class Flummpress {
+    private server?;
+    private middleware;
+    router: Router;
+    constructor();
+    use(plugin: Router | Handler): this;
+    private processPipeline;
+    listen(...args: any[]): this;
+    private parseRequest;
+    private readBody;
+    private createResponse;
+}

dist/index.js

@@ -0,0 +1,133 @@
+var __awaiter = (this && this.__awaiter) || function (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());
+    });
+};
+import http from "node:http";
+import { URL } from "node:url";
+import querystring from "node:querystring";
+import Router from "./router.js";
+import Tpl from "./template.js";
+export { Router, Tpl };
+export default class Flummpress {
+    constructor() {
+        this.router = new Router();
+        this.middleware = [];
+    }
+    use(plugin) {
+        if (plugin instanceof Router)
+            this.router.use(plugin);
+        else if (typeof plugin === "function")
+            this.middleware.push(plugin);
+        return this;
+    }
+    processPipeline(handlers, req, res) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const handler of handlers) {
+                if (typeof handler !== "function")
+                    throw new TypeError(`Handler is not a function: ${handler}`);
+                let nextCalled = false;
+                yield handler(req, res, () => nextCalled = true);
+                if (!nextCalled || res.writableEnded)
+                    return;
+            }
+        });
+    }
+    listen(...args) {
+        this.server = http.createServer((request, response) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const req = this.parseRequest(request);
+            const res = this.createResponse(response);
+            const start = process.hrtime();
+            try {
+                yield this.processPipeline(this.middleware, req, res);
+                const route = this.router.getRoute(req.url.pathname, req.method);
+                if (route) {
+                    const handler = route.methods[(_a = req.method) === null || _a === void 0 ? void 0 : _a.toLowerCase()];
+                    req.params = ((_b = req.url.pathname.match(new RegExp(route.path))) === null || _b === void 0 ? void 0 : _b.groups) || {};
+                    req.post = yield this.readBody(req);
+                    yield this.processPipeline(handler, req, res);
+                }
+                else {
+                    res.writeHead(404).end("404 - Not Found");
+                }
+            }
+            catch (err) {
+                console.error(err);
+                res.writeHead(500).end("500 - Internal Server Error");
+            }
+            console.log([
+                `[${new Date().toISOString()}]`,
+                `${(process.hrtime(start)[1] / 1e6).toFixed(2)}ms`,
+                `${req.method} ${res.statusCode}`,
+                req.url.pathname,
+            ].join(" | "));
+        }));
+        this.server.listen(...args);
+        return this;
+    }
+    parseRequest(request) {
+        const url = new URL(request.url.replace(/(?!^.)(\/+)?$/, ""), "http://localhost");
+        const req = request;
+        req.url = {
+            pathname: url.pathname,
+            split: url.pathname.split("/").slice(1),
+            searchParams: url.searchParams,
+            qs: Object.fromEntries(url.searchParams.entries()),
+        };
+        req.cookies = {};
+        if (req.headers.cookie) {
+            req.headers.cookie.split("; ").forEach(cookie => {
+                const [key, value] = cookie.split("=");
+                req.cookies[key] = decodeURIComponent(value);
+            });
+        }
+        return req;
+    }
+    readBody(req) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                let body = "";
+                req.on("data", (chunk) => {
+                    body += chunk;
+                });
+                req.on("end", () => {
+                    try {
+                        resolve(req.headers["content-type"] === "application/json"
+                            ? JSON.parse(body)
+                            : querystring.parse(body));
+                    }
+                    catch (err) {
+                        reject(err);
+                    }
+                });
+                req.on("error", reject);
+            });
+        });
+    }
+    createResponse(response) {
+        const res = response;
+        res.reply = ({ code = 200, type = "text/html", body }) => {
+            res.writeHead(code, { "Content-Type": `${type}; charset=utf-8` });
+            res.end(body);
+        };
+        res.status = (code = 200) => {
+            return res.writeHead(code);
+        };
+        res.json = (body, code = 200) => {
+            res.reply({ code, type: "application/json", body: JSON.stringify(body) });
+        };
+        res.html = (body, code = 200) => {
+            res.reply({ code, type: "text/html", body });
+        };
+        res.redirect = (target, code = 302) => {
+            res.writeHead(code, { Location: encodeURI(target) });
+            res.end();
+        };
+        return res;
+    }
+}

dist/router.d.ts

@@ -0,0 +1,47 @@
+import { IncomingMessage, ServerResponse } from "node:http";
+export interface Request extends Omit<IncomingMessage, 'url'> {
+    url: {
+        pathname: string;
+        split: string[];
+        searchParams: URLSearchParams;
+        qs: Record<string, string>;
+    };
+    cookies?: Record<string, string>;
+    params?: Record<string, string>;
+    post?: Record<string, string>;
+}
+export interface Response extends ServerResponse {
+    reply: (options: {
+        code?: number;
+        type?: string;
+        body: string;
+    }) => void;
+    status: (code: number) => Response;
+    json: (body: JSON, code?: number) => void;
+    html: (body: string, code?: number) => void;
+    redirect: (target: string, code?: number) => void;
+}
+export type Handler = (req: Request, res: Response, next?: () => void) => void | Promise<void>;
+export default class Router {
+    private routes;
+    private mimes;
+    constructor();
+    importRoutesFromPath(p: string): Promise<this>;
+    group(basePath: string | RegExp, callback: (methods: any) => void): this;
+    private combinePaths;
+    use(obj: Router): void;
+    get(path: string | RegExp, ...callback: Handler[]): this;
+    post(path: string | RegExp, ...callback: Handler[]): this;
+    head(path: string | RegExp, ...callback: Handler[]): this;
+    put(path: string | RegExp, ...callback: Handler[]): this;
+    delete(path: string | RegExp, ...callback: Handler[]): this;
+    patch(path: string | RegExp, ...callback: Handler[]): this;
+    private registerRoute;
+    getRoute(path: string, method: string): any;
+    private sortRoutes;
+    private readMimes;
+    static({ dir, route }: {
+        dir?: string;
+        route?: RegExp;
+    }): this;
+}

dist/router.js

@@ -0,0 +1,191 @@
+var __awaiter = (this && this.__awaiter) || function (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());
+    });
+};
+import fs from "node:fs";
+import path from "node:path";
+export default class Router {
+    constructor() {
+        this.routes = [];
+        this.mimes = new Map();
+    }
+    importRoutesFromPath(p) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dirEntries = yield fs.promises.readdir(path.resolve() + '/' + p, { withFileTypes: true });
+            for (const tmp of dirEntries) {
+                if (tmp.isFile() && (tmp.name.endsWith(".mjs") || tmp.name.endsWith(".js"))) {
+                    const routeModule = (yield import(`${path.resolve()}/${p}/${tmp.name}`)).default;
+                    this.use(routeModule(this));
+                }
+                else if (tmp.isDirectory()) {
+                    yield this.importRoutesFromPath(p + '/' + tmp.name);
+                }
+            }
+            return this;
+        });
+    }
+    group(basePath, callback) {
+        const self = this;
+        const methods = {
+            get(path, ...handlers) {
+                const fullPath = self.combinePaths(basePath, path);
+                return self.registerRoute(fullPath, "get", handlers);
+            },
+            post(path, ...handlers) {
+                const fullPath = self.combinePaths(basePath, path);
+                return self.registerRoute(fullPath, "post", handlers);
+            },
+            put(path, ...handlers) {
+                const fullPath = self.combinePaths(basePath, path);
+                return self.registerRoute(fullPath, "put", handlers);
+            },
+            delete(path, ...handlers) {
+                const fullPath = self.combinePaths(basePath, path);
+                return self.registerRoute(fullPath, "delete", handlers);
+            },
+            patch(path, ...handlers) {
+                const fullPath = self.combinePaths(basePath, path);
+                return self.registerRoute(fullPath, "patch", handlers);
+            }
+        };
+        callback(methods);
+        return this;
+    }
+    combinePaths(basePath, subPath) {
+        if (typeof basePath === "string" && typeof subPath === "string")
+            return `${basePath.replace(/\/$/, "")}/${subPath.replace(/^\//, "")}`;
+        if (basePath instanceof RegExp && typeof subPath === "string")
+            return new RegExp(`${basePath.source}${subPath.replace(/^\//, "")}`);
+        if (typeof basePath === "string" && subPath instanceof RegExp)
+            return new RegExp(`${basePath.replace(/\/$/, "")}${subPath.source}`);
+        if (basePath instanceof RegExp && subPath instanceof RegExp)
+            return new RegExp(`${basePath.source}${subPath.source}`);
+        throw new TypeError("Invalid path types. Both basePath and subPath must be either string or RegExp.");
+    }
+    use(obj) {
+        if (obj instanceof Router) {
+            if (!Array.isArray(obj.routes))
+                throw new TypeError("Routes must be an array.");
+            this.routes = [...this.routes, ...obj.routes];
+            this.sortRoutes();
+        }
+    }
+    get(path, ...callback) {
+        this.registerRoute(path, "get", callback);
+        return this;
+    }
+    post(path, ...callback) {
+        this.registerRoute(path, "post", callback);
+        return this;
+    }
+    head(path, ...callback) {
+        this.registerRoute(path, "head", callback);
+        return this;
+    }
+    put(path, ...callback) {
+        this.registerRoute(path, "put", callback);
+        return this;
+    }
+    delete(path, ...callback) {
+        this.registerRoute(path, "delete", callback);
+        return this;
+    }
+    patch(path, ...callback) {
+        this.registerRoute(path, "patch", callback);
+        return this;
+    }
+    registerRoute(path, method, handler) {
+        const route = this.routes.find(route => typeof route.path === "string"
+            ? route.path === path
+            : route.path instanceof RegExp && path instanceof RegExp && route.path.toString() === path.toString());
+        if (route) {
+            route.methods[method] = [
+                ...(route.methods[method] || []),
+                ...handler
+            ];
+        }
+        else {
+            this.routes.push({
+                path,
+                methods: { [method]: handler }
+            });
+        }
+        console.log("route set:", method.toUpperCase(), path);
+        this.sortRoutes();
+        return this;
+    }
+    getRoute(path, method) {
+        return this.routes
+            .find(r => {
+            var _a, _b;
+            return typeof r.path === "string"
+                ? r.path === path
+                : ((_b = (_a = r.path).exec) === null || _b === void 0 ? void 0 : _b.call(_a, path))
+                    && r.methods[method.toLowerCase()];
+        });
+    }
+    sortRoutes() {
+        this.routes.sort((a, b) => {
+            const aLength = typeof a.path === "string" ? a.path.length : a.path.source.length;
+            const bLength = typeof b.path === "string" ? b.path.length : b.path.source.length;
+            if (typeof a.path === "string" && typeof b.path === "string")
+                return bLength - aLength;
+            if (typeof a.path === "string")
+                return -1;
+            if (typeof b.path === "string")
+                return 1;
+            return bLength - aLength;
+        });
+        return this;
+    }
+    readMimes(file = "/etc/mime.types") {
+        fs.readFileSync(file, "utf-8")
+            .split("\n")
+            .filter(line => !line.startsWith("#") && line)
+            .forEach(line => {
+            const [mimeType, extensions] = line.split(/\s+/);
+            extensions === null || extensions === void 0 ? void 0 : extensions.split(" ").forEach(ext => this.mimes.set(ext, mimeType));
+        });
+    }
+    static({ dir = path.resolve() + "/public", route = /^\/public/ }) {
+        if (!this.mimes.size)
+            this.readMimes();
+        this.get(route, (req, res, next) => {
+            try {
+                const filename = req.url.pathname.replace(route, "") || "index.html";
+                const mime = this.mimes.get(filename.split(".").pop() || "");
+                const file = path.join(dir, filename);
+                const stat = fs.statSync(file);
+                if (req.headers.range) {
+                    const [startStr, endStr] = req.headers.range.replace(/bytes=/, "").split("-");
+                    const start = parseInt(startStr, 10);
+                    const end = endStr ? parseInt(endStr, 10) : stat.size - 1;
+                    res.writeHead(206, {
+                        "Content-Range": `bytes ${start}-${end}/${stat.size}`,
+                        "Accept-Ranges": "bytes",
+                        "Content-Length": end - start + 1,
+                        "Content-Type": mime,
+                    });
+                    fs.createReadStream(file, { start, end }).pipe(res);
+                }
+                else {
+                    res.writeHead(200, {
+                        "Content-Length": stat.size,
+                        "Content-Type": mime,
+                    });
+                    fs.createReadStream(file).pipe(res);
+                }
+            }
+            catch (err) {
+                console.error(err);
+                res.reply({ code: 404, body: "404 - File not found" });
+            }
+        });
+        return this;
+    }
+}

dist/template.d.ts

@@ -0,0 +1,18 @@
+export default class Template {
+    views: string;
+    globals: Record<string, any>;
+    cache: boolean;
+    debug: boolean;
+    private templates;
+    constructor();
+    setDebug(debug: boolean): void;
+    setViews(views: string): void;
+    setGlobals(globals: Record<string, any>): void;
+    setCache(cache: boolean): void;
+    private readdir;
+    private getTemplate;
+    render(file: string, data?: Record<string, any>, locals?: Record<string, any>): string;
+    escape(str: string): string;
+    forEach(o: any, f: (value: any, key: string | number) => void): void;
+    getMtime(file: string): number;
+}

dist/template.js

@@ -0,0 +1,122 @@
+import fs from "node:fs";
+import path from "node:path";
+export default class Template {
+    constructor() {
+        this.views = "./views";
+        this.globals = {};
+        this.debug = false;
+        this.cache = true;
+        this.templates = new Map();
+    }
+    setDebug(debug) {
+        this.debug = debug;
+    }
+    setViews(views) {
+        this.views = views;
+        this.readdir(views);
+    }
+    setGlobals(globals) {
+        this.globals = globals;
+    }
+    setCache(cache) {
+        this.cache = cache;
+    }
+    readdir(dir, root = dir) {
+        for (const d of fs.readdirSync(`${path.resolve()}/${dir}`)) {
+            if (d.endsWith(".html")) {
+                const file = path.parse(`${dir.replace(this.views, "")}/${d}`);
+                const t_dir = file.dir.substring(1);
+                const t_file = file.name;
+                this.getTemplate(!t_dir ? t_file : `${t_dir}/${t_file}`);
+            }
+            else {
+                this.readdir(`${dir}/${d}`, root);
+            }
+        }
+    }
+    getTemplate(tpl) {
+        let template;
+        let cache = false;
+        if (this.cache && this.templates.has(tpl)) {
+            template = this.templates.get(tpl);
+            cache = true;
+        }
+        else {
+            template = {
+                code: fs.readFileSync(`${this.views}/${tpl}.html`, "utf-8"),
+                cached: new Date(),
+            };
+            this.templates.set(tpl, template);
+        }
+        return [
+            template.code,
+            this.debug ? `<!-- ${tpl}.html ${cache ? `cached ${template.cached}` : "not cached"} -->` : "",
+        ].join("");
+    }
+    render(file, data = {}, locals = {}) {
+        data = Object.assign(Object.assign(Object.assign({}, data), locals), this.globals);
+        try {
+            const code = 'with(_data){const __html = [];' +
+                '__html.push(`' +
+                this.getTemplate(file)
+                    .replace(/[\t]/g, " ")
+                    .split("`")
+                    .join("\\`")
+                    .replace(/{{--(.*?)--}}/g, "")
+                    .replace(/{{(.+?)}}/g, "`, $1, `")
+                    .replace(/{!!(.+?)!!}/g, "`, this.escape($1), `")
+                    .replace(/@js/g, "`);")
+                    .replace(/@endjs/g, ";__html.push(`")
+                    .replace(/@mtime\((.*?)\)/g, "`);__html.push(this.getMtime('$1'));__html.push(`")
+                    .replace(/@include\((.*?)\)/g, (_, inc) => this.render(inc, data))
+                    .replace(/@for\((.*?)\)$/gm, "`); for($1) { __html.push(`")
+                    .replace(/@endfor/g, "`); } __html.push(`")
+                    .replace(/@each\((.*?) as (.*?)\)/g, "`); this.forEach($1, ($2, key) => { __html.push(`")
+                    .replace(/@endeach/g, "`); }); __html.push(`")
+                    .replace(/@elseif\((.*?)\)(\)?)/g, "`); } else if ($1$2) { __html.push(`")
+                    .replace(/@if\((.*?)\)(\)?)/g, "`); if ($1$2) { __html.push(`")
+                    .replace(/@else/g, "`); } else { __html.push(`")
+                    .replace(/@endif/g, "`); } __html.push(`") +
+                "`); return __html.join('').replace(/\\n\\s*\\n/g, '\\n'); }";
+            return new Function("_data", code).bind({
+                escape: this.escape,
+                forEach: this.forEach,
+                getMtime: this.getMtime,
+            })(data);
+        }
+        catch (err) {
+            console.log(file, err.message);
+            return this.debug ? `${err.message} in ${file}` : "";
+        }
+    }
+    escape(str) {
+        return (str + "")
+            .replace(/&/g, "&amp;")
+            .replace(/</g, "&lt;")
+            .replace(/>/g, "&gt;")
+            .replace(/"/g, "&quot;")
+            .replace(/'/g, "&#39;")
+            .replace(/{/g, "&#123;")
+            .replace(/}/g, "&#125;");
+    }
+    forEach(o, f) {
+        if (Array.isArray(o)) {
+            o.forEach(f);
+        }
+        else if (typeof o === "object") {
+            Object.keys(o).forEach((k) => f.call(null, o[k], k));
+        }
+        else {
+            throw new Error(`${o} is not an iterable object`);
+        }
+    }
+    getMtime(file) {
+        try {
+            return +`${fs.statSync(path.normalize(process.cwd() + file)).mtimeMs}`.split(".")[0];
+        }
+        catch (err) {
+            console.log(err);
+            return 0;
+        }
+    }
+}

docs/README.md

@@ -0,0 +1,11 @@
+**flummpress**
+
+***
+
+# flummpress
+
+## Classes
+
+- [default](classes/default.md)
+- [Router](classes/Router.md)
+- [Tpl](classes/Tpl.md)

docs/classes/Router.md

@@ -0,0 +1,347 @@
+[**flummpress**](../README.md)
+
+***
+
+[flummpress](../README.md) / Router
+
+# Class: Router
+
+Defined in: router.ts:7
+
+## Constructors
+
+### new Router()
+
+> **new Router**(): `Router`
+
+Defined in: router.ts:12
+
+#### Returns
+
+`Router`
+
+## Methods
+
+### delete()
+
+> **delete**(`path`, ...`callback`): `this`
+
+Defined in: router.ts:158
+
+Registers a route for HTTP DELETE requests.
+
+#### Parameters
+
+##### path
+
+The URL path or pattern for the route.
+
+`string` | `RegExp`
+
+##### callback
+
+...`Handler`[]
+
+An array of middleware or handler functions to execute for this route.
+
+#### Returns
+
+`this`
+
+The current instance for method chaining.
+
+***
+
+### get()
+
+> **get**(`path`, ...`callback`): `this`
+
+Defined in: router.ts:114
+
+Registers a route for HTTP GET requests.
+
+#### Parameters
+
+##### path
+
+The URL path or pattern for the route.
+
+`string` | `RegExp`
+
+##### callback
+
+...`Handler`[]
+
+An array of middleware or handler functions to execute for this route.
+
+#### Returns
+
+`this`
+
+The current instance for method chaining.
+
+***
+
+### getRoute()
+
+> **getRoute**(`path`, `method`): `any`
+
+Defined in: router.ts:220
+
+Finds and returns the route matching the given path and method.
+
+#### Parameters
+
+##### path
+
+`string`
+
+The requested path.
+
+##### method
+
+`string`
+
+The HTTP method (e.g., "GET").
+
+#### Returns
+
+`any`
+
+The matching route or undefined.
+
+***
+
+### group()
+
+> **group**(`basePath`, `callback`): `this`
+
+Defined in: router.ts:42
+
+Registers a new route group with common base path and middleware.
+
+#### Parameters
+
+##### basePath
+
+The base path or RegExp.
+
+`string` | `RegExp`
+
+##### callback
+
+(`methods`) => `void`
+
+Callback to define routes within the group.
+
+#### Returns
+
+`this`
+
+The Router instance for chaining.
+
+***
+
+### head()
+
+> **head**(`path`, ...`callback`): `this`
+
+Defined in: router.ts:136
+
+Registers a route for HTTP HEAD requests.
+
+#### Parameters
+
+##### path
+
+The URL path or pattern for the route.
+
+`string` | `RegExp`
+
+##### callback
+
+...`Handler`[]
+
+An array of middleware or handler functions to execute for this route.
+
+#### Returns
+
+`this`
+
+The current instance for method chaining.
+
+***
+
+### importRoutesFromPath()
+
+> **importRoutesFromPath**(`p`, `tpl`): `Promise`\<`Router`\>
+
+Defined in: router.ts:22
+
+Dynamically imports routes from a directory and registers them.
+
+#### Parameters
+
+##### p
+
+`string`
+
+Path to the directory containing route files.
+
+##### tpl
+
+Optional template instance to use with the routes.
+
+`false` | [`Tpl`](Tpl.md)
+
+#### Returns
+
+`Promise`\<`Router`\>
+
+The Router instance for chaining.
+
+***
+
+### patch()
+
+> **patch**(`path`, ...`callback`): `this`
+
+Defined in: router.ts:169
+
+Registers a route for HTTP PATCH requests.
+
+#### Parameters
+
+##### path
+
+The URL path or pattern for the route.
+
+`string` | `RegExp`
+
+##### callback
+
+...`Handler`[]
+
+An array of middleware or handler functions to execute for this route.
+
+#### Returns
+
+`this`
+
+The current instance for method chaining.
+
+***
+
+### post()
+
+> **post**(`path`, ...`callback`): `this`
+
+Defined in: router.ts:125
+
+Registers a route for HTTP POST requests.
+
+#### Parameters
+
+##### path
+
+The URL path or pattern for the route.
+
+`string` | `RegExp`
+
+##### callback
+
+...`Handler`[]
+
+An array of middleware or handler functions to execute for this route.
+
+#### Returns
+
+`this`
+
+The current instance for method chaining.
+
+***
+
+### put()
+
+> **put**(`path`, ...`callback`): `this`
+
+Defined in: router.ts:147
+
+Registers a route for HTTP PUT requests.
+
+#### Parameters
+
+##### path
+
+The URL path or pattern for the route.
+
+`string` | `RegExp`
+
+##### callback
+
+...`Handler`[]
+
+An array of middleware or handler functions to execute for this route.
+
+#### Returns
+
+`this`
+
+The current instance for method chaining.
+
+***
+
+### static()
+
+> **static**(`options`): `this`
+
+Defined in: router.ts:270
+
+Serves static files from a specified directory.
+
+#### Parameters
+
+##### options
+
+Options for serving static files.
+
+###### dir?
+
+`string` = `...`
+
+Directory containing the static files.
+
+###### route?
+
+`RegExp` = `...`
+
+Regular expression to match the route for static files.
+
+#### Returns
+
+`this`
+
+The Router instance for chaining.
+
+***
+
+### use()
+
+> **use**(`obj`): `void`
+
+Defined in: router.ts:96
+
+Merges routes or assigns a template instance to the Router.
+
+#### Parameters
+
+##### obj
+
+An instance of Router or Tpl.
+
+[`Tpl`](Tpl.md) | `Router`
+
+#### Returns
+
+`void`

docs/classes/Tpl.md

@@ -0,0 +1,221 @@
+[**flummpress**](../README.md)
+
+***
+
+[flummpress](../README.md) / Tpl
+
+# Class: Tpl
+
+Defined in: template.ts:4
+
+## Constructors
+
+### new Tpl()
+
+> **new Tpl**(): `Template`
+
+Defined in: template.ts:11
+
+#### Returns
+
+`Template`
+
+## Methods
+
+### escape()
+
+> **escape**(`str`): `string`
+
+Defined in: template.ts:147
+
+Escapes a string for safe usage in HTML.
+
+#### Parameters
+
+##### str
+
+`string`
+
+The string to escape.
+
+#### Returns
+
+`string`
+
+The escaped string.
+
+***
+
+### forEach()
+
+> **forEach**(`o`, `f`): `void`
+
+Defined in: template.ts:163
+
+Iterates over an object or array and applies a callback function.
+
+#### Parameters
+
+##### o
+
+`any`
+
+The object or array to iterate over.
+
+##### f
+
+(`value`, `key`) => `void`
+
+The callback function.
+
+#### Returns
+
+`void`
+
+***
+
+### getMtime()
+
+> **getMtime**(`file`): `number`
+
+Defined in: template.ts:180
+
+Retrieves the last modification time of a file.
+
+#### Parameters
+
+##### file
+
+`string`
+
+The file path to check.
+
+#### Returns
+
+`number`
+
+The last modification time in milliseconds.
+
+***
+
+### render()
+
+> **render**(`file`, `data`, `locals`): `string`
+
+Defined in: template.ts:103
+
+Renders a template with the provided data and local variables.
+
+#### Parameters
+
+##### file
+
+`string`
+
+The name of the template file (without extension).
+
+##### data
+
+`Record`\<`string`, `any`\> = `{}`
+
+Data object to inject into the template.
+
+##### locals
+
+`Record`\<`string`, `any`\> = `{}`
+
+Local variables to be used within the template.
+
+#### Returns
+
+`string`
+
+The rendered HTML string.
+
+***
+
+### setCache()
+
+> **setCache**(`cache`): `void`
+
+Defined in: template.ts:48
+
+Enables or disables the template caching mechanism.
+
+#### Parameters
+
+##### cache
+
+`boolean`
+
+If true, enables caching.
+
+#### Returns
+
+`void`
+
+***
+
+### setDebug()
+
+> **setDebug**(`debug`): `void`
+
+Defined in: template.ts:23
+
+Enables or disables debug mode.
+
+#### Parameters
+
+##### debug
+
+`boolean`
+
+If true, enables debug mode.
+
+#### Returns
+
+`void`
+
+***
+
+### setGlobals()
+
+> **setGlobals**(`globals`): `void`
+
+Defined in: template.ts:40
+
+Sets global variables to be used in all templates.
+
+#### Parameters
+
+##### globals
+
+`Record`\<`string`, `any`\>
+
+An object containing global variables.
+
+#### Returns
+
+`void`
+
+***
+
+### setViews()
+
+> **setViews**(`views`): `void`
+
+Defined in: template.ts:31
+
+Sets the directory for template files and preloads all templates.
+
+#### Parameters
+
+##### views
+
+`string`
+
+The directory path for template files.
+
+#### Returns
+
+`void`

docs/classes/default.md

@@ -0,0 +1,100 @@
+[**flummpress**](../README.md)
+
+***
+
+[flummpress](../README.md) / default
+
+# Class: default
+
+Defined in: index.ts:12
+
+## Constructors
+
+### new default()
+
+> **new default**(): `Flummpress`
+
+Defined in: index.ts:18
+
+#### Returns
+
+`Flummpress`
+
+## Properties
+
+### middleware
+
+> **middleware**: `Handler`[]
+
+Defined in: index.ts:16
+
+***
+
+### router
+
+> **router**: [`Router`](Router.md)
+
+Defined in: index.ts:14
+
+***
+
+### tpl
+
+> **tpl**: [`Tpl`](Tpl.md)
+
+Defined in: index.ts:15
+
+## Methods
+
+### listen()
+
+> **listen**(...`args`): `this`
+
+Defined in: index.ts:80
+
+Starts the HTTP server and begins listening for incoming requests.
+
+#### Parameters
+
+##### args
+
+...`any`[]
+
+Arguments passed to `http.Server.listen`.
+
+#### Returns
+
+`this`
+
+- The current instance for chaining.
+
+***
+
+### use()
+
+> **use**(`plugin`): `this`
+
+Defined in: index.ts:37
+
+Adds a plugin to the application, which can be a Router instance, Tpl instance,
+or a middleware handler function. The method determines the type of the plugin
+and performs the appropriate action.
+
+- If the plugin is an instance of `Router`, it is added to the application's router.
+- If the plugin is an instance of `Tpl`, it sets the application's template engine.
+- If the plugin is a middleware function, it is added to the middleware stack.
+
+#### Parameters
+
+##### plugin
+
+The plugin to add, which can be a `Router` instance,
+a `Tpl` instance, or a middleware handler function.
+
+[`Tpl`](Tpl.md) | [`Router`](Router.md) | `Handler`
+
+#### Returns
+
+`this`
+
+The current instance for method chaining.

package.json

@@ -1,17 +1,19 @@
 {
   "name": "flummpress",
-  "version": "2.0.7",
+  "version": "3.0.0",
   "description": "Express für arme",
-  "main": "src/index.mjs",
-  "repository": {
-    "type": "git",
-    "url": "gitea@git.lat:keinBot/flummpress.git"
+  "main": "./dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "doc": "typedoc --out docs src"
   },
-  "scripts": {},
+  "keywords": [],
   "author": "Flummi",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://git.lat/keinBot/flummpress/issues"
-  },
-  "homepage": "https://git.lat/keinBot/flummpress#readme"
+  "license": "ISC",
+  "type": "module",
+  "devDependencies": {
+    "@types/node": "^22.13.10",
+    "typedoc-plugin-markdown": "^4.5.0",
+    "typescript": "^5.8.2"
+  }
 }

src/index.mjs

@@ -1,139 +0,0 @@
-import http from "http";
-import { URL } from "url";
-import { Buffer } from "buffer";
-import querystring from "querystring";
-
-import Router from "./router.mjs";
-import Tpl from "./template.mjs";
-
-export { Router, Tpl };
-
-export default class flummpress {
-  #server;
-
-  constructor() {
-    this.router = new Router();
-    this.tpl = new Tpl();
-    this.middleware = new Set();
-    return this;
-  };
-
-  use(obj) {
-    if(obj instanceof Router) {
-      this.router.use(obj);
-    }
-    else if(obj instanceof Tpl) {
-      this.tpl = obj;
-    }
-    else {
-      if(!this.middleware.has(obj))
-        this.middleware.add(obj);
-    }
-    return this;
-  };
-
-  listen(...args) {
-    this.#server = http.createServer(async (req, res) => {
-      const t_start = process.hrtime();
-
-      const _url = new URL(req.url.replace(/(?!^.)(\/+)?$/, ''), "relative:///");
-      req.url = {
-        pathname: _url.pathname,
-        split: _url.pathname.split("/").slice(1),
-        searchParams: _url.searchParams,
-        qs: {...querystring.parse(_url.search.substring(1))} // legacy
-      };
-
-      req.cookies = {};
-      if(req.headers.cookie) {
-        req.headers.cookie.split("; ").forEach(c => {
-          const parts = c.split('=');
-          req.cookies[parts.shift().trim()] = decodeURI(parts.join('='));
-        });
-      }
-
-      await Promise.all([...this.middleware].map(m => m(req, res)));
-
-      const method = req.method === 'HEAD' ? 'get' : req.method.toLowerCase();
-      const route = this.router.getRoute(req.url.pathname, req.method == 'HEAD' ? 'GET' : req.method);
-
-      if(route) { // 200
-        const cb = route[1][method];
-        const middleware = route[1][`${method}mw`];
-        req.params = req.url.pathname.match(new RegExp(route[0]))?.groups;
-        req.post = await this.readBody(req);
-
-        const result = await this.processMiddleware(middleware, req, this.createResponse(res));
-        if(result)
-          cb(req, res);
-      }
-      else { // 404
-        res
-          .writeHead(404)
-          .end(`404 - ${req.method} ${req.url.pathname}`);
-      }
-
-      console.log([
-        `[${(new Date()).toLocaleTimeString()}]`,
-        `${(process.hrtime(t_start)[1] / 1e6).toFixed(2)}ms`,
-        `${req.method} ${res.statusCode}`,
-        req.url.pathname
-      ].map(e => e.toString().padEnd(15)).join(""));
-
-    }).listen(...args);
-    return this;
-  };
-
-  readBody(req) {
-    return new Promise((resolve, _, data = "") => req
-      .on("data", d => void (data += d))
-      .on("end", () => {
-        if(req.headers['content-type'] === "application/json") {
-          try {
-            return void resolve(JSON.parse(data));
-          } catch(err) {}
-        }
-        void resolve(Object.fromEntries(Object.entries(querystring.parse(data)).map(([k, v]) => {
-          try {
-            return [k, decodeURIComponent(v)];
-          } catch(err) {
-            return [k, v];
-          }
-        })));
-      }));
-  };
-
-  createResponse(res) {
-    res.reply = ({
-      code = 200,
-      type = "text/html",
-      body
-    }) => {
-      res.writeHead(code, {
-        "content-type": `${type}; charset=UTF-8`,
-        "content-length": Buffer.byteLength(body, 'utf-8')
-      });
-      if(res.method === 'HEAD')
-        body = null;
-      res.end(body);
-      return res;
-    };
-    res.json = (body, code = 200) => {
-      if(typeof body === 'object')
-        body = JSON.stringify(body);
-      return res.reply({ code, body, type: "application/json" });
-    };
-    res.html = (body, code = 200) => res.reply({ code, body, type: "text/html" });
-    res.redirect = (target, code = 307) => res.writeHead(code, {
-      "Cache-Control": "no-cache, public",
-      "Location": target
-    }).end();
-    return res;
-  };
-
-  processMiddleware(middleware, req, res) {
-    if(!middleware)
-      return new Promise(resolve => resolve(true));
-    return new Promise(resolve => middleware(req, res, () => resolve(true)));
-  };
-};

src/index.ts

@@ -0,0 +1,151 @@
+import http, { IncomingMessage, ServerResponse } from "node:http";
+import { URL } from "node:url";
+import querystring from "node:querystring";
+
+import Router, { Request, Response, Handler } from "./router.js";
+import Tpl from "./template.js";
+
+export { Router, Tpl, Request, Response, Handler };
+
+export default class Flummpress {
+  private server?: http.Server;
+  private middleware: Handler[];
+  public router: Router;
+
+  constructor() {
+    this.router = new Router();
+    this.middleware = [];
+  }
+
+  public use(plugin: Router | Handler): this {
+    if(plugin instanceof Router)
+      this.router.use(plugin);
+    else if(typeof plugin === "function")
+      this.middleware.push(plugin);
+    return this;
+  }
+
+  private async processPipeline(handlers: Handler[], req: Request, res: Response) {
+    for(const handler of handlers) {
+      if(typeof handler !== "function")
+        throw new TypeError(`Handler is not a function: ${handler}`);
+
+      let nextCalled = false;
+      await handler(req, res, () => nextCalled = true);
+      if(!nextCalled || res.writableEnded)
+        return;
+    }
+  }
+
+  public listen(...args: any[]): this {
+    this.server = http.createServer(async (request: IncomingMessage, response: ServerResponse) => {
+      const req: Request = this.parseRequest(request);
+      const res: Response = this.createResponse(response);
+      const start = process.hrtime();
+  
+      try {
+        await this.processPipeline(this.middleware, req, res);
+  
+        const route = this.router.getRoute(req.url.pathname, req.method!);
+  
+        if(route) {
+          const handler = route.methods[req.method?.toLowerCase()!];
+  
+          req.params = req.url.pathname.match(new RegExp(route.path))?.groups || {};
+          req.post = await this.readBody(req);
+          await this.processPipeline(handler, req, res);
+        }
+        else {
+          res.writeHead(404).end("404 - Not Found");
+        }
+      }
+      catch(err: any) {
+        console.error(err);
+        res.writeHead(500).end("500 - Internal Server Error");
+      }
+  
+      console.log([
+        `[${new Date().toISOString()}]`,
+        `${(process.hrtime(start)[1] / 1e6).toFixed(2)}ms`,
+        `${req.method} ${res.statusCode}`,
+        req.url.pathname,
+      ].join(" | "));
+    })
+    this.server.listen(...args);
+  
+    return this;
+  }
+
+  private parseRequest(request: IncomingMessage): Request {
+    const url = new URL(request.url!.replace(/(?!^.)(\/+)?$/, ""), "http://localhost");
+    const req = request as unknown as Request;
+    req.url = {
+      pathname: url.pathname,
+      split: url.pathname.split("/").slice(1),
+      searchParams: url.searchParams,
+      qs: Object.fromEntries(url.searchParams.entries()),
+    };
+
+    req.cookies = {};
+    if(req.headers.cookie) {
+      req.headers.cookie.split("; ").forEach(cookie => {
+        const [key, value] = cookie.split("=");
+        req.cookies![key] = decodeURIComponent(value);
+      });
+    }
+    return req;
+  }
+
+  private async readBody(req: Request): Promise<Record<string, string>> {
+    return new Promise((resolve, reject) => {
+      let body: string = "";
+
+      req.on("data", (chunk: string) => {
+        body += chunk;
+      });
+
+      req.on("end", () => {
+        try {
+          resolve(
+            req.headers["content-type"] === "application/json"
+              ? JSON.parse(body)
+              : querystring.parse(body)
+          );
+        }
+        catch(err: any) {
+          reject(err);
+        }
+      });
+
+      req.on("error", reject);
+    });
+  }
+
+  private createResponse(response: ServerResponse): Response {
+    const res: Response = response as Response;
+
+    res.reply = ({ code = 200, type = "text/html", body }) => {
+      res.writeHead(code, { "Content-Type": `${type}; charset=utf-8` });
+      res.end(body);
+    };
+
+    res.status = (code = 200) => {
+      return res.writeHead(code);
+    };
+
+    res.json = (body: any, code = 200) => {
+      res.reply({ code, type: "application/json", body: JSON.stringify(body) });
+    };
+
+    res.html = (body, code = 200) => {
+      res.reply({ code, type: "text/html", body });
+    };
+
+    res.redirect = (target, code = 302) => {
+      res.writeHead(code, { Location: encodeURI(target) });
+      res.end();
+    };
+
+    return res;
+  }
+}

src/router.mjs

@@ -1,200 +0,0 @@
-import fs from "fs";
-import path from "path";
-import Tpl from "./template.mjs";
-
-export default class Router {
-  #mimes;
-
-  constructor() {
-    this.routes = new Map();
-    return this;
-  };
-
-  async importRoutesFromPath(p, tpl = false) {
-    for(let tmp of await fs.promises.readdir(path.resolve() + '/' + p, { withFileTypes: true }))
-      if(tmp.isFile() && tmp.name.endsWith('.mjs'))
-        this.use((await import(`${path.resolve()}/${p}/${tmp.name}`)).default(this, tpl));
-      else if(tmp.isDirectory())
-        await this.importRoutesFromPath(p + '/' + tmp.name);
-    return this;
-  };
-
-  group(path, cb) {
-    const methods = {
-      get:  this.get.bind(this),
-      post: this.post.bind(this),
-      head: this.head.bind(this),
-      put: this.put.bind(this),
-      delete: this.delete.bind(this),
-      patch: this.patch.bind(this),
-    };
-    const target = {
-      path: new RegExp(path),
-    };
-    const handler = {
-      get: (opt, method) => (p, ...args) => methods[method](
-        new RegExp([ opt.path, new RegExp(p === "/" ? "$": p) ]
-          .map(regex => regex.source)
-          .join("")
-          .replace(/(\\\/){1,}/g, "/")),
-        ...args,
-      )
-    };
-    cb(new Proxy(target, handler));
-    return this;
-  };
-
-  use(obj) {
-    if(obj instanceof Router) {
-      this.routes = new Map([ ...this.routes, ...obj.routes ]);
-      this.sortRoutes();
-    }
-    if(obj instanceof Tpl) {
-      this.tpl = obj;
-    }
-  }
-
-  get(path, ...args) {
-    if(args.length === 1)
-      this.registerRoute(path, args[0], "get");
-    else
-      this.registerRoute(path, args[1], "get", args[0]);
-    return this;
-  };
-
-  post(path, ...args) {
-    if(args.length === 1)
-      this.registerRoute(path, args[0], "post");
-    else
-      this.registerRoute(path, args[1], "post", args[0]);
-    return this;
-  };
-
-  head(path, ...args) {
-    if(args.length === 1)
-      this.registerRoute(path, args[0], "head");
-    else
-      this.registerRoute(path, args[1], "head", args[0]);
-    return this;
-  };
-
-  put(path, ...args) {
-    if(args.length === 1)
-      this.registerRoute(path, args[0], "put");
-    else
-      this.registerRoute(path, args[1], "put", args[0]);
-    return this;
-  };
-
-  delete(path, ...args) {
-    if(args.length === 1)
-      this.registerRoute(path, args[0], "delete");
-    else
-      this.registerRoute(path, args[1], "delete", args[0]);
-    return this;
-  };
-
-  patch(path, ...args) {
-    if(args.length === 1)
-      this.registerRoute(path, args[0], "patch");
-    else
-      this.registerRoute(path, args[1], "patch", args[0]);
-    return this;
-  };
-
-  registerRoute(path, cb, method, middleware) {
-    if(!this.routes.has(path))
-      this.routes.set(path, {});
-    this.routes.set(path, {
-      ...this.routes.get(path),
-      [method]: cb,
-      [method + "mw"]: middleware,
-    });
-    console.log("route set:", method.toUpperCase(), path);
-    this.sortRoutes();
-    return this;
-  };
-
-  getRoute(path, method) {
-    method = method.toLowerCase();
-    return [...this.routes.entries()].filter(r => {
-      return (r[0] === path || r[0].exec?.(path)) && r[1].hasOwnProperty(method);
-    })[0];
-  };
-
-  sortRoutes() {
-    this.routes = new Map([...this.routes.entries()].sort().reverse());
-    return this;
-  };
-
-  readMimes(file = "/etc/mime.types") {
-    this.#mimes = new Map();
-    (fs.readFileSync(file, "utf-8"))
-      .split("\n")
-      .filter(e => !e.startsWith("#") && e)
-      .map(e => e.split(/\s{2,}/))
-      .filter(e => e.length > 1)
-      .forEach(m => m[1].split(" ").forEach(ext => this.#mimes.set(ext, m[0])));
-  };
-
-  static({ dir = path.resolve() + "/public", route = /^\/public/ }) {
-    if(!this.#mimes)
-      this.readMimes();
-
-    this.get(route, (req, res) => {
-      try {
-        const filename = req.url.pathname.replace(route, "") || "index.html";
-        const mime = this.#mimes.get(filename.split(".").pop());
-        const file = path.join(dir, filename);
-        let stat;
-        try {
-          stat = fs.statSync(file);
-        } catch(err) {
-          console.log(err);
-          res.reply({
-            code: 404,
-            body: "404 - file not found."
-          });
-          return this;
-        }
-
-        if(!mime.startsWith("video") && !mime.startsWith("audio")) {
-          res.writeHead(200, {
-            "Content-Length": stat.size,
-            "Content-Type": this.#mimes.get(filename.split(".").pop()).toLowerCase()
-          }).end(fs.readFileSync(path.join(dir, filename)));
-          return this;
-        }
-        
-        if(req.headers.range) {
-          const parts = req.headers.range.replace(/bytes=/, "").split("-");
-          const start = parseInt(parts[0], 10);
-          const end = parts[1] ? parseInt(parts[1], 10) : stat.size - 1;
-          res.writeHead(206, {
-            "Content-Range": `bytes ${start}-${end}/${stat.size}`,
-            "Accept-Ranges": "bytes",
-            "Content-Length": (end - start) + 1,
-            "Content-Type": mime,
-          });
-          const stream = fs.createReadStream(file, { start: start, end: end })
-            .on("open", () => stream.pipe(res))
-            .on("error", err => res.end(err));
-        }
-        else {
-          res.writeHead(200, {
-            "Content-Length": stat.size,
-            "Content-Type": mime,
-          });
-          fs.createReadStream(file).pipe(res);
-        }
-      } catch(err) {
-        console.error(err);
-        res.reply({
-          code: 500,
-          body: "500 - internal server error"
-        });
-      }
-    });
-    return this;
-  };
-};

src/router.ts

@@ -0,0 +1,242 @@
+import fs from "node:fs";
+import path from "node:path";
+import { IncomingMessage, ServerResponse } from "node:http";
+
+export interface Request extends Omit<IncomingMessage, 'url'> {
+  url: {
+    pathname: string;
+    split: string[];
+    searchParams: URLSearchParams;
+    qs: Record<string, string>;
+  };
+  cookies?: Record<string, string>;
+  params?: Record<string, string>;
+  post?: Record<string, string>;
+}
+
+export interface Response extends ServerResponse {
+  reply: (options: { code?: number; type?: string; body: string }) => void;
+  status: (code: number) => Response;
+  json: (body: JSON, code?: number) => void;
+  html: (body: string, code?: number) => void;
+  redirect: (target: string, code?: number) => void;
+}
+
+export type Handler = (req: Request, res: Response, next?: () => void) => void | Promise<void>;
+
+export default class Router {
+  private routes: Array<{
+    path: string | RegExp;
+    methods: { [method: string]: Handler[] }
+  }> = [];
+  private mimes: Map<string, string>;
+
+  constructor() {
+    this.mimes = new Map();
+  }
+
+  async importRoutesFromPath(p: string): Promise<this> {
+    const dirEntries = await fs.promises.readdir(path.resolve() + '/' + p, { withFileTypes: true });
+    for(const tmp of dirEntries) {
+      if(tmp.isFile() && (tmp.name.endsWith(".mjs") || tmp.name.endsWith(".js"))) {
+        const routeModule = (await import(`${path.resolve()}/${p}/${tmp.name}`)).default;
+        this.use(routeModule(this));
+      }
+      else if(tmp.isDirectory()) {
+        await this.importRoutesFromPath(p + '/' + tmp.name);
+      }
+    }
+    return this;
+  }
+
+  group(basePath: string | RegExp, callback: (methods: any) => void): this {
+    const self = this;
+
+    const methods = {
+      get(path: string | RegExp, ...handlers: Handler[]) {
+        const fullPath = self.combinePaths(basePath, path);
+        return self.registerRoute(fullPath, "get", handlers);
+      },
+      post(path: string | RegExp, ...handlers: Handler[]) {
+        const fullPath = self.combinePaths(basePath, path);
+        return self.registerRoute(fullPath, "post", handlers);
+      },
+      put(path: string | RegExp, ...handlers: Handler[]) {
+        const fullPath = self.combinePaths(basePath, path);
+        return self.registerRoute(fullPath, "put", handlers);
+      },
+      delete(path: string | RegExp, ...handlers: Handler[]) {
+        const fullPath = self.combinePaths(basePath, path);
+        return self.registerRoute(fullPath, "delete", handlers);
+      },
+      patch(path: string | RegExp, ...handlers: Handler[]) {
+        const fullPath = self.combinePaths(basePath, path);
+        return self.registerRoute(fullPath, "patch", handlers);
+      }
+    };
+  
+    callback(methods);
+
+    return this;
+  }
+
+  private combinePaths(basePath: string | RegExp, subPath: string | RegExp): string | RegExp {
+    if(typeof basePath === "string" && typeof subPath === "string")
+      return `${basePath.replace(/\/$/, "")}/${subPath.replace(/^\//, "")}`;
+    if(basePath instanceof RegExp && typeof subPath === "string")
+      return new RegExp(`${basePath.source}${subPath.replace(/^\//, "")}`);
+    if(typeof basePath === "string" && subPath instanceof RegExp)
+      return new RegExp(`${basePath.replace(/\/$/, "")}${subPath.source}`);
+    if(basePath instanceof RegExp && subPath instanceof RegExp)
+      return new RegExp(`${basePath.source}${subPath.source}`);
+
+    throw new TypeError("Invalid path types. Both basePath and subPath must be either string or RegExp.");
+  }
+
+  use(obj: Router): void {
+    if(obj instanceof Router) {
+      if(!Array.isArray(obj.routes))
+        throw new TypeError("Routes must be an array.");
+      this.routes = [ ...this.routes, ...obj.routes ];
+      this.sortRoutes();
+    }
+  }
+
+  get(path: string | RegExp, ...callback: Handler[]): this {
+    this.registerRoute(path, "get", callback);
+    return this;
+  }
+
+  post(path: string | RegExp, ...callback: Handler[]): this {
+    this.registerRoute(path, "post", callback);
+    return this;
+  }
+
+  head(path: string | RegExp, ...callback: Handler[]): this {
+    this.registerRoute(path, "head", callback);
+    return this;
+  }
+
+  put(path: string | RegExp, ...callback: Handler[]): this {
+    this.registerRoute(path, "put", callback);
+    return this;
+  }
+
+  delete(path: string | RegExp, ...callback: Handler[]): this {
+    this.registerRoute(path, "delete", callback);
+    return this;
+  }
+
+  patch(path: string | RegExp, ...callback: Handler[]): this {
+    this.registerRoute(path, "patch", callback);
+    return this;
+  }
+
+  private registerRoute(
+    path: string | RegExp,
+    method: string,
+    handler: Handler[]
+  ): this {
+    const route = this.routes.find(route =>
+      typeof route.path === "string"
+        ? route.path === path
+        : route.path instanceof RegExp && path instanceof RegExp && route.path.toString() === path.toString()
+    );
+  
+    if(route) {
+      route.methods[method] = [
+        ...(route.methods[method] || []),
+        ...handler
+      ];
+    }
+    else {
+      this.routes.push({
+        path,
+        methods: { [method]: handler }
+      });
+    }
+
+    console.log("route set:", method.toUpperCase(), path);
+    this.sortRoutes();
+    return this;
+  }
+
+  getRoute(path: string, method: string): any {
+    return this.routes
+      .find(r => typeof r.path === "string"
+        ? r.path === path
+        : r.path.exec?.(path)
+      && r.methods[method.toLowerCase()]
+    );
+  }
+
+  private sortRoutes(): this {
+    this.routes.sort((a, b) => {
+      const aLength = typeof a.path === "string" ? a.path.length : a.path.source.length;
+      const bLength = typeof b.path === "string" ? b.path.length : b.path.source.length;
+  
+      if(typeof a.path === "string" && typeof b.path === "string")
+        return bLength - aLength;
+      if(typeof a.path === "string")
+        return -1;
+      if(typeof b.path === "string")
+        return 1;
+      return bLength - aLength;
+    });
+    return this;
+  }
+
+  private readMimes(file: string = "/etc/mime.types"): void {
+    fs.readFileSync(file, "utf-8")
+      .split("\n")
+      .filter(line => !line.startsWith("#") && line)
+      .forEach(line => {
+        const [mimeType, extensions] = line.split(/\s+/);
+        extensions?.split(" ").forEach(ext => this.mimes.set(ext, mimeType));
+      });
+  }
+
+  static({
+    dir = path.resolve() + "/public",
+    route = /^\/public/
+  }: { dir?: string; route?: RegExp }): this {
+    if(!this.mimes.size)
+      this.readMimes();
+
+    this.get(route, (req: Request, res: Response, next?: () => void) => {
+      try {
+        const filename = req.url.pathname.replace(route, "") || "index.html";
+        const mime = this.mimes.get(filename.split(".").pop() || "");
+        const file = path.join(dir, filename);
+        const stat = fs.statSync(file);
+
+        if(req.headers.range) {
+          const [startStr, endStr] = req.headers.range.replace(/bytes=/, "").split("-");
+          const start = parseInt(startStr, 10);
+          const end = endStr ? parseInt(endStr, 10) : stat.size - 1;
+
+          res.writeHead(206, {
+            "Content-Range": `bytes ${start}-${end}/${stat.size}`,
+            "Accept-Ranges": "bytes",
+            "Content-Length": end - start + 1,
+            "Content-Type": mime,
+          });
+          fs.createReadStream(file, { start, end }).pipe(res);
+        }
+        else {
+          res.writeHead(200, {
+            "Content-Length": stat.size,
+            "Content-Type": mime,
+          });
+          fs.createReadStream(file).pipe(res);
+        }
+      }
+      catch(err: any) {
+        console.error(err);
+        res.reply({ code: 404, body: "404 - File not found" });
+      }
+    });
+
+    return this;
+  }
+}

src/template.mjs

@@ -1,139 +0,0 @@
-import fs from "fs";
-import path from "path";
-
-export default class {
-  #views;
-  #globals;
-  #cache;
-  #templates;
-  #debug;
-
-  constructor() {
-    this.#views = "./views";
-    this.#globals = {};
-    this.#debug = false;
-    this.#cache = true;
-    this.#templates = new Map();
-  };
-
-  set debug(d) {
-    this.#debug = !!d;
-  };
-  set views(v) {
-    this.#views = v;
-    this.readdir(v);
-  };
-  set globals(g) {
-    this.#globals = g;
-  };
-  set cache(c) {
-    this.#cache = !!c;
-  };
-
-  readdir(dir, root = dir) {
-    for(const d of fs.readdirSync(`${path.resolve()}/${dir}`)) {
-      if(d.endsWith(".html")) { // template
-        const file = path.parse(`${dir.replace(this.#views, '')}/${d}`);
-        const t_dir = file.dir.substring(1);
-        const t_file = file.name;
-        this.getTemplate(!t_dir ? t_file : `${t_dir}/${t_file}`);
-      }
-      else { // directory
-        this.readdir(`${dir}/${d}`, root);
-      }
-    }
-  }
-
-  getTemplate(tpl) {
-    let template = {};
-    let cache = false;
-    if(this.#cache && this.#templates.has(tpl)) {
-      template = this.#templates.get(tpl);
-      cache = template.cached;
-    }
-    else {
-      template = {
-        code: fs.readFileSync(`${this.#views}/${tpl}.html`, "utf-8"),
-        cached: new Date()
-      };
-      this.#templates.set(tpl, template);
-    }
-    return [
-      template.code,
-      (this.#debug ? `<!-- ${tpl}.html ` + (cache ? `cached ${template.cached}` : `not cached`) + " -->" : "")
-    ].join("");
-  };
-
-  render(file, data = {}, locals) {
-    data = { ...data, ...locals, ...this.#globals };
-    try {
-      const code = 'with(_data){const __html = [];' +
-        '__html.push(\`' +
-        this.getTemplate(file)
-          .replace(/[\t]/g, ' ')
-          .split('\`').join('\\\`')
-
-          .replace(/{{--(.*?)--}}/g, "") // comments
-          .replace(/{{(.+?)}}/g, '\`,$1,\`') // yield variable
-          .replace(/{!!(.+?)!!}/g, '\`,this.escape($1),\`') // yield escaped variable
-
-          .replace(/@js/g, "`);") // inject bare javascript
-          .replace(/@endjs/g, ";__html.push(`")
-
-          .replace(/@mtime\((.*?)\)/g, `\`);__html.push(this.getMtime('$1'));__html.push(\``)
-
-          .replace(/@include\((.*?)\)/g, (_, inc) => this.render(inc, data)) // include template
-
-          .replace(/@for\((.*?)\)$/gm, `\`);for($1){__html.push(\``)
-          .replace(/@endfor/g, `\`);}__html.push(\``)
-
-          .replace(/@each\((.*?) as (.*?)\)/g, `\`);this.forEach($1,($2,key)=>{__html.push(\``) // foreach for the poor
-          .replace(/@endeach/g, "\`);});__html.push(`")
-
-          .replace(/@elseif\((.*?)\)(\)?)/g, `\`);}else if($1$2){__html.push(\``) // if lol
-          .replace(/@if\((.*?)\)(\)?)/g, `\`);if($1$2){__html.push(\``)
-          .replace(/@else/g, "`);}else{__html.push(`")
-          .replace(/@endif/g, "`);}__html.push(`") +
-        '\`);return __html.join(\'\').replace(/\\n\\s*\\n/g, "\\n");}';
-
-      return (new Function("_data", code)).bind({
-        escape: this.escape,
-        forEach: this.forEach,
-        getMtime: this.getMtime
-      })(data);
-    } catch(err) {
-      console.log(file, err.message);
-      return (this.#debug ? `${err.message} in ${file}` : '');
-    }
-  };
-
-  escape(str) {
-    return (str + '')
-      .replace(/&/g, '&amp;')
-      .replace(/</g, '&lt;')
-      .replace(/>/g, '&gt')
-      .replace(/"/g, '&quot;')
-      .replace(/'/g, '&#39;')
-      .replace(/{/g, '&#123;')
-      .replace(/}/g, '&#125;')
-    ;
-  };
-
-  forEach(o, f) {
-    if(Array.isArray(o))
-      o.forEach(f);
-    else if(typeof o === "object")
-      Object.keys(o).forEach(k => f.call(null, o[k], k));
-    else
-      throw new Error(`${o} is not a iterable object`);
-  };
-
-  getMtime(file) {
-    try {
-      return +(fs.statSync(path.normalize(process.cwd() + file)).mtimeMs + '').split(".")[0];
-    } catch(err) {
-      console.log(err);
-      return 0;
-    }
-  }
-};

src/template.ts

@@ -0,0 +1,141 @@
+import fs from "node:fs";
+import path from "node:path";
+
+export default class Template {
+  public views: string;
+  public globals: Record<string, any>;
+  public cache: boolean;
+  public debug: boolean;
+  private templates: Map<string, { code: string; cached: Date }>;
+
+  constructor() {
+    this.views = "./views";
+    this.globals = {};
+    this.debug = false;
+    this.cache = true;
+    this.templates = new Map();
+  }
+
+  setDebug(debug: boolean): void {
+    this.debug = debug;
+  }
+
+  setViews(views: string): void {
+    this.views = views;
+    this.readdir(views);
+  }
+
+  setGlobals(globals: Record<string, any>): void {
+    this.globals = globals;
+  }
+
+  setCache(cache: boolean): void {
+    this.cache = cache;
+  }
+
+  private readdir(dir: string, root: string = dir): void {
+    for(const d of fs.readdirSync(`${path.resolve()}/${dir}`)) {
+      if(d.endsWith(".html")) {
+        const file = path.parse(`${dir.replace(this.views, "")}/${d}`);
+        const t_dir = file.dir.substring(1);
+        const t_file = file.name;
+        this.getTemplate(!t_dir ? t_file : `${t_dir}/${t_file}`);
+      }
+      else {
+        this.readdir(`${dir}/${d}`, root);
+      }
+    }
+  }
+
+  private getTemplate(tpl: string): string {
+    let template: { code: string; cached: Date };
+    let cache = false;
+    if(this.cache && this.templates.has(tpl)) {
+      template = this.templates.get(tpl)!;
+      cache = true;
+    }
+    else {
+      template = {
+        code: fs.readFileSync(`${this.views}/${tpl}.html`, "utf-8"),
+        cached: new Date(),
+      };
+      this.templates.set(tpl, template);
+    }
+    return [
+      template.code,
+      this.debug ? `<!-- ${tpl}.html ${cache ? `cached ${template.cached}` : "not cached"} -->` : "",
+    ].join("");
+  }
+
+  render(file: string, data: Record<string, any> = {}, locals: Record<string, any> = {}): string {
+    data = { ...data, ...locals, ...this.globals };
+    try {
+      const code =
+        'with(_data){const __html = [];' +
+        '__html.push(`' +
+        this.getTemplate(file)
+          .replace(/[\t]/g, " ")
+          .split("`")
+          .join("\\`")
+          .replace(/{{--(.*?)--}}/g, "")
+          .replace(/{{(.+?)}}/g, "`, $1, `")
+          .replace(/{!!(.+?)!!}/g, "`, this.escape($1), `")
+          .replace(/@js/g, "`);")
+          .replace(/@endjs/g, ";__html.push(`")
+          .replace(/@mtime\((.*?)\)/g, "`);__html.push(this.getMtime('$1'));__html.push(`")
+          .replace(/@include\((.*?)\)/g, (_, inc) => this.render(inc, data))
+          .replace(/@for\((.*?)\)$/gm, "`); for($1) { __html.push(`")
+          .replace(/@endfor/g, "`); } __html.push(`")
+          .replace(/@each\((.*?) as (.*?)\)/g, "`); this.forEach($1, ($2, key) => { __html.push(`")
+          .replace(/@endeach/g, "`); }); __html.push(`")
+          .replace(/@elseif\((.*?)\)(\)?)/g, "`); } else if ($1$2) { __html.push(`")
+          .replace(/@if\((.*?)\)(\)?)/g, "`); if ($1$2) { __html.push(`")
+          .replace(/@else/g, "`); } else { __html.push(`")
+          .replace(/@endif/g, "`); } __html.push(`") +
+        "`); return __html.join('').replace(/\\n\\s*\\n/g, '\\n'); }";
+
+      return new Function("_data", code).bind({
+        escape: this.escape,
+        forEach: this.forEach,
+        getMtime: this.getMtime,
+      })(data);
+    }
+    catch(err: any) {
+      console.log(file, (err as Error).message);
+      return this.debug ? `${(err as Error).message} in ${file}` : "";
+    }
+  }
+
+  escape(str: string): string {
+    return (str + "")
+      .replace(/&/g, "&amp;")
+      .replace(/</g, "&lt;")
+      .replace(/>/g, "&gt;")
+      .replace(/"/g, "&quot;")
+      .replace(/'/g, "&#39;")
+      .replace(/{/g, "&#123;")
+      .replace(/}/g, "&#125;");
+  }
+
+  forEach(o: any, f: (value: any, key: string | number) => void): void {
+    if(Array.isArray(o)) {
+      o.forEach(f);
+    }
+    else if(typeof o === "object") {
+      Object.keys(o).forEach((k) => f.call(null, o[k], k));
+    }
+    else {
+      throw new Error(`${o} is not an iterable object`);
+    }
+  }
+
+  getMtime(file: string): number {
+    try {
+      return +`${fs.statSync(path.normalize(process.cwd() + file)).mtimeMs}`.split(".")[0];
+    }
+    catch(err: any) {
+      console.log(err);
+      return 0;
+    }
+  }
+}

tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES6",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "removeComments": true,
+    "declaration": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules"]
+}

typedoc.json

@@ -0,0 +1,5 @@
+{
+  "entryPoints": ["./src/index.ts"],
+  "out": "docs",
+  "plugin": ["typedoc-plugin-markdown"]
+}