@esportsplus/routing 0.1.31 → 0.2.0

package/build/browser.js

@@ -1,7 +1,7 @@
 import { effect, reactive, root } from '@esportsplus/reactivity';
 import { next } from '@esportsplus/pipeline';
 import factory from './router/index.js';
-let cache = [];
+let cache = [], location = window.location;
 function back() {
     window.history.back();
 }
@@ -9,30 +9,32 @@ function forward() {
     window.history.forward();
 }
 function href() {
-    let data = new URL(window.location?.href || ''), path = data.hash ? data.hash.slice(1).split('?') : ['/', ''], request = {
-        href: data.href,
-        hostname: data.hostname,
+    let hash = location.hash || '#/', path = hash ? hash.slice(1).split('?') : ['/', ''], request = {
+        href: location.href,
+        hostname: location.hostname,
         method: 'GET',
-        origin: data.origin,
+        origin: location.origin,
         path: path[0],
-        port: data.port,
-        protocol: data.protocol,
+        port: location.port,
+        protocol: location.protocol,
         query: {}
     };
     if (path[1]) {
-        for (let [key, value] of (new URLSearchParams(path[1])).entries()) {
-            request.query[key] = value;
+        let query = request.query, params = new URLSearchParams(path[1]);
+        for (let [key, value] of params.entries()) {
+            query[key] = value;
         }
     }
     return request;
 }
 function match(request, router, subdomain) {
     if (router.subdomains !== null) {
-        for (let i = 0, n = router.subdomains.length; i < n; i++) {
-            if (!request.hostname.startsWith(router.subdomains[i])) {
+        let hostname = request.hostname, subdomains = router.subdomains;
+        for (let i = 0, n = subdomains.length; i < n; i++) {
+            if (!hostname.startsWith(subdomains[i])) {
                 continue;
             }
-            subdomain = router.subdomains[i];
+            subdomain = subdomains[i];
             break;
         }
     }

package/build/constants.d.ts

@@ -2,7 +2,7 @@ declare const ON_DELETE: string[];
 declare const ON_GET: string[];
 declare const ON_POST: string[];
 declare const ON_PUT: string[];
-declare const PLACEHOLDER = 0;
+declare const PARAMETER = 0;
 declare const STATIC = 1;
 declare const WILDCARD = 2;
-export { ON_DELETE, ON_GET, ON_POST, ON_PUT, PLACEHOLDER, STATIC, WILDCARD };
+export { ON_DELETE, ON_GET, ON_POST, ON_PUT, PARAMETER, STATIC, WILDCARD };

package/build/constants.js

@@ -2,7 +2,7 @@ const ON_DELETE = ['DELETE'];
 const ON_GET = ['GET'];
 const ON_POST = ['POST'];
 const ON_PUT = ['PUT'];
-const PLACEHOLDER = 0;
+const PARAMETER = 0;
 const STATIC = 1;
 const WILDCARD = 2;
-export { ON_DELETE, ON_GET, ON_POST, ON_PUT, PLACEHOLDER, STATIC, WILDCARD };
+export { ON_DELETE, ON_GET, ON_POST, ON_PUT, PARAMETER, STATIC, WILDCARD };

package/build/index.d.ts

@@ -1,4 +1,3 @@
 export { default as browser } from './browser.js';
 export { default as router } from './router/index.js';
-export { default as slugify } from './slugify.js';
 export * from './types.js';

package/build/index.js

@@ -1,4 +1,3 @@
 export { default as browser } from './browser.js';
 export { default as router } from './router/index.js';
-export { default as slugify } from './slugify.js';
 export * from './types.js';

package/build/router/index.d.ts

@@ -1,12 +1,14 @@
 import { Name, Options, Route, RouteOptions } from '../types.js';
 import { Node } from './node.js';
+declare function key(method: string, subdomain?: string | null): string;
 declare class Router<T> {
+    bucket: Record<ReturnType<typeof key>, {
+        root: Node<T>;
+        static: Record<string, Route<T>>;
+    }>;
     groups: Options<T>[];
-    root: Node<T>;
     routes: Record<Name, Route<T>>;
-    static: Record<Name, Route<T>>;
     subdomains: string[] | null;
-    constructor();
     private add;
     private route;
     delete(options: RouteOptions<T>): this;

package/build/router/index.js

@@ -1,28 +1,31 @@
 import { ON_DELETE, ON_GET, ON_POST, ON_PUT, STATIC } from '../constants.js';
 import { Node } from './node.js';
 import pipeline from '@esportsplus/pipeline';
+function key(method, subdomain) {
+    return (method + (subdomain ? subdomain + ' ' : '')).toUpperCase();
+}
 function normalize(path) {
-    if (path[0] !== '/') {
-        path = '/' + path;
-    }
-    if (path.at(-1) === '/') {
-        path = path.slice(0, -1);
+    if (path) {
+        if (path[0] !== '/') {
+            path = '/' + path;
+        }
+        if (path.length > 1 && path[path.length - 1] === '/') {
+            path = path.slice(0, -1);
+        }
     }
     return path || '/';
 }
-function radixkey(method, path, subdomain) {
-    return ((subdomain ? subdomain + ' ' : '') + method).toUpperCase() + ' ' + normalize(path);
-}
 function set(route, options) {
+    let pipeline = route.pipeline;
     for (let key in options) {
         let value = options[key];
         if (key === 'middleware') {
             for (let i = 0, n = value.length; i < n; i++) {
-                route.pipeline.add(value[i]);
+                pipeline.add(value[i]);
             }
         }
         else if (key === 'responder') {
-            route.pipeline.add(value);
+            pipeline.add(value);
         }
         else {
             route[key] = (route[key] || '') + value;
@@ -30,20 +33,20 @@ function set(route, options) {
     }
 }
 class Router {
+    bucket = {};
     groups = [];
-    root;
     routes = {};
-    static = {};
     subdomains = null;
-    constructor() {
-        this.root = new Node();
-    }
-    add(radixkey, route) {
-        if (radixkey.indexOf(':') === -1 || this.root.add(radixkey, route).type === STATIC) {
-            if (this.static[radixkey]) {
-                throw new Error(`Routing: static path '${radixkey}' is already in use`);
+    add(method, path, route) {
+        let bucket = this.bucket[key(method, route.subdomain)] ??= {
+            root: new Node(),
+            static: {}
+        };
+        if (path.indexOf(':') === -1 || bucket.root.add(path, route).type === STATIC) {
+            if (path in bucket.static) {
+                throw new Error(`Routing: static path '${path}' is already in use`);
             }
-            this.static[radixkey] = route;
+            bucket.static[path] = route;
         }
         return this;
     }
@@ -82,43 +85,43 @@ class Router {
         };
     }
     match(method, path, subdomain) {
-        let key = radixkey(method, path, subdomain);
-        if (key in this.static) {
-            return {
-                route: this.static[key]
-            };
+        let bucket = this.bucket[key(method, subdomain)];
+        if (!bucket) {
+            return {};
+        }
+        path = normalize(path);
+        if (path in bucket.static) {
+            return { route: bucket.static[path] };
         }
-        return this.root.find(key);
+        return bucket.root.find(path);
     }
     on(methods, options) {
         let route = this.route(options);
-        if (route.name) {
-            if (this.routes[route.name]) {
-                throw new Error(`Routing: '${route.name}' is already in use`);
+        let name = route.name, path = route.path, subdomain = route.subdomain;
+        if (name) {
+            if (this.routes[name]) {
+                throw new Error(`Routing: '${name}' is already in use`);
             }
-            this.routes[route.name] = route;
+            this.routes[name] = route;
         }
-        if (route.path) {
+        if (path) {
             for (let i = 0, n = methods.length; i < n; i++) {
-                let key = radixkey(methods[i], route.path, route.subdomain);
-                if (key.indexOf('?:') !== -1) {
-                    let segments = key.split('?:'), url = '';
-                    for (let i = 0, n = segments.length; i < n; i++) {
-                        this.add((url += (i > 0 ? '/:' : '/') + segments[i]), route);
+                let method = methods[i];
+                if (path.indexOf('?:') !== -1) {
+                    let segments = path.split('?:'), url = segments[0];
+                    this.add(method, url, route);
+                    for (let i = 1; i < segments.length; i++) {
+                        url += '/:' + segments[i];
+                        this.add(method, url, route);
                     }
                 }
                 else {
-                    this.add(key, route);
+                    this.add(method, path, route);
                 }
             }
         }
-        if (route.subdomain) {
-            if (!this.subdomains) {
-                this.subdomains = [route.subdomain];
-            }
-            else {
-                this.subdomains.push(route.subdomain);
-            }
+        if (subdomain) {
+            (this.subdomains ??= []).push(subdomain.toLowerCase());
         }
         return this;
     }

package/build/router/node.d.ts

@@ -1,17 +1,18 @@
 import { Route } from './index.js';
 declare class Node<T> {
-    children: Map<string | number, Node<T>> | null;
     parent: Node<T> | null;
     path: string | null;
-    property: string | null;
     route: Route<T> | null;
+    static: Map<string | number, Node<T>> | null;
     type: number | null;
+    name: string | null;
+    parameter: Node<T> | null;
+    wildcard: Node<T> | null;
     constructor(parent?: Node<T>['parent']);
     add(path: string, route: Route<T>): Node<T>;
     find(path: string): {
         parameters?: Readonly<Record<PropertyKey, unknown>>;
         route?: Readonly<Route<T>>;
     };
-    remove(path: string): void;
 }
 export { Node };

package/build/router/node.js

@@ -1,36 +1,44 @@
-import { PLACEHOLDER, STATIC, WILDCARD } from '../constants.js';
+import { PARAMETER, STATIC, WILDCARD } from '../constants.js';
 class Node {
-    children = null;
     parent = null;
     path = null;
-    property = null;
     route = null;
+    static = null;
     type = null;
+    name = null;
+    parameter = null;
+    wildcard = null;
     constructor(parent = null) {
         this.parent = parent;
     }
     add(path, route) {
         let node = this, segments = path.split('/'), type = STATIC, unnamed = 0;
         for (let i = 0, n = segments.length; i < n; i++) {
-            let child = node.children?.get(segments[i]);
-            if (!child) {
-                let segment = segments[i], symbol = segment[0];
-                if (!node.children) {
-                    node.children = new Map();
+            let segment = segments[i], symbol = segment[0];
+            if (symbol === ':') {
+                if (!node.parameter) {
+                    node.parameter = new Node(node);
+                    node.parameter.name = (segment.slice(1) || unnamed++).toString();
                 }
-                node.children.set(segment, (child = new Node(node)));
-                if (symbol === ':') {
-                    child.property = (segment.slice(1) || unnamed++).toString();
-                    node.children.set(PLACEHOLDER, child);
-                    type = null;
+                node = node.parameter;
+                type = PARAMETER;
+            }
+            else if (symbol === '*') {
+                if (!node.wildcard) {
+                    node.wildcard = new Node(node);
+                    node.wildcard.name = (segment.slice(2) || unnamed++).toString();
                 }
-                else if (symbol === '*') {
-                    child.property = (segment.slice(2) || unnamed++).toString();
-                    node.children.set(WILDCARD, child);
-                    type = null;
+                node = node.wildcard;
+                type = WILDCARD;
+            }
+            else {
+                let next = node.static?.get(segment);
+                if (!next) {
+                    next = new Node(node);
+                    (node.static ??= new Map()).set(segment, next);
                 }
+                node = next;
             }
-            node = child;
         }
         node.path = path;
         node.route = route;
@@ -38,56 +46,35 @@ class Node {
         return node;
     }
     find(path) {
-        let node = this, parameters = {}, segments = path.split('/'), wildcard = null;
+        let node = this, parameters, segments = path.split('/'), wildcard;
         for (let i = 0, n = segments.length; i < n; i++) {
-            let segment = segments[i], wc = node.children?.get(WILDCARD);
-            if (wc) {
+            let segment = segments[i];
+            if (node.wildcard) {
                 wildcard = {
-                    node: wc,
+                    node: node.wildcard,
                     value: segments.slice(i).join('/')
                 };
             }
-            let next = node.children?.get(segment);
+            let next = node.static?.get(segment);
             if (next) {
                 node = next;
+                continue;
             }
-            else {
-                node = node.children?.get(PLACEHOLDER);
-                if (!node) {
-                    break;
-                }
-                parameters[node.property] = segment;
+            if (!node.parameter) {
+                node = undefined;
+                break;
             }
+            node = node.parameter;
+            (parameters ??= {})[node.name] = segment;
         }
-        if ((node === undefined || node.route === null) && wildcard !== null) {
+        if ((node === undefined || node.route === null) && wildcard) {
             node = wildcard.node;
-            parameters[node.property] = wildcard.value;
-        }
-        if (!node) {
-            return {};
+            (parameters ??= {})[node.name] = wildcard.value;
         }
         return {
             parameters,
-            route: node.route
+            route: node?.route || undefined
         };
     }
-    remove(path) {
-        let node = this, segments = path.split('/');
-        for (let i = 0, n = segments.length; i < n; i++) {
-            node = node.children?.get(segments[i]);
-            if (!node) {
-                return;
-            }
-        }
-        if (node.children?.size) {
-            return;
-        }
-        let parent = node.parent;
-        if (parent && parent.children) {
-            parent.children.delete(segments[segments.length - 1]);
-            parent.children.delete(WILDCARD);
-            parent.children.delete(PLACEHOLDER);
-        }
-    }
 }
 export { Node };

package/package.json

@@ -2,8 +2,8 @@
   "author": "ICJR",
   "dependencies": {
     "@esportsplus/pipeline": "^1.1.5",
-    "@esportsplus/reactivity": "^0.12.3",
-    "@esportsplus/utilities": "^0.21.1"
+    "@esportsplus/reactivity": "^0.12.4",
+    "@esportsplus/utilities": "^0.22.0"
   },
   "devDependencies": {
     "@esportsplus/typescript": "^0.9.2"
@@ -12,10 +12,12 @@
   "name": "@esportsplus/routing",
   "private": false,
   "type": "module",
+  "sideEffects": false,
   "types": "./build/index.d.ts",
-  "version": "0.1.31",
+  "version": "0.2.0",
   "scripts": {
     "build": "tsc && tsc-alias",
-    "-": "-"
+    "-": "-",
+    "bench": "node bench/index.mjs"
   }
 }

package/src/browser.ts

@@ -4,7 +4,8 @@ import { next } from '@esportsplus/pipeline';
 import factory from './router';
 
 
-let cache: Request<any>[] = [];
+let cache: Request<any>[] = [],
+    location = window.location;
 
 
 function back() {
@@ -16,22 +17,25 @@ function forward() {
 }
 
 function href<T>() {
-    let data = new URL( window.location?.href || '' ),
-        path = data.hash ? data.hash.slice(1).split('?') : ['/', ''],
+    let hash = location.hash || '#/',
+        path = hash ? hash.slice(1).split('?') : ['/', ''],
         request = {
-            href: data.href,
-            hostname: data.hostname,
+            href: location.href,
+            hostname: location.hostname,
             method: 'GET',
-            origin: data.origin,
+            origin: location.origin,
             path: path[0],
-            port: data.port,
-            protocol: data.protocol,
+            port: location.port,
+            protocol: location.protocol,
             query: {} as Record<PropertyKey, unknown>
         };
 
     if (path[1]) {
-        for (let [key, value] of (new URLSearchParams(path[1])).entries()) {
-            request.query[key] = value;
+        let query = request.query,
+            params = new URLSearchParams(path[1]);
+
+        for (let [key, value] of params.entries()) {
+            query[key] = value;
         }
     }
 
@@ -40,12 +44,15 @@ function href<T>() {
 
 function match<T>(request: Request<T>, router: Router<T>, subdomain?: string) {
     if (router.subdomains !== null) {
-        for (let i = 0, n = router.subdomains.length; i < n; i++) {
-            if (!request.hostname.startsWith(router.subdomains[i])) {
+        let hostname = request.hostname,
+            subdomains = router.subdomains;
+
+        for (let i = 0, n = subdomains.length; i < n; i++) {
+            if (!hostname.startsWith(subdomains[i])) {
                 continue;
             }
 
-            subdomain = router.subdomains[i];
+            subdomain = subdomains[i];
             break;
         }
     }

package/src/constants.ts

@@ -7,11 +7,11 @@ const ON_POST = ['POST'];
 const ON_PUT = ['PUT'];
 
 
-const PLACEHOLDER = 0;
+const PARAMETER = 0;
 
 const STATIC = 1;
 
 const WILDCARD = 2;
 
 
-export { ON_DELETE, ON_GET, ON_POST, ON_PUT, PLACEHOLDER, STATIC, WILDCARD };
+export { ON_DELETE, ON_GET, ON_POST, ON_PUT, PARAMETER, STATIC, WILDCARD };

package/src/index.ts

@@ -1,4 +1,3 @@
 export { default as browser } from './browser';
 export { default as router } from './router';
-export { default as slugify } from './slugify';
 export * from './types';

package/src/router/index.ts

@@ -1,36 +1,40 @@
-import { ON_DELETE, ON_GET, ON_POST, ON_PUT, STATIC } from '~/constants';
-import { Name, Options, Request, Route, RouteOptions } from '~/types';
+import { ON_DELETE, ON_GET, ON_POST, ON_PUT, STATIC } from '../constants';
+import { Name, Options, Request, Route, RouteOptions } from '../types';
 import { Node } from './node';
 import pipeline from '@esportsplus/pipeline';
 
 
+function key(method: string, subdomain?: string | null) {
+    return (method + (subdomain ? subdomain + ' ' : '')).toUpperCase();
+}
+
 function normalize(path: string) {
-    if (path[0] !== '/') {
-        path = '/' + path;
-    }
+    if (path) {
+        if (path[0] !== '/') {
+            path = '/' + path;
+        }
 
-    if (path.at(-1) === '/') {
-        path = path.slice(0, -1);
+        if (path.length > 1 && path[path.length - 1] === '/') {
+            path = path.slice(0, -1);
+        }
     }
 
     return path || '/';
 }
 
-function radixkey(method: string, path: string, subdomain?: string | null) {
-    return ((subdomain ? subdomain + ' ' : '') + method).toUpperCase() + ' ' + normalize(path);
-}
-
 function set<T>(route: Route<T>, options: Options<T> | RouteOptions<T>) {
+    let pipeline = route.pipeline;
+
     for (let key in options) {
         let value = options[key as keyof typeof options] as any;
 
         if (key === 'middleware') {
             for (let i = 0, n = value.length; i < n; i++) {
-                route.pipeline.add(value[i]);
+                pipeline.add(value[i]);
             }
         }
         else if (key === 'responder') {
-            route.pipeline.add(value);
+            pipeline.add(value);
         }
         else {
             // @ts-ignore
@@ -41,25 +45,24 @@ function set<T>(route: Route<T>, options: Options<T> | RouteOptions<T>) {
 
 
 class Router<T> {
+    bucket: Record<ReturnType<typeof key>, { root: Node<T>, static: Record<string, Route<T>> }> = {};
     groups: Options<T>[] = [];
-    root: Node<T>;
     routes: Record<Name, Route<T>> = {};
-    static: Record<Name, Route<T>> = {};
     subdomains: string[] | null = null;
 
 
-    constructor() {
-        this.root = new Node();
-    }
-
+    private add(method: string, path: string, route: Route<T>) {
+        let bucket = this.bucket[ key(method, route.subdomain) ] ??= {
+                root: new Node(),
+                static: {}
+            };
 
-    private add(radixkey: string, route: Route<T>) {
-        if (radixkey.indexOf(':') === -1 || this.root.add(radixkey, route).type === STATIC) {
-            if (this.static[radixkey]) {
-                throw new Error(`Routing: static path '${radixkey}' is already in use`);
+        if (path.indexOf(':') === -1 || bucket.root.add(path, route).type === STATIC) {
+            if (path in bucket.static) {
+                throw new Error(`Routing: static path '${path}' is already in use`);
             }
 
-            this.static[radixkey] = route;
+            bucket.static[path] = route;
         }
 
         return this;
@@ -111,53 +114,59 @@ class Router<T> {
     }
 
     match(method: string, path: string, subdomain?: string | null) {
-        let key = radixkey(method, path, subdomain);
+        let bucket = this.bucket[ key(method, subdomain) ];
 
-        if (key in this.static) {
-            return {
-                route: this.static[key] as Readonly<Route<T>>
-            };
+        if (!bucket) {
+            return {};
         }
 
-        return this.root.find(key);
+        path = normalize(path);
+
+        if (path in bucket.static) {
+            return { route: bucket.static[path] };
+        }
+
+        return bucket.root.find(path);
     }
 
     on(methods: string[], options: RouteOptions<T>) {
         let route = this.route(options);
 
-        if (route.name) {
-            if (this.routes[route.name]) {
-                throw new Error(`Routing: '${route.name}' is already in use`);
+        let name = route.name,
+            path = route.path,
+            subdomain = route.subdomain;
+
+        if (name) {
+            if (this.routes[name]) {
+                throw new Error(`Routing: '${name}' is already in use`);
             }
 
-            this.routes[route.name] = route;
+            this.routes[name] = route;
         }
 
-        if (route.path) {
+        if (path) {
             for (let i = 0, n = methods.length; i < n; i++) {
-                let key = radixkey(methods[i], route.path, route.subdomain);
+                let method = methods[i];
+
+                if (path.indexOf('?:') !== -1) {
+                    let segments = path.split('?:'),
+                        url = segments[0];
 
-                if (key.indexOf('?:') !== -1) {
-                    let segments = key.split('?:'),
-                        url = '';
+                    this.add(method, url, route);
 
-                    for (let i = 0, n = segments.length; i < n; i++) {
-                        this.add((url += (i > 0 ? '/:' : '/') + segments[i]), route);
+                    for (let i = 1; i < segments.length; i++) {
+                        url += '/:' + segments[i];
+                        this.add(method, url, route);
                     }
                 }
                 else {
-                    this.add(key, route);
+                    this.add(method, path, route);
                 }
             }
         }
 
-        if (route.subdomain) {
-            if (!this.subdomains) {
-                this.subdomains = [route.subdomain];
-            }
-            else {
-                this.subdomains.push(route.subdomain);
-            }
+        if (subdomain) {
+            (this.subdomains ??= []).push( subdomain.toLowerCase() );
         }
 
         return this;

package/src/router/node.ts

@@ -1,15 +1,19 @@
-import { PLACEHOLDER, STATIC, WILDCARD } from '~/constants';
+import { PARAMETER, STATIC, WILDCARD } from '../constants';
 import { Route } from './index';
 
 
 class Node<T> {
-    children: Map<string | number, Node<T>> | null = null;
     parent: Node<T> | null = null;
     path: string | null = null;
-    property: string | null = null;
     route: Route<T> | null = null;
+    static: Map<string | number, Node<T>> | null = null;
     type: number | null = null;
 
+    // Parameter or Wildcard parameter name
+    name: string | null = null;
+    parameter: Node<T> | null = null;
+    wildcard: Node<T> | null = null;
+
 
     constructor(parent: Node<T>['parent'] = null) {
         this.parent = parent;
@@ -23,33 +27,40 @@ class Node<T> {
             unnamed = 0;
 
         for (let i = 0, n = segments.length; i < n; i++) {
-            let child: Node<T> | undefined = node.children?.get(segments[i]);
+            let segment = segments[i],
+                symbol = segment[0];
 
-            if (!child) {
-                let segment = segments[i],
-                    symbol = segment[0];
+            // Named name
+            if (symbol === ':') {
+                if (!node.parameter) {
+                    node.parameter = new Node<T>(node);
+                    node.parameter.name = (segment.slice(1) || unnamed++).toString();
+                }
 
-                if (!node.children) {
-                    node.children = new Map();
+                node = node.parameter;
+                type = PARAMETER;
+            }
+            // "*:" Wildcard name
+            else if (symbol === '*') {
+                if (!node.wildcard) {
+                    node.wildcard = new Node<T>(node);
+                    node.wildcard.name = (segment.slice(2) || unnamed++).toString();
                 }
 
-                node.children.set(segment, (child = new Node<T>(node)));
+                node = node.wildcard;
+                type = WILDCARD;
+            }
+            // Static name
+            else {
+                let next: Node<T> | undefined = node.static?.get(segment);
 
-                // Named property
-                if (symbol === ':') {
-                    child.property = (segment.slice(1) || unnamed++).toString();
-                    node.children.set(PLACEHOLDER, child);
-                    type = null;
+                if (!next) {
+                    next = new Node<T>(node);
+                    (node.static ??= new Map()).set(segment, next);
                 }
-                // "*:" Wildcard property
-                else if (symbol === '*') {
-                    child.property = (segment.slice(2) || unnamed++).toString();
-                    node.children.set(WILDCARD, child);
-                    type = null;
-                }
-            }
 
-            node = child;
+                node = next;
+            }
         }
 
         node.path = path;
@@ -64,77 +75,47 @@ class Node<T> {
         route?: Readonly<Route<T>>;
     } {
         let node: Node<T> | undefined = this,
-            parameters: Record<PropertyKey, unknown> = {},
+            parameters: Record<PropertyKey, unknown> | undefined,
             segments = path.split('/'),
-            wildcard: { node: Node<T>, value: string } | null = null;
+            wildcard: { node: Node<T>, value: string } | undefined;
 
         for (let i = 0, n = segments.length; i < n; i++) {
-            let segment = segments[i],
-                wc = node.children?.get(WILDCARD);
+            let segment = segments[i];
 
-            if (wc) {
+            if (node.wildcard) {
                 wildcard = {
-                    node: wc,
+                    node: node.wildcard,
                     value: segments.slice(i).join('/')
                 };
             }
 
-            // Exact matches take precedence over placeholders
-            let next: Node<T> | undefined = node.children?.get(segment);
+            // Exact matches take precedence over parameters
+            let next: Node<T> | undefined = node.static?.get(segment) as Node<T> | undefined;
 
             if (next) {
                 node = next;
+                continue;
             }
-            else {
-                node = node.children?.get(PLACEHOLDER);
 
-                if (!node) {
-                    break;
-                }
-
-                parameters[ node.property! ] = segment;
+            if (!node.parameter) {
+                node = undefined;
+                break;
             }
-        }
 
-        if ((node === undefined || node.route === null) && wildcard !== null) {
-            node = wildcard.node;
-            parameters[ node.property! ] = wildcard.value;
+            node = node.parameter;
+            (parameters ??= {})[node.name!] = segment;
         }
 
-        if (!node) {
-            return {};
+        if ((node === undefined || node.route === null) && wildcard) {
+            node = wildcard.node;
+            (parameters ??= {})[ node.name! ] = wildcard.value;
         }
 
         return {
             parameters,
-            route: node.route!
+            route: node?.route || undefined
         };
     }
-
-    remove(path: string) {
-        let node: Node<T> | undefined = this,
-            segments = path.split('/');
-
-        for (let i = 0, n = segments.length; i < n; i++) {
-            node = node.children?.get( segments[i] );
-
-            if (!node) {
-                return;
-            }
-        }
-
-        if (node.children?.size) {
-            return;
-        }
-
-        let parent = node.parent;
-
-        if (parent && parent.children) {
-            parent.children.delete( segments[segments.length - 1] );
-            parent.children.delete(WILDCARD);
-            parent.children.delete(PLACEHOLDER);
-        }
-    }
 }
 
 

package/src/types.ts

@@ -41,4 +41,9 @@ type RouteOptions<T> = Options<T> & {
 };
 
 
-export type { Middleware, Name, Next, Options, Request, Route, RouteOptions, Router };
+export type {
+    Middleware,
+    Name, Next,
+    Options,
+    Request, Route, RouteOptions, Router
+};

package/build/slugify.d.ts

@@ -1,2 +0,0 @@
-declare const _default: (value: string) => string;
-export default _default;

package/build/slugify.js

@@ -1,3 +0,0 @@
-export default (value) => {
-    return value.replace(/\W+/g, '-').replace(/[-]+$/, '').toLowerCase();
-};

package/src/slugify.ts

@@ -1,4 +0,0 @@
-// https://twitter.com/Swizec/status/1589416111971635201
-export default (value: string) => {
-    return value.replace(/\W+/g, '-').replace(/[-]+$/, '').toLowerCase();
-};