k99 0.6.0 → 0.7.0

package/index.js

@@ -1,6 +1,6 @@
 /*!
- * k99 v0.6.0
- * (c) 2019-2024 猛火Fierflame
+ * k99 v0.7.0
+ * (c) 2019-2025 猛火Fierflame
  * @license MIT
  */
 (function (global, factory) {
@@ -17,20 +17,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
@@ -55,7 +41,7 @@
 		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)) {
@@ -99,7 +85,7 @@
 		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') {
@@ -124,8 +110,7 @@
 				if (!data) { continue; }
 				await write(writer, data);
 			}
-			await writable.close();
-		})().catch(() => {});
+		})().then(() => writable.close(), r => writable.abort(r)).catch(() => {});
 		return [readable, 0, ''];
 	}
 	/**
@@ -148,11 +133,12 @@
 		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;
@@ -165,7 +151,7 @@
 	/**
 	 *
 	 * @param {Headers} headers
-	 * @param {import('./types').Cookie[]} cookies
+	 * @param {Cookie[]} cookies
 	 * @returns {void}
 	 */
 	function setCookiesHeader(headers, cookies) {
@@ -199,10 +185,10 @@
 	}
 	/**
 	 *
-	 * @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(
@@ -214,11 +200,11 @@
 		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) {
@@ -229,6 +215,9 @@
 		}
 	}
 
+	/** @import { Context, Cookie, CookieOption, FindHandler, Method, Options, Params, Service } from './types' */
+
+
 	const noBodyMethods = new Set(['GET', 'OPTIONS']);
 	/**
 	 *
@@ -265,7 +254,7 @@
 	 *
 	 * @param {Request} request
 	 * @param {string | ((request: Request) => string)} [toMethod]
-	 * @returns {import('./types').Method}
+	 * @returns {Method}
 	 */
 	function getMethod(request, toMethod) {
 		let methodStr = '';
@@ -277,13 +266,13 @@
 		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(
@@ -293,7 +282,7 @@
 		/**
 		 *
 		 * @param {Request} request
-		 * @param {import('./types').Context} [parent]
+		 * @param {Context} [parent]
 		 * @returns {Promise<Response | null>}
 		 */
 		function exec(request, parent) {
@@ -301,10 +290,10 @@
 			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;
@@ -320,9 +309,9 @@
 			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,
@@ -386,8 +375,8 @@
 				},
 				/**
 				 *
-				 * @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) {
@@ -424,69 +413,72 @@
 		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));
@@ -505,43 +497,44 @@
 		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') {
@@ -565,39 +558,40 @@
 		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;
@@ -634,16 +628,18 @@
 		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}
 	 */
@@ -654,30 +650,33 @@
 		};
 	}
 
+	/** @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; }
@@ -696,12 +695,12 @@
 
 	/**
 	 * 
-	 * @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)) {
@@ -740,16 +739,16 @@
 		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) => {
@@ -777,19 +776,21 @@
 		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
 	 */
 
@@ -860,7 +861,7 @@
 	 * @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];
@@ -883,38 +884,101 @@
 		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 () => {
@@ -925,43 +989,49 @@
 			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) {
@@ -975,25 +1045,24 @@
 			.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 方法列表
 	 */
 
 	/**
@@ -1004,16 +1073,16 @@
 
 
 	/**
-	 * @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) {
@@ -1028,18 +1097,18 @@
 		#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}
 		 */
 		/**
 		 * 添加子路由
@@ -1056,12 +1125,11 @@
 		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;
@@ -1069,10 +1137,10 @@
 		}
 		/**
 		 *
-		 * @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)) {
@@ -1093,29 +1161,29 @@
 		/**
 		 * 注册处理函数
 		 * @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) {
@@ -1126,14 +1194,14 @@
 		/**
 		 * 注册 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}
 		 */
 		/**
@@ -1159,14 +1227,14 @@
 		/**
 		 * 注册 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}
 		 */
 		/**
@@ -1190,14 +1258,14 @@
 		/**
 		 * 注册 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}
 		 */
 		/**
@@ -1221,14 +1289,14 @@
 		/**
 		 * 注册 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}
 		 */
 		/**
@@ -1252,14 +1320,14 @@
 		/**
 		 * 注册 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}
 		 */
 		/**
@@ -1283,14 +1351,14 @@
 		/**
 		 * 注册 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}
 		 */
 		/**
@@ -1314,14 +1382,14 @@
 		/**
 		 * 注册 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}
 		 */
 		/**
@@ -1367,21 +1435,22 @@
 		};
 	}
 
+	/** @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;
@@ -1390,7 +1459,44 @@
 		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;