k99 0.8.0 → 0.9.1

package/index.js

@@ -1,5 +1,5 @@
 /*!
- * k99 v0.8.0
+ * k99 v0.9.1
  * (c) 2019-2026 猛火Fierflame
  * @license MIT
  */
@@ -413,7 +413,7 @@
 					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 => {
@@ -432,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}`.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' */
@@ -647,151 +758,6 @@
 		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' */
 	/**
@@ -974,19 +940,20 @@
 		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;
@@ -998,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]
@@ -1054,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' */
 
 	/**
@@ -1063,78 +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 {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);
@@ -1147,10 +1161,9 @@
 		 *
 		 * @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;
@@ -1170,7 +1183,7 @@
 		 * 注册处理函数
 		 * @overload
 		 * @param {Method | Iterable<Method> | ArrayLike<Method>} method  要注册的方法
-		 * @param {Handler} handler 要注册的处理函数
+		 * @param {T} handler 要注册的处理函数
 		 * @returns {() => void}
 		 */
 		/**
@@ -1178,7 +1191,7 @@
 		 * @overload
 		 * @param {Method | Iterable<Method> | ArrayLike<Method>} method  要注册的方法
 		 * @param {string} path 要注册的路径
-		 * @param {Handler} handler 要注册的处理函数
+		 * @param {T} handler 要注册的处理函数
 		 * @returns {() => void}
 		 */
 		/**
@@ -1186,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) {
 			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);
@@ -1249,18 +1272,18 @@
 		 * 注册 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); }
 		/**
@@ -1280,18 +1303,18 @@
 		 * 注册 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); }
 		/**
@@ -1311,18 +1334,18 @@
 		 * 注册 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); }
 		/**
@@ -1342,18 +1365,18 @@
 		 * 注册 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); }
 		/**
@@ -1373,18 +1396,18 @@
 		 * 注册 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); }
 		/**
@@ -1404,18 +1427,18 @@
 		 * 注册 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); }
 	}
@@ -1443,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();
@@ -1503,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;