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

package/dist/Router.js

@@ -1,5 +1,776 @@
-import "./Layer-CPiRgFSm.js";
-import "./types-CxAOQAAb.js";
-import { Router } from "./Router-CWrZ5wcC.js";
-
-export { Router };
+/**
+ * RESTful resource routing middleware for eggjs.
+ */
+import { debuglog } from 'node:util';
+import assert from 'node:assert';
+import compose from 'koa-compose';
+import HttpError from 'http-errors';
+import methods from 'methods';
+import { Layer } from "./Layer.js";
+import {} from "./types.js";
+const debug = debuglog('egg/router:Router');
+export class Router {
+    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) {
+        // support array of paths
+        // use(paths, ...middlewares)
+        if (Array.isArray(pathOrMiddleware) && typeof pathOrMiddleware[0] === 'string') {
+            for (const path of pathOrMiddleware) {
+                this.use(path, ...middlewares);
+            }
+            return this;
+        }
+        let path = '';
+        let hasPath = false;
+        if (typeof pathOrMiddleware === 'string') {
+            // use(path, ...middlewares)
+            path = pathOrMiddleware;
+            hasPath = true;
+        }
+        else if (typeof pathOrMiddleware === 'function') {
+            // use(...middlewares)
+            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 matchedLayers = matched.pathAndMethod;
+            const layerChain = matchedLayers.reduce((memo, layer) => {
+                memo.push((ctx, next) => {
+                    // ctx.captures = layer.captures(routerPath, ctx.captures);
+                    ctx.captures = layer.captures(routerPath);
+                    ctx.params = layer.params(routerPath, ctx.captures, ctx.params);
+                    // ctx._matchedRouteName & ctx._matchedRoute for compatibility
+                    ctx._matchedRouteName = ctx.routerName = layer.name;
+                    if (!layer.name) {
+                        ctx._matchedRouteName = undefined;
+                    }
+                    ctx._matchedRoute = ctx.routerPath = layer.path;
+                    return next();
+                });
+                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 = Object.keys(allowed);
+            if (!implemented.includes(ctx.method)) {
+                if (options?.throw) {
+                    let notImplementedThrowable;
+                    if (typeof options?.notImplemented === 'function') {
+                        notImplementedThrowable = options.notImplemented(); // set whatever the user returns from their function
+                    }
+                    else {
+                        notImplementedThrowable = new HttpError.NotImplemented();
+                    }
+                    throw notImplementedThrowable;
+                }
+                else {
+                    ctx.status = 501;
+                    ctx.set('Allow', allowedMethods.join(', '));
+                }
+            }
+            else if (allowedMethods.length > 0) {
+                if (ctx.method === 'OPTIONS') {
+                    ctx.status = 200;
+                    ctx.body = '';
+                    ctx.set('Allow', allowedMethods.join(', '));
+                }
+                else if (!allowed[ctx.method]) {
+                    if (options?.throw) {
+                        let notAllowedThrowable;
+                        if (typeof options?.methodNotAllowed === 'function') {
+                            notAllowedThrowable = options.methodNotAllowed(); // set whatever the user returns from their function
+                        }
+                        else {
+                            notAllowedThrowable = new HttpError.MethodNotAllowed();
+                        }
+                        throw notAllowedThrowable;
+                    }
+                    else {
+                        ctx.status = 405;
+                        ctx.set('Allow', allowedMethods.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) {
+        // lookup source route by name
+        if (source[0] !== '/') {
+            const routeUrl = this.url(source);
+            if (routeUrl instanceof Error) {
+                throw routeUrl;
+            }
+            source = routeUrl;
+        }
+        // lookup destination route by name
+        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, middleware, opts) {
+        // support array of paths
+        if (Array.isArray(path)) {
+            const routes = [];
+            for (const p of path) {
+                const route = this.#register(p, methods, middleware, opts);
+                routes.push(route);
+            }
+            return routes;
+        }
+        // create route
+        const route = this.#register(path, methods, middleware, opts);
+        return route;
+    }
+    #register(path, methods, middleware, opts) {
+        opts = opts ?? {};
+        // create route
+        const route = new Layer(path, methods, 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,
+        });
+        // FIXME: why???
+        if (this.opts.prefix) {
+            route.setPrefix(this.opts.prefix);
+        }
+        // add parameter middleware to the new route layer
+        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 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 = {
+            // matched path
+            path: [],
+            // matched path and method(including none method)
+            pathAndMethod: [],
+            // method matched or not
+            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;
+                    }
+                }
+                // if (layer.methods.length === 0) {
+                //   matched.pathAndMethod.push(layer);
+                // } else if (layer.methods.includes(method)) {
+                //   matched.pathAndMethod.push(layer);
+                //   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('/')) {
+            // verb(method, path, ...middlewares)
+            path = nameOrPath;
+            middlewares = [pathOrMiddleware, ...middlewares];
+            if (typeof pathOrMiddleware === 'string') {
+                // verb(method, path, controllerString)
+                // set controller name to router name
+                options.name = pathOrMiddleware;
+            }
+        }
+        else if (nameOrPath instanceof RegExp) {
+            // verb(method, pathRegex, ...middlewares)
+            path = nameOrPath;
+            middlewares = [pathOrMiddleware, ...middlewares];
+            if (typeof pathOrMiddleware === 'string') {
+                // verb(method, pathRegex, controllerString)
+                // set controller name to router name
+                options.name = pathOrMiddleware;
+            }
+        }
+        else if (Array.isArray(nameOrPath)) {
+            // verb(method, paths, ...middlewares)
+            path = nameOrPath;
+            middlewares = [pathOrMiddleware, ...middlewares];
+            if (typeof pathOrMiddleware === 'string') {
+                // verb(method, pathRegex, controllerString)
+                // set controller name to router name
+                options.name = pathOrMiddleware;
+            }
+        }
+        else if (typeof pathOrMiddleware === 'string' || pathOrMiddleware instanceof RegExp) {
+            // verb(method, name, path, ...middlewares)
+            path = pathOrMiddleware;
+            assert(typeof nameOrPath === 'string', 'route name should be string');
+            options.name = nameOrPath;
+        }
+        else if (Array.isArray(pathOrMiddleware)) {
+            // verb(method, name, paths, ...middlewares)
+            path = pathOrMiddleware;
+            assert(typeof nameOrPath === 'string', 'route name should be string');
+            options.name = nameOrPath;
+        }
+        else {
+            // verb(method, path, ...middlewares)
+            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);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Router.js","sourceRoot":"","sources":["../src/Router.ts"],"names":[],"mappings":"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"}