k99 0.7.1 → 0.9.0

package/index.js

@@ -1,6 +1,6 @@
 /*!
- * k99 v0.7.1
- * (c) 2019-2025 猛火Fierflame
+ * k99 v0.9.0
+ * (c) 2019-2026 猛火Fierflame
  * @license MIT
  */
 (function (global, factory) {
@@ -12,9 +12,10 @@
 	/**
 	 *
 	 * @param {string} str
-	 * @returns {Uint8Array}
+	 * @returns {Uint8Array<ArrayBuffer>}
 	 */
 	function str2utf8bin(str) {
+		// @ts-ignore
 		return new TextEncoder().encode(str);
 	}
 	/**
@@ -53,26 +54,15 @@
 		}
 	}
 
-	/**
-	 *
-	 * @param {any} k
-	 * @param {any} v
-	 * @returns {any}
-	 */
-	function replacer(k, v) {
-		if (typeof v === 'bigint') {
-			return String(v);
-		}
-		return v;
-	}
 
 	/**
 	 *
 	 * @param {any} result
+	 * @param {(this: any, key: string, value: any) => any} replacer
 	 * @param {Promise<never>} [aborted]
 	 * @returns {[BodyInit, number, string] | null}
 	 */
-	function toBodyData(result, aborted) {
+	function toBodyData(result, replacer, aborted) {
 		if (result instanceof ReadableStream) {
 			return [result, 0, ''];
 		}
@@ -86,11 +76,16 @@
 			return [result, 0, ''];
 		}
 		if (ArrayBuffer.isView(result) || result instanceof ArrayBuffer) {
+			// @ts-ignore
 			return [result, result.byteLength, ''];
 		}
 		if (typeof result === 'string') {
 			const body = str2utf8bin(result);
-			return [body, body.byteLength, ''];
+			return [body, body.byteLength, 'text/plain'];
+		}
+		if (['bigint', 'boolean', 'number'].includes(typeof result)) {
+			const body = str2utf8bin(JSON.stringify(result, replacer));
+			return [body, body.byteLength, 'application/json'];
 		}
 		if (typeof result !== 'object') {
 			return null;
@@ -117,11 +112,12 @@
 	 *
 	 * @param {any} result
 	 * @param {Headers} headers
+	 * @param {(this: any, key: string, value: any) => any} replacer
 	 * @param {Promise<never>} [aborted]
 	 * @returns
 	 */
-	function toBody(result, headers, aborted) {
-		const bodyData = toBodyData(result, aborted);
+	function toBody(result, headers, replacer, aborted) {
+		const bodyData = toBodyData(result, replacer, aborted);
 		if (!bodyData) { return null; }
 		const [body, size, type] = bodyData;
 		if (type && !headers.get('Content-Type')) {
@@ -215,7 +211,7 @@
 		}
 	}
 
-	/** @import { Context, Cookie, CookieOption, FindHandler, Method, Options, Params, Service } from './types' */
+	/** @import { Context, Cookie, CookieOption, FindHandler, HandlerResult, Method, Options, Params, Service } from './types' */
 
 
 	const noBodyMethods = new Set(['GET', 'OPTIONS']);
@@ -268,6 +264,18 @@
 		}
 		return /** @type {Method} */(methodStr.toUpperCase());
 	}
+	/**
+	 *
+	 * @param {any} k
+	 * @param {any} v
+	 * @returns {any}
+	 */
+	function defaultReplacer(k, v) {
+		if (typeof v === 'bigint') {
+			return String(v);
+		}
+		return v;
+	}
 	/**
 	 *
 	 * @param {Request} request
@@ -275,10 +283,15 @@
 	 * @param {Options} [options]
 	 * @returns {Promise<Response | null>}
 	 */
-	function main(
-		request, getHandler,
-		{ runner, error: echoError, catch: catchError, method: toMethod, environment } = {},
-	) {
+	function main(request, getHandler, {
+		runner,
+		error: echoError,
+		catch: catchError,
+		method: toMethod,
+		environment,
+		replacer: JSONReplacer,
+	} = {}) {
+		const replacer = typeof JSONReplacer === 'function' ? JSONReplacer : defaultReplacer;
 		/**
 		 *
 		 * @param {Request} request
@@ -302,12 +315,12 @@
 			/** @type {any} */
 			let error = null;
 
-			let resolve = () => {};
+			let resolve = () => { };
 			/** @type {(error: unknown) => void} */
-			let reject = () => {};
+			let reject = () => { };
 			/** @type {Promise<void>} */
 			const donePromise = new Promise((a, b) => { resolve = a; reject = b; });
-			donePromise.catch(() => {});
+			donePromise.catch(() => { });
 
 			/** @type {Params} */
 			let params = {};
@@ -325,7 +338,7 @@
 					if (!data || noBodyMethods.has(method.toUpperCase())) {
 						return exec(new Request(fetchUrl, { method, headers, signal }), context);
 					}
-					const body = toBody(data, headers);
+					const body = toBody(data, headers, replacer);
 					return exec(new Request(fetchUrl, { method, headers, signal, body }), context);
 				},
 				done(onfulfilled, onrejected) {
@@ -370,7 +383,7 @@
 				set responseType(type) { setHeader(responseHeaders, 'content-type', type); },
 				getCookie(name) { return getCookie(sentCookies, name); },
 				setCookie(name, value, { expire, domain, path, secure, httpOnly } = {}) {
-					sentCookies.push({name, value, expire, domain, path, secure, httpOnly});
+					sentCookies.push({ name, value, expire, domain, path, secure, httpOnly });
 					setCookiesHeader(responseHeaders, sentCookies);
 				},
 				/**
@@ -388,16 +401,22 @@
 				return Promise.race([
 					aborted,
 					Promise.resolve().then(() => getHandler(context, v => { params = v; })),
-				]).then(handler => handler ? Promise.race([aborted, handler(context)]).then(result => {
-					if (result instanceof Response) {
-						return result;
+				]).then(async handlers => {
+					const allHandlers = [handlers].flat().filter(h => typeof h === 'function');
+					if (!allHandlers.length) { return null; }
+					/** @type {HandlerResult?} */
+					let result;
+					for (const handle of allHandlers) {
+						result = await Promise.race([aborted, handle(context)]);
+						if (result !== undefined) { break; }
 					}
+					if (result instanceof Response) { return result; }
 					const headers = new Headers(context.responseHeaders);
 					const { status } = context;
-					if (!result) { return new Response(null, { status, headers }); }
-					const body = toBody(result, headers, aborted);
+					if (!result == null) { return new Response(null, { status, headers }); }
+					const body = toBody(result, headers, replacer, aborted);
 					return new Response(body, { status, headers });
-				}) : null).then(response => {
+				}).then(response => {
 					destroyed = true;
 					resolve();
 					return response;
@@ -413,40 +432,151 @@
 		return exec(request);
 	}
 
-	/** @import { FindHandler, Options } from './main/types' */
+	/** @import { Method, Params } from './main/types' */
 
 	/**
-	 *
-	 * @param {FindHandler} getHandler
-	 * @param {Options} options
-	 * @returns {(request: Request) => Promise<Response | null>}
+	 * @template {Function} T
+	 * @typedef {[T | T[] | Router<T>, Record<string | symbol, any>, string[]]} FindItem
 	 */
-	function make(getHandler, options) {
-		return r => main(r, getHandler, options);
+	/**
+	 * @template {Function} T
+	 * @callback Finder
+	 * @this {Router<T>}
+	 * @param {Method} method
+	 * @param {string[]} path
+	 * @returns {AsyncIterable<FindItem<T>> | Iterable<FindItem<T>>}
+	 */
+
+	/**
+	 * @abstract
+	 * @template {Function} T
+	 */
+	class Router {
+		disabled = false;
+		/**
+		 * 
+		 * @template {Function} T
+		 * @param {Router<T> | T[] | T} route 
+		 * @param {Method} method 
+		 * @param {string[]} path 
+		 * @param {Params} params 
+		 * @param {AbortSignal?} [signal] 
+		 * @param {((v: Params) => void)?} [setParams] 
+		 * @returns {Promise<T[] | null>}
+		 */
+		static async #find(route, method, path, params, signal, setParams) {
+			if (!(route instanceof Router)) {
+				if (typeof setParams === 'function') { setParams(params); }
+				// @ts-ignore
+				return [route].flat();
+			}
+			if (route.disabled) { return null; }
+			if (signal?.aborted) { return null; }
+			for await (const [r, result, p] of route.find(method, path)) {
+				if (signal?.aborted) { return null; }
+				const res = await Router.#find(r, method, p, { ...params, ...result }, signal, setParams);
+				if (res) { return [...route.#guards, ...res]; }
+			}
+			return null;
+		}
+		/**
+		 * 
+		 * @template {Function} T
+		 * @param {Router<T>[]} routers 
+		 * @param {Method} method 
+		 * @param {string[]} path 
+		 * @param {AbortSignal?} [signal] 
+		 * @param {((v: Params) => void)?} [setParams] 
+		 * @returns {Promise<T[] | null>}
+		 */
+		static async find(routers, method, path, signal, setParams) {
+			const m = `${method}`.toLowerCase();
+			for (const route of routers.flat()) {
+				const res = await Router.#find(route, m, path, {}, signal, setParams);
+				if (res) { return res; }
+			}
+			return null;
+		}
+		/**
+		 * @abstract
+		 * @param {Method} method 
+		 * @param {string[]} path 
+		 * @returns {AsyncIterable<FindItem<T>> | Iterable<FindItem<T>>}
+		 */
+		find(method, path) { return []; }
+
+
+		/** @type {T[]} */
+		#guards = [];
+		/**
+		 * 
+		 * @param  {...T | T[]} guards 
+		 */
+		guard(...guards) {
+			const list = this.#guards;
+			for (const guard of guards.flat()) {
+				if (typeof guard !== 'function') { continue; }
+				// @ts-ignore
+				list.push(guard);
+			}
+		}
+
+		/**
+		 * 
+		 * @template {Function} T
+		 * @param {Finder<T>} find 
+		 * @returns {Router<T>}
+		 */
+		static create(find) {
+			return Object.defineProperties(new Router(), {
+				'find': { configurable: true, value: find, writable: true },
+			});
+		}
 	}
 
-	/** @import { Context, Handler } from './main/types' */
+	/** @import { FindHandler, Handler, Options } from './main/types' */
+
+	/**
+	 * 
+	 * @param {string} t 
+	 * @returns 
+	 */
+	function uriDecode(t) {
+		try {
+			return decodeURIComponent(t);
+		} catch {
+			return t;
+		}
+	}
 	/**
 	 *
-	 * @param {Context} context
-	 * @param {Handler[]} handlers
-	 * @returns {Promise<string | boolean | object | undefined>}
+	 * @param {Router<Handler> | Router<Handler>[] | FindHandler} routers
+	 * @param {Options} options
+	 * @returns {(request: Request) => Promise<Response | null>}
 	 */
-	async function runHandles(context, handlers) {
-		for (const handle of handlers) {
-			const result = await handle(context);
-			if (result === undefined) { continue; }
-			return result;
+	function make(routers, options) {
+		if (typeof routers === 'function') {
+			return r => main(r, routers, options);
 		}
+		const list = [routers].flat();
+		/** @type {FindHandler} */
+		const getHandler = (ctx, setParams) => {
+			const path = ctx.url.pathname.split('/').filter(Boolean).map(uriDecode);
+			return Router.find(list, ctx.method, path, ctx.signal, setParams);
+		};
+		return r => main(r, getHandler, options);
 	}
 
+	/** @import { FindHandler, Options } from './main/types' */
+
 	/**
 	 *
-	 * @param  {...(Handler | Handler[])} handlers
-	 * @returns {Handler}
+	 * @param {FindHandler} getHandler
+	 * @param {Options} options
+	 * @returns {(request: Request) => Promise<Response | null>}
 	 */
-	function merge(...handlers) {
-		return ctx => runHandles(ctx, handlers.flat());
+	function bind$1(getHandler, options) {
+		return r => main(r, getHandler, options);
 	}
 
 	/** @import { Context, Service } from './main/types' */
@@ -628,162 +758,6 @@
 		return service;
 	}
 
-	/** @import { Handler } from './main/types' */
-	/** @import { Onionskin } from './onionskin.mjs' */
-	/**
-	 * @callback Packer
-	 * @param {Handler} handler
-	 * @returns {Handler}
-	 */
-	/** @type {Packer} */
-	const noop$1 = h => h;
-	/**
-	 *
-	 * @param {Onionskin} onionskin
-	 * @param {Packer} [packer]
-	 * @returns {Packer}
-	 */
-	function packer(onionskin, packer = noop$1) {
-		return h => {
-			const handler = packer(h);
-			return async (ctx) => onionskin(ctx, async () => handler(ctx));
-		};
-	}
-
-	/** @import { Context, FindHandler, Handler, Method, Params } from './main/types' */
-	/** @import { Onionskin } from './onionskin.mjs' */
-
-	/**
-	 * @callback Guard
-	 * @param {Context} ctx
-	 * @returns {PromiseLike<boolean | Handler | void> | boolean | Handler | void}
-	 */
-	/**
-	 * @typedef {[Handler | Router, Record<string | symbol, any>, string[]]} FindItem
-	 */
-	/**
-	 * @callback Finder
-	 * @this {Router}
-	 * @param {Method} method
-	 * @param {string[]} path
-	 * @param {Context} ctx 
-	 * @returns {AsyncIterable<FindItem> | Iterable<FindItem>}
-	 */
-
-	/**
-	 * 
-	 * @param {Set<Guard>} guards 
-	 * @param {Context} ctx 
-	 * @param {(v: any) => void} setParams 
-	 * @param {object} params 
-	 * @returns {Promise<boolean | Handler>}
-	 */
-	async function execGuard(guards, ctx, setParams, params) {
-		if (!guards.size) { return true; }
-		setParams(params);
-		for (const guard of guards) {
-			if (ctx.destroyed) { return false; }
-			const ret = await guard(Object.create(ctx, {
-				params: { value: { ...params } },
-			}));
-			if (ret === false) { return false; }
-			// @ts-ignore
-			if (typeof ret === 'function') { return ret; }
-		}
-		return true;
-	}
-
-	/**
-	 * 
-	 * @param {Router | Handler} route 
-	 * @param {string[]} path 
-	 * @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)) {
-			setParams(params);
-			return route;
-		}
-		if (route.disabled) { return null; }
-		const guardResult = await execGuard(route.guards, ctx, setParams, params);
-		if (!guardResult) { return null; }
-		if (typeof guardResult === 'function') { return guardResult; }
-		if (ctx.destroyed) { return null; }
-		for await (const [r, result, p] of route.find(ctx.method, path, ctx)) {
-			if (ctx.destroyed) { return null; }
-			const res = await find(r, p, ctx, setParams, { ...params, ...result });
-			if (res) { return route.__onionskin(res); }
-		}
-		return null;
-	}
-
-	/**
-	 * 
-	 * @param {string} t 
-	 * @returns 
-	 */
-	function uriDecode(t) {
-		try {
-			return decodeURIComponent(t);
-		} catch {
-			return t;
-		}
-	}
-	/**
-	 * @abstract
-	 */
-	class Router {
-		disabled = false;
-		/**
-		 * @abstract
-		 * @param {Method} method 
-		 * @param {string[]} path 
-		 * @param {Context} ctx 
-		 * @returns {AsyncIterable<FindItem> | Iterable<FindItem>}
-		 */
-		find(method, path, ctx) { return []; }
-		/**
-		 * 
-		 * @param {Router[]} routers 
-		 * @returns {FindHandler}
-		 */
-		static make(routers) {
-			return async (ctx, setParams) => {
-				const list = routers.flat();
-				const path = ctx.url.pathname.split('/').filter(Boolean).map(uriDecode);
-				for (const route of list) {
-					const res = await find(route, path, ctx, setParams, {});
-					if (res) { return res; }
-				}
-				return null;
-			};
-		}
-
-		/**
-		 * 
-		 * @param {Finder} find 
-		 * @returns {Router}
-		 */
-		static create(find) {
-			return Object.defineProperties(new Router(), {
-				'find': { configurable: true, value: find, writable: true },
-			});
-		}
-		/** @readonly @type {Set<Guard>} */
-		guards = new Set();
-		/**
-		 * 
-		 * @param {Handler} h 
-		 * @returns {Handler}
-		 */
-		__onionskin = (h) => h;
-		/** @param {Onionskin} os */
-		onionskin(os) { this.__onionskin = packer(os, this.__onionskin); }
-	}
-
 	/** @import { Match } from './index.mjs' */
 	/** @import { Params } from '../main/types.js' */
 	/**
@@ -966,20 +940,21 @@
 		return path => exec(list, path, end);
 	}
 
-	/** @import { Handler, Method } from '../main/types' */
+	/** @import { Method } from '../main/types' */
 	/** @import { Binder, Match, Route, RouterRoute } from './index.mjs' */
 
 	/**
 	 *
-	 * @param {(Route | RouterRoute)[]} routes
+	 * @template {Function} T
+	 * @param {(Route<T> | RouterRoute<T>)[]} routes
 	 * @param {Set<Method>} methods
 	 * @param {Match | undefined} match
-	 * @param {Handler[]} handlers
+	 * @param {T[]} handlers
 	 * @returns {() => void}
 	 */
 	function bind(routes, methods, match, handlers) {
-		/** @type {Route} */
-		const route = { match, methods, handler: ctx => runHandles(ctx, handlers) };
+		/** @type {Route<T>} */
+		const route = { match, methods, handlers: handlers };
 		routes.push(route);
 		let removed = false;
 		return () => {
@@ -990,45 +965,45 @@
 			routes.splice(index, 1);
 		};
 	}
-	/** @type {(v: any) => v is Handler} */
+	/** @type {(v: any) => v is Function} */
 	const findHandler = v => typeof v === 'function';
 	/**
 	 *
-	 * @param {(Route | RouterRoute)[]} routes
+	 * @template {Function} T
+	 * @param {(Route<T> | RouterRoute<T>)[]} routes
 	 * @param {Iterable<Method>} methods
 	 * @param {any[]} p
-	 * @returns {Binder | (() => void)}
+	 * @returns {Binder<T> | (() => void)}
 	 */
 	function verb(routes, methods, p) {
 		const methodSet = new Set(methods);
 		if (!p.length) {
 			const match = undefined;
-			/** @type {Binder} */
+			/** @type {Binder<T>} */
 			return (...handlers) => bind(routes, methodSet, match, handlers);
 		}
 		const [path] = p;
 		if (path && typeof path === 'object') {
 			const match = toMatch([path, p.slice(1)], true);
-			/** @type {Binder} */
+			/** @type {Binder<T>} */
 			return (...handlers) => bind(routes, methodSet, match, handlers);
 		}
 		const match = toMatch(typeof path === 'string' ? path : '', true);
 		const handlers = p.filter(findHandler);
 		if (!handlers.length) {
-			/** @type {Binder} */
+			/** @type {Binder<T>} */
 			return (...handlers) => bind(routes, methodSet, match, handlers);
 		}
 		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 Method}
 	 */
-	function isMethod(v) { return methods.has(v); }
+	function isMethod(v) { return Boolean(v); }
 	/**
 	 *
 	 * @param {Method | Iterable<Method> | ArrayLike<Method>} [methods]
@@ -1046,7 +1021,7 @@
 			.filter(isMethod);
 	}
 
-	/** @import { Context, Handler, Method, Params } from '../main/types' */
+	/** @import { Handler, Method, Params } from '../main/types' */
 	/** @import { Finder, FindItem } from '../Router.mjs' */
 
 	/**
@@ -1055,79 +1030,125 @@
 	 * @returns {[Params, string[]] | undefined}
 	 */
 
-	/** @typedef {(handler: Handler, ...handlers: Handler[]) => () => void} Binder */
+	/**
+	 * @template {Function} T
+	 * @typedef {(handler: T, ...handlers: T[]) => () => void} Binder
+	 */
+
+
+	/**
+	 * @template {Function} T
+	 * @callback Verb1
+	 * @param {T} handler 要注册的处理函数
+	 * @param {...T} handlers 要注册的处理函数
+	 * @returns {() => void}
+	 */
+	/**
+	 * @template {Function} T
+	 * @callback Verb2
+	 * @param {string} path 要注册的路径
+	 * @param {T} handler 要注册的处理函数
+	 * @param {...T} handlers 要注册的处理函数
+	 * @returns {() => void}
+	 */
+	/**
+	 * @template {Function} T
+	 * @callback Verb3
+	 * @param {string} path 要注册的路径
+	 * @returns {Binder<T>}
+	 */
+	/**
+	 * @template {Function} T
+	 * @callback Verb4
+	 * @param {TemplateStringsArray} template 要注册的路径模板
+	 * @param {...any} substitutions 要注册的路径模板代替内容
+	 * @returns {Binder<T>}
+	 */
+	/**
+	 * @template {Function} T
+	 * @typedef {Verb1<T> & Verb2<T> & Verb3<T> & Verb4<T>} Verb
+	 */
 
 	/**
+	 * @template {Function} T
 	 * @typedef {object} Route
 	 * @property {Match} [match] 路径匹配
 	 * @property {null} [router]
-	 * @property {string} [plugin] 所属插件
-	 * @property {Handler} handler 处理函数
+	 * @property {T[]} handlers 处理函数
 	 * @property {Set<Method>} methods 方法列表
 	 */
 
 	/**
+	 * @template {Function} T
 	 * @typedef {object} RouterRoute
 	 * @property {Match} [match] 路径匹配
-	 * @property {Router} router
+	 * @property {Router<T>} router
 	 */
 
 
 	/**
-	 * @template {Router | Finder} [T=ApiRouter]
+	 * @template {Function} T
+	 * @template {Router<T> | Finder<T>} [P=MapRouter<T>]
 	 * @callback RouteBinder
-	 * @param {T} [router] 要注册的子路由或子路由的 Finder
-	 * @returns {T extends Finder ? Router : T}
+	 * @param {P} [router] 要注册的子路由或子路由的 Finder<T>
+	 * @returns {P extends Finder<T> ? Router<T> : P}
 	 */
 	/**
 	 *
-	 * @param {(Route | RouterRoute)[]} routes
+	 * @template {Function} T
+	 * @param {(Route<T> | RouterRoute<T>)[]} routes
 	 * @param {string | [string[], any[]]} path
-	 * @param {Router | Finder} [r]
-	 * @returns {Router}
+	 * @param {Router<T> | Finder<T>} [r]
+	 * @returns {Router<T>}
 	 */
 	function bindRouter(routes, path, r) {
+		/** @type {Router<T>} */
 		const router = r instanceof Router ? r
 			: typeof r === 'function' ? Router.create(r)
-				: new ApiRouter();
+				: new MapRouter();
 		routes.push({ match: toMatch(path, false), router });
 		return router;
 	}
-	class ApiRouter extends Router {
-		/** @readonly @type {(Route | RouterRoute)[]} 路由列表 */
+	/**
+	 * 
+	 * @template {Function} T
+	 * @extends {Router<T>}
+	 */
+	class MapRouter extends Router {
+		/** @readonly @type {(Route<T> | RouterRoute<T>)[]} 路由列表 */
 		#routes = [];
 		/**
 		 * 添加子路由
-		 * @template {Router | Finder} [T=ApiRouter]
+		 * @template {Router<T> | Finder<T>} [P=MapRouter<T>]
 		 * @overload
-		 * @param {T} [router] 要注册的子路由或子路由的 Finder
-		 * @returns {T extends Finder ? Router : T}
+		 * @param {P} [router] 要注册的子路由或子路由的 Finder<T>
+		 * @returns {P extends Finder<T> ? Router<T> : P}
 		 */
 		/**
 		 * 添加子路由
-		 * @template {Router | Finder} [T=ApiRouter]
+		 * @template {Router<T> | Finder<T>} [P=MapRouter<T>]
 		 * @overload
 		 * @param {string} path   要注册的路径
-		 * @param {T} [router] 要注册的子路由或子路由的 Finder
-		 * @returns {T extends Finder ? Router : T}
+		 * @param {P} [router] 要注册的子路由或子路由的 Finder<T>
+		 * @returns {P extends Finder<T> ? Router<T> : P}
 		 */
 		/**
 		 * 添加子路由
 		 * @overload
 		 * @param {TemplateStringsArray} template 要注册的路径模板
 		 * @param {...any} substitutions 要注册的路径模板代替内容
-		 * @returns {RouteBinder}
+		 * @returns {RouteBinder<T>}
 		 */
 		/**
 		 * 添加子路由
 		 * @param {...any} p 要注册的路径
-		 * @returns {Router | RouteBinder}
+		 * @returns {Router<T> | RouteBinder<T>}
 		 */
 		route(...p) {
 			const [a] = p;
 			if (a && typeof a === 'object' && !(a instanceof Router)) {
 				/**
-				 * @param { Finder | Router} [r];
+				 * @param { Finder<T> | Router<T>} [r];
 				 * @returns {any}
 				 */
 				return r => bindRouter(this.#routes, [a, p.slice(1)], r);
@@ -1140,30 +1161,29 @@
 		 *
 		 * @param {Method} method
 		 * @param {string[]} path
-		 * @param {Context} ctx
-		 * @returns {Iterable<FindItem>}
+		 * @returns {Iterable<FindItem<T>>}
 		 */
-		*find(method, path, ctx) {
+		*find(method, path) {
 			for (const route of Array.from(this.#routes)) {
 				if (!route.router && !route.methods.has(method)) { continue; }
 				const {match} = route;
 				if (!match) {
 					if (route.router || !path.length) {
-						yield [route.router || route.handler, {}, path];
+						yield [route.router || route.handlers, {}, path];
 					}
 					continue;
 				}
 				if (!path.length) { continue; }
 				const result = match(path);
 				if (!result) { continue; }
-				yield [route.router || route.handler, ...result];
+				yield [route.router || route.handlers, ...result];
 			}
 		}
 		/**
 		 * 注册处理函数
 		 * @overload
 		 * @param {Method | Iterable<Method> | ArrayLike<Method>} method  要注册的方法
-		 * @param {Handler} handler 要注册的处理函数
+		 * @param {T} handler 要注册的处理函数
 		 * @returns {() => void}
 		 */
 		/**
@@ -1171,7 +1191,7 @@
 		 * @overload
 		 * @param {Method | Iterable<Method> | ArrayLike<Method>} method  要注册的方法
 		 * @param {string} path 要注册的路径
-		 * @param {Handler} handler 要注册的处理函数
+		 * @param {T} handler 要注册的处理函数
 		 * @returns {() => void}
 		 */
 		/**
@@ -1179,48 +1199,58 @@
 		 * @overload
 		 * @param {Method | Iterable<Method> | ArrayLike<Method>} method  要注册的方法
 		 * @param {string} path   要注册的路径
-		 * @returns {Binder}
+		 * @returns {Binder<T>}
 		 */
 		/**
 		 * @param {Method | Iterable<Method> | ArrayLike<Method>} methods
-		 * @param {string| Handler} [path]
-		 * @param {Handler} [handler]
-		 * @returns {Binder | (() => void)}
+		 * @param {string| T} [path]
+		 * @param {...T} handler
+		 * @returns {Binder<T> | (() => void)}
 		 */
-		verb(methods, path, handler) {
+		verb(methods, path, ...handler) {
 			const allMethods = getMethods(methods);
 			if (!allMethods.length) { return () => {}; }
-			return verb(this.#routes, allMethods, [path, handler]);
+			return verb(this.#routes, allMethods, [path, ...handler]);
+		}
+
+		/**
+		 * @param {Method | Iterable<Method> | ArrayLike<Method>} method  要注册的方法
+		 * @returns {Verb<T>}
+		 */
+		method(method) {
+			const methods = getMethods(method);
+			// @ts-ignore
+			return (...p) => verb(this.#routes, methods, p);
 		}
 		/**
 		 * 注册 HTTP GET/POST/PUT/DELETE 处理函数
 		 * @overload
-		 * @param {Handler} handler 要注册的处理函数
+		 * @param {...T} handlers 要注册的处理函数
 		 * @returns {() => void}
 		 */
 		/**
 		 * 注册处理函数
 		 * @overload
 		 * @param {string} path 要注册的路径
-		 * @param {Handler} handler 要注册的处理函数
+		 * @param {...T} handlers 要注册的处理函数
 		 * @returns {() => void}
 		 */
 		/**
 		 * 注册 HTTP GET/POST/PUT/DELETE 处理函数
 		 * @overload
 		 * @param {string} path 要注册的路径
-		 * @returns {Binder}
+		 * @returns {Binder<T>}
 		 */
 		/**
 		 * 注册 HTTP GET/POST/PUT/DELETE 处理函数
 		 * @overload
 		 * @param {TemplateStringsArray} template 要注册的路径模板
 		 * @param {...any} substitutions 要注册的路径模板代替内容
-		 * @returns {Binder}
+		 * @returns {Binder<T>}
 		 */
 		/**
 		 * @param {...any} p 要注册的路径
-		 * @returns {Binder | (() => void)}
+		 * @returns {Binder<T> | (() => void)}
 		 */
 		match(...p) {
 			return verb(this.#routes, ['GET', 'POST', 'PUT', 'DELETE'], p);
@@ -1228,187 +1258,187 @@
 		/**
 		 * 注册 HTTP GET 处理函数
 		 * @overload
-		 * @param {Handler} handler 要注册的处理函数
+		 * @param {...Handler} handlers 要注册的处理函数
 		 * @returns {() => void}
 		 */
 		/**
 		 * 注册 HTTP GET 处理函数
 		 * @overload
 		 * @param {string} path 要注册的路径
-		 * @param {Handler} handler 要注册的处理函数
+		 * @param {...Handler} handlers 要注册的处理函数
 		 * @returns {() => void}
 		 */
 		/**
 		 * 注册 HTTP GET 处理函数
 		 * @overload
 		 * @param {string} path 要注册的路径
-		 * @returns {Binder}
+		 * @returns {Binder<T>}
 		 */
 		/**
 		 * 注册 HTTP GET 处理函数
 		 * @overload
 		 * @param {TemplateStringsArray} template 要注册的路径模板
 		 * @param {...any} substitutions 要注册的路径模板代替内容
-		 * @returns {Binder}
+		 * @returns {Binder<T>}
 		 */
 		/**
 		 * @param {...any} p 要注册的路径
-		 * @returns {Binder | (() => void)}
+		 * @returns {Binder<T> | (() => void)}
 		 */
 		get(...p) { return verb(this.#routes, ['GET'], p); }
 		/**
 		 * 注册 HTTP POST 处理函数
 		 * @overload
-		 * @param {Handler} handler 要注册的处理函数
+		 * @param {...Handler} handlers 要注册的处理函数
 		 * @returns {() => void}
 		 */
 		/**
 		 * 注册 HTTP POST 处理函数
 		 * @overload
 		 * @param {string} path 要注册的路径
-		 * @param {Handler} handler 要注册的处理函数
+		 * @param {...Handler} handlers 要注册的处理函数
 		 * @returns {() => void}
 		 */
 		/**
 		 * 注册 HTTP POST 处理函数
 		 * @overload
 		 * @param {string} path 要注册的路径
-		 * @returns {Binder}
+		 * @returns {Binder<T>}
 		 */
 		/**
 		 * 注册 HTTP POST 处理函数
 		 * @overload
 		 * @param {TemplateStringsArray} template 要注册的路径模板
 		 * @param {...any} substitutions 要注册的路径模板代替内容
-		 * @returns {Binder}
+		 * @returns {Binder<T>}
 		 */
 		/**
 		 * @param {...any} p 要注册的路径
-		 * @returns {Binder | (() => void)}
+		 * @returns {Binder<T> | (() => void)}
 		 */
 		post(...p) { return verb(this.#routes, ['POST'], p); }
 		/**
 		 * 注册 HTTP PUT 处理函数
 		 * @overload
-		 * @param {Handler} handler 要注册的处理函数
+		 * @param {...Handler} handlers 要注册的处理函数
 		 * @returns {() => void}
 		 */
 		/**
 		 * 注册 HTTP PUT 处理函数
 		 * @overload
 		 * @param {string} path 要注册的路径
-		 * @param {Handler} handler 要注册的处理函数
+		 * @param {...Handler} handlers 要注册的处理函数
 		 * @returns {() => void}
 		 */
 		/**
 		 * 注册 HTTP PUT 处理函数
 		 * @overload
 		 * @param {string} path 要注册的路径
-		 * @returns {Binder}
+		 * @returns {Binder<T>}
 		 */
 		/**
 		 * 注册 HTTP PUT 处理函数
 		 * @overload
 		 * @param {TemplateStringsArray} template 要注册的路径模板
 		 * @param {...any} substitutions 要注册的路径模板代替内容
-		 * @returns {Binder}
+		 * @returns {Binder<T>}
 		 */
 		/**
 		 * @param {...any} p 要注册的路径
-		 * @returns {Binder | (() => void)}
+		 * @returns {Binder<T> | (() => void)}
 		 */
 		put(...p) { return verb(this.#routes, ['PUT'], p); }
 		/**
 		 * 注册 HTTP DELETE 处理函数
 		 * @overload
-		 * @param {Handler} handler 要注册的处理函数
+		 * @param {...Handler} handlers 要注册的处理函数
 		 * @returns {() => void}
 		 */
 		/**
 		 * 注册 HTTP DELETE 处理函数
 		 * @overload
 		 * @param {string} path 要注册的路径
-		 * @param {Handler} handler 要注册的处理函数
+		 * @param {...Handler} handlers 要注册的处理函数
 		 * @returns {() => void}
 		 */
 		/**
 		 * 注册 HTTP DELETE 处理函数
 		 * @overload
 		 * @param {string} path 要注册的路径
-		 * @returns {Binder}
+		 * @returns {Binder<T>}
 		 */
 		/**
 		 * 注册 HTTP DELETE 处理函数
 		 * @overload
 		 * @param {TemplateStringsArray} template 要注册的路径模板
 		 * @param {...any} substitutions 要注册的路径模板代替内容
-		 * @returns {Binder}
+		 * @returns {Binder<T>}
 		 */
 		/**
 		 * @param {...any} p 要注册的路径
-		 * @returns {Binder | (() => void)}
+		 * @returns {Binder<T> | (() => void)}
 		 */
 		delete(...p) { return verb(this.#routes, ['DELETE'], p); }
 		/**
 		 * 注册 HTTP HEAD 处理函数
 		 * @overload
-		 * @param {Handler} handler 要注册的处理函数
+		 * @param {...Handler} handlers 要注册的处理函数
 		 * @returns {() => void}
 		 */
 		/**
 		 * 注册 HTTP HEAD 处理函数
 		 * @overload
 		 * @param {string} path 要注册的路径
-		 * @param {Handler} handler 要注册的处理函数
+		 * @param {...Handler} handlers 要注册的处理函数
 		 * @returns {() => void}
 		 */
 		/**
 		 * 注册 HTTP HEAD 处理函数
 		 * @overload
 		 * @param {string} path 要注册的路径
-		 * @returns {Binder}
+		 * @returns {Binder<T>}
 		 */
 		/**
 		 * 注册 HTTP HEAD 处理函数
 		 * @overload
 		 * @param {TemplateStringsArray} template 要注册的路径模板
 		 * @param {...any} substitutions 要注册的路径模板代替内容
-		 * @returns {Binder}
+		 * @returns {Binder<T>}
 		 */
 		/**
 		 * @param {...any} p 要注册的路径
-		 * @returns {Binder | (() => void)}
+		 * @returns {Binder<T> | (() => void)}
 		 */
 		head(...p) { return verb(this.#routes, ['HEAD'], p); }
 		/**
 		 * 注册 HTTP OPTIONS 处理函数
 		 * @overload
-		 * @param {Handler} handler 要注册的处理函数
+		 * @param {...Handler} handlers 要注册的处理函数
 		 * @returns {() => void}
 		 */
 		/**
 		 * 注册 HTTP OPTIONS 处理函数
 		 * @overload
 		 * @param {string} path 要注册的路径
-		 * @param {Handler} handler 要注册的处理函数
+		 * @param {...Handler} handlers 要注册的处理函数
 		 * @returns {() => void}
 		 */
 		/**
 		 * 注册 HTTP OPTIONS 处理函数
 		 * @overload
 		 * @param {string} path 要注册的路径
-		 * @returns {Binder}
+		 * @returns {Binder<T>}
 		 */
 		/**
 		 * 注册 HTTP OPTIONS 处理函数
 		 * @overload
 		 * @param {TemplateStringsArray} template 要注册的路径模板
 		 * @param {...any} substitutions 要注册的路径模板代替内容
-		 * @returns {Binder}
+		 * @returns {Binder<T>}
 		 */
 		/**
 		 * @param {...any} p 要注册的路径
-		 * @returns {Binder | (() => void)}
+		 * @returns {Binder<T> | (() => void)}
 		 */
 		options(...p) { return verb(this.#routes, ['OPTIONS'], p); }
 	}
@@ -1436,30 +1466,6 @@
 		};
 	}
 
-	/** @import { Context, Handler, HandlerResult } from './main/types' */
-	/**
-	 * @callback Onionskin
-	 * @param {Context} ctx
-	 * @param {() => Promise<HandlerResult>} next
-	 * @returns {PromiseLike<HandlerResult> | HandlerResult}
-	 */
-
-	const noop = () => {};
-	/**
-	 *
-	 * @param  {...(Onionskin | Onionskin[])} handlers
-	 * @returns {Handler}
-	 */
-	function onionskin(...handlers) {
-		/** @type {Handler} */
-		let handler = noop;
-		for (const os of handlers.flat()) {
-			const currentHandler = handler;
-			handler = async ctx => os(ctx, async () => currentHandler(ctx));
-		}
-		return handler;
-	}
-
 	/** @import { Context } from './main/types.js' */
 	class Param {
 		#symbol = Symbol();
@@ -1496,15 +1502,13 @@
 		}
 	}
 
-	exports.ApiRouter = ApiRouter;
+	exports.MapRouter = MapRouter;
 	exports.Param = Param;
 	exports.Router = Router;
+	exports.bind = bind$1;
 	exports.createFetch = createFetch;
 	exports.main = main;
 	exports.make = make;
-	exports.merge = merge;
-	exports.onionskin = onionskin;
-	exports.packer = packer;
 	exports.service = service;
 	exports.stateService = stateService;
 	exports.storeService = storeService;