@esportsplus/routing 0.1.32 → 0.2.1

package/bench/index.mjs

@@ -0,0 +1,217 @@
+import { performance } from 'node:perf_hooks';
+import routerFactory from '../build/router/index.js';
+
+function fmt(n) {
+  return new Intl.NumberFormat('en-US').format(n);
+}
+
+function timeit(fn, durationMs = 1000) {
+  // Warmup
+  for (let i = 0; i < 5_000; i++) fn();
+
+  const end = performance.now() + durationMs;
+  let count = 0;
+  while (performance.now() < end) {
+    fn();
+    count++;
+  }
+  return count * (1000 / durationMs);
+}
+
+function buildStaticPaths(length, count) {
+  const paths = new Array(count);
+  for (let i = 0; i < count; i++) {
+    const id = i.toString(36).padStart(3, '0');
+    paths[i] = '/a'.repeat(length) + '/' + id;
+  }
+  return paths;
+}
+
+function buildDynamicPaths(length, count) {
+  // Route patterns
+  const patterns = new Array(count);
+  for (let i = 0; i < count; i++) {
+    patterns[i] = '/a'.repeat(length) + '/:id';
+  }
+  return patterns;
+}
+
+function buildDynamicTestPaths(length, count) {
+  // Concrete paths to match against dynamic patterns
+  const paths = new Array(count);
+  for (let i = 0; i < count; i++) {
+    const id = i.toString(36).padStart(3, '0');
+    paths[i] = '/a'.repeat(length) + '/' + id;
+  }
+  return paths;
+}
+
+function buildWildcardPatterns(length, count) {
+  // Unique patterns: /a.../<token>/*:rest
+  const patterns = new Array(count);
+  for (let i = 0; i < count; i++) {
+    const token = i.toString(36);
+    patterns[i] = '/a'.repeat(length) + '/' + token + '/*:rest';
+  }
+  return patterns;
+}
+
+function buildWildcardTestPaths(length, count, tailSegments = 4) {
+  // Concrete paths that should match the wildcard patterns above
+  const paths = new Array(count);
+  const tail = Array.from({ length: tailSegments }, (_, j) => 'x' + j).join('/');
+  for (let i = 0; i < count; i++) {
+    const token = i.toString(36);
+    paths[i] = '/a'.repeat(length) + '/' + token + '/' + tail;
+  }
+  return paths;
+}
+
+function buildOptionalPatterns(baseLen, optionalCount, count) {
+  // Unique patterns: /a.../<token>?:p1?:p2?...?:pN
+  const patterns = new Array(count);
+  for (let i = 0; i < count; i++) {
+    const token = i.toString(36);
+    let p = '/a'.repeat(baseLen) + '/' + token;
+    for (let k = 1; k <= optionalCount; k++) {
+      p += '?:p' + k;
+    }
+    patterns[i] = p;
+  }
+  return patterns;
+}
+
+function buildOptionalTestPaths(baseLen, optionalCount, count) {
+  // Concrete paths using the max number of optionals to exercise the longest route
+  const paths = new Array(count);
+  for (let i = 0; i < count; i++) {
+    const token = i.toString(36);
+    let p = '/a'.repeat(baseLen) + '/' + token;
+    for (let k = 1; k <= optionalCount; k++) {
+      p += '/' + 'v' + k;
+    }
+    paths[i] = p;
+  }
+  return paths;
+}
+
+function benchAdd(paths, { dynamic = false, resetEvery = 25000, uniquePath } = {}) {
+  let router = routerFactory();
+  const resp = (req) => 1;
+  let k = 0;
+  let unique = 0;
+
+  return timeit(() => {
+    // Generate a unique path to avoid duplicate key errors
+    const base = paths[k++ % paths.length];
+    const path = uniquePath
+      ? uniquePath(base, unique++)
+      : (dynamic ? (base + '/x' + (unique++)) : (base + '-' + (unique++)));
+    router.get({ path, responder: resp });
+
+    // Periodically reset to keep memory bounded
+    if (unique % resetEvery === 0) {
+      router = routerFactory();
+    }
+  });
+}
+
+function benchMatch(router, paths, { method = 'GET' } = {}) {
+  let k = 0;
+  return timeit(() => {
+    const path = paths[k++ % paths.length];
+    const { route } = router.match(method, path);
+    if (!route) throw new Error('route not found');
+  });
+}
+
+function prepareRouterStatic(paths) {
+  const router = routerFactory();
+  const resp = (req) => 1;
+  for (const p of paths) router.get({ path: p, responder: resp });
+  return router;
+}
+
+function prepareRouterDynamic(paths) {
+  const router = routerFactory();
+  const resp = (req) => 1;
+  for (const p of paths) router.get({ path: p, responder: resp });
+  return router;
+}
+
+function section(title) {
+  console.log('\n' + title);
+  console.log('-'.repeat(title.length));
+}
+
+(async function main() {
+  const lengths = [1, 2, 4, 8];
+  const poolSize = 1_000;
+
+  section('Add routes (ops/sec)');
+  for (const len of lengths) {
+    const staticPaths = buildStaticPaths(len, poolSize);
+    const dynamicPatterns = buildDynamicPaths(len, poolSize);
+
+    const addS = benchAdd(staticPaths);
+    const addD = benchAdd(dynamicPatterns, { dynamic: true });
+
+    console.log(`length=${len}  static_add=${fmt(addS)}  dynamic_add=${fmt(addD)}`);
+  }
+
+  section('Match routes (ops/sec)');
+  for (const len of lengths) {
+    const staticPaths = buildStaticPaths(len, poolSize);
+    const dynamicPatterns = buildDynamicPaths(len, poolSize);
+    const dynamicTestPaths = buildDynamicTestPaths(len, poolSize);
+
+    const routerS = prepareRouterStatic(staticPaths);
+    const routerD = prepareRouterDynamic(dynamicPatterns);
+
+    const matchS = benchMatch(routerS, staticPaths);
+    const matchD = benchMatch(routerD, dynamicTestPaths);
+
+    console.log(`length=${len}  static_match=${fmt(matchS)}  dynamic_match=${fmt(matchD)}`);
+  }
+
+  // Wildcard creation and matching
+  section('Wildcard routes (ops/sec)');
+  for (const len of lengths) {
+    const wildcardPatterns = buildWildcardPatterns(len, poolSize);
+    // For wildcard, uniqueness must be inserted before '/*:rest'
+    const addW = benchAdd(wildcardPatterns, {
+      dynamic: true,
+      uniquePath: (base, n) => {
+        const idx = base.indexOf('/*:rest');
+        return base.slice(0, idx) + '-u' + n + base.slice(idx);
+      },
+    });
+
+    const routerW = prepareRouterDynamic(wildcardPatterns);
+    const wildcardTests = buildWildcardTestPaths(len, poolSize, 8);
+    const matchW = benchMatch(routerW, wildcardTests);
+
+    console.log(`length=${len}  wildcard_add=${fmt(addW)}  wildcard_match=${fmt(matchW)}`);
+  }
+
+  // Optional parameter count scaling
+  section('Optional params scaling (ops/sec)');
+  const optionalCounts = [1, 2, 4, 8];
+  const baseLen = 2;
+  for (const nOpt of optionalCounts) {
+    const optPatterns = buildOptionalPatterns(baseLen, nOpt, poolSize);
+    const addO = benchAdd(optPatterns, {
+      dynamic: true,
+      uniquePath: (base, n) => {
+        const idx = base.indexOf('?:');
+        return idx === -1 ? (base + '-u' + n) : (base.slice(0, idx) + '-u' + n + base.slice(idx));
+      }
+    });
+
+    const routerO = prepareRouterDynamic(optPatterns);
+    const optTests = buildOptionalTestPaths(baseLen, nOpt, poolSize);
+    const matchO = benchMatch(routerO, optTests);
+
+    console.log(`optionals=${nOpt}  opt_add=${fmt(addO)}  opt_match=${fmt(matchO)}`);
+  }
+})();

package/build/browser.js

@@ -29,9 +29,9 @@ function href() {
 }
 function match(request, router, subdomain) {
     if (router.subdomains !== null) {
-        let subdomains = router.subdomains;
+        let hostname = request.hostname, subdomains = router.subdomains;
         for (let i = 0, n = subdomains.length; i < n; i++) {
-            if (!request.hostname.startsWith(subdomains[i])) {
+            if (!hostname.startsWith(subdomains[i])) {
                 continue;
             }
             subdomain = subdomains[i];

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,30 +1,31 @@
-import { ON_DELETE, ON_GET, ON_POST, ON_PUT, STATIC } from '../constants.js';
+import { ON_DELETE, ON_GET, ON_POST, ON_PUT } 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) {
         if (path[0] !== '/') {
             path = '/' + path;
         }
-        if (path.at(-1) === '/') {
+        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;
@@ -32,20 +33,23 @@ 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 (radixkey in this.static) {
-                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) {
+            if (path in bucket.static) {
+                throw new Error(`Routing: static path '${path}' is already in use`);
             }
-            this.static[radixkey] = route;
+            bucket.static[path] = route;
+        }
+        else {
+            bucket.root.add(path, route);
         }
         return this;
     }
@@ -84,44 +88,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 {};
         }
-        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, 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) {
-            let subdomain = route.subdomain.toLowerCase();
-            if (!this.subdomains) {
-                this.subdomains = [subdomain];
-            }
-            else {
-                this.subdomains.push(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,
-                    value: segments.slice(i).join('/')
+                    node: node.wildcard,
+                    start: i
                 };
             }
-            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] = segments.slice(wildcard.start).join('/');
         }
         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

@@ -3,7 +3,7 @@
   "dependencies": {
     "@esportsplus/pipeline": "^1.1.5",
     "@esportsplus/reactivity": "^0.12.4",
-    "@esportsplus/utilities": "^0.21.1"
+    "@esportsplus/utilities": "^0.22.1"
   },
   "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.32",
+  "version": "0.2.1",
   "scripts": {
     "build": "tsc && tsc-alias",
-    "-": "-"
+    "-": "-",
+    "bench": "node bench/index.mjs"
   }
 }

package/src/browser.ts

@@ -44,10 +44,11 @@ function href<T>() {
 
 function match<T>(request: Request<T>, router: Router<T>, subdomain?: string) {
     if (router.subdomains !== null) {
-        let subdomains = router.subdomains;
+        let hostname = request.hostname,
+            subdomains = router.subdomains;
 
         for (let i = 0, n = subdomains.length; i < n; i++) {
-            if (!request.hostname.startsWith(subdomains[i])) {
+            if (!hostname.startsWith(subdomains[i])) {
                 continue;
             }
 

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,16 +1,20 @@
-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 } 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) {
         if (path[0] !== '/') {
             path = '/' + path;
         }
 
-        if (path.at(-1) === '/') {
+        if (path.length > 1 && path[path.length - 1] === '/') {
             path = path.slice(0, -1);
         }
     }
@@ -18,21 +22,19 @@ function normalize(path: string) {
     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
@@ -43,25 +45,27 @@ 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 (radixkey in this.static) {
-                throw new Error(`Routing: static path '${radixkey}' is already in use`);
+        if (path.indexOf(':') === -1) {
+            if (path in bucket.static) {
+                throw new Error(`Routing: static path '${path}' is already in use`);
             }
 
-            this.static[radixkey] = route;
+            bucket.static[path] = route;
+        }
+        else {
+            bucket.root.add(path, route);
         }
 
         return this;
@@ -113,55 +117,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 (key.indexOf('?:') !== -1) {
-                    let segments = key.split('?:'),
-                        url = '';
+                if (path.indexOf('?:') !== -1) {
+                    let segments = path.split('?:'),
+                        url = segments[0];
 
-                    for (let i = 0, n = segments.length; i < n; i++) {
-                        this.add((url += (i > 0 ? '/:' : '/') + segments[i]), route);
+                    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) {
-            let subdomain = route.subdomain.toLowerCase();
-
-            if (!this.subdomains) {
-                this.subdomains = [subdomain];
-            }
-            else {
-                this.subdomains.push(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];
+            // Parameter
+            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
+            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>, start: number } | 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,
-                    value: segments.slice(i).join('/')
+                    node: node.wildcard,
+                    start: i
                 };
             }
 
-            // 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! ] = segments.slice(wildcard.start).join('/');
         }
 
         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();
-};