clear-router 2.7.6 → 2.7.7

package/dist/core/router.d.mts

@@ -0,0 +1,274 @@
+import { ApiResourceMiddleware, ControllerAction, HttpMethod, RouterConfig } from "../types/basic.mjs";
+import { Response } from "./Response.mjs";
+import { Route } from "../Route.mjs";
+import { Request } from "./Request.mjs";
+import { ClearRouterPluginArgumentsContext, ClearRouterPluginInput, ClearRouterPluginRequestContext, PluginArgumentsResolver, PluginBind } from "./plugins.mjs";
+import { Controller } from "../Controller.mjs";
+import { AsyncLocalStorage } from "node:async_hooks";
+
+//#region src/core/router.d.ts
+/**
+ * @class clear-router CoreRouter
+ * @description Core routing logic for clear-router, shared between all supported adapters (Express.js, H3, etc.)
+ * @author 3m1n3nc3
+ * @repository https://github.com/arkstack-tmp/clear-router
+ */
+declare abstract class CoreRouter {
+  protected static routerStateNamespace: string;
+  private static readonly stateStoreKey;
+  private static readonly stateBoundKey;
+  private static readonly defaultConfigKey;
+  private static readonly pluginStoreKey;
+  private static readonly pluginPendingKey;
+  private static readonly pluginHttpCtxResolversKey;
+  private static readonly pluginArgumentResolversKey;
+  private static requestProvider?;
+  private static responseProvider?;
+  static config: RouterConfig;
+  protected static groupContext: AsyncLocalStorage<{
+    prefix: string;
+    groupMiddlewares: any[];
+  }>;
+  protected static pluginRequestContext: AsyncLocalStorage<ClearRouterPluginRequestContext<any>>;
+  static routes: Set<Route<any, any, any>>;
+  static routesByPathMethod: Map<string, Route<any, any, any>>;
+  static routesByMethod: Map<"GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "OPTIONS" | "HEAD", Route<any, any, any>[]>;
+  static routesByName: Map<string, Route<any, any, any>>;
+  static prefix: string;
+  static groupMiddlewares: any[];
+  static globalMiddlewares: any[];
+  /**
+   * Resets the router to it's default state
+   */
+  static reset(): typeof CoreRouter;
+  protected static createBaseConfig(): RouterConfig;
+  protected static mergeConfig(target: RouterConfig, source?: RouterConfig): RouterConfig;
+  protected static getDefaultConfig(): RouterConfig;
+  protected static resolveStateNamespace(): string;
+  protected static getStateStore(): Record<string, any>;
+  protected static getPluginStore(): Set<string>;
+  protected static getPluginPendingStore(): Set<Promise<void>>;
+  protected static getPluginArgumentResolvers(): Set<PluginArgumentsResolver>;
+  protected static getPluginHttpCtxResolvers(): Set<PluginArgumentsResolver>;
+  protected static createDefaultState(): {
+    config: RouterConfig;
+    groupContext: AsyncLocalStorage<{
+      prefix: string;
+      groupMiddlewares: any[];
+    }>;
+    routes: Set<never>;
+    routesByPathMethod: Map<any, any>;
+    routesByMethod: Map<any, any>;
+    routesByName: Map<any, any>;
+    prefix: string;
+    groupMiddlewares: any[];
+    globalMiddlewares: any[];
+  };
+  protected static bindStateAccessors(): void;
+  protected static createDefaultOptionsHandler(): any;
+  /**
+   * Default configuration used for everytime the router is reset
+   *
+   * @param options
+   */
+  static configureDefaults(options?: RouterConfig): void;
+  /**
+   * Use a registered plugin
+   *
+   * @param this
+   * @param plugin
+   * @param options
+   * @returns
+   */
+  static use<Options = any>(plugin: ClearRouterPluginInput<Options>, options?: Options): Promise<void>;
+  protected static pluginsReady(): Promise<void>;
+  protected static getCurrentPluginRequestContext(): ClearRouterPluginRequestContext | undefined;
+  protected static createPluginRequestContext(ctx: any): ClearRouterPluginRequestContext;
+  protected static createPluginBind(): PluginBind;
+  protected static resolvePluginArguments(ctx: any, routeContext: Omit<ClearRouterPluginArgumentsContext, keyof ClearRouterPluginRequestContext>): Promise<any[] | undefined>;
+  protected static resolvePluginHttpCtx(ctx: any): Promise<void>;
+  protected static ensureState(): void;
+  /**
+   * Normalizes a path by ensuring it starts with a single slash and does not have trailing
+   * slashes, while preserving dynamic segments and parameters.
+   *
+   * @param path  The path to normalize.
+   * @returns     The normalized path.
+   */
+  static normalizePath(path: string): string;
+  protected static parseRouteParameters(path: string): Array<{
+    name: string;
+    field?: string;
+    optional: boolean;
+  }>;
+  protected static expandRoutePath(path: string): string[];
+  protected static routeRegistrationPaths(path: string): string[];
+  /**
+   * Configures the router with the given options, such as method override settings.
+   *
+   * @param this
+   * @param options
+   * @returns
+   */
+  static configure(this: any, options?: RouterConfig): void;
+  protected static resolveMethodOverride(method: string, headers: Headers | Record<string, any>, body: unknown): HttpMethod | null;
+  /**
+   * Adds a new route to the router.
+   *
+   * @param this
+   * @param methods
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static add(methods: HttpMethod | HttpMethod[], path: string, handler: any, middlewares?: any[] | any): Route<any, any, any>;
+  /**
+   * Define a resourceful API controller with standard CRUD routes.
+   *
+   * @param this
+   * @param basePath
+   * @param controller
+   * @param options
+   */
+  static apiResource(basePath: string, controller: any, options?: {
+    only?: ControllerAction[];
+    except?: ControllerAction[];
+    middlewares?: ApiResourceMiddleware<any>;
+  }): void;
+  /**
+   * Adds a new GET route to the router.
+   *
+   * @param this          The router instance.
+   * @param path          The path for the GET route.
+   * @param handler       The handler function for the GET route.
+   * @param middlewares   Optional middlewares to apply to the GET route.
+   */
+  static get(path: string, handler: any, middlewares?: any[] | any): Route<any, any, any>;
+  /**
+   * Adds a new POST route to the router.
+   *
+   * @param this
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static post(path: string, handler: any, middlewares?: any[] | any): Route<any, any, any>;
+  /**
+   * Adds a new PUT route to the router.
+   *
+   * @param this
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static put(path: string, handler: any, middlewares?: any[] | any): Route<any, any, any>;
+  /**
+   * Adds a new DELETE route to the router.
+   *
+   * @param this
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static delete(path: string, handler: any, middlewares?: any[] | any): Route<any, any, any>;
+  /**
+   * Adds a new PATCH route to the router.
+   *
+   * @param this
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static patch(path: string, handler: any, middlewares?: any[] | any): Route<any, any, any>;
+  /**
+   * Adds a new OPTIONS route to the router.
+   *
+   * @param this
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static options(path: string, handler: any, middlewares?: any[] | any): Route<any, any, any>;
+  /**
+   * Adds a new HEAD route to the router.
+   *
+   * @param this
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
+  static head(path: string, handler: any, middlewares?: any[] | any): Route<any, any, any>;
+  /**
+   * Defines a group of routes with a common prefix.
+   *
+   * @param this
+   * @param prefix
+   * @param callback
+   * @param middlewares
+   */
+  static group(prefix: string, callback: () => void | Promise<void>, middlewares?: any[]): Promise<void>;
+  /**
+   * Adds global middlewares to the router, which will be applied to all routes.
+   *
+   * @param this
+   * @param middlewares
+   * @param callback
+   */
+  static middleware(middlewares: any[], callback: () => void): void;
+  /**
+   * Retrieves all registered routes in the router, optionally organized by path or method
+   * for easier access and management.
+   *
+   * @param this
+   */
+  static allRoutes(): Array<Route<any, any, any>>;
+  /**
+   * @param this
+   * @param type  - 'path' to get routes organized by path
+   */
+  static allRoutes(type: 'path'): Record<string, Route<any, any, any>>;
+  /**
+   * @param this
+   * @param type  - 'method' to get routes organized by method
+   */
+  static allRoutes(type: 'method'): { [method in Uppercase<HttpMethod>]?: Array<Route<any, any, any>> };
+  static allRoutes(type: 'name'): Record<string, Route<any, any, any>>;
+  static route(name: string): Route<any, any, any> | undefined;
+  static url(name: string, params?: Record<string, any>): string | undefined;
+  /**
+   * Provide a class that will overide the base Request instance
+   *
+   * @param provider
+   */
+  static setRequestProvider(provider: typeof Request): void;
+  /**
+   * Provide a class that will overide the base Response instance
+   *
+   * @param provider
+   */
+  static setResponseProvider(provider: typeof Response): void;
+  private static hasPackageInstalled;
+  /**
+   * Provide a class that will overide the base Response instance
+   *
+   * @param provider
+   */
+  private static initializeInstance;
+  protected static resolveHandler(route: Route<any, any, any>): {
+    handlerFunction: ((ctx: any, req: Request) => any | Promise<any>) | null;
+    instance: Controller<any> | null;
+    bindingTarget?: object;
+    bindingMethod?: PropertyKey;
+    bindingHandler?: object;
+    bindingMetadata?: object;
+  };
+  protected static callHandler(handlerFunction: (ctx: any, req: Request) => any | Promise<any>, ctx: any, bindingTarget?: object, bindingMethod?: PropertyKey, bindingHandler?: object, bindingMetadata?: object): Promise<any>;
+  protected static bindRequestToInstance(ctx: any, instance: Controller<any> | Route<any, any, any> | null, route: Route<any, any, any>, payload: {
+    body: Record<string, any>;
+    query: Record<string, any>;
+    params: Record<string, any>;
+    method?: HttpMethod | string;
+  }): void;
+}
+//#endregion
+export { CoreRouter };

package/dist/{router-Dc9w86Wn.mjs → core/router.mjs}

@@ -1,63 +1,10 @@
-import { a as getStandardMetadata, c as Request, i as getDesignParamTypes, n as Container, o as isClass, r as getBindingMetadataFromTargets, s as Response } from "./bindings-XLDXFpHZ.mjs";
+import { Request } from "./Request.mjs";
+import { Response } from "./Response.mjs";
+import { Container, getBindingMetadataFromTargets, getDesignParamTypes, getStandardMetadata, isClass } from "./bindings.mjs";
+import { Route } from "../Route.mjs";
 import { createRequire } from "node:module";
 import { AsyncLocalStorage } from "node:async_hooks";
 
-//#region src/Route.ts
-var Route = class {
-	ctx;
-	body = {};
-	query = {};
-	params = {};
-	clearRequest;
-	methods;
-	path;
-	registrationPaths;
-	parameters;
-	routeName;
-	handler;
-	middlewares;
-	controllerName;
-	actionName;
-	handlerType;
-	middlewareCount;
-	constructor(methods, path, handler, middlewares = [], options = {}) {
-		this.methods = methods;
-		this.path = path;
-		this.registrationPaths = options.registrationPaths || [path];
-		this.parameters = options.parameters || [];
-		this.handler = handler;
-		this.middlewares = middlewares;
-		this.handlerType = Array.isArray(handler) ? "controller" : "function";
-		this.middlewareCount = middlewares.length;
-		this.controllerName = Array.isArray(handler) ? handler[0]?.name : void 0;
-		this.actionName = Array.isArray(handler) ? handler[1] : typeof handler === "function" ? handler.constructor.name ?? handler.name : void 0;
-		this.onName = options.onName;
-	}
-	onName;
-	name(name) {
-		const previousName = this.routeName;
-		this.routeName = name;
-		this.onName?.(name, this, previousName);
-		return this;
-	}
-	toPath(params = {}) {
-		return this.path.replace(/\/?\{([^{}]+)\}/g, (segment, raw) => {
-			const optional = raw.endsWith("?");
-			const [rawName, rawField] = (optional ? raw.slice(0, -1) : raw).split(":", 2);
-			const name = rawName.trim();
-			const field = rawField?.trim();
-			const value = params[name];
-			const resolved = field && value && typeof value === "object" ? value[field] : value;
-			if (typeof resolved === "undefined" || resolved === null || resolved === "") {
-				if (optional) return "";
-				throw new Error(`Missing required route parameter: ${name}`);
-			}
-			return `${segment.startsWith("/") ? "/" : ""}${encodeURIComponent(String(resolved))}`;
-		}) || "/";
-	}
-};
-
-//#endregion
 //#region src/core/router.ts
 /**
 * @class clear-router CoreRouter
@@ -856,4 +803,4 @@ var CoreRouter = class {
 };
 
 //#endregion
-export { CoreRouter as t };
+export { CoreRouter };

package/dist/decorators/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_bindings = require('../bindings-CLsZjOEy.cjs');
+const require_bindings = require('../core/bindings.cjs');
 
 exports.Bind = require_bindings.Bind;
 exports.Container = require_bindings.Container;

package/dist/decorators/index.d.cts

@@ -1,2 +1,2 @@
-import { a as BindValue, i as BindToken, n as BindDecorator, o as Container, r as BindFactory, t as Bind } from "../bindings-CxvtC8XS.cjs";
+import { Bind, BindDecorator, BindFactory, BindToken, BindValue, Container } from "../core/bindings.cjs";
 export { Bind, type BindDecorator, type BindFactory, type BindToken, type BindValue, Container };

package/dist/decorators/index.d.mts

@@ -1,2 +1,2 @@
-import { a as BindValue, i as BindToken, n as BindDecorator, o as Container, r as BindFactory, t as Bind } from "../bindings-CNL7bpz5.mjs";
+import { Bind, BindDecorator, BindFactory, BindToken, BindValue, Container } from "../core/bindings.mjs";
 export { Bind, type BindDecorator, type BindFactory, type BindToken, type BindValue, Container };

package/dist/decorators/index.mjs

@@ -1,3 +1,3 @@
-import { n as Container, t as Bind } from "../bindings-XLDXFpHZ.mjs";
+import { Bind, Container } from "../core/bindings.mjs";
 
 export { Bind, Container };

package/dist/decorators/setup.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_bindings = require('../bindings-CLsZjOEy.cjs');
-const require_router = require('../router-C6W-k6sS.cjs');
+const require_bindings = require('../core/bindings.cjs');
+const require_router = require('../core/router.cjs');
 require('./index.cjs');
 require("reflect-metadata");
 

package/dist/decorators/setup.d.cts

@@ -1,2 +1,2 @@
-import { a as BindValue, i as BindToken, n as BindDecorator, o as Container, r as BindFactory, t as Bind } from "../bindings-CxvtC8XS.cjs";
+import { Bind, BindDecorator, BindFactory, BindToken, BindValue, Container } from "../core/bindings.cjs";
 export { Bind, BindDecorator, BindFactory, BindToken, BindValue, Container };

package/dist/decorators/setup.d.mts

@@ -1,3 +1,3 @@
-import { a as BindValue, i as BindToken, n as BindDecorator, o as Container, r as BindFactory, t as Bind } from "../bindings-CNL7bpz5.mjs";
+import { Bind, BindDecorator, BindFactory, BindToken, BindValue, Container } from "../core/bindings.mjs";
 import "reflect-metadata";
 export { Bind, BindDecorator, BindFactory, BindToken, BindValue, Container };

package/dist/decorators/setup.mjs

@@ -1,5 +1,5 @@
-import { n as Container, t as Bind } from "../bindings-XLDXFpHZ.mjs";
-import { t as CoreRouter } from "../router-Dc9w86Wn.mjs";
+import { Bind, Container } from "../core/bindings.mjs";
+import { CoreRouter } from "../core/router.mjs";
 import "./index.mjs";
 import "reflect-metadata";
 

package/dist/express/index.cjs

@@ -1,267 +1,4 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-require('../bindings-CLsZjOEy.cjs');
-const require_router = require('../router-C6W-k6sS.cjs');
-const require_responses = require('../responses-Bvnk0uvc.cjs');
+const require_router = require('./router.cjs');
 
-//#region src/express/router.ts
-/**
-* @class clear-router Express Router
-* @description Laravel-style routing system for Express.js and H3 with support for CommonJS, ESM, and TypeScript
-* @author Refkinscallv
-* @author 3m1n3nc3
-* @repository https://github.com/arkstack-tmp/clear-router
-*/
-var Router = class Router extends require_router.CoreRouter {
-	static routerStateNamespace = "clear-router:express";
-	static ensureRequestBodyAccessor(req) {
-		if (typeof req.getBody !== "function") req.getBody = () => req.body ?? {};
-	}
-	static async sendReturnValue(ctx, value, method, path) {
-		const { req, res } = ctx;
-		if (require_responses.responseWasSent(res) || value === res || require_responses.responseWasSent(value)) return;
-		const meta = require_responses.resolveResponseMeta(value, {
-			headers: req.headers,
-			method,
-			path
-		});
-		if (!meta) return;
-		res.status(meta.status);
-		meta.headers?.forEach((headerValue, key) => {
-			res.setHeader(key, headerValue);
-		});
-		if (require_responses.isFetchResponse(meta.body)) {
-			meta.body.headers.forEach((headerValue, key) => {
-				res.setHeader(key, headerValue);
-			});
-			res.status(meta.body.status);
-			const body = Buffer.from(await meta.body.arrayBuffer());
-			res.send(body);
-			return;
-		}
-		if (meta.contentType && !res.getHeader("Content-Type")) res.setHeader("Content-Type", meta.contentType);
-		if (meta.isEmpty) {
-			res.sendStatus(meta.status);
-			return;
-		}
-		res.send(meta.body);
-	}
-	/**
-	* Adds a new route to the router.
-	* 
-	* @param methods 
-	* @param path 
-	* @param handler 
-	* @param middlewares 
-	*/
-	static add(methods, path, handler, middlewares) {
-		return super.add(methods, path, handler, middlewares);
-	}
-	/**
-	* Define a resourceful API controller with standard CRUD routes
-	* 
-	* @param basePath 
-	* @param controller 
-	* @param options 
-	*/
-	static apiResource(basePath, controller, options) {
-		super.apiResource(basePath, controller, options);
-	}
-	/**
-	* Adds a new GET route to the router.
-	* 
-	* @param path 
-	* @param handler 
-	* @param middlewares 
-	*/
-	static get(path, handler, middlewares) {
-		return super.get(path, handler, middlewares);
-	}
-	/**
-	* Adds a new POST route to the router.
-	* 
-	* @param path 
-	* @param handler 
-	* @param middlewares 
-	*/
-	static post(path, handler, middlewares) {
-		return super.post(path, handler, middlewares);
-	}
-	/**
-	* Adds a new PUT route to the router.
-	* 
-	* @param path 
-	* @param handler 
-	* @param middlewares 
-	*/
-	static put(path, handler, middlewares) {
-		return super.put(path, handler, middlewares);
-	}
-	/**
-	* Adds a new DELETE route to the router.
-	* 
-	* @param path 
-	* @param handler 
-	* @param middlewares 
-	*/
-	static delete(path, handler, middlewares) {
-		return super.delete(path, handler, middlewares);
-	}
-	/**
-	* Adds a new PATCH route to the router.
-	* 
-	* @param path 
-	* @param handler 
-	* @param middlewares 
-	*/
-	static patch(path, handler, middlewares) {
-		return super.patch(path, handler, middlewares);
-	}
-	/**
-	* Adds a new OPTIONS route to the router.
-	* 
-	* @param path 
-	* @param handler 
-	* @param middlewares 
-	*/
-	static options(path, handler, middlewares) {
-		return super.options(path, handler, middlewares);
-	}
-	/**
-	* Adds a new HEAD route to the router.
-	* 
-	* @param path 
-	* @param handler 
-	* @param middlewares 
-	*/
-	static head(path, handler, middlewares) {
-		return super.head(path, handler, middlewares);
-	}
-	/**
-	* Defines a group of routes with a common prefix.
-	* 
-	* @param prefix 
-	* @param callback 
-	* @param middlewares 
-	*/
-	static async group(prefix, callback, middlewares) {
-		await super.group(prefix, callback, middlewares);
-	}
-	/**
-	* Adds global middlewares to the router, which will be applied to all routes.
-	* 
-	* @param middlewares 
-	* @param callback 
-	*/
-	static middleware(middlewares, callback) {
-		super.middleware(middlewares, callback);
-	}
-	static allRoutes(type) {
-		return super.allRoutes(type);
-	}
-	static route(name) {
-		return super.route(name);
-	}
-	static async apply(router) {
-		for (const route of Array.from(this.routes)) {
-			let handlerFunction = null;
-			let instance = null;
-			let bindingTarget;
-			let bindingMethod;
-			let bindingHandler;
-			let bindingMetadata;
-			try {
-				const resolved = this.resolveHandler(route);
-				handlerFunction = resolved.handlerFunction;
-				instance = resolved.instance;
-				bindingTarget = resolved.bindingTarget;
-				bindingMethod = resolved.bindingMethod;
-				bindingHandler = resolved.bindingHandler;
-				bindingMetadata = resolved.bindingMetadata;
-			} catch (error) {
-				console.error(`[ROUTES] Error setting up route ${route.path}:`, error.message);
-				throw error;
-			}
-			if (!handlerFunction) continue;
-			for (const method of route.methods) {
-				const allowedMethods = [
-					"get",
-					"post",
-					"put",
-					"delete",
-					"patch",
-					"options",
-					"head"
-				];
-				if (method === "options" && route.methods.length > 1) continue;
-				if (!allowedMethods.includes(method)) {
-					const error = /* @__PURE__ */ new Error(`Invalid HTTP method: ${method} for route: ${route.path}`);
-					console.error("[ROUTES]", error.message);
-					throw error;
-				}
-				for (const registrationPath of route.registrationPaths) router[method](registrationPath, (req, _res, next) => {
-					Router.ensureRequestBodyAccessor(req);
-					const override = Router.resolveMethodOverride(req.method, req.headers, req.body);
-					if (method === "post" && override && override !== "post") return next("route");
-					return next();
-				}, ...route.middlewares || [], async (req, res, next) => {
-					try {
-						Router.ensureRequestBodyAccessor(req);
-						const ctx = {
-							req,
-							res,
-							next
-						};
-						const inst = instance ?? route;
-						Router.bindRequestToInstance(ctx, inst, route, {
-							body: ctx.req.getBody(),
-							query: ctx.req.query,
-							params: ctx.req.params,
-							method
-						});
-						const result = await Router.callHandler(handlerFunction, ctx, bindingTarget, bindingMethod, bindingHandler, bindingMetadata);
-						const resolved = await Promise.resolve(result);
-						const outgoing = typeof resolved === "undefined" && ctx.clearResponse?.sent ? ctx.clearResponse : resolved;
-						await Router.sendReturnValue(ctx, outgoing, method, route.path);
-					} catch (error) {
-						next(error);
-					}
-				});
-				if ([
-					"put",
-					"patch",
-					"delete"
-				].includes(method)) for (const registrationPath of route.registrationPaths) router.post(registrationPath, (req, _res, next) => {
-					Router.ensureRequestBodyAccessor(req);
-					if (Router.resolveMethodOverride(req.method, req.headers, req.body) !== method) return next("route");
-					req.method = method.toUpperCase();
-					return next();
-				}, ...route.middlewares || [], async (req, res, next) => {
-					try {
-						Router.ensureRequestBodyAccessor(req);
-						const ctx = {
-							req,
-							res,
-							next
-						};
-						const inst = instance ?? route;
-						Router.bindRequestToInstance(ctx, inst, route, {
-							body: ctx.req.getBody(),
-							query: ctx.req.query,
-							params: ctx.req.params,
-							method
-						});
-						const result = await Router.callHandler(handlerFunction, ctx, bindingTarget, bindingMethod, bindingHandler, bindingMetadata);
-						const resolved = await Promise.resolve(result);
-						const outgoing = typeof resolved === "undefined" && ctx.clearResponse?.sent ? ctx.clearResponse : resolved;
-						await Router.sendReturnValue(ctx, outgoing, method, route.path);
-					} catch (error) {
-						next(error);
-					}
-				});
-			}
-		}
-	}
-};
-
-//#endregion
-exports.Router = Router;
+exports.Router = require_router;