k99 0.7.1 → 0.9.0

package/index.mjs

@@ -1,14 +1,15 @@
 /*!
- * k99 v0.7.1
- * (c) 2019-2025 猛火Fierflame
+ * k99 v0.9.0
+ * (c) 2019-2026 猛火Fierflame
  * @license MIT
  */
 /**
  *
  * @param {string} str
- * @returns {Uint8Array}
+ * @returns {Uint8Array<ArrayBuffer>}
  */
 function str2utf8bin(str) {
+	// @ts-ignore
 	return new TextEncoder().encode(str);
 }
 /**
@@ -47,26 +48,15 @@ async function write(writer, chunk) {
 	}
 }
 
-/**
- *
- * @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, ''];
 	}
@@ -80,11 +70,16 @@ function toBodyData(result, aborted) {
 		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;
@@ -111,11 +106,12 @@ function toBodyData(result, aborted) {
  *
  * @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')) {
@@ -209,7 +205,7 @@ function clearCookie(
 	}
 }
 
-/** @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']);
@@ -262,6 +258,18 @@ function getMethod(request, toMethod) {
 	}
 	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
@@ -269,10 +277,15 @@ function getMethod(request, toMethod) {
  * @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
@@ -296,12 +309,12 @@ function main(
 		/** @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 = {};
@@ -319,7 +332,7 @@ function main(
 				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) {
@@ -364,7 +377,7 @@ function main(
 			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);
 			},
 			/**
@@ -382,16 +395,22 @@ function main(
 			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;
@@ -407,40 +426,151 @@ function main(
 	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' */
@@ -622,162 +752,6 @@ function storeService(destroy, exec, options) {
 	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' */
 /**
@@ -960,20 +934,21 @@ function toMatch(path, end) {
 	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 () => {
@@ -984,45 +959,45 @@ function bind(routes, methods, match, handlers) {
 		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]
@@ -1040,7 +1015,7 @@ function getMethods(methods) {
 		.filter(isMethod);
 }
 
-/** @import { Context, Handler, Method, Params } from '../main/types' */
+/** @import { Handler, Method, Params } from '../main/types' */
 /** @import { Finder, FindItem } from '../Router.mjs' */
 
 /**
@@ -1049,79 +1024,125 @@ function getMethods(methods) {
  * @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);
@@ -1134,30 +1155,29 @@ class ApiRouter extends Router {
 	 *
 	 * @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}
 	 */
 	/**
@@ -1165,7 +1185,7 @@ class ApiRouter extends Router {
 	 * @overload
 	 * @param {Method | Iterable<Method> | ArrayLike<Method>} method  要注册的方法
 	 * @param {string} path 要注册的路径
-	 * @param {Handler} handler 要注册的处理函数
+	 * @param {T} handler 要注册的处理函数
 	 * @returns {() => void}
 	 */
 	/**
@@ -1173,48 +1193,58 @@ class ApiRouter extends Router {
 	 * @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);
@@ -1222,187 +1252,187 @@ class ApiRouter extends Router {
 	/**
 	 * 注册 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); }
 }
@@ -1430,30 +1460,6 @@ function createFetch(run, notFound) {
 	};
 }
 
-/** @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();
@@ -1490,4 +1496,4 @@ class Param {
 	}
 }
 
-export { ApiRouter, Param, Router, createFetch, main, make, merge, onionskin, packer, service, stateService, storeService };
+export { MapRouter, Param, Router, bind$1 as bind, createFetch, main, make, service, stateService, storeService };