@ndiinginc/router 4.7.0 → 4.8.0

package/README.md

@@ -5,8 +5,8 @@ Router HTTP kecil, cepat, dan **zero-dependency** untuk Node.js. Dibangun langsu
 ## Fitur
 
 - Zero dependency, murni `node:http`
-- Routing berbasis tree per segmen (static match diprioritaskan, lalu dynamic)
-- Parameter dinamis `:id` dan wildcard `*`
+- Routing berbasis tree per segmen: static, lalu `:param`, lalu wildcard `*`, dengan backtracking
+- Parameter dinamis `:id` dan wildcard `*` yang menangkap sisa path
 - LRU cache untuk hasil lookup route
 - Nested router dengan `use(path, router)`
 - Middleware global dan per-path, mendukung `async`
@@ -82,7 +82,7 @@ app.get("/profile", authenticate, loadUser, (req, res) => {
 
 ### Parameter dinamis
 
-Nilai parameter otomatis di-decode dengan `decodeURIComponent`. Jika formatnya tidak valid (misalnya `%`), nilai mentah dipakai apa adanya.
+Segmen yang diawali `:` adalah parameter. Nilainya otomatis di-decode dengan `decodeURIComponent`; jika formatnya tidak valid (misalnya `%`), nilai mentah dipakai apa adanya.
 
 ```js
 app.get("/posts/:postId/comments/:commentId", (req, res) => {
@@ -91,20 +91,28 @@ app.get("/posts/:postId/comments/:commentId", (req, res) => {
 });
 ```
 
+Satu segmen adalah satu parameter utuh; nama parameter tidak bisa digabung dengan teks lain dalam segmen yang sama (`:id.json` akan dianggap parameter bernama `id.json`).
+
+> Di setiap level hanya ada satu parameter. Jika `/users/:id` dan `/users/:userId/posts` didaftarkan bersamaan, keduanya memakai nama yang pertama didaftarkan (`id`). Pakai nama yang sama untuk level yang sama.
+
 ### Wildcard
 
-`*` cocok dengan karakter apa pun **di dalam satu segmen**. Wildcard tidak melintasi `/`.
+Segmen `*` menangkap **seluruh sisa path** (termasuk `/`) dan nilainya tersedia di `req.params[0]`.
 
 ```js
-app.get("/files/report-*", (req, res) => {
-    res.json({ path: req.path });
+app.get("/files/*", (req, res) => {
+    res.json({ file: req.params[0] });
 });
+
+// GET /files/images/logo.png -> { file: "images/logo.png" }
 ```
 
+Wildcard butuh minimal satu segmen tersisa, jadi `/files/*` tidak cocok dengan `/files`.
+
 ### Aturan matching
 
-- Untuk setiap segmen, router mencoba **static match dulu**, baru pattern dinamis. Jadi `/users/me` menang atas `/users/:id` bila keduanya terdaftar.
-- Jika ada beberapa pattern dinamis di level yang sama, yang **terdaftar lebih dulu** yang dipakai (tanpa backtracking).
+- Di setiap level, router mencoba **static dulu, lalu parameter, lalu wildcard**. Jadi `/users/me` menang atas `/users/:id` bila keduanya terdaftar.
+- Jika cabang static gagal di tengah jalan, router mundur (backtrack) dan mencoba parameter, lalu wildcard.
 - Trailing slash dan slash ganda diabaikan: `/users`, `/users/`, dan `//users` dianggap sama.
 
 ## Middleware
@@ -127,7 +135,7 @@ app.use("/admin", async (req, res) => {
 
 Chain berhenti otomatis begitu response selesai dikirim (`res.writableEnded`), jadi handler berikutnya tidak dipanggil.
 
-> Middleware tetap dijalankan walaupun tidak ada route yang cocok, sebelum respons 404 dikirim.
+> Jika path tidak cocok dengan route mana pun, hanya middleware global (tanpa path) yang dijalankan sebelum respons 404 dikirim.
 
 ## Nested Router
 
@@ -226,7 +234,7 @@ app.get("/proxy", async (req, res) => {
 | --- | --- |
 | `req.path` | Pathname tanpa query string |
 | `req.query` | Object query string, di-parse secara lazy. Key yang berulang menjadi array, dan `+` di-decode menjadi spasi |
-| `req.params` | Parameter dari route dinamis (sudah di-decode) |
+| `req.params` | Parameter dari route dinamis (sudah di-decode). Wildcard `*` ada di `req.params[0]` |
 | `req.body` | Hasil parse body (butuh middleware `json()`) |
 | `req.signal` | `AbortSignal` yang di-abort saat timeout atau error handler (hanya jika `requestTimeout` aktif) |
 
@@ -237,7 +245,7 @@ app.get("/search", (req, res) => {
 });
 ```
 
-`req.query` dan `req.params` memakai object tanpa prototype, jadi gunakan `Object.hasOwn(req.query, "key")` atau `"key" in req.query`, bukan `req.query.hasOwnProperty(...)`.
+`req.query` dan `req.params` yang sampai ke handler memakai object tanpa prototype, jadi gunakan `Object.hasOwn(req.query, "key")` atau `"key" in req.query`, bukan `req.query.hasOwnProperty(...)`.
 
 `Request` adalah turunan `http.IncomingMessage`, jadi `req.headers`, `req.method`, dan lainnya tetap tersedia.
 
@@ -280,7 +288,7 @@ Perilaku:
 ```js
 app.use(
     App.cors({
-        origin: "https://example.com",
+        origin: ["https://example.com", "https://app.example.com"],
         credentials: true,
         methods: ["GET", "POST", "PUT", "DELETE"],
         headers: ["Content-Type", "Authorization"],
@@ -291,17 +299,17 @@ app.use(
 
 | Opsi | Default | Keterangan |
 | --- | --- | --- |
-| `origin` | `"*"` | `"*"`, satu origin, daftar dipisah koma, pola dengan `*` (misalnya `https://*.example.com`), atau `null` |
+| `origin` | `"*"` | `"*"`, satu origin, array origin, atau `null` |
 | `credentials` | `false` | Mengirim `Access-Control-Allow-Credentials: true` |
-| `headers` | - | `"*"` atau array nama header |
-| `methods` | - | `"*"` atau array nama method |
+| `headers` | - | `"*"` atau array nama header (tidak membedakan huruf besar/kecil) |
+| `methods` | - | `"*"` atau array nama method (tidak membedakan huruf besar/kecil) |
 | `maxAge` | `0` | Lama cache preflight (detik). `0` berarti header tidak dikirim |
 
 Perilaku:
 
 - Request `OPTIONS` dijawab langsung dengan `204` dan chain berhenti
-- `Access-Control-Allow-Headers` dan `Access-Control-Allow-Methods` hanya dikirim pada preflight, jika nilai yang diminta ada di daftar
-- Jika `origin` berupa daftar atau pola (atau `"*"` dengan `credentials: true`), origin dari request dipantulkan bila cocok. Pencocokan dilakukan pada seluruh string (tanpa memperhatikan huruf besar/kecil), dan header `Vary: Origin` ditambahkan pada request non-preflight
+- Origin dicocokkan **persis sama** (case-sensitive) dengan header `Origin` dari request. Jika cocok, origin tersebut dipantulkan, dan header `Vary: Origin` ditambahkan pada request non-preflight
+- `Access-Control-Allow-Headers` dan `Access-Control-Allow-Methods` hanya dikirim pada preflight, dan hanya jika **semua** header atau method yang diminta ada di daftar
 - Nilai `"*"` untuk `headers` dan `methods` diabaikan saat `credentials: true`, sesuai spesifikasi CORS
 - Pada request non-preflight, `headers` (jika array) dikirim sebagai `Access-Control-Expose-Headers`
 
@@ -315,8 +323,8 @@ const app = new App({ cacheSize: 1000, requestTimeout: 5000 });
 
 | Opsi | Default | Keterangan |
 | --- | --- | --- |
-| `cacheSize` | `1000` | Jumlah maksimum entri LRU cache untuk hasil lookup `METHOD path` |
-| `requestTimeout` | - | Batas waktu handler dalam ms (khusus `App`). Lihat bagian [Timeout](#requestTimeout) |
+| `cacheSize` | `1000` | Jumlah maksimum entri LRU cache untuk hasil lookup `METHOD path`. Cache dikosongkan setiap ada route baru didaftarkan |
+| `requestTimeout` | `0` | Batas waktu handler dalam ms (khusus `App`). Lihat bagian [Timeout](#timeout) |
 
 `Router` hanya menerima `cacheSize`.
 
@@ -351,19 +359,6 @@ const server = app.listen(0); // port acak
 console.log(server.address().port);
 ```
 
-## Benchmark
-
-Hello world dengan satu route `GET /`, diuji memakai `autocannon -c 100 -d 40 -p 10` di mesin lokal.
-
-| package           | Latency  | Req/Sec  | Bytes/Sec | Result                                |
-| ----------------- | -------- | -------- | --------- | ------------------------------------- |
-| fastify           | 25.3 ms  | 38,738.4 | 7.24 MB   | 1550k requests in 40.06s, 290 MB read |
-| @ndiinginc/router | 28.45 ms | 34,541.4 | 5.91 MB   | 1383k requests in 40.06s, 236 MB read |
-| express           | 41 ms    | 24,095.6 | 6.05 MB   | 965k requests in 40.06s, 242 MB read  |
-
-
-Hasil bervariasi tergantung mesin, versi Node.js, dan jumlah route. Benchmark ini hanya menggambarkan overhead dasar, bukan performa aplikasi nyata.
-
 ## Testing
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ndiinginc/router",
-  "version": "4.7.0",
+  "version": "4.8.0",
   "description": "",
   "main": "./src/index.js",
   "scripts": {
@@ -19,7 +19,7 @@
   "type": "commonjs",
   "devDependencies": {
     "@ndiinginc/commit": "^1.0.1",
-    "@ndiinginc/test": "^1.7.1",
+    "@ndiinginc/test": "^1.17.0",
     "@types/jest": "^30.0.0",
     "@types/node": "^26.6.5"
   }

package/src/app.js

@@ -67,6 +67,10 @@ class App extends Router {
                 err = new Error(error.message, { cause: err });
             }
         }
+        err = this.fallback(res, err);
+    }
+
+    fallback(res, err) {
         if (!res.writableEnded) {
             if (!err) err = ErrorResponse.status(404);
             res.statusCode = err.statusCode || 500;
@@ -76,6 +80,7 @@ class App extends Router {
             }
             res.json({ error });
         }
+        return err;
     }
 
     listen(...params) {

package/src/cache.js

@@ -1,5 +1,5 @@
 class Cache {
-    constructor(size) {
+    constructor(size = 0) {
         this.size = size;
         this.map = new Map();
     }
@@ -19,6 +19,10 @@ class Cache {
         }
         this.map.set(key, value);
     }
+
+    clear() {
+        this.map.clear();
+    }
 }
 
 exports.Cache = Cache;

package/src/middleware/cors.js

@@ -1,14 +1,3 @@
-function pattern(string) {
-    return new RegExp(
-        `^(${String(string)
-            .replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
-            .replace(/ /g, "")
-            .replace(/,/g, "|")
-            .replace(/\\\*/g, ".*")})$`,
-        "i",
-    );
-}
-
 /**
  * @typedef CORSOptions
  * @property {String} [origin="*"]
@@ -22,9 +11,12 @@ function pattern(string) {
  * @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);
+    if (headers && Array.isArray(headers)) {
+        headers = headers.map((header) => header.toLowerCase());
+    }
+    if (methods && Array.isArray(methods)) {
+        methods = methods.map((method) => method.toUpperCase());
+    }
 
     /**
      * @param {import('http').ServerResponse} res
@@ -40,12 +32,13 @@ function cors({ origin = "*", credentials = false, headers, maxAge = 0, methods
      * @param {import('http').ServerResponse} res
      */
     function setAllowHeaders(req, res) {
-        const reqHeaders = req.headers["access-control-request-headers"];
+        let reqHeaders = req.headers["access-control-request-headers"];
         if (!reqHeaders) return;
+        reqHeaders = reqHeaders.split(",").map((header) => header.trim().toLowerCase());
         let value;
         if (headers === "*" && !credentials) {
             value = "*";
-        } else if (Array.isArray(headers) && HEADERS_PATTERN && HEADERS_PATTERN.test(reqHeaders)) {
+        } else if (Array.isArray(headers) && reqHeaders.every((reqHeader) => headers.some((header) => header === reqHeader))) {
             value = headers;
         }
         if (value) res.setHeader("Access-Control-Allow-Headers", value);
@@ -61,7 +54,7 @@ function cors({ origin = "*", credentials = false, headers, maxAge = 0, methods
         let value;
         if (methods === "*" && !credentials) {
             value = "*";
-        } else if (Array.isArray(methods) && METHODS_PATTERN && METHODS_PATTERN.test(reqMethod)) {
+        } else if (Array.isArray(methods) && methods.some((method) => method === reqMethod.toUpperCase())) {
             value = methods;
         }
         if (value) res.setHeader("Access-Control-Allow-Methods", value);
@@ -80,7 +73,7 @@ function cors({ origin = "*", credentials = false, headers, maxAge = 0, methods
             value = "*";
         } else if (origin === null) {
             value = "null";
-        } else if (ORIGIN_PATTERN.test(reqOrigin)) {
+        } else if (origin === "*" || origin === reqOrigin || (Array.isArray(origin) && origin.some((origin) => origin === reqOrigin))) {
             value = reqOrigin;
             explicit = true;
         }

package/src/node.js

@@ -1,46 +1,80 @@
-const { Pattern } = require("./pattern.js");
-
 class Node {
     constructor(segment = "") {
-        this.hasRegExpChildren = false;
-        this.pattern = /[:*]/.test(segment) && new Pattern(segment);
-        /**@type {Map<string,Node>}*/
-        this.children = new Map();
+        this.segment = segment;
+        /**@type {Map<string, Node>}*/
+        this.staticChildren = new Map();
+        this.paramChild = null;
+        this.paramName = null;
+        this.wildcardChild = null;
+        /**@type {Map<string, Function[]>}*/
         this.handlers = new Map();
     }
-
+    /**
+     * @param {String} segment
+     * @returns {Node}
+     */
     add(segment) {
-        return this.children.getOrInsertComputed(segment, () => {
-            const node = new Node(segment);
-            if (node.pattern) this.hasRegExpChildren = true;
-            return node;
-        });
+        if (segment.startsWith(":")) {
+            if (this.paramChild) return this.paramChild;
+            this.paramChild = new Node(segment);
+            this.paramChild.paramName = segment.slice(1);
+            this.paramChild.type = "param";
+            return this.paramChild;
+        } else if (segment.startsWith("*")) {
+            if (this.wildcardChild) return this.wildcardChild;
+            this.wildcardChild = new Node(segment);
+            this.wildcardChild.type = "wildcard";
+            return this.wildcardChild;
+        } else {
+            return this.staticChildren.getOrInsertComputed(segment, (segment) => {
+                const node = new Node(segment);
+                node.type = "wildcard";
+                return node;
+            });
+        }
     }
-
+    /**
+     * @param {Node} node
+     */
     merge(node, offset) {
         for (const [method, entries] of node.handlers) {
-            const target = this.handlers.getOrInsert(method, []);
             for (const entry of entries) {
-                target.push({ ...entry, seq: entry.seq + offset });
+                this.handlers.getOrInsert(method, []).push({
+                    ...entry,
+                    seq: entry.seq + offset,
+                });
             }
         }
-        for (const [segment, child] of node.children) {
-            const target = this.children.getOrInsertComputed(segment, () => new Node(segment));
-            if (target.pattern) this.hasRegExpChildren = true;
-            target.merge(child, offset);
+
+        if (node.paramChild) {
+            this.add(node.paramChild.segment).merge(node.paramChild, offset);
+        }
+        if (node.wildcardChild) {
+            this.add(node.wildcardChild.segment).merge(node.wildcardChild, offset);
+        }
+        for (const [segment, child] of node.staticChildren) {
+            this.add(segment).merge(child, offset);
         }
     }
 
     getMaxSeq() {
         let max = -1;
-        for (const [, handlers] of this.handlers) {
-            for (const entry of handlers) {
+        for (const [method, entries] of this.handlers) {
+            for (const entry of entries) {
                 max = Math.max(max, entry.seq);
             }
         }
-        for (const [, child] of this.children) {
+
+        if (this.paramChild) {
+            max = Math.max(max, this.paramChild.getMaxSeq());
+        }
+        if (this.wildcardChild) {
+            max = Math.max(max, this.wildcardChild.getMaxSeq());
+        }
+        for (const [path, child] of this.staticChildren) {
             max = Math.max(max, child.getMaxSeq());
         }
+
         return max;
     }
 }

package/src/response.js

@@ -7,7 +7,7 @@ class Response extends http.ServerResponse {
     }
     send(chunk) {
         if (this.writableEnded) return;
-        this.end(chunk,null,null);//avoid ArgumentsAdaptorTrampoline from V8
+        this.end(chunk, null, null); //avoid ArgumentsAdaptorTrampoline from V8
     }
     json(value) {
         if (this.writableEnded) return;
@@ -16,7 +16,7 @@ class Response extends http.ServerResponse {
             return;
         }
         this.setHeader("Content-Type", "application/json");
-        this.end(JSON.stringify(value),null,null);//avoid ArgumentsAdaptorTrampoline from V8
+        this.end(JSON.stringify(value), null, null); //avoid ArgumentsAdaptorTrampoline from V8
     }
 }
 exports.Response = Response;

package/src/router.js

@@ -1,6 +1,6 @@
 const { Node } = require("./node.js");
 const { Cache } = require("./cache.js");
-const {  decodePathParam } = require("./util.js");
+const { decodePathParam } = require("./util.js");
 
 class Router {
     constructor(options = {}) {
@@ -16,14 +16,16 @@ class Router {
     }
 
     add(method, path, ...handlers) {
+        this.cache.clear();
+
         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);
+        if (path) {
+            for (const part of this.split(path)) {
+                node = node.add(part);
             }
         }
 
@@ -32,10 +34,10 @@ class Router {
                 node.merge(handler.root, this.seq);
                 this.seq += handler.root.getMaxSeq() + 1;
             } else {
-                node.handlers.getOrInsert(method, []).push({
+                const newMethod = handler.length === 3 ? "CATCH" : method;
+                node.handlers.getOrInsert(newMethod, []).push({
                     handler,
                     seq: this.seq++,
-                    isErrorHandler: handler.length === 3,
                 });
             }
         }
@@ -96,71 +98,96 @@ class Router {
         return this;
     }
 
-    matchRegExp(node, input, params) {
-        let matched;
-        for (const [, child] of node.children) {
-            if (!child.pattern) continue;
-            const match = child.pattern.exec(input);
-            if (match) {
-                matched = child;
-                for (const name in match.groups) {
-                    params[name] = decodePathParam(match.groups[name]);
-                }
-                break;
+    collectMiddleware(node, handlers, errorHandlers) {
+        if (node.handlers.has("ALL")) {
+            for (const entry of node.handlers.get("ALL")) {
+                handlers[entry.seq] = entry.handler;
+            }
+        }
+        if (node.handlers.has("CATCH")) {
+            for (const entry of node.handlers.get("CATCH")) {
+                errorHandlers[entry.seq] = entry.handler;
+            }
+        }
+    }
+
+    collectHandler(node, method, handlers) {
+        if (node && node.handlers.has(method)) {
+            for (const entry of node.handlers.get(method)) {
+                handlers[entry.seq] = entry.handler;
             }
         }
-        return matched;
     }
 
     /**
-     * @param {'GET'|'QUERY'|'HEAD'|'OPTIONS'|'TRACE'|'PUT'|'DELETE'|'POST'|'PATCH'|'CONNECT'} method
-     * @param {String} path
-     * @returns {{params: {};handlers: any[];errorHandlers: any[];}}
+     * @param {Node} node
+     * @param {*} parts
+     * @param {*} i
+     * @param {*} params
+     * @param {*} path
+     * @returns
      */
+    search(node, parts, i, params, path) {
+        if (!node) return null;
+        path.push(node);
+        if (i === parts.length) return path;
+
+        const part = parts[i];
+
+        if (node.staticChildren.has(part)) {
+            const r = this.search(node.staticChildren.get(part), parts, i + 1, params, path);
+            if (r) return r;
+        }
+
+        if (node.paramChild) {
+            const saved = params[node.paramChild.paramName];
+            params[node.paramChild.paramName] = decodePathParam(part);
+            const r = this.search(node.paramChild, parts, i + 1, params, path);
+            if (r) return r;
+            if (saved === undefined) delete params[node.paramChild.paramName];
+            else params[node.paramChild.paramName] = saved;
+        }
+
+        if (node.wildcardChild) {
+            params[0] = decodePathParam(parts.slice(i).join("/"));
+            path.push(node.wildcardChild);
+            return path;
+        }
+
+        path.pop();
+        return null;
+    }
+
     find(method, path) {
         const key = `${method} ${path}`;
         const cached = this.cache.get(key);
         if (cached) return cached;
-        let node = this.root;
-        let params = Object.create(null);
+
+        const parts = this.split(path);
+        const params = {};
+        const nodePath = [];
+        const result = this.search(this.root, parts, 0, params, nodePath);
+
         const handlers = {};
         const errorHandlers = {};
-        for (const input of this.split(path)) {
-            let matched = node.children.get(input);
-            if (!matched && node.hasRegExpChildren) {
-                matched = this.matchRegExp(node, input, params);
-            }
-            if (!matched) {
-                node = null;
-                params = Object.create(null);
-                break;
-            }
-            node = matched;
-            if (node.handlers.has("ALL")) {
-                for (const entry of node.handlers.get("ALL")) {
-                    if (entry.isErrorHandler) errorHandlers[entry.seq] = entry.handler;
-                    else handlers[entry.seq] = entry.handler;
-                }
-            }
-        }
-        if (this.root.handlers.has("ALL")) {
-            for (const entry of this.root.handlers.get("ALL")) {
-                if (entry.isErrorHandler) errorHandlers[entry.seq] = entry.handler;
-                else handlers[entry.seq] = entry.handler;
-            }
-        }
-        if (node && node.handlers.has(method)) {
-            for (const entry of node.handlers.get(method)) {
-                handlers[entry.seq] = entry.handler;
+
+        if (result) {
+            for (const n of result) {
+                this.collectMiddleware(n, handlers, errorHandlers);
             }
+            this.collectHandler(result[result.length - 1], method, handlers);
+        } else {
+            this.collectMiddleware(this.root, handlers, errorHandlers);
         }
-        const result = {
+
+        const value = {
             params,
             handlers: Object.values(handlers),
             errorHandlers: Object.values(errorHandlers),
         };
-        this.cache.set(key, result);
-        return result;
+        this.cache.set(key, value);
+
+        return value;
     }
 }
 exports.Router = Router;

package/src/util.js

@@ -1,11 +1,9 @@
-const URL_REGEX = /^([^?#]*)(\?([^#]*))?(#.*)?$/;
-const QUERY_STRING_REGEX = /([^=&]*)?=([^&]*)?/g;
-
 function decodeQueryParam(encoded) {
+    const normalize = encoded.replace(/\+/g, " ");
     try {
-        return decodeURIComponent(encoded.replace(/\+/g, " "));
+        return decodeURIComponent(normalize);
     } catch (error) {
-        return encoded;
+        return normalize;
     }
 }
 exports.decodeQueryParam = decodeQueryParam;
@@ -17,26 +15,32 @@ function decodePathParam(encoded) {
         return encoded;
     }
 }
-exports.decodePathParam=decodePathParam
+
+exports.decodePathParam = decodePathParam;
 
 function parseQueryString(queryString) {
-    const result = Object.create(null);
+    const query = Object.create(null);
+    if (!queryString) return query;
+    const regex = /([^=&]*)?=([^&]*)?/g;
     let match;
-    while ((match = QUERY_STRING_REGEX.exec(queryString)) !== null) {
+    while ((match = regex.exec(queryString))) {
         const [, rawName = "", rawValue = ""] = match;
         const name = decodeQueryParam(rawName);
         const value = decodeQueryParam(rawValue);
-        if (Object.hasOwn(result, name)) {
-            if (Array.isArray(result[name])) result[name].push(value);
-            else result[name] = [result[name], value];
-        } else result[name] = value;
+        if (Object.hasOwn(query, name)) {
+            if (Array.isArray(query[name])) query[name].push(value);
+            else query[name] = [query[name], value];
+        } else {
+            query[name] = value;
+        }
     }
-    return result;
+    return query;
 }
 exports.parseQueryString = parseQueryString;
 
 function parseUrl(url) {
-    const [, rawPath = "", , queryString = ""] = URL_REGEX.exec(url);
-    return { path: rawPath || "/", queryString };
+    const regex = /^([^?#]*)(\?([^#]*))?(#.*)?$/;
+    const [, path = "/", , queryString = ""] = regex.exec(url);
+    return { path: path || "/", queryString };
 }
 exports.parseUrl = parseUrl;

package/src/pattern.js

@@ -1,34 +0,0 @@
-/**
- * @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;