@ndiinginc/router 4.1.3 → 4.2.0

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@ndiinginc/router",
-  "version": "4.1.3",
+  "version": "4.2.0",
   "description": "",
-  "main": "./src/app.js",
+  "main": "./src/index.js",
   "scripts": {
     "test": "nodemon --exec \"node -e \\\"require('@ndiinginc/test')(require('path').resolve('tests'),{verbose:true})\\\"\"",
-    "dev": "nodemon src/app.js",
+    "dev": "nodemon src/index.js",
     "prettier": "npx prettier . --write",
     "commit": "node -e \"require('@ndiinginc/commit')()\"",
     "npm:dry-run": "npm publish --dry-run",

package/src/app.js

@@ -1,67 +1,76 @@
-const http = require("node:http");
-const { Response } = require("./response.js");
-const { Request } = require("./request.js");
-const { Router } = require("./Router.js");
-
-class App extends Router {
-    /**
-     * @param {import('http').IncomingMessage} req
-     * @param {import('http').ServerResponse} res
-     */
-    async handleRequest(req, res) {
-        let err;
-
-        const { params, handlers, errorHandlers } = this.find(req.method, req.path);
-        req.params = params;
-
-        try {
-            for (const handler of handlers) {
-                if (res.done) break;
-                await handler(req, res);
-            }
-        } catch (error) {
-            err = error;
-
-            try {
-                for (const handler of errorHandlers) {
-                    if (res.done) break;
-                    await handler(err, req, res);
-                }
-            } catch (error) {
-                err = error;
-            }
-        }
-
-        if (!res.done) {
-            if (!err) {
-                res.statusCode = 404;
-                err = new Error(http.STATUS_CODES[res.statusCode]);
-            }
-
-            res.statusCode = res.statusCode >= 200 && res.statusCode < 300 ? 500 : res.statusCode;
-            const error = { message: err.message };
-            if (process.env.NODE_ENV === "development") error.stack = err.stack;
-            res.json({ error });
-        }
-    }
-
-    /**
-     * @param {import('net').ListenOptions} options
-     * @returns {import('http').Server}
-     */
-    listen(...args) {
-        const serverOptions = {
-            IncomingMessage: Request,
-            ServerResponse: Response,
-        };
-        const requestListener = (req, res) => this.handleRequest(req, res);
-
-        const server = http.createServer(serverOptions, requestListener);
-
-        server.listen(...args);
-
-        return server;
-    }
-}
-
-module.exports = 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,28 +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

@@ -0,0 +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;

package/src/index.js

@@ -0,0 +1,9 @@
+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

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

@@ -1,52 +1,55 @@
-const http = require("node:http");
-
-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");
-        }
-    };
-}
-module.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,86 +1,81 @@
-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();
-        /**@type {Map<string, FunctionHandler[]>}*/
-        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
-     * @param {Number} offset
-     */
-    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);
-            }
-        }
-    }
-
-    /**
-     * @param {Number} 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.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;

package/src/pattern.js

@@ -1,34 +1,34 @@
-/**
- * @typedef {Object} PatternExec
- * @property {number} index - The zero-based index of the match in the input string.
- * @property {string} input - The original input string.
- * @property {Object.<string, string>} [groups] - Named capture groups, or undefined.
- */
-class Pattern {
-    constructor(input) {
-        const pattern = input
-            .replace(/[.+*?^${}()|[\]\\]/g, "\\$&")
-            .replace(/:(\w+)/g, "(?<$1>[^/]+)")
-            .replace(/\\\*/g, ".*");
-
-        Object.defineProperty(this, "re", {
-            value: new RegExp(`^${pattern}$`),
-            writable: true,
-            enumerable: false,
-            configurable: true,
-        });
-    }
-
-    test(input) {
-        return this.re.test(input);
-    }
-
-    /**
-     * @param {String} input
-     * @returns {PatternExec | null}
-     */
-    exec(input) {
-        return this.re.exec(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(/\*/, ".*")}$`;
+        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,43 +1,37 @@
-const http = require("node:http");
-
-class Request extends http.IncomingMessage {
-    static base = "http://127.0.0";
-
-    get path() {
-        if (this._path) return this._path;
-
-        if (this.url.indexOf('?')===-1) {
-            this._path = this.url;
-            return this._path;
-        }
-
-        this.parsed = URL.parse(this.url, Request.base);
-        this._path = this.parsed.pathname;
-        return this._path;
-    }
-
-    get query() {
-        if (this._query) return this._query;
-
-        if (!this.parsed) {
-            this._query = {};
-            return this._query;
-        }
-
-        const query = {};
-        for (const [name, value] of this.parsed.searchParams) {
-            if (query[name]) {
-                if (Array.isArray(query[name])) {
-                    query[name].push(value);
-                } else {
-                    query[name] = [query[name], value];
-                }
-            } else {
-                query[name] = value;
-            }
-        }
-        this._query = query;
-        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,14 +1,13 @@
-const http = require("node:http");
-
-class Response extends http.ServerResponse {
-    send(string) {
-        this.end(string);
-        this.done = true;
-    }
-
-    json(object) {
-        this.setHeader("content-type", "application/json");
-        this.send(JSON.stringify(object));
-    }
-}
-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,179 +1,164 @@
-const { Node } = require("./node");
-const { Cache } = require("./cache");
-
-/**
- * @callback Handler
- * @param {*} req
- * @param {*} res
- */
-/**
- * @callback Middleware
- * @param {*} req
- */
-/**
- * @callback ErrorHandler
- * @param {*} err
- * @param {*} req
- * @param {*} res
- */
-/**
- * @typedef {Handler|Middleware|ErrorHandler} FunctionHandler
- */
-
-class Router {
-    constructor(options = {}) {
-        this.cacheSize = options.cacheSize ?? 30_000;
-
-        this.root = new Node("/");
-        this.seq = 0;
-        this.cache = new Cache(this.cacheSize);
-    }
-
-    split(path) {
-        if (path === "/") return [];
-
-        return path.split("/").filter(Boolean);
-    }
-
-    /**
-     * @param {*} method
-     * @param {*} path
-     * @param {FunctionHandler[]} handler
-     */
-    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;
-    }
-
-    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 value = { params, handlers: Object.values(handlers), errorHandlers: Object.values(errorHandlers) };
-        this.cache.set(key, value);
-        return value;
-    }
-}
-module.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) {
+                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;

package/src/util.js

@@ -0,0 +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;