@eggjs/router 4.0.0-beta.20 → 4.0.0-beta.22

package/dist/Router-CWrZ5wcC.js

@@ -1,676 +0,0 @@
-import { Layer } from "./Layer-CPiRgFSm.js";
-import assert from "node:assert";
-import methods from "methods";
-import { debuglog } from "node:util";
-import compose from "koa-compose";
-import HttpError from "http-errors";
-
-//#region src/Router.ts
-const debug = debuglog("egg/router:Router");
-var Router = class {
-	opts;
-	methods;
-	/** Layer stack */
-	stack = [];
-	params = {};
-	/**
-	* Create a new router.
-	*
-	* @example
-	*
-	* Basic usage:
-	*
-	* ```javascript
-	* var Koa = require('koa');
-	* var Router = require('koa-router');
-	*
-	* var app = new Koa();
-	* var router = new Router();
-	*
-	* router.get('/', (ctx, next) => {
-	*   // ctx.router available
-	* });
-	*
-	* app
-	*   .use(router.routes())
-	*   .use(router.allowedMethods());
-	* ```
-	*
-	* @alias module:koa-router
-	* @param {Object=} opts optional
-	* @param {String=} opts.prefix prefix router paths
-	* @class
-	*/
-	constructor(opts) {
-		this.opts = opts ?? {};
-		this.methods = this.opts.methods ?? [
-			"HEAD",
-			"OPTIONS",
-			"GET",
-			"PUT",
-			"PATCH",
-			"POST",
-			"DELETE"
-		];
-	}
-	use(pathOrMiddleware, ...middlewares) {
-		if (Array.isArray(pathOrMiddleware) && typeof pathOrMiddleware[0] === "string") {
-			for (const path$1 of pathOrMiddleware) this.use(path$1, ...middlewares);
-			return this;
-		}
-		let path = "";
-		let hasPath = false;
-		if (typeof pathOrMiddleware === "string") {
-			path = pathOrMiddleware;
-			hasPath = true;
-		} else if (typeof pathOrMiddleware === "function") middlewares = [pathOrMiddleware, ...middlewares];
-		for (const m of middlewares) if (m.router) {
-			for (const nestedLayer of m.router.stack) {
-				if (path) nestedLayer.setPrefix(path);
-				if (this.opts.prefix) nestedLayer.setPrefix(this.opts.prefix);
-				this.stack.push(nestedLayer);
-			}
-			if (this.params) for (const key in this.params) m.router.param(key, this.params[key]);
-		} else this.register(path || "(.*)", [], m, {
-			end: false,
-			ignoreCaptures: !hasPath
-		});
-		return this;
-	}
-	/**
-	* Set the path prefix for a Router instance that was already initialized.
-	*
-	* @example
-	*
-	* ```javascript
-	* router.prefix('/things/:thing_id')
-	* ```
-	*
-	* @param {String} prefix prefix string
-	* @return {Router} router instance
-	*/
-	prefix(prefix) {
-		prefix = prefix.replace(/\/$/, "");
-		this.opts.prefix = prefix;
-		for (const layer of this.stack) layer.setPrefix(prefix);
-		return this;
-	}
-	/**
-	* Returns router middleware which dispatches a route matching the request.
-	*
-	* @return {Function} middleware function
-	*/
-	routes() {
-		const dispatch = (ctx, next) => {
-			const routerPath = this.opts.routerPath || ctx.routerPath || ctx.path;
-			const matched = this.match(routerPath, ctx.method);
-			debug("dispatch: %s %s, routerPath: %s, matched: %s", ctx.method, ctx.path, routerPath, matched.route);
-			if (ctx.matched) ctx.matched.push(...matched.path);
-			else ctx.matched = matched.path;
-			ctx.router = this;
-			if (!matched.route) return next();
-			const layerChain = matched.pathAndMethod.reduce((memo, layer) => {
-				memo.push((ctx$1, next$1) => {
-					ctx$1.captures = layer.captures(routerPath);
-					ctx$1.params = layer.params(routerPath, ctx$1.captures, ctx$1.params);
-					ctx$1._matchedRouteName = ctx$1.routerName = layer.name;
-					if (!layer.name) ctx$1._matchedRouteName = void 0;
-					ctx$1._matchedRoute = ctx$1.routerPath = layer.path;
-					return next$1();
-				});
-				return memo.concat(layer.stack);
-			}, []);
-			return compose(layerChain)(ctx, next);
-		};
-		dispatch.router = this;
-		return dispatch;
-	}
-	/**
-	* @alias to routes()
-	*/
-	middleware() {
-		return this.routes();
-	}
-	/**
-	* Returns separate middleware for responding to `OPTIONS` requests with
-	* an `Allow` header containing the allowed methods, as well as responding
-	* with `405 Method Not Allowed` and `501 Not Implemented` as appropriate.
-	*
-	* @example
-	*
-	* ```javascript
-	* var Koa = require('koa');
-	* var Router = require('koa-router');
-	*
-	* var app = new Koa();
-	* var router = new Router();
-	*
-	* app.use(router.routes());
-	* app.use(router.allowedMethods());
-	* ```
-	*
-	* **Example with [Boom](https://github.com/hapijs/boom)**
-	*
-	* ```javascript
-	* var Koa = require('koa');
-	* var Router = require('koa-router');
-	* var Boom = require('boom');
-	*
-	* var app = new Koa();
-	* var router = new Router();
-	*
-	* app.use(router.routes());
-	* app.use(router.allowedMethods({
-	*   throw: true,
-	*   notImplemented: () => new Boom.notImplemented(),
-	*   methodNotAllowed: () => new Boom.methodNotAllowed()
-	* }));
-	* ```
-	*
-	* @param {Object=} options optional params
-	* @param {Boolean=} options.throw throw error instead of setting status and header
-	* @param {Function=} options.notImplemented throw the returned value in place of the default NotImplemented error
-	* @param {Function=} options.methodNotAllowed throw the returned value in place of the default MethodNotAllowed error
-	* @return {Function} middleware function
-	*/
-	allowedMethods(options) {
-		const implemented = this.methods;
-		return async function allowedMethods(ctx, next) {
-			await next();
-			if (ctx.status && ctx.status !== 404) return;
-			const allowed = {};
-			ctx.matched.forEach((route) => {
-				route.methods.forEach((method) => {
-					allowed[method] = method;
-				});
-			});
-			const allowedMethods$1 = Object.keys(allowed);
-			if (!implemented.includes(ctx.method)) if (options?.throw) {
-				let notImplementedThrowable;
-				if (typeof options?.notImplemented === "function") notImplementedThrowable = options.notImplemented();
-				else notImplementedThrowable = new HttpError.NotImplemented();
-				throw notImplementedThrowable;
-			} else {
-				ctx.status = 501;
-				ctx.set("Allow", allowedMethods$1.join(", "));
-			}
-			else if (allowedMethods$1.length > 0) {
-				if (ctx.method === "OPTIONS") {
-					ctx.status = 200;
-					ctx.body = "";
-					ctx.set("Allow", allowedMethods$1.join(", "));
-				} else if (!allowed[ctx.method]) if (options?.throw) {
-					let notAllowedThrowable;
-					if (typeof options?.methodNotAllowed === "function") notAllowedThrowable = options.methodNotAllowed();
-					else notAllowedThrowable = new HttpError.MethodNotAllowed();
-					throw notAllowedThrowable;
-				} else {
-					ctx.status = 405;
-					ctx.set("Allow", allowedMethods$1.join(", "));
-				}
-			}
-		};
-	}
-	/**
-	* Redirect `source` to `destination` URL with optional 30x status `code`.
-	*
-	* Both `source` and `destination` can be route names.
-	*
-	* ```javascript
-	* router.redirect('/login', 'sign-in');
-	* ```
-	*
-	* This is equivalent to:
-	*
-	* ```javascript
-	* router.all('/login', ctx => {
-	*   ctx.redirect('/sign-in');
-	*   ctx.status = 301;
-	* });
-	* ```
-	*
-	* @param {String} source URL or route name.
-	* @param {String} destination URL or route name.
-	* @param {Number=} status HTTP status code (default: 301).
-	* @return {Router} router instance
-	*/
-	redirect(source, destination, status = 301) {
-		if (source[0] !== "/") {
-			const routeUrl = this.url(source);
-			if (routeUrl instanceof Error) throw routeUrl;
-			source = routeUrl;
-		}
-		if (destination[0] !== "/") {
-			const routeUrl = this.url(destination);
-			if (routeUrl instanceof Error) throw routeUrl;
-			destination = routeUrl;
-		}
-		return this.all(source, (ctx) => {
-			ctx.redirect(destination);
-			ctx.status = status;
-		});
-	}
-	/**
-	* Create and register a route.
-	*
-	* @param {String|RegExp|(String|RegExp)[]} path Path string.
-	* @param {String[]} methods Array of HTTP verbs.
-	* @param {Function|Function[]} middleware Multiple middleware also accepted.
-	* @param {Object} [opts] optional params
-	* @private
-	*/
-	register(path, methods$1, middleware, opts) {
-		if (Array.isArray(path)) {
-			const routes = [];
-			for (const p of path) {
-				const route = this.#register(p, methods$1, middleware, opts);
-				routes.push(route);
-			}
-			return routes;
-		}
-		return this.#register(path, methods$1, middleware, opts);
-	}
-	#register(path, methods$1, middleware, opts) {
-		opts = opts ?? {};
-		const route = new Layer(path, methods$1, middleware, {
-			end: opts.end === false ? opts.end : true,
-			name: opts.name,
-			sensitive: opts.sensitive ?? this.opts.sensitive ?? false,
-			strict: opts.strict ?? this.opts.strict ?? false,
-			prefix: opts.prefix ?? this.opts.prefix ?? "",
-			ignoreCaptures: opts.ignoreCaptures
-		});
-		if (this.opts.prefix) route.setPrefix(this.opts.prefix);
-		for (const param in this.params) route.param(param, this.params[param]);
-		this.stack.push(route);
-		return route;
-	}
-	/**
-	* Lookup route with given `name`.
-	*
-	* @param {String} name route name
-	* @return {Layer|false} layer instance of false
-	*/
-	route(name) {
-		for (const route of this.stack) if (route.name === name) return route;
-		return false;
-	}
-	/**
-	* Generate URL for route. Takes a route name and map of named `params`.
-	*
-	* @example
-	*
-	* ```javascript
-	* router.get('user', '/users/:id', (ctx, next) => {
-	*   // ...
-	* });
-	*
-	* router.url('user', 3);
-	* // => "/users/3"
-	*
-	* router.url('user', { id: 3 });
-	* // => "/users/3"
-	*
-	* router.use((ctx, next) => {
-	*   // redirect to named route
-	*   ctx.redirect(ctx.router.url('sign-in'));
-	* })
-	*
-	* router.url('user', { id: 3 }, { query: { limit: 1 } });
-	* // => "/users/3?limit=1"
-	*
-	* router.url('user', { id: 3 }, { query: "limit=1" });
-	* // => "/users/3?limit=1"
-	* ```
-	*/
-	url(name, params, ...paramsOrOptions) {
-		const route = this.route(name);
-		if (route) return route.url(params, ...paramsOrOptions);
-		return /* @__PURE__ */ new Error(`No route found for name: ${name}`);
-	}
-	/**
-	* Generate URL from url pattern and given `params`.
-	*
-	* @example
-	*
-	* ```javascript
-	* var url = Router.url('/users/:id', { id: 1 });
-	* // => "/users/1"
-	* ```
-	*
-	* @param {String} path url pattern
-	* @param {Object} params url parameters
-	* @return {String} url string
-	*/
-	static url(path, params, ...paramsOrOptions) {
-		return Layer.prototype.url.call({ path }, params, ...paramsOrOptions);
-	}
-	/**
-	* Match given `path` and return corresponding routes.
-	*
-	* @param {String} path path string
-	* @param {String} method method name
-	* @return {Object.<path, pathAndMethod>} returns layers that matched path and
-	* path and method.
-	* @private
-	*/
-	match(path, method) {
-		const matched = {
-			path: [],
-			pathAndMethod: [],
-			route: false
-		};
-		for (const layer of this.stack) {
-			debug("test %s %s", layer.path, layer.regexp);
-			if (layer.match(path)) {
-				matched.path.push(layer);
-				if (layer.methods.length === 0 || layer.methods.includes(method)) {
-					matched.pathAndMethod.push(layer);
-					if (layer.methods.length > 0) matched.route = true;
-				}
-			}
-		}
-		return matched;
-	}
-	/**
-	* Run middleware for named route parameters. Useful for auto-loading or
-	* validation.
-	*
-	* @example
-	*
-	* ```javascript
-	* router
-	*   .param('user', (id, ctx, next) => {
-	*     ctx.user = users[id];
-	*     if (!ctx.user) return ctx.status = 404;
-	*     return next();
-	*   })
-	*   .get('/users/:user', ctx => {
-	*     ctx.body = ctx.user;
-	*   })
-	*   .get('/users/:user/friends', ctx => {
-	*     return ctx.user.getFriends().then(function(friends) {
-	*       ctx.body = friends;
-	*     });
-	*   })
-	*   // /users/3 => {"id": 3, "name": "Alex"}
-	*   // /users/3/friends => [{"id": 4, "name": "TJ"}]
-	* ```
-	*
-	* @param {String} param param
-	* @param {Function} middleware route middleware
-	* @return {Router} instance
-	*/
-	param(param, middleware) {
-		this.params[param] = middleware;
-		for (const route of this.stack) route.param(param, middleware);
-		return this;
-	}
-	_formatRouteParams(nameOrPath, pathOrMiddleware, middlewares) {
-		const options = {};
-		let path;
-		if (typeof nameOrPath === "string" && nameOrPath.startsWith("/")) {
-			path = nameOrPath;
-			middlewares = [pathOrMiddleware, ...middlewares];
-			if (typeof pathOrMiddleware === "string") options.name = pathOrMiddleware;
-		} else if (nameOrPath instanceof RegExp) {
-			path = nameOrPath;
-			middlewares = [pathOrMiddleware, ...middlewares];
-			if (typeof pathOrMiddleware === "string") options.name = pathOrMiddleware;
-		} else if (Array.isArray(nameOrPath)) {
-			path = nameOrPath;
-			middlewares = [pathOrMiddleware, ...middlewares];
-			if (typeof pathOrMiddleware === "string") options.name = pathOrMiddleware;
-		} else if (typeof pathOrMiddleware === "string" || pathOrMiddleware instanceof RegExp) {
-			path = pathOrMiddleware;
-			assert(typeof nameOrPath === "string", "route name should be string");
-			options.name = nameOrPath;
-		} else if (Array.isArray(pathOrMiddleware)) {
-			path = pathOrMiddleware;
-			assert(typeof nameOrPath === "string", "route name should be string");
-			options.name = nameOrPath;
-		} else {
-			path = nameOrPath;
-			middlewares = [pathOrMiddleware, ...middlewares];
-		}
-		return {
-			path,
-			middlewares,
-			options
-		};
-	}
-	/**
-	* Create `router.verb()` methods, where *verb* is one of the HTTP verbs such
-	* as `router.get()` or `router.post()`.
-	*
-	* Match URL patterns to callback functions or controller actions using `router.verb()`,
-	* where **verb** is one of the HTTP verbs such as `router.get()` or `router.post()`.
-	*
-	* Additionally, `router.all()` can be used to match against all methods.
-	*
-	* ```javascript
-	* router
-	*   .get('/', (ctx, next) => {
-	*     ctx.body = 'Hello World!';
-	*   })
-	*   .post('/users', (ctx, next) => {
-	*     // ...
-	*   })
-	*   .put('/users/:id', (ctx, next) => {
-	*     // ...
-	*   })
-	*   .del('/users/:id', (ctx, next) => {
-	*     // ...
-	*   })
-	*   .all('/users/:id', (ctx, next) => {
-	*     // ...
-	*   });
-	* ```
-	*
-	* When a route is matched, its path is available at `ctx._matchedRoute` and if named,
-	* the name is available at `ctx._matchedRouteName`
-	*
-	* Route paths will be translated to regular expressions using
-	* [path-to-regexp](https://github.com/pillarjs/path-to-regexp).
-	*
-	* Query strings will not be considered when matching requests.
-	*
-	* #### Named routes
-	*
-	* Routes can optionally have names. This allows generation of URLs and easy
-	* renaming of URLs during development.
-	*
-	* ```javascript
-	* router.get('user', '/users/:id', (ctx, next) => {
-	*  // ...
-	* });
-	*
-	* router.url('user', 3);
-	* // => "/users/3"
-	* ```
-	*
-	* #### Multiple middleware
-	*
-	* Multiple middleware may be given:
-	*
-	* ```javascript
-	* router.get(
-	*   '/users/:id',
-	*   (ctx, next) => {
-	*     return User.findOne(ctx.params.id).then(function(user) {
-	*       ctx.user = user;
-	*       next();
-	*     });
-	*   },
-	*   ctx => {
-	*     console.log(ctx.user);
-	*     // => { id: 17, name: "Alex" }
-	*   }
-	* );
-	* ```
-	*
-	* ### Nested routers
-	*
-	* Nesting routers is supported:
-	*
-	* ```javascript
-	* var forums = new Router();
-	* var posts = new Router();
-	*
-	* posts.get('/', (ctx, next) => {...});
-	* posts.get('/:pid', (ctx, next) => {...});
-	* forums.use('/forums/:fid/posts', posts.routes(), posts.allowedMethods());
-	*
-	* // responds to "/forums/123/posts" and "/forums/123/posts/123"
-	* app.use(forums.routes());
-	* ```
-	*
-	* #### Router prefixes
-	*
-	* Route paths can be prefixed at the router level:
-	*
-	* ```javascript
-	* var router = new Router({
-	*   prefix: '/users'
-	* });
-	*
-	* router.get('/', ...); // responds to "/users"
-	* router.get('/:id', ...); // responds to "/users/:id"
-	* ```
-	*
-	* #### URL parameters
-	*
-	* Named route parameters are captured and added to `ctx.params`.
-	*
-	* ```javascript
-	* router.get('/:category/:title', (ctx, next) => {
-	*   console.log(ctx.params);
-	*   // => { category: 'programming', title: 'how-to-node' }
-	* });
-	* ```
-	*
-	* The [path-to-regexp](https://github.com/pillarjs/path-to-regexp) module is
-	* used to convert paths to regular expressions.
-	*
-	*/
-	verb(method, nameOrPath, pathOrMiddleware, ...middleware) {
-		const { options, path, middlewares } = this._formatRouteParams(nameOrPath, pathOrMiddleware, middleware);
-		if (typeof method === "string") method = [method];
-		this.register(path, method, middlewares, options);
-		return this;
-	}
-	all(nameOrPath, pathOrMiddleware, ...middlewares) {
-		return this.verb(methods, nameOrPath, pathOrMiddleware, ...middlewares);
-	}
-	acl(nameOrPath, pathOrMiddleware, ...middlewares) {
-		return this.verb("acl", nameOrPath, pathOrMiddleware, ...middlewares);
-	}
-	bind(nameOrPath, pathOrMiddleware, ...middlewares) {
-		return this.verb("bind", nameOrPath, pathOrMiddleware, ...middlewares);
-	}
-	checkout(nameOrPath, pathOrMiddleware, ...middlewares) {
-		return this.verb("checkout", nameOrPath, pathOrMiddleware, ...middlewares);
-	}
-	connect(nameOrPath, pathOrMiddleware, ...middlewares) {
-		return this.verb("connect", nameOrPath, pathOrMiddleware, ...middlewares);
-	}
-	copy(nameOrPath, pathOrMiddleware, ...middlewares) {
-		return this.verb("copy", nameOrPath, pathOrMiddleware, ...middlewares);
-	}
-	delete(nameOrPath, pathOrMiddleware, ...middlewares) {
-		return this.verb("delete", nameOrPath, pathOrMiddleware, ...middlewares);
-	}
-	del(nameOrPath, pathOrMiddleware, ...middlewares) {
-		return this.verb("delete", nameOrPath, pathOrMiddleware, ...middlewares);
-	}
-	get(nameOrPath, pathOrMiddleware, ...middlewares) {
-		return this.verb("get", nameOrPath, pathOrMiddleware, ...middlewares);
-	}
-	query(nameOrPath, pathOrMiddleware, ...middlewares) {
-		return this.verb("query", nameOrPath, pathOrMiddleware, ...middlewares);
-	}
-	head(nameOrPath, pathOrMiddleware, ...middlewares) {
-		return this.verb("head", nameOrPath, pathOrMiddleware, ...middlewares);
-	}
-	link(nameOrPath, pathOrMiddleware, ...middlewares) {
-		return this.verb("link", nameOrPath, pathOrMiddleware, ...middlewares);
-	}
-	lock(nameOrPath, pathOrMiddleware, ...middlewares) {
-		return this.verb("lock", nameOrPath, pathOrMiddleware, ...middlewares);
-	}
-	["m-search"](nameOrPath, pathOrMiddleware, ...middlewares) {
-		return this.verb("m-search", nameOrPath, pathOrMiddleware, ...middlewares);
-	}
-	merge(nameOrPath, pathOrMiddleware, ...middlewares) {
-		return this.verb("merge", nameOrPath, pathOrMiddleware, ...middlewares);
-	}
-	mkactivity(nameOrPath, pathOrMiddleware, ...middlewares) {
-		return this.verb("mkactivity", nameOrPath, pathOrMiddleware, ...middlewares);
-	}
-	mkcalendar(nameOrPath, pathOrMiddleware, ...middlewares) {
-		return this.verb("mkcalendar", nameOrPath, pathOrMiddleware, ...middlewares);
-	}
-	mkcol(nameOrPath, pathOrMiddleware, ...middlewares) {
-		return this.verb("mkcol", nameOrPath, pathOrMiddleware, ...middlewares);
-	}
-	move(nameOrPath, pathOrMiddleware, ...middlewares) {
-		return this.verb("move", nameOrPath, pathOrMiddleware, ...middlewares);
-	}
-	notify(nameOrPath, pathOrMiddleware, ...middlewares) {
-		return this.verb("notify", nameOrPath, pathOrMiddleware, ...middlewares);
-	}
-	options(nameOrPath, pathOrMiddleware, ...middlewares) {
-		return this.verb("options", nameOrPath, pathOrMiddleware, ...middlewares);
-	}
-	patch(nameOrPath, pathOrMiddleware, ...middlewares) {
-		return this.verb("patch", nameOrPath, pathOrMiddleware, ...middlewares);
-	}
-	post(nameOrPath, pathOrMiddleware, ...middlewares) {
-		return this.verb("post", nameOrPath, pathOrMiddleware, ...middlewares);
-	}
-	propfind(nameOrPath, pathOrMiddleware, ...middlewares) {
-		return this.verb("propfind", nameOrPath, pathOrMiddleware, ...middlewares);
-	}
-	proppatch(nameOrPath, pathOrMiddleware, ...middlewares) {
-		return this.verb("proppatch", nameOrPath, pathOrMiddleware, ...middlewares);
-	}
-	purge(nameOrPath, pathOrMiddleware, ...middlewares) {
-		return this.verb("purge", nameOrPath, pathOrMiddleware, ...middlewares);
-	}
-	put(nameOrPath, pathOrMiddleware, ...middlewares) {
-		return this.verb("put", nameOrPath, pathOrMiddleware, ...middlewares);
-	}
-	rebind(nameOrPath, pathOrMiddleware, ...middlewares) {
-		return this.verb("rebind", nameOrPath, pathOrMiddleware, ...middlewares);
-	}
-	report(nameOrPath, pathOrMiddleware, ...middlewares) {
-		return this.verb("report", nameOrPath, pathOrMiddleware, ...middlewares);
-	}
-	search(nameOrPath, pathOrMiddleware, ...middlewares) {
-		return this.verb("search", nameOrPath, pathOrMiddleware, ...middlewares);
-	}
-	source(nameOrPath, pathOrMiddleware, ...middlewares) {
-		return this.verb("source", nameOrPath, pathOrMiddleware, ...middlewares);
-	}
-	subscribe(nameOrPath, pathOrMiddleware, ...middlewares) {
-		return this.verb("subscribe", nameOrPath, pathOrMiddleware, ...middlewares);
-	}
-	trace(nameOrPath, pathOrMiddleware, ...middlewares) {
-		return this.verb("trace", nameOrPath, pathOrMiddleware, ...middlewares);
-	}
-	unbind(nameOrPath, pathOrMiddleware, ...middlewares) {
-		return this.verb("unbind", nameOrPath, pathOrMiddleware, ...middlewares);
-	}
-	unlink(nameOrPath, pathOrMiddleware, ...middlewares) {
-		return this.verb("unlink", nameOrPath, pathOrMiddleware, ...middlewares);
-	}
-	unlock(nameOrPath, pathOrMiddleware, ...middlewares) {
-		return this.verb("unlock", nameOrPath, pathOrMiddleware, ...middlewares);
-	}
-	unsubscribe(nameOrPath, pathOrMiddleware, ...middlewares) {
-		return this.verb("unsubscribe", nameOrPath, pathOrMiddleware, ...middlewares);
-	}
-};
-
-//#endregion
-export { Router };

package/dist/types-CxAOQAAb.js

@@ -1 +0,0 @@
-export {  };

package/dist/types-DvonNcgV.d.ts

@@ -1,21 +0,0 @@
-//#region src/types.d.ts
-type Next = () => Promise<void>;
-type MiddlewareFunc = (ctx: any, next: Next) => Promise<void> | void;
-type MiddlewareFuncWithParamProperty = MiddlewareFunc & {
-  param?: string;
-};
-type ParamMiddlewareFunc = (param: string, ctx: any, next: Next) => Promise<void> | void;
-type MiddlewareFuncWithRouter<T> = MiddlewareFunc & {
-  router: T;
-};
-interface ResourcesController {
-  index?: MiddlewareFunc;
-  new?: MiddlewareFunc;
-  create?: MiddlewareFunc;
-  show?: MiddlewareFunc;
-  edit?: MiddlewareFunc;
-  update?: MiddlewareFunc;
-  destroy?: MiddlewareFunc;
-}
-//#endregion
-export { MiddlewareFunc, MiddlewareFuncWithParamProperty, MiddlewareFuncWithRouter, Next, ParamMiddlewareFunc, ResourcesController };