@ndiinginc/router 4.2.0 → 4.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ndiinginc/router",
-  "version": "4.2.0",
+  "version": "4.4.0",
   "description": "",
   "main": "./src/index.js",
   "scripts": {

package/src/app.js

@@ -1,76 +1,76 @@
-const http = require("node:http");
-const { Router } = require("./router.js");
-const { Request } = require("./request.js");
-const { Response } = require("./response.js");
-const { ErrorResponse } = require("./error.js");
-
-/**@type {import('http').ServerOptions}*/
-const SERVER_OPTIONS = {
-    IncomingMessage: Request,
-    ServerResponse: Response,
-};
-
-class App extends Router {
-    async withTimeout(handlerPromise, delay) {
-        let timeout;
-        const timeoutPromise = new Promise((_, reject) => {
-            timeout = setTimeout(() => reject(ErrorResponse.status(504)), delay);
-        });
-
-        await Promise.race([handlerPromise, timeoutPromise]).finally(() => clearTimeout(timeout));
-    }
-
-    /**
-     * @param {import('http').IncomingMessage} req
-     * @param {import('http').ServerResponse} res
-     */
-    async handle(req, res) {
-        const { params, handlers, errorHandlers } = this.find(req.method, req.path);
-        req.params = params;
-
-        let err;
-        try {
-            const handlerPromise = (async () => {
-                for (const handler of handlers) {
-                    if (res.writableEnded) break;
-                    await handler(req, res);
-                }
-            })();
-
-            if (req.timeout) await this.withTimeout(handlerPromise, req.timeout);
-            else await handlerPromise;
-        } catch (error) {
-            err = error;
-
-            try {
-                for (const handler of errorHandlers) {
-                    if (res.writableEnded) break;
-                    await handler(err, req, res);
-                }
-            } catch (error) {
-                err = new Error(error.message, { cause: err });
-            }
-        }
-
-        if (!res.writableEnded) {
-            if (!err) err = ErrorResponse.status(404);
-
-            if (!res.statusCode || res.statusCode < 400) {
-                res.statusCode = err.statusCode || 500;
-            }
-
-            res.json({ error: { message: err.message, stack: err.stack } });
-        }
-    }
-
-    listen(...params) {
-        const requestListener = (req, res) => this.handle(req, res);
-        const server = http.createServer(SERVER_OPTIONS, requestListener);
-        server.listen(...params);
-        return server;
-    }
-}
-
-App.SERVER_OPTIONS = SERVER_OPTIONS;
-
-exports.App = App;
+const http = require("node:http");
+const { Router } = require("./router.js");
+const { Request } = require("./request.js");
+const { Response } = require("./response.js");
+const { ErrorResponse } = require("./error.js");
+
+/**@type {import('http').ServerOptions}*/
+const SERVER_OPTIONS = {
+    IncomingMessage: Request,
+    ServerResponse: Response,
+};
+
+class App extends Router {
+    async withTimeout(handlerPromise, delay) {
+        let timeout;
+        const timeoutPromise = new Promise((_, reject) => {
+            timeout = setTimeout(() => reject(ErrorResponse.status(504)), delay);
+        });
+
+        await Promise.race([handlerPromise, timeoutPromise]).finally(() => clearTimeout(timeout));
+    }
+
+    /**
+     * @param {import('http').IncomingMessage} req
+     * @param {import('http').ServerResponse} res
+     */
+    async handle(req, res) {
+        const { params, handlers, errorHandlers } = this.find(req.method, req.path);
+        req.params = params;
+
+        let err;
+        try {
+            const handlerPromise = (async () => {
+                for (const handler of handlers) {
+                    if (res.writableEnded) break;
+                    await handler(req, res);
+                }
+            })();
+
+            if (req.timeout) await this.withTimeout(handlerPromise, req.timeout);
+            else await handlerPromise;
+        } catch (error) {
+            err = error;
+
+            try {
+                for (const handler of errorHandlers) {
+                    if (res.writableEnded) break;
+                    await handler(err, req, res);
+                }
+            } catch (error) {
+                err = new Error(error.message, { cause: err });
+            }
+        }
+
+        if (!res.writableEnded) {
+            if (!err) err = ErrorResponse.status(404);
+
+            if (!res.statusCode || res.statusCode < 400) {
+                res.statusCode = err.statusCode || 500;
+            }
+
+            res.json({ error: { message: err.message, stack: err.stack } });
+        }
+    }
+
+    listen(...params) {
+        const requestListener = (req, res) => this.handle(req, res);
+        const server = http.createServer(SERVER_OPTIONS, requestListener);
+        server.listen(...params);
+        return server;
+    }
+}
+
+App.SERVER_OPTIONS = SERVER_OPTIONS;
+
+exports.App = App;

package/src/cache.js

@@ -1,24 +1,24 @@
-class Cache {
-    constructor(size) {
-        this.size = size;
-        this.map = new Map();
-    }
-
-    get(key) {
-        if (!this.map.has(key)) return undefined;
-        const value = this.map.get(key);
-        this.map.delete(key);
-        this.map.set(key, value);
-        return value;
-    }
-
-    set(key, value) {
-        if (this.map.has(key)) this.map.delete(key);
-        else if (this.map.size >= this.size) {
-            this.map.delete(this.map.keys().next().value);
-        }
-        this.map.set(key, value);
-    }
-}
-
-exports.Cache = Cache;
+class Cache {
+    constructor(size) {
+        this.size = size;
+        this.map = new Map();
+    }
+
+    get(key) {
+        if (!this.map.has(key)) return undefined;
+        const value = this.map.get(key);
+        this.map.delete(key);
+        this.map.set(key, value);
+        return value;
+    }
+
+    set(key, value) {
+        if (this.map.has(key)) this.map.delete(key);
+        else if (this.map.size >= this.size) {
+            this.map.delete(this.map.keys().next().value);
+        }
+        this.map.set(key, value);
+    }
+}
+
+exports.Cache = Cache;

package/src/error.js

@@ -1,26 +1,26 @@
-const http = require("node:http");
-
-// Client error responses (400 – 499)
-// Server error responses (500 – 599)
-class ErrorResponse extends Error {
-    constructor({ statusCode, message } = {}, options) {
-        super(message, options);
-
-        this.name = this.constructor.name;
-
-        if (Error.captureStackTrace) {
-            Error.captureStackTrace(this, this.constructor);
-        }
-        
-        this.statusCode = statusCode;
-    }
-
-    static status(statusCode) {
-        return new ErrorResponse({
-            statusCode,
-            message: http.STATUS_CODES[statusCode],
-        });
-    }
-}
-
-exports.ErrorResponse = ErrorResponse;
+const http = require("node:http");
+
+// Client error responses (400 – 499)
+// Server error responses (500 – 599)
+class ErrorResponse extends Error {
+    constructor({ statusCode, message } = {}, options) {
+        super(message, options);
+
+        this.name = this.constructor.name;
+
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+
+        this.statusCode = statusCode;
+    }
+
+    static status(statusCode) {
+        return new ErrorResponse({
+            statusCode,
+            message: http.STATUS_CODES[statusCode],
+        });
+    }
+}
+
+exports.ErrorResponse = ErrorResponse;

package/src/index.js

@@ -1,9 +1,11 @@
-const { inspect } = require("node:util");
-const { json } = require("./json.js");
-const { App } = require("./app.js");
-const { Router } = require("./router.js");
-
-App.Router=Router
-App.json=json
-
-module.exports=App
+const { inspect } = require("node:util");
+const { json } = require("./middleware/json.js");
+const { cors } = require("./middleware/cors.js");
+const { App } = require("./app.js");
+const { Router } = require("./router.js");
+
+App.Router = Router;
+App.json = json;
+App.cors = cors;
+
+module.exports = App;

package/src/middleware/cors.js

@@ -0,0 +1,139 @@
+function pattern(string) {
+    return new RegExp(
+        `(${String(string)
+            .replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+            .replace(/ /g, "")
+            .replace(/,/g, "|")
+            .replace(/\\\*/g, ".*")})`,
+        "i",
+    );
+}
+
+/**
+ * @typedef CORSOptions
+ * @property {String} [origin="*"]
+ * @property {Boolean} [credentials=false]
+ * @property {String|Array} headers
+ * @property {Number} [maxAge=0]
+ * @property {String|Array} methods
+ */
+
+/**
+ * @param {CORSOptions} options
+ */
+function cors({ origin = "*", credentials = false, headers, maxAge = 0, methods } = {}) {
+    const HEADERS_PATTERN = headers && pattern(headers);
+    const METHODS_PATTERN = methods && pattern(methods);
+    const ORIGIN_PATTERN = pattern(origin);
+
+    /**
+     * @param {import('http').ServerResponse} res
+     */
+    function setAllowCredentials(res) {
+        if (credentials) {
+            res.setHeader("Access-Control-Allow-Credentials", "true");
+        }
+    }
+
+    /**
+     * @param {import('http').IncomingMessage} req
+     * @param {import('http').ServerResponse} res
+     */
+    function setAllowHeaders(req, res) {
+        const reqHeaders = req.headers["access-control-request-headers"];
+        if (!reqHeaders) return;
+
+        let value;
+        if (headers === "*" && !credentials) {
+            value = "*";
+        } else if (Array.isArray(headers) && HEADERS_PATTERN && HEADERS_PATTERN.test(reqHeaders)) {
+            value = headers;
+        }
+        if (value) res.setHeader("Access-Control-Allow-Headers", value);
+    }
+
+    /**
+     * @param {import('http').IncomingMessage} req
+     * @param {import('http').ServerResponse} res
+     */
+    function setAllowMethods(req, res) {
+        const reqMethod = req.headers["access-control-request-method"];
+        if (!reqMethod) return;
+
+        let value;
+        if (methods === "*" && !credentials) {
+            value = "*";
+        } else if (Array.isArray(methods) && METHODS_PATTERN && METHODS_PATTERN.test(reqMethod)) {
+            value = methods;
+        }
+        if (value) res.setHeader("Access-Control-Allow-Methods", value);
+    }
+
+    /**
+     * @param {import('http').IncomingMessage} req
+     * @param {import('http').ServerResponse} res
+     */
+    function setAllowOrigin(req, res) {
+        const reqOrigin = req.headers["origin"];
+
+        let value;
+        let explicit;
+        if (origin === "*") {
+            if (!credentials) value = "*";
+            else {
+                value = reqOrigin;
+                explicit = true;
+            }
+        } else if (origin === null) {
+            value = "null";
+        } else if (typeof origin === "string" && ORIGIN_PATTERN.test(reqOrigin)) {
+            value = origin;
+            explicit = true;
+        }
+        if (value) res.setHeader("Access-Control-Allow-Origin", value);
+        if (explicit) res.appendHeader("Vary", "Origin");
+    }
+
+    /**
+     * @param {import('http').ServerResponse} res
+     */
+    function setExposeHeaders(res) {
+        let value;
+        if (headers === "*" && !credentials) {
+            value = "*";
+        } else if (Array.isArray(headers)) {
+            value = headers;
+        }
+        if (value) res.setHeader("Access-Control-Expose-Headers", value);
+    }
+
+    /**
+     * @param {import('http').ServerResponse} res
+     */
+    function setMaxAge(res) {
+        if (maxAge > 0) {
+            res.setHeader("Access-Control-Max-Age", maxAge);
+        }
+    }
+
+    /**
+     * @param {import('http').IncomingMessage} req
+     * @param {import('http').ServerResponse} res
+     */
+    return (req, res) => {
+        setAllowCredentials(res);
+        setAllowOrigin(req, res);
+        if (req.method === "OPTIONS") {
+            setAllowHeaders(req, res);
+            setAllowMethods(req, res);
+            setMaxAge(res);
+
+            res.statusCode = 204;
+            res.setHeader("Content-Length", "0");
+            res.end();
+        } else {
+            setExposeHeaders(res);
+        }
+    };
+}
+exports.cors = cors;

package/src/{json.js → middleware/json.js}

@@ -1,55 +1,55 @@
-const http = require("node:http");
-
-// middleware
-function json({ limit = 100 * 1024 } = {}) {
-    const reviver = (key, value) => {
-        if (key === "__proto__" || key === "constructor" || key === "prototype") {
-            return undefined;
-        }
-        return value;
-    };
-    
-    return async (req, res) => {
-        if (!["POST", "PUT", "PATCH", "QUERY"].includes(req.method)) {
-            return;
-        }
-
-        const contentType = req.headers["content-type"];
-        if (!contentType || !contentType.includes("application/json")) {
-            return;
-        }
-
-        const contentLength = parseInt(req.headers["content-length"], 10);
-        if (contentLength && contentLength > limit) {
-            res.statusCode = 413;
-            throw new Error(http.STATUS_CODES[res.statusCode]);
-        }
-
-        let chunkLength = 0;
-
-        const chunks = [];
-
-        for await (const chunk of req) {
-            chunkLength += chunk.length;
-            if (chunkLength > limit) {
-                res.statusCode = 413;
-                throw new Error(http.STATUS_CODES[res.statusCode]);
-            }
-            chunks.push(chunk);
-        }
-
-        if (chunks.length === 0) {
-            req.body = null;
-            return;
-        }
-
-        try {
-            req.body = JSON.parse(Buffer.concat(chunks), reviver);
-        } catch (error) {
-            res.statusCode = 400;
-            throw new Error("Invalid JSON body");
-        }
-    };
-}
-
-exports.json = json;
+const http = require("node:http");
+
+// middleware
+function json({ limit = 100 * 1024 } = {}) {
+    const reviver = (key, value) => {
+        if (key === "__proto__" || key === "constructor" || key === "prototype") {
+            return undefined;
+        }
+        return value;
+    };
+
+    return async (req, res) => {
+        if (!["POST", "PUT", "PATCH", "QUERY"].includes(req.method)) {
+            return;
+        }
+
+        const contentType = req.headers["content-type"];
+        if (!contentType || !contentType.includes("application/json")) {
+            return;
+        }
+
+        const contentLength = parseInt(req.headers["content-length"], 10);
+        if (contentLength && contentLength > limit) {
+            res.statusCode = 413;
+            throw new Error(http.STATUS_CODES[res.statusCode]);
+        }
+
+        let chunkLength = 0;
+
+        const chunks = [];
+
+        for await (const chunk of req) {
+            chunkLength += chunk.length;
+            if (chunkLength > limit) {
+                res.statusCode = 413;
+                throw new Error(http.STATUS_CODES[res.statusCode]);
+            }
+            chunks.push(chunk);
+        }
+
+        if (chunks.length === 0) {
+            req.body = null;
+            return;
+        }
+
+        try {
+            req.body = JSON.parse(Buffer.concat(chunks), reviver);
+        } catch (error) {
+            res.statusCode = 400;
+            throw new Error("Invalid JSON body");
+        }
+    };
+}
+
+exports.json = json;

package/src/node.js

@@ -1,81 +1,88 @@
-const { Pattern } = require("./pattern.js");
-
-class Node {
-    constructor(segment = "") {
-        this.segment = segment;
-        this.pattern = new Pattern(segment);
-        /**@type {Map<string,Node>}*/
-        this.children = new Map();
-        this.handlers = new Map([
-            ["ALL", []],
-            ["GET", []],
-            ["QUERY", []],
-            ["HEAD", []],
-            ["OPTIONS", []],
-            ["TRACE", []],
-            ["PUT", []],
-            ["DELETE", []],
-            ["POST", []],
-            ["PATCH", []],
-            ["CONNECT", []],
-        ]);
-    }
-
-    add(segment) {
-        if (!this.children.has(segment)) {
-            this.children.set(segment, new Node(segment));
-        }
-        return this.children.get(segment);
-    }
-
-    /**
-     * @param {Node} node
-     */
-    merge(node, offset) {
-        for (const [method, handlers] of node.handlers) {
-            for (const handler of handlers) {
-                handler.seq += offset;
-                this.handlers.get(method).push(handler);
-            }
-        }
-
-        for (const [segment, child] of node.children) {
-            if (!this.children.has(segment)) {
-                child.setSeqOffset(offset);
-                this.children.set(segment, child);
-            } else {
-                this.children.get(segment).merge(child, offset);
-            }
-        }
-    }
-
-    setSeqOffset(offset) {
-        for (const [, handlers] of this.handlers) {
-            for (const handler of handlers) {
-                handler.seq += offset;
-            }
-        }
-
-        for (const [, child] of this.children) {
-            child.setSeqOffset(offset);
-        }
-    }
-
-    getMaxSeq() {
-        let max = -1;
-
-        for (const [, handlers] of this.handlers) {
-            for (const handler of handlers) {
-                max = Math.max(max, handler.seq);
-            }
-        }
-
-        for (const [, child] of this.children) {
-            max = Math.max(max, child.getMaxSeq());
-        }
-        
-        return max;
-    }
-}
-
-exports.Node = Node;
+const { Pattern } = require("./pattern.js");
+
+class Node {
+    constructor(segment = "") {
+        this.segment = segment;
+        this.hasRegExp = segment.startsWith(":") || segment.indexOf("*") !== -1;
+        this.hasRegExpChildren = false;
+        this.pattern = this.hasRegExp && new Pattern(segment);
+        /**@type {Map<string,Node>}*/
+        this.children = new Map();
+        this.handlers = new Map([
+            ["ALL", []],
+            ["GET", []],
+            ["QUERY", []],
+            ["HEAD", []],
+            ["OPTIONS", []],
+            ["TRACE", []],
+            ["PUT", []],
+            ["DELETE", []],
+            ["POST", []],
+            ["PATCH", []],
+            ["CONNECT", []],
+        ]);
+        // debug
+        Object.defineProperty(this, "handlers", { configurable: true, enumerable: false, writable: true });
+    }
+
+    add(segment) {
+        if (!this.children.has(segment)) {
+            const node = new Node(segment);
+            if (node.hasRegExp) this.hasRegExpChildren = true; // node.hasRegExp;
+            this.children.set(segment, node);
+        }
+        return this.children.get(segment);
+    }
+
+    /**
+     * @param {Node} node
+     */
+    merge(node, offset) {
+        for (const [method, handlers] of node.handlers) {
+            for (const handler of handlers) {
+                handler.seq += offset;
+                this.handlers.get(method).push(handler);
+            }
+        }
+
+        for (const [segment, child] of node.children) {
+            if (child.hasRegExp) this.hasRegExpChildren = true; // child.hasRegExp;
+            if (!this.children.has(segment)) {
+                child.setSeqOffset(offset);
+                this.children.set(segment, child);
+            } else {
+                this.children.get(segment).merge(child, offset);
+            }
+        }
+    }
+
+    setSeqOffset(offset) {
+        for (const [, handlers] of this.handlers) {
+            for (const handler of handlers) {
+                handler.seq += offset;
+            }
+        }
+
+        for (const [, child] of this.children) {
+            child.setSeqOffset(offset);
+        }
+    }
+
+    getMaxSeq() {
+        let max = -1;
+
+        for (const [, handlers] of this.handlers) {
+            for (const handler of handlers) {
+                max = Math.max(max, handler.seq);
+            }
+        }
+
+        for (const [, child] of this.children) {
+            max = Math.max(max, child.getMaxSeq());
+        }
+
+        return max;
+    }
+}
+
+exports.Node = Node;

package/src/pattern.js

@@ -1,34 +1,34 @@
-/**
- * @typedef PatternExecResult
- * @property {number} index
- * @property {string} input
- * @property {Record<string, string>} [groups]
- * @property {number} length
- */
-class Pattern {
-    constructor(input) {
-        const pattern = `^${input
-            .replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
-            .replace(/:(\w+)/g, "(?<$1>[^/]+)")
-            .replace(/\*/, ".*")}$`;
-        Object.defineProperty(this, "regex", {
-            value: new RegExp(pattern),
-            configurable: true,
-            enumerable: false,
-        });
-    }
-    
-    /**
-     * @param {string} input
-     * @returns {PatternExecResult | null}
-     */
-    exec(input) {
-        return this.regex.exec(input);
-    }
-
-    test(input) {
-        return this.regex.test(input);
-    }
-}
-
-exports.Pattern = Pattern;
+/**
+ * @typedef PatternExecResult
+ * @property {number} index
+ * @property {string} input
+ * @property {Record<string, string>} [groups]
+ * @property {number} length
+ */
+class Pattern {
+    constructor(input) {
+        const pattern = `^${input
+            .replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+            .replace(/:(\w+)/g, "(?<$1>[^/]+)")
+            .replace(/\\\*/g, ".*")}$`;
+        Object.defineProperty(this, "regex", {
+            value: new RegExp(pattern),
+            configurable: true,
+            enumerable: false,
+        });
+    }
+
+    /**
+     * @param {string} input
+     * @returns {PatternExecResult | null}
+     */
+    exec(input) {
+        return this.regex.exec(input);
+    }
+
+    test(input) {
+        return this.regex.test(input);
+    }
+}
+
+exports.Pattern = Pattern;

package/src/request.js

@@ -1,37 +1,37 @@
-const http = require("node:http");
-const { parseUrl, parseQueryString } = require("./util.js");
-
-class Request extends http.IncomingMessage {
-    _path;
-    _parsed;
-    _query;
-    params={};
-    timeout=0;
-
-    get path() {
-        if (this._path) return this._path;
-
-        if (this.url.indexOf("?") === -1) {
-            this._path = this.url;
-            return this._path;
-        }
-
-        this._parsed = parseUrl(this.url)
-        this._path = this._parsed.path;
-        return this._path;
-    }
-    
-    get query() {
-        if (this._query) return this._query;
-
-        if (!this._parsed) {
-            this._query = {};
-            return this._query;
-        }
-        
-        this._query = parseQueryString(this._parsed.queryString);
-        return this._query;
-    }
-}
-
-exports.Request = Request;
+const http = require("node:http");
+const { parseUrl, parseQueryString } = require("./util.js");
+
+class Request extends http.IncomingMessage {
+    _path;
+    _parsed;
+    _query;
+    params = {};
+    timeout = 0;
+
+    get path() {
+        if (this._path) return this._path;
+
+        if (this.url.indexOf("?") === -1) {
+            this._path = this.url;
+            return this._path;
+        }
+
+        this._parsed = parseUrl(this.url);
+        this._path = this._parsed.path;
+        return this._path;
+    }
+
+    get query() {
+        if (this._query) return this._query;
+
+        if (!this._parsed) {
+            this._query = {};
+            return this._query;
+        }
+
+        this._query = parseQueryString(this._parsed.queryString);
+        return this._query;
+    }
+}
+
+exports.Request = Request;

package/src/response.js

@@ -1,13 +1,13 @@
-const http = require("node:http");
-
-class Response extends http.ServerResponse {
-    send(chunk) {
-        this.end(chunk);
-    }
-    
-    json(value) {
-        this.setHeader("Content-Type","application/json")
-        this.end(JSON.stringify(value));
-    }
-}
-exports.Response = Response;
+const http = require("node:http");
+
+class Response extends http.ServerResponse {
+    send(chunk) {
+        this.end(chunk);
+    }
+
+    json(value) {
+        this.setHeader("Content-Type", "application/json");
+        this.end(JSON.stringify(value));
+    }
+}
+exports.Response = Response;

package/src/router.js

@@ -1,164 +1,165 @@
-const { Node } = require("./node.js");
-const { Cache } = require("./cache.js");
-
-class Router {
-    constructor(options = {}) {
-        this.cacheSize = options.size ?? 1000;
-
-        this.root = new Node();
-        this.seq = 0;
-        this.cache = new Cache(this.cacheSize);
-    }
-
-    split(path) {
-        return path.split("/").filter(Boolean);
-    }
-
-    add(method, path, ...handlers) {
-        if (typeof path === "function") {
-            handlers = [path, ...handlers];
-            path = null;
-        }
-
-        let node = this.root;
-
-        if (path !== null) {
-            for (const segment of this.split(path)) {
-                node = node.add(segment);
-            }
-        }
-
-        for (const handler of handlers) {
-            if (handler.root) {
-                node.merge(handler.root, this.seq);
-                this.seq = node.getMaxSeq() + 1;
-            } else {
-                handler.seq = this.seq++;
-                node.handlers.get(method).push(handler);
-            }
-        }
-    }
-
-    use(path, ...handlers) {
-        this.add("ALL", path, ...handlers);
-        return this;
-    }
-
-    get(path, ...handlers) {
-        this.add("GET", path, ...handlers);
-        return this;
-    }
-
-    query(path, ...handlers) {
-        this.add("QUERY", path, ...handlers);
-        return this;
-    }
-
-    head(path, ...handlers) {
-        this.add("HEAD", path, ...handlers);
-        return this;
-    }
-
-    options(path, ...handlers) {
-        this.add("OPTIONS", path, ...handlers);
-        return this;
-    }
-
-    trace(path, ...handlers) {
-        this.add("TRACE", path, ...handlers);
-        return this;
-    }
-
-    put(path, ...handlers) {
-        this.add("PUT", path, ...handlers);
-        return this;
-    }
-
-    delete(path, ...handlers) {
-        this.add("DELETE", path, ...handlers);
-        return this;
-    }
-
-    post(path, ...handlers) {
-        this.add("POST", path, ...handlers);
-        return this;
-    }
-
-    patch(path, ...handlers) {
-        this.add("PATCH", path, ...handlers);
-        return this;
-    }
-
-    connect(path, ...handlers) {
-        this.add("CONNECT", path, ...handlers);
-        return this;
-    }
-
-    /**
-     * @param {'GET'|'QUERY'|'HEAD'|'OPTIONS'|'TRACE'|'PUT'|'DELETE'|'POST'|'PATCH'|'CONNECT'} method
-     * @param {String} path
-     * @returns {{params: {};handlers: any[];errorHandlers: any[];}}
-     */
-    find(method, path) {
-        const key = `${method} ${path}`;
-
-        const cached = this.cache.get(key);
-        if (cached) return cached;
-
-        let node = this.root;
-
-        let params = {};
-        const handlers = {};
-        const errorHandlers = {};
-
-        for (const input of this.split(path)) {
-            let matched = node.children.get(input);
-
-            if (!matched) {
-                for (const [, child] of node.children) {
-                    const match = child.pattern.exec(input);
-                    if (match) {
-                        matched = child;
-                        Object.assign(params, match.groups);
-                        break;
-                    }
-                }
-            }
-
-            if (!matched) {
-                node = null;
-                params = {};
-                break;
-            }
-
-            node = matched;
-
-            for (const handler of node.handlers.get("ALL")) {
-                if (handler.length === 3) errorHandlers[handler.seq] = handler;
-                else handlers[handler.seq] = handler;
-            }
-        }
-
-        for (const handler of this.root.handlers.get("ALL")) {
-            if (handler.length === 3) errorHandlers[handler.seq] = handler;
-            else handlers[handler.seq] = handler;
-        }
-
-        if (node) {
-            for (const handler of node.handlers.get(method)) {
-                handlers[handler.seq] = handler
-            }
-        }
-        
-        const result = {
-            params,
-            handlers: Object.values(handlers),
-            errorHandlers: Object.values(errorHandlers),
-        };
-
-        this.cache.set(key, result);
-
-        return result;
-    }
-}
-exports.Router = Router;
+const { Node } = require("./node.js");
+const { Cache } = require("./cache.js");
+
+class Router {
+    constructor(options = {}) {
+        this.cacheSize = options.size ?? 1000;
+
+        this.root = new Node();
+        this.seq = 0;
+        this.cache = new Cache(this.cacheSize);
+    }
+
+    split(path) {
+        return path.split("/").filter(Boolean);
+    }
+
+    add(method, path, ...handlers) {
+        if (typeof path === "function") {
+            handlers = [path, ...handlers];
+            path = null;
+        }
+
+        let node = this.root;
+
+        if (path !== null) {
+            for (const segment of this.split(path)) {
+                node = node.add(segment);
+            }
+        }
+
+        for (const handler of handlers) {
+            if (handler.root) {
+                node.merge(handler.root, this.seq);
+                this.seq = node.getMaxSeq() + 1;
+            } else {
+                handler.seq = this.seq++;
+                node.handlers.get(method).push(handler);
+            }
+        }
+    }
+
+    use(path, ...handlers) {
+        this.add("ALL", path, ...handlers);
+        return this;
+    }
+
+    get(path, ...handlers) {
+        this.add("GET", path, ...handlers);
+        return this;
+    }
+
+    query(path, ...handlers) {
+        this.add("QUERY", path, ...handlers);
+        return this;
+    }
+
+    head(path, ...handlers) {
+        this.add("HEAD", path, ...handlers);
+        return this;
+    }
+
+    options(path, ...handlers) {
+        this.add("OPTIONS", path, ...handlers);
+        return this;
+    }
+
+    trace(path, ...handlers) {
+        this.add("TRACE", path, ...handlers);
+        return this;
+    }
+
+    put(path, ...handlers) {
+        this.add("PUT", path, ...handlers);
+        return this;
+    }
+
+    delete(path, ...handlers) {
+        this.add("DELETE", path, ...handlers);
+        return this;
+    }
+
+    post(path, ...handlers) {
+        this.add("POST", path, ...handlers);
+        return this;
+    }
+
+    patch(path, ...handlers) {
+        this.add("PATCH", path, ...handlers);
+        return this;
+    }
+
+    connect(path, ...handlers) {
+        this.add("CONNECT", path, ...handlers);
+        return this;
+    }
+
+    /**
+     * @param {'GET'|'QUERY'|'HEAD'|'OPTIONS'|'TRACE'|'PUT'|'DELETE'|'POST'|'PATCH'|'CONNECT'} method
+     * @param {String} path
+     * @returns {{params: {};handlers: any[];errorHandlers: any[];}}
+     */
+    find(method, path) {
+        const key = `${method} ${path}`;
+
+        const cached = this.cache.get(key);
+        if (cached) return cached;
+
+        let node = this.root;
+
+        let params = {};
+        const handlers = {};
+        const errorHandlers = {};
+
+        for (const input of this.split(path)) {
+            let matched = node.children.get(input);
+
+            if (!matched && node.hasRegExpChildren) {
+                for (const [, child] of node.children) {
+                    if (!child.hasRegExp) continue;
+                    const match = child.pattern.exec(input);
+                    if (match) {
+                        matched = child;
+                        Object.assign(params, match.groups);
+                        break;
+                    }
+                }
+            }
+
+            if (!matched) {
+                node = null;
+                params = {};
+                break;
+            }
+
+            node = matched;
+
+            for (const handler of node.handlers.get("ALL")) {
+                if (handler.length === 3) errorHandlers[handler.seq] = handler;
+                else handlers[handler.seq] = handler;
+            }
+        }
+
+        for (const handler of this.root.handlers.get("ALL")) {
+            if (handler.length === 3) errorHandlers[handler.seq] = handler;
+            else handlers[handler.seq] = handler;
+        }
+
+        if (node) {
+            for (const handler of node.handlers.get(method)) {
+                handlers[handler.seq] = handler;
+            }
+        }
+
+        const result = {
+            params,
+            handlers: Object.values(handlers),
+            errorHandlers: Object.values(errorHandlers),
+        };
+
+        this.cache.set(key, result);
+
+        return result;
+    }
+}
+exports.Router = Router;

package/src/util.js

@@ -1,27 +1,27 @@
-const URL_REGEX = /^([^?#]*)(\?([^#]*))?(#.*)?$/;
-const QUERY_STRING_REGEX = /([^=&]*)?=([^&]*)?/g;
-
-function parseQueryString(queryString) {
-    const result = {};
-
-    let match;
-    while ((match = QUERY_STRING_REGEX.exec(queryString)) !== null) {
-        const [, name = "", raw = ""] = match;
-        
-        const value = decodeURIComponent(raw);
-        
-        if (result[name]) {
-            if (Array.isArray(result[name])) result[name].push(value);
-            else result[name] = [result[name], value];
-        } else result[name] = value;
-    }
-
-    return result;
-}
-exports.parseQueryString = parseQueryString;
-
-function parseUrl(url) {
-    const [, path = "/", , queryString = ""] = URL_REGEX.exec(url);
-    return { path, queryString };
-}
-exports.parseUrl = parseUrl;
+const URL_REGEX = /^([^?#]*)(\?([^#]*))?(#.*)?$/;
+const QUERY_STRING_REGEX = /([^=&]*)?=([^&]*)?/g;
+
+function parseQueryString(queryString) {
+    const result = {};
+
+    let match;
+    while ((match = QUERY_STRING_REGEX.exec(queryString)) !== null) {
+        const [, name = "", raw = ""] = match;
+
+        const value = decodeURIComponent(raw);
+
+        if (result[name]) {
+            if (Array.isArray(result[name])) result[name].push(value);
+            else result[name] = [result[name], value];
+        } else result[name] = value;
+    }
+
+    return result;
+}
+exports.parseQueryString = parseQueryString;
+
+function parseUrl(url) {
+    const [, path = "/", , queryString = ""] = URL_REGEX.exec(url);
+    return { path, queryString };
+}
+exports.parseUrl = parseUrl;