k99 0.8.0 → 0.9.1

package/index.mjs

@@ -1,5 +1,5 @@
 /*!
- * k99 v0.8.0
+ * k99 v0.9.1
  * (c) 2019-2026 猛火Fierflame
  * @license MIT
  */
@@ -407,7 +407,7 @@ function main(request, getHandler, {
 				if (result instanceof Response) { return result; }
 				const headers = new Headers(context.responseHeaders);
 				const { status } = context;
-				if (!result) { return new Response(null, { status, headers }); }
+				if (!result == null) { return new Response(null, { status, headers }); }
 				const body = toBody(result, headers, replacer, aborted);
 				return new Response(body, { status, headers });
 			}).then(response => {
@@ -426,40 +426,151 @@ function main(request, getHandler, {
 	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}`.toUpperCase();
+		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, HandlerResult } 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<HandlerResult>}
+ * @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' */
@@ -641,151 +752,6 @@ function storeService(destroy, exec, options) {
 	return service;
 }
 
-/** @import { Handler } from './main/types' */
-/** @import { Onionskin } from './onionskin.mjs' */
-/**
- * @callback Packer
- * @param {Handler | Handler[]} handler
- * @returns {Handler | 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 () => runHandles(ctx, [handler].flat()));
-	};
-}
-
-/** @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 | 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 {string} t 
- * @returns 
- */
-function uriDecode(t) {
-	try {
-		return decodeURIComponent(t);
-	} catch {
-		return t;
-	}
-}
-/**
- * @abstract
- */
-class Router {
-	disabled = false;
-	/**
-	 * 
-	 * @param {Router | Handler[] | Handler} route 
-	 * @param {string[]} path 
-	 * @param {Context} ctx 
-	 * @param {(v: Params) => void} setParams 
-	 * @param {Params} params 
-	 * @returns {Promise<Handler[] | null>}
-	 */
-	static async #find(route, path, ctx, setParams, params) {
-		if (!(route instanceof Router)) {
-			setParams(params);
-			return [route].flat();
-		}
-		if (route.disabled) { return null; }
-		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 Router.#find(r, p, ctx, setParams, { ...params, ...result });
-			if (res) { return [route.#guards, route.#onionskin(res)].flat(); }
-		}
-		return null;
-	}
-	/**
-	 * @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 Router.#find(route, path, ctx, setParams, {});
-				if (res) { return res; }
-			}
-			return null;
-		};
-	}
-
-
-	/** @type {Handler[]} */
-	#guards = [];
-	/**
-	 * 
-	 * @param  {...Handler | Handler[]} guards 
-	 */
-	guard(...guards) {
-		const list =this.#guards;
-		for (const guard of guards.flat()) {
-			if (typeof guard !== 'function') { continue; }
-			list.push(guard);
-		}
-	}
-
-	/**
-	 * 
-	 * @param {Finder} find 
-	 * @returns {Router}
-	 */
-	static create(find) {
-		return Object.defineProperties(new Router(), {
-			'find': { configurable: true, value: find, writable: true },
-		});
-	}
-	/**
-	 * 
-	 * @param {Handler | Handler[]} h 
-	 * @returns {Handler | 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' */
 /**
@@ -968,19 +934,20 @@ 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} */
+	/** @type {Route<T>} */
 	const route = { match, methods, handlers: handlers };
 	routes.push(route);
 	let removed = false;
@@ -992,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]
@@ -1048,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' */
 
 /**
@@ -1057,78 +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 {Handler[]} handlers 处理函数
+ * @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);
@@ -1141,10 +1155,9 @@ 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;
@@ -1164,7 +1177,7 @@ class ApiRouter extends Router {
 	 * 注册处理函数
 	 * @overload
 	 * @param {Method | Iterable<Method> | ArrayLike<Method>} method  要注册的方法
-	 * @param {Handler} handler 要注册的处理函数
+	 * @param {T} handler 要注册的处理函数
 	 * @returns {() => void}
 	 */
 	/**
@@ -1172,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}
 	 */
 	/**
@@ -1180,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) {
 		const allMethods = getMethods(methods);
 		if (!allMethods.length) { return () => {}; }
 		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} handlers 要注册的处理函数
+	 * @param {...T} handlers 要注册的处理函数
 	 * @returns {() => void}
 	 */
 	/**
 	 * 注册处理函数
 	 * @overload
 	 * @param {string} path 要注册的路径
-	 * @param {...Handler} handlers 要注册的处理函数
+	 * @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);
@@ -1243,18 +1266,18 @@ class ApiRouter extends Router {
 	 * 注册 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); }
 	/**
@@ -1274,18 +1297,18 @@ class ApiRouter extends Router {
 	 * 注册 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); }
 	/**
@@ -1305,18 +1328,18 @@ class ApiRouter extends Router {
 	 * 注册 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); }
 	/**
@@ -1336,18 +1359,18 @@ class ApiRouter extends Router {
 	 * 注册 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); }
 	/**
@@ -1367,18 +1390,18 @@ class ApiRouter extends Router {
 	 * 注册 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); }
 	/**
@@ -1398,18 +1421,18 @@ class ApiRouter extends Router {
 	 * 注册 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); }
 }
@@ -1437,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();
@@ -1497,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 };