k99 0.6.0 → 0.7.0

package/index.cjs

@@ -1,6 +1,6 @@
 /*!
- * k99 v0.6.0
- * (c) 2019-2024 猛火Fierflame
+ * k99 v0.7.0
+ * (c) 2019-2025 猛火Fierflame
  * @license MIT
  */
 'use strict';
@@ -13,20 +13,6 @@
 function str2utf8bin(str) {
 	return new TextEncoder().encode(str);
 }
-/**
- *
- * @param {unknown} chunk
- * @returns {chunk is ArrayBuffer | SharedArrayBuffer}
- */
-function isBufferSource(chunk) {
-	if (chunk instanceof ArrayBuffer) { return true; }
-	try {
-		if (chunk instanceof SharedArrayBuffer) { return true; }
-	} catch {
-
-	}
-	return false;
-}
 /**
  *
  * @template T
@@ -51,7 +37,7 @@ async function write(writer, chunk) {
 	if (ArrayBuffer.isView(chunk)) {
 		return writer.write(new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength));
 	}
-	if (isBufferSource(chunk)) {
+	if (chunk instanceof ArrayBuffer) {
 		return writer.write(new Uint8Array(chunk));
 	}
 	if (!isIterable(chunk)) {
@@ -95,7 +81,7 @@ function toBodyData(result, aborted) {
 	if (result instanceof FormData) {
 		return [result, 0, ''];
 	}
-	if (ArrayBuffer.isView(result) || isBufferSource(result)) {
+	if (ArrayBuffer.isView(result) || result instanceof ArrayBuffer) {
 		return [result, result.byteLength, ''];
 	}
 	if (typeof result === 'string') {
@@ -120,8 +106,7 @@ function toBodyData(result, aborted) {
 			if (!data) { continue; }
 			await write(writer, data);
 		}
-		await writable.close();
-	})().catch(() => {});
+	})().then(() => writable.close(), r => writable.abort(r)).catch(() => {});
 	return [readable, 0, ''];
 }
 /**
@@ -144,11 +129,12 @@ function toBody(result, headers, aborted) {
 	return body;
 }
 
+/** @import { Cookie, CookieOption } from './types' */
 /**
  *
- * @param {import('./types').Cookie[]} sentCookies
+ * @param {Cookie[]} sentCookies
  * @param {string} [name]
- * @returns {Iterable<import('./types').Cookie>}
+ * @returns {Iterable<Cookie>}
  */
 function *getCookie(sentCookies, name) {
 	const list = sentCookies;
@@ -161,7 +147,7 @@ function *getCookie(sentCookies, name) {
 /**
  *
  * @param {Headers} headers
- * @param {import('./types').Cookie[]} cookies
+ * @param {Cookie[]} cookies
  * @returns {void}
  */
 function setCookiesHeader(headers, cookies) {
@@ -195,10 +181,10 @@ function getRequestCookies(cookie) {
 }
 /**
  *
- * @param {import('./types').Cookie[]} sentCookies
+ * @param {Cookie[]} sentCookies
  * @param {Record<string, string>} cookies
- * @param {string | import('./types').CookieOption} [name]
- * @param {import('./types').CookieOption | boolean} [opt]
+ * @param {string | CookieOption} [name]
+ * @param {CookieOption | boolean} [opt]
  * @returns {void}
  */
 function clearCookie(
@@ -210,11 +196,11 @@ function clearCookie(
 	let expire = 'Fri, 31 Dec 1999 16:00:00 GMT';
 	if (typeof name === 'string') {
 		if (!name) { return; }
-		/** @type {import('./types').CookieOption} */
+		/** @type {CookieOption} */
 		const { domain, path, secure, httpOnly } = opt !== true && opt || {};
 		sentCookies.push({ name, value: 'delete', expire, domain, path, secure, httpOnly });
 	} else {
-		/** @type {import('./types').CookieOption} */
+		/** @type {CookieOption} */
 		const { domain, path, secure, httpOnly } = name || {};
 		sentCookies.length = 0;
 		if (opt) {
@@ -225,6 +211,9 @@ function clearCookie(
 	}
 }
 
+/** @import { Context, Cookie, CookieOption, FindHandler, Method, Options, Params, Service } from './types' */
+
+
 const noBodyMethods = new Set(['GET', 'OPTIONS']);
 /**
  *
@@ -261,7 +250,7 @@ function setHeader(headers, name, value) {
  *
  * @param {Request} request
  * @param {string | ((request: Request) => string)} [toMethod]
- * @returns {import('./types').Method}
+ * @returns {Method}
  */
 function getMethod(request, toMethod) {
 	let methodStr = '';
@@ -273,13 +262,13 @@ function getMethod(request, toMethod) {
 	if (!methodStr || typeof methodStr !== 'string') {
 		methodStr = request.method || 'GET';
 	}
-	return /** @type {import('./types').Method} */(methodStr.toUpperCase());
+	return /** @type {Method} */(methodStr.toUpperCase());
 }
 /**
  *
  * @param {Request} request
- * @param {import('./types').FindHandler} getHandler
- * @param {import('./types').Options} [options]
+ * @param {FindHandler} getHandler
+ * @param {Options} [options]
  * @returns {Promise<Response | null>}
  */
 function main(
@@ -289,7 +278,7 @@ function main(
 	/**
 	 *
 	 * @param {Request} request
-	 * @param {import('./types').Context} [parent]
+	 * @param {Context} [parent]
 	 * @returns {Promise<Response | null>}
 	 */
 	function exec(request, parent) {
@@ -297,10 +286,10 @@ function main(
 		const url = new URL(request.url);
 		const { signal, headers } = request;
 		const aborted = signal2promise(signal);
-		/** @type {Map<import('./types').Service<any, any>, Function>} */
+		/** @type {Map<Service<any, any>, Function>} */
 		const services = new Map();
 		const cookies = getRequestCookies(headers.get('cookie') || '');
-		/** @type {import('./types').Cookie[]} */
+		/** @type {Cookie[]} */
 		const sentCookies = [];
 		const responseHeaders = new Headers();
 		const root = parent?.root;
@@ -316,9 +305,9 @@ function main(
 		const donePromise = new Promise((a, b) => { resolve = a; reject = b; });
 		donePromise.catch(() => {});
 
-		/** @type {any} */
+		/** @type {Params} */
 		let params = {};
-		/** @type {import('./types').Context} */
+		/** @type {Context} */
 		const context = {
 			environment,
 			parent,
@@ -382,8 +371,8 @@ function main(
 			},
 			/**
 			 *
-			 * @param {string | import('./types').CookieOption} [name]
-			 * @param {import('./types').CookieOption | boolean} [opt]
+			 * @param {string | CookieOption} [name]
+			 * @param {CookieOption | boolean} [opt]
 			 * @returns {void}
 			 */
 			clearCookie(name, opt) {
@@ -420,69 +409,72 @@ function main(
 	return exec(request);
 }
 
+/** @import { FindHandler, Options } from './main/types' */
+
 /**
  *
- * @param {import('./main/types').FindHandler} getHandler
- * @param {import('./main/types').Options} options
+ * @param {FindHandler} getHandler
+ * @param {Options} options
  * @returns {(request: Request) => Promise<Response | null>}
  */
 function make(getHandler, options) {
 	return r => main(r, getHandler, options);
 }
 
+/** @import { Context, Handler } from './main/types' */
 /**
  *
- * @param {import('./main/types').Context} context
- * @param {import('./main/types').Handler[]} handlers
+ * @param {Context} context
+ * @param {Handler[]} handlers
  * @returns {Promise<string | boolean | object | undefined>}
  */
 async function runHandles(context, handlers) {
 	for (const handle of handlers) {
 		const result = await handle(context);
-		if (typeof result === 'boolean') { return result; }
-		if (!result) { continue; }
+		if (result === undefined) { continue; }
 		return result;
 	}
 }
 
 /**
  *
- * @param  {...(import('./main/types').Handler | import('./main/types').Handler[])} handlers
- * @returns {import('./main/types').Handler}
+ * @param  {...(Handler | Handler[])} handlers
+ * @returns {Handler}
  */
 function merge(...handlers) {
 	return ctx => runHandles(ctx, handlers.flat());
 }
 
+/** @import { Context, Service } from './main/types' */
 /**
  *
  * @template T
  * @template {any[]} P
  * @overload
- * @param {(ctx: import('./main/types').Context, ...p: P) => T} exec
- * @param {((ctx: import('./main/types').Context, error?: unknown) => PromiseLike<void> | void)?} [destroy]
- * @param {import('./main/types').Service.Options?} [options]
- * @returns {import('./main/types').Service<T, P>}
+ * @param {(ctx: Context, ...p: P) => T} exec
+ * @param {((ctx: Context, error?: unknown) => PromiseLike<void> | void)?} [destroy]
+ * @param {Service.Options?} [options]
+ * @returns {Service<T, P>}
  */
 /**
  *
  * @template T
  * @template {any[]} P
  * @overload
- * @param {(ctx: import('./main/types').Context, ...p: P) => T} exec
- * @param {import('./main/types').Service.Options?} [options]
- * @returns {import('./main/types').Service<T, P>}
+ * @param {(ctx: Context, ...p: P) => T} exec
+ * @param {Service.Options?} [options]
+ * @returns {Service<T, P>}
  */
 /**
  * @template T
  * @template {any[]} P
- * @param {(ctx: import('./main/types').Context, ...p: P) => T} exec
- * @param {((ctx: import('./main/types').Context, error?: unknown) => PromiseLike<void> | void) | import('./main/types').Service.Options | null} [destroy]
- * @param {import('./main/types').Service.Options?} [options]
- * @returns {import('./main/types').Service<T, P>}
+ * @param {(ctx: Context, ...p: P) => T} exec
+ * @param {((ctx: Context, error?: unknown) => PromiseLike<void> | void) | Service.Options | null} [destroy]
+ * @param {Service.Options?} [options]
+ * @returns {Service<T, P>}
  */
 function service(exec, destroy, options) {
-	/** @type {import('./main/types').Service<T, P>} */
+	/** @type {Service<T, P>} */
 	const service = function (ctx) {
 		if (typeof destroy === 'function') {
 			ctx.done(() => destroy(ctx), error => destroy(ctx, error));
@@ -501,43 +493,44 @@ function service(exec, destroy, options) {
 	return service;
 }
 
+/** @import { Context, Service, StateService } from './main/types' */
 /**
  *
  * @template T
  * @overload
- * @param {(ctx: import('./main/types').Context) => T} init
- * @param {import('./main/types').Service.Options} [options]
- * @returns {import('./main/types').StateService<T>}
+ * @param {(ctx: Context) => T} init
+ * @param {Service.Options} [options]
+ * @returns {StateService<T>}
  */
 /**
  *
  * @template T
  * @overload
- * @param {(ctx: import('./main/types').Context) => T} init
- * @param {((state: T | undefined, ctx: import('./main/types').Context, error?: unknown) => PromiseLike<void> | void)?} [destroy]
- * @param {import('./main/types').Service.Options?} [options]
- * @returns {import('./main/types').StateService<T>}
+ * @param {(ctx: Context) => T} init
+ * @param {((state: T | undefined, ctx: Context, error?: unknown) => PromiseLike<void> | void)?} [destroy]
+ * @param {Service.Options?} [options]
+ * @returns {StateService<T>}
  */
 /**
  *
  * @template T
  * @overload
- * @param {(ctx: import('./main/types').Context) => T} init
- * @param {((state: T | undefined, ctx: import('./main/types').Context, error?: unknown) => PromiseLike<void> | void)?} [destroy]
- * @param {((state: T, ctx: import('./main/types').Context) => any)?} [exec]
- * @param {import('./main/types').Service.Options?} [options]
- * @returns {import('./main/types').StateService<T>}
+ * @param {(ctx: Context) => T} init
+ * @param {((state: T | undefined, ctx: Context, error?: unknown) => PromiseLike<void> | void)?} [destroy]
+ * @param {((state: T, ctx: Context) => any)?} [exec]
+ * @param {Service.Options?} [options]
+ * @returns {StateService<T>}
  */
 /**
  * @template T
- * @param {(ctx: import('./main/types').Context) => T} init
- * @param {((state: T | undefined, ctx: import('./main/types').Context, error?: unknown) => PromiseLike<void> | void) | import('./main/types').Service.Options | null} [destroy]
- * @param {((state: T, ctx: import('./main/types').Context) => any) | import('./main/types').Service.Options | null} [exec]
- * @param {import('./main/types').Service.Options?} [options]
- * @returns {import('./main/types').StateService<T>}
+ * @param {(ctx: Context) => T} init
+ * @param {((state: T | undefined, ctx: Context, error?: unknown) => PromiseLike<void> | void) | Service.Options | null} [destroy]
+ * @param {((state: T, ctx: Context) => any) | Service.Options | null} [exec]
+ * @param {Service.Options?} [options]
+ * @returns {StateService<T>}
  */
 function stateService(init, destroy, exec, options) {
-	/** @type {import('./main/types').StateService<T>} */
+	/** @type {StateService<T>} */
 	const service = function (ctx) {
 		const state = init(ctx) || /** @type {T} */({});
 		if (typeof destroy === 'function') {
@@ -561,39 +554,40 @@ function stateService(init, destroy, exec, options) {
 	return service;
 }
 
+/** @import { Context, Service, StoreService } from './main/types' */
 /**
  *
  * @template T
  * @overload
- * @param {import('./main/types').Service.Options?} [options]
- * @returns {import('./main/types').StoreService<T>}
+ * @param {Service.Options?} [options]
+ * @returns {StoreService<T>}
  */
 /**
  *
  * @template T
  * @overload
- * @param {((state: T | undefined, ctx: import('./main/types').Context, error?: unknown) => PromiseLike<void> | void)?} [destroy]
- * @param {import('./main/types').Service.Options?} [options]
- * @returns {import('./main/types').StoreService<T>}
+ * @param {((state: T | undefined, ctx: Context, error?: unknown) => PromiseLike<void> | void)?} [destroy]
+ * @param {Service.Options?} [options]
+ * @returns {StoreService<T>}
  */
 /**
  *
  * @template T
  * @overload
- * @param {((state: T | undefined, ctx: import('./main/types').Context, error?: unknown) => PromiseLike<void> | void)?} [destroy]
- * @param {((state: T | undefined, ctx: import('./main/types').Context) => any)?} [exec]
- * @param {import('./main/types').Service.Options?} [options]
- * @returns {import('./main/types').StoreService<T>}
+ * @param {((state: T | undefined, ctx: Context, error?: unknown) => PromiseLike<void> | void)?} [destroy]
+ * @param {((state: T | undefined, ctx: Context) => any)?} [exec]
+ * @param {Service.Options?} [options]
+ * @returns {StoreService<T>}
  */
 /**
  * @template T
- * @param {((state: T | undefined, ctx: import('./main/types').Context, error?: unknown) => PromiseLike<void> | void) | import('./main/types').Service.Options | null} [destroy]
- * @param {((state: T | undefined, ctx: import('./main/types').Context) => any) | import('./main/types').Service.Options | null} [exec]
- * @param {import('./main/types').Service.Options?} [options]
- * @returns {import('./main/types').StoreService<T>}
+ * @param {((state: T | undefined, ctx: Context, error?: unknown) => PromiseLike<void> | void) | Service.Options | null} [destroy]
+ * @param {((state: T | undefined, ctx: Context) => any) | Service.Options | null} [exec]
+ * @param {Service.Options?} [options]
+ * @returns {StoreService<T>}
  */
 function storeService(destroy, exec, options) {
-	/** @type {import('./main/types').StoreService<T>} */
+	/** @type {StoreService<T>} */
 	const service = function (ctx) {
 		/** @type {T | undefined} */
 		let state;
@@ -630,16 +624,18 @@ function storeService(destroy, exec, options) {
 	return service;
 }
 
+/** @import { Handler } from './main/types' */
+/** @import { Onionskin } from './onionskin.mjs' */
 /**
  * @callback Packer
- * @param {import('./main/types').Handler} handler
- * @returns {import('./main/types').Handler}
+ * @param {Handler} handler
+ * @returns {Handler}
  */
 /** @type {Packer} */
 const noop$1 = h => h;
 /**
  *
- * @param {import('./onionskin.mjs').Onionskin} onionskin
+ * @param {Onionskin} onionskin
  * @param {Packer} [packer]
  * @returns {Packer}
  */
@@ -650,30 +646,33 @@ function packer(onionskin, packer = noop$1) {
 	};
 }
 
+/** @import { Context, FindHandler, Handler, Method, Params } from './main/types' */
+/** @import { Onionskin } from './onionskin.mjs' */
+
 /**
  * @callback Guard
- * @param {import('./main/types').Context} ctx
- * @returns {PromiseLike<boolean | import('./main/types').Handler | void> | boolean | import('./main/types').Handler | void}
+ * @param {Context} ctx
+ * @returns {PromiseLike<boolean | Handler | void> | boolean | Handler | void}
  */
 /**
- * @typedef {[import('./main/types').Handler | Router, Record<string, any>, string[]]} FindItem
+ * @typedef {[Handler | Router, Record<string | symbol, any>, string[]]} FindItem
  */
 /**
  * @callback Finder
  * @this {Router}
- * @param {import('./main/types').Method} method
+ * @param {Method} method
  * @param {string[]} path
- * @param {import('./main/types').Context} ctx 
+ * @param {Context} ctx 
  * @returns {AsyncIterable<FindItem> | Iterable<FindItem>}
  */
 
 /**
  * 
  * @param {Set<Guard>} guards 
- * @param {import('./main/types').Context} ctx 
+ * @param {Context} ctx 
  * @param {(v: any) => void} setParams 
  * @param {object} params 
- * @returns {Promise<boolean | import('./main/types').Handler>}
+ * @returns {Promise<boolean | Handler>}
  */
 async function execGuard(guards, ctx, setParams, params) {
 	if (!guards.size) { return true; }
@@ -692,12 +691,12 @@ async function execGuard(guards, ctx, setParams, params) {
 
 /**
  * 
- * @param {Router | import('./main/types').Handler} route 
+ * @param {Router | Handler} route 
  * @param {string[]} path 
- * @param {import('./main/types').Context} ctx 
- * @param {(v: any) => void} setParams 
- * @param {object} params 
- * @returns {Promise<import('./main/types').Handler | null>}
+ * @param {Context} ctx 
+ * @param {(v: Params) => void} setParams 
+ * @param {Params} params 
+ * @returns {Promise<Handler | null>}
  */
 async function find(route, path, ctx, setParams, params) {
 	if (!(route instanceof Router)) {
@@ -736,16 +735,16 @@ class Router {
 	disabled = false;
 	/**
 	 * @abstract
-	 * @param {import('./main/types').Method} method 
+	 * @param {Method} method 
 	 * @param {string[]} path 
-	 * @param {import('./main/types').Context} ctx 
+	 * @param {Context} ctx 
 	 * @returns {AsyncIterable<FindItem> | Iterable<FindItem>}
 	 */
 	find(method, path, ctx) { return []; }
 	/**
 	 * 
 	 * @param {Router[]} routers 
-	 * @returns {import('./main/types').FindHandler}
+	 * @returns {FindHandler}
 	 */
 	static make(routers) {
 		return async (ctx, setParams) => {
@@ -773,19 +772,21 @@ class Router {
 	guards = new Set();
 	/**
 	 * 
-	 * @param {import('./main/types').Handler} h 
-	 * @returns {import('./main/types').Handler}
+	 * @param {Handler} h 
+	 * @returns {Handler}
 	 */
 	__onionskin = (h) => h;
-	/** @param {import('./onionskin.mjs').Onionskin} os */
+	/** @param {Onionskin} os */
 	onionskin(os) { this.__onionskin = packer(os, this.__onionskin); }
 }
 
+/** @import { Match } from './index.mjs' */
+/** @import { Params } from '../main/types.js' */
 /**
  * @typedef {object} Pattern
- * @property {string} name
- * @property {boolean} optional
- * @property {boolean} many
+ * @property {string | symbol} name
+ * @property {boolean} [optional]
+ * @property {boolean} [many]
  * @property {RegExp} pattern
  */
 
@@ -856,7 +857,7 @@ function parse(p) {
  * @returns {[Record<string, string | string[]>, string[]] | undefined}
  */
 function exec(match, path, end) {
-	/** @type {Record<string, string | string[]>} */
+	/** @type {Params} */
 	const params = {};
 	for (let i = 0; i < match.length; i++) {
 		const m = match[i];
@@ -879,38 +880,101 @@ function exec(match, path, end) {
 	return [params, []];
 
 }
+/**
+ * 
+ * @param {string[]} paths 
+ * @param {*} values 
+ * @returns {Iterable<[string[], any[]]>}
+ */
+function* split([...paths], [...values]) {
+	let els = (paths.shift() || '').split('/');
+	let list = [els.pop() || ''];
+	for (const f of els) {
+		yield [[f], []];
+	}
+	for (const path of paths) {
+		const els = path.split('/');
+		if (els.length <= 1) {
+			list.push(path);
+			continue;
+		}
+		const pathValue = values.splice(0, list.length);
+		list.push(els.shift() || '');
+		yield [list, pathValue];
+		list = [els.pop() || ''];
+		for (const f of els) {
+			yield [[f], []];
+		}
+	}
+	yield [list, values];
+}
 /**
  *
- * @param {string} path
+ * @param {string | [string[], any[]]} path
  * @param {boolean} end
- * @returns {import('./index.mjs').Match | undefined}
+ * @returns {Match | undefined}
  */
 function toMatch(path, end) {
 	/** @type {(Pattern | string)[]} */
 	const list = [];
-	for (const p of path.split('/')) {
-		if (!p || /^\.+$/.test(p)) { continue; }
-		list.push(parse(p));
+	if (typeof path === 'string') {
+		for (const p of path.split('/')) {
+			if (!p || /^\.+$/.test(p)) { continue; }
+			list.push(parse(p));
+		}
+	} else {
+		for (const [paths, values] of split(...path)) {
+			if (paths.length === 2 && !paths[0]) {
+				const modifier = paths[1];
+				if (['', '?', '+', '*'].includes(modifier)) {
+					const value = values[0];
+					if (typeof value === 'symbol') {
+						list.push({
+							name: value, pattern: /^.*$/,
+							optional: modifier === '?' || modifier === '*',
+							many: modifier === '+' || modifier === '*',
+						});
+						continue;
+					} else if (value && typeof value === 'object') {
+						const {name, pattern} = value;
+						if (typeof name === 'symbol') {
+							list.push({
+								name, pattern: pattern instanceof RegExp ? pattern : /^.*$/,
+								optional: modifier === '?' || modifier === '*',
+								many: modifier === '+' || modifier === '*',
+							});
+						}
+					}
+				}
+			}
+			const last = paths.pop() || '';
+			const strings = paths.map((v, i) => [v, values[i]]).flat();
+			strings.push(last);
+			const p = strings.join('');
+			if (!p || /^\.+$/.test(p)) { continue; }
+			list.push(parse(p));
+			continue;
+		}
+
 	}
 	if (!list.length) { return; }
 	return path => exec(list, path, end);
 }
 
+/** @import { Handler, Method } from '../main/types' */
+/** @import { Binder, Match, Route, RouterRoute } from './index.mjs' */
+
 /**
  *
- * @param {(import('./index.mjs').Route | import('./index.mjs').RouterRoute)[]} routes
- * @param {import('../main/types').Method[]} methods
- * @param {string} path
- * @param {import('../main/types').Handler} handler
+ * @param {(Route | RouterRoute)[]} routes
+ * @param {Set<Method>} methods
+ * @param {Match | undefined} match
+ * @param {Handler[]} handlers
  * @returns {() => void}
  */
-function bind(routes, methods, path, handler) {
-	/** @type {import('./index.mjs').Route} */
-	const route = {
-		match: toMatch(path || '', true),
-		methods: new Set(methods),
-		handler,
-	};
+function bind(routes, methods, match, handlers) {
+	/** @type {Route} */
+	const route = { match, methods, handler: ctx => runHandles(ctx, handlers) };
 	routes.push(route);
 	let removed = false;
 	return () => {
@@ -921,43 +985,49 @@ function bind(routes, methods, path, handler) {
 		routes.splice(index, 1);
 	};
 }
-/** @type {(v: any) => v is import('../main/types').Handler} */
+/** @type {(v: any) => v is Handler} */
 const findHandler = v => typeof v === 'function';
 /**
  *
- * @param {(import('./index.mjs').Route | import('./index.mjs').RouterRoute)[]} routes
- * @param {import('../main/types').Method[]} methods
+ * @param {(Route | RouterRoute)[]} routes
+ * @param {Iterable<Method>} methods
  * @param {any[]} p
- * @returns {import('./index.mjs').Binder | (() => void)}
+ * @returns {Binder | (() => void)}
  */
 function verb(routes, methods, p) {
+	const methodSet = new Set(methods);
 	if (!p.length) {
-		return handler => bind(routes, methods, '', handler);
+		const match = undefined;
+		/** @type {Binder} */
+		return (...handlers) => bind(routes, methodSet, match, handlers);
 	}
-	const [a, b] = p;
-	if (a && typeof a === 'object') {
-		const path = String.raw(a, ...p.slice(1));
-		return handler => bind(routes, methods, path, handler);
+	const [path] = p;
+	if (path && typeof path === 'object') {
+		const match = toMatch([path, p.slice(1)], true);
+		/** @type {Binder} */
+		return (...handlers) => bind(routes, methodSet, match, handlers);
 	}
-	const path = typeof a === 'string' ? a : '';
-	const handler = [a, b].find(findHandler);
-	if (!handler) {
-		return handler => bind(routes, methods, path, handler);
+	const match = toMatch(typeof path === 'string' ? path : '', true);
+	const handlers = p.filter(findHandler);
+	if (!handlers.length) {
+		/** @type {Binder} */
+		return (...handlers) => bind(routes, methodSet, match, handlers);
 	}
-	return bind(routes, methods, path, handler);
+	return bind(routes, methodSet, match, handlers);
 }
 
+/** @import { Method } from '../main/types' */
 const methods = new Set(['GET', 'POST', 'PUT', 'DELETE', 'HEAD', 'OPTIONS']);
 /**
  *
  * @param {any} v
- * @returns {v is import('../main/types').Method}
+ * @returns {v is Method}
  */
 function isMethod(v) { return methods.has(v); }
 /**
  *
- * @param {import('../main/types').Method | Iterable<import('../main/types').Method> | ArrayLike<import('../main/types').Method>} [methods]
- * @returns {import('../main/types').Method[]}
+ * @param {Method | Iterable<Method> | ArrayLike<Method>} [methods]
+ * @returns {Method[]}
  */
 function getMethods(methods) {
 	if (!methods) {
@@ -971,25 +1041,24 @@ function getMethods(methods) {
 		.filter(isMethod);
 }
 
+/** @import { Context, Handler, Method, Params } from '../main/types' */
+/** @import { Finder, FindItem } from '../Router.mjs' */
+
 /**
  * @callback Match
  * @param {string[]} paths
- * @returns {[Record<string, string | string[]>, string[]] | undefined}
+ * @returns {[Params, string[]] | undefined}
  */
 
-/**
- * @callback Binder
- * @param {import('../main/types').Handler} handler
- * @returns {() => void}
- */
+/** @typedef {(handler: Handler, ...handlers: Handler[]) => () => void} Binder */
 
 /**
  * @typedef {object} Route
  * @property {Match} [match] 路径匹配
  * @property {null} [router]
  * @property {string} [plugin] 所属插件
- * @property {import('../main/types').Handler} handler 处理函数
- * @property {Set<import('../main/types').Method>} methods 方法列表
+ * @property {Handler} handler 处理函数
+ * @property {Set<Method>} methods 方法列表
  */
 
 /**
@@ -1000,16 +1069,16 @@ function getMethods(methods) {
 
 
 /**
- * @template {Router | import('../Router.mjs').Finder} [T=ApiRouter]
+ * @template {Router | Finder} [T=ApiRouter]
  * @callback RouteBinder
  * @param {T} [router] 要注册的子路由或子路由的 Finder
- * @returns {T extends import('../Router.mjs').Finder ? Router : T}
+ * @returns {T extends Finder ? Router : T}
  */
 /**
  *
  * @param {(Route | RouterRoute)[]} routes
- * @param {string} path
- * @param {Router | import('../Router.mjs').Finder} [r]
+ * @param {string | [string[], any[]]} path
+ * @param {Router | Finder} [r]
  * @returns {Router}
  */
 function bindRouter(routes, path, r) {
@@ -1024,18 +1093,18 @@ class ApiRouter extends Router {
 	#routes = [];
 	/**
 	 * 添加子路由
-	 * @template {Router | import('../Router.mjs').Finder} [T=ApiRouter]
+	 * @template {Router | Finder} [T=ApiRouter]
 	 * @overload
 	 * @param {T} [router] 要注册的子路由或子路由的 Finder
-	 * @returns {T extends import('../Router.mjs').Finder ? Router : T}
+	 * @returns {T extends Finder ? Router : T}
 	 */
 	/**
 	 * 添加子路由
-	 * @template {Router | import('../Router.mjs').Finder} [T=ApiRouter]
+	 * @template {Router | Finder} [T=ApiRouter]
 	 * @overload
 	 * @param {string} path   要注册的路径
 	 * @param {T} [router] 要注册的子路由或子路由的 Finder
-	 * @returns {T extends import('../Router.mjs').Finder ? Router : T}
+	 * @returns {T extends Finder ? Router : T}
 	 */
 	/**
 	 * 添加子路由
@@ -1052,12 +1121,11 @@ class ApiRouter extends Router {
 	route(...p) {
 		const [a] = p;
 		if (a && typeof a === 'object' && !(a instanceof Router)) {
-			const path = String.raw(a, ...p.slice(1));
 			/**
-			 * @param { import('../Router.mjs').Finder | Router} [r];
+			 * @param { Finder | Router} [r];
 			 * @returns {any}
 			 */
-			return r => bindRouter(this.#routes, path, r);
+			return r => bindRouter(this.#routes, [a, p.slice(1)], r);
 		}
 		const path = typeof a === 'string' ? a : '';
 		const r = typeof a === 'string' ? p[1] : a;
@@ -1065,10 +1133,10 @@ class ApiRouter extends Router {
 	}
 	/**
 	 *
-	 * @param {import('../main/types').Method} method
+	 * @param {Method} method
 	 * @param {string[]} path
-	 * @param {import('../main/types').Context} ctx
-	 * @returns {Iterable<import('../Router.mjs').FindItem>}
+	 * @param {Context} ctx
+	 * @returns {Iterable<FindItem>}
 	 */
 	*find(method, path, ctx) {
 		for (const route of Array.from(this.#routes)) {
@@ -1089,29 +1157,29 @@ class ApiRouter extends Router {
 	/**
 	 * 注册处理函数
 	 * @overload
-	 * @param {import('../main/types').Method | Iterable<import('../main/types').Method> | ArrayLike<import('../main/types').Method>} method  要注册的方法
-	 * @param {import('../main/types').Handler} handler 要注册的处理函数
+	 * @param {Method | Iterable<Method> | ArrayLike<Method>} method  要注册的方法
+	 * @param {Handler} handler 要注册的处理函数
 	 * @returns {() => void}
 	 */
 	/**
 	 * 注册处理函数
 	 * @overload
-	 * @param {import('../main/types').Method | Iterable<import('../main/types').Method> | ArrayLike<import('../main/types').Method>} method  要注册的方法
+	 * @param {Method | Iterable<Method> | ArrayLike<Method>} method  要注册的方法
 	 * @param {string} path 要注册的路径
-	 * @param {import('../main/types').Handler} handler 要注册的处理函数
+	 * @param {Handler} handler 要注册的处理函数
 	 * @returns {() => void}
 	 */
 	/**
 	 * 注册处理函数
 	 * @overload
-	 * @param {import('../main/types').Method | Iterable<import('../main/types').Method> | ArrayLike<import('../main/types').Method>} method  要注册的方法
+	 * @param {Method | Iterable<Method> | ArrayLike<Method>} method  要注册的方法
 	 * @param {string} path   要注册的路径
 	 * @returns {Binder}
 	 */
 	/**
-	 * @param {import('../main/types').Method | Iterable<import('../main/types').Method> | ArrayLike<import('../main/types').Method>} methods
-	 * @param {string| import('../main/types').Handler} [path]
-	 * @param {import('../main/types').Handler} [handler]
+	 * @param {Method | Iterable<Method> | ArrayLike<Method>} methods
+	 * @param {string| Handler} [path]
+	 * @param {Handler} [handler]
 	 * @returns {Binder | (() => void)}
 	 */
 	verb(methods, path, handler) {
@@ -1122,14 +1190,14 @@ class ApiRouter extends Router {
 	/**
 	 * 注册 HTTP GET/POST/PUT/DELETE 处理函数
 	 * @overload
-	 * @param {import('../main/types').Handler} handler 要注册的处理函数
+	 * @param {Handler} handler 要注册的处理函数
 	 * @returns {() => void}
 	 */
 	/**
 	 * 注册处理函数
 	 * @overload
 	 * @param {string} path 要注册的路径
-	 * @param {import('../main/types').Handler} handler 要注册的处理函数
+	 * @param {Handler} handler 要注册的处理函数
 	 * @returns {() => void}
 	 */
 	/**
@@ -1155,14 +1223,14 @@ class ApiRouter extends Router {
 	/**
 	 * 注册 HTTP GET 处理函数
 	 * @overload
-	 * @param {import('../main/types').Handler} handler 要注册的处理函数
+	 * @param {Handler} handler 要注册的处理函数
 	 * @returns {() => void}
 	 */
 	/**
 	 * 注册 HTTP GET 处理函数
 	 * @overload
 	 * @param {string} path 要注册的路径
-	 * @param {import('../main/types').Handler} handler 要注册的处理函数
+	 * @param {Handler} handler 要注册的处理函数
 	 * @returns {() => void}
 	 */
 	/**
@@ -1186,14 +1254,14 @@ class ApiRouter extends Router {
 	/**
 	 * 注册 HTTP POST 处理函数
 	 * @overload
-	 * @param {import('../main/types').Handler} handler 要注册的处理函数
+	 * @param {Handler} handler 要注册的处理函数
 	 * @returns {() => void}
 	 */
 	/**
 	 * 注册 HTTP POST 处理函数
 	 * @overload
 	 * @param {string} path 要注册的路径
-	 * @param {import('../main/types').Handler} handler 要注册的处理函数
+	 * @param {Handler} handler 要注册的处理函数
 	 * @returns {() => void}
 	 */
 	/**
@@ -1217,14 +1285,14 @@ class ApiRouter extends Router {
 	/**
 	 * 注册 HTTP PUT 处理函数
 	 * @overload
-	 * @param {import('../main/types').Handler} handler 要注册的处理函数
+	 * @param {Handler} handler 要注册的处理函数
 	 * @returns {() => void}
 	 */
 	/**
 	 * 注册 HTTP PUT 处理函数
 	 * @overload
 	 * @param {string} path 要注册的路径
-	 * @param {import('../main/types').Handler} handler 要注册的处理函数
+	 * @param {Handler} handler 要注册的处理函数
 	 * @returns {() => void}
 	 */
 	/**
@@ -1248,14 +1316,14 @@ class ApiRouter extends Router {
 	/**
 	 * 注册 HTTP DELETE 处理函数
 	 * @overload
-	 * @param {import('../main/types').Handler} handler 要注册的处理函数
+	 * @param {Handler} handler 要注册的处理函数
 	 * @returns {() => void}
 	 */
 	/**
 	 * 注册 HTTP DELETE 处理函数
 	 * @overload
 	 * @param {string} path 要注册的路径
-	 * @param {import('../main/types').Handler} handler 要注册的处理函数
+	 * @param {Handler} handler 要注册的处理函数
 	 * @returns {() => void}
 	 */
 	/**
@@ -1279,14 +1347,14 @@ class ApiRouter extends Router {
 	/**
 	 * 注册 HTTP HEAD 处理函数
 	 * @overload
-	 * @param {import('../main/types').Handler} handler 要注册的处理函数
+	 * @param {Handler} handler 要注册的处理函数
 	 * @returns {() => void}
 	 */
 	/**
 	 * 注册 HTTP HEAD 处理函数
 	 * @overload
 	 * @param {string} path 要注册的路径
-	 * @param {import('../main/types').Handler} handler 要注册的处理函数
+	 * @param {Handler} handler 要注册的处理函数
 	 * @returns {() => void}
 	 */
 	/**
@@ -1310,14 +1378,14 @@ class ApiRouter extends Router {
 	/**
 	 * 注册 HTTP OPTIONS 处理函数
 	 * @overload
-	 * @param {import('../main/types').Handler} handler 要注册的处理函数
+	 * @param {Handler} handler 要注册的处理函数
 	 * @returns {() => void}
 	 */
 	/**
 	 * 注册 HTTP OPTIONS 处理函数
 	 * @overload
 	 * @param {string} path 要注册的路径
-	 * @param {import('../main/types').Handler} handler 要注册的处理函数
+	 * @param {Handler} handler 要注册的处理函数
 	 * @returns {() => void}
 	 */
 	/**
@@ -1363,21 +1431,22 @@ function createFetch(run, notFound) {
 	};
 }
 
+/** @import { Context, Handler, HandlerResult } from './main/types' */
 /**
  * @callback Onionskin
- * @param {import('./main/types').Context} ctx
- * @param {() => Promise<import('./main/types').HandlerResult>} next
- * @returns {PromiseLike<import('./main/types').HandlerResult> | import('./main/types').HandlerResult}
+ * @param {Context} ctx
+ * @param {() => Promise<HandlerResult>} next
+ * @returns {PromiseLike<HandlerResult> | HandlerResult}
  */
 
 const noop = () => {};
 /**
  *
  * @param  {...(Onionskin | Onionskin[])} handlers
- * @returns {import('./main/types').Handler}
+ * @returns {Handler}
  */
 function onionskin(...handlers) {
-	/** @type {import('./main/types').Handler} */
+	/** @type {Handler} */
 	let handler = noop;
 	for (const os of handlers.flat()) {
 		const currentHandler = handler;
@@ -1386,7 +1455,44 @@ function onionskin(...handlers) {
 	return handler;
 }
 
+/** @import { Context } from './main/types.js' */
+class Param {
+	#symbol = Symbol();
+	get name() { return this.#symbol}
+	#pattern
+	get pattern() { return this.#pattern; }
+	/**
+	 * 
+	 * @param {RegExp} pattern 
+	 */
+	constructor(pattern) {
+		this.#pattern = pattern;
+	}
+	/**
+	 * 
+	 * @param {Context} ctx 
+	 * @returns {string?}
+	 */
+	param(ctx) {
+		const param = ctx.params[this.#symbol];
+		if (Array.isArray(param)) { return param[0] ?? null; }
+		return param ?? null;
+	}
+	/**
+	 * 
+	 * @param {Context} ctx 
+	 * @returns {string[]?}
+	 */
+	params(ctx) {
+		const param = ctx.params[this.#symbol];
+		if (typeof param === 'string') { return [param]; }
+		if (Array.isArray(param)) { return param; }
+		return null;
+	}
+}
+
 exports.ApiRouter = ApiRouter;
+exports.Param = Param;
 exports.Router = Router;
 exports.createFetch = createFetch;
 exports.main = main;