@nocobase/plugin-idp-oauth 2.2.17 → 2.2.19

package/dist/node_modules/oidc-provider/node_modules/@koa/router/dist/index.mjs

@@ -1,1573 +0,0 @@
-// src/utils/router-events.ts
-import compose from "koa-compose";
-var RouterEvents = {
-  /**
-   * Fires when no route matched the request path + HTTP method.
-   */
-  NotFound: "not-found"
-  // /**
-  //  * Fires when the request path matched a registered route but the HTTP
-  //  * method did not match any of its allowed methods.
-  //  *
-  //  * @planned Not yet active — handlers are stored but not called.
-  //  */
-  // MethodNotAllowed: 'method-not-allowed',
-  // /**
-  //  * Fires after a route is matched and before its handlers run.
-  //  * Useful for tracing and logging the matched route.
-  //  *
-  //  * @planned Not yet active — handlers are stored but not called.
-  //  */
-  // Match: 'match',
-  // /**
-  //  * Fires on every request that enters the router, before route matching.
-  //  * Useful for per-router metrics and request logging.
-  //  *
-  //  * @planned Not yet active — handlers are stored but not called.
-  //  */
-  // Dispatch: 'dispatch'
-};
-function resolveEvent(selector) {
-  return typeof selector === "function" ? selector(RouterEvents) : selector;
-}
-var RouterEventEmitter = class {
-  _handlers = /* @__PURE__ */ new Map();
-  /**
-   * Register a handler for the given event.
-   * Multiple handlers for the same event are composed in registration order.
-   */
-  register(event, handler) {
-    const existing = this._handlers.get(event) ?? [];
-    existing.push(handler);
-    this._handlers.set(event, existing);
-  }
-  /**
-   * Emit an event by composing and running all registered handlers.
-   * If no handlers are registered for the event, calls `next()` directly.
-   *
-   * @param event   - The event to emit
-   * @param context - The router context
-   * @param next    - The downstream next function
-   */
-  emit(event, context, next) {
-    const handlers = this._handlers.get(event);
-    if (handlers && handlers.length > 0) {
-      return compose(handlers)(context, next);
-    }
-    return next();
-  }
-};
-
-// src/utils/parameter-match.ts
-import createHttpError from "http-errors";
-function createParameterValidationMiddleware(parameterName, pattern, options = {}) {
-  if (!(pattern instanceof RegExp)) {
-    throw new TypeError("pattern must be a RegExp instance");
-  }
-  const matcher = new RegExp(pattern.source, pattern.flags);
-  const createDefaultHttpError = (message) => {
-    const httpError = createHttpError(options.status ?? 400, message);
-    if (options.expose !== void 0) {
-      httpError.expose = options.expose;
-    }
-    return httpError;
-  };
-  const validateValue = (value) => {
-    if (matcher.global || matcher.sticky) {
-      matcher.lastIndex = 0;
-    }
-    if (matcher.test(value)) {
-      return;
-    }
-    if (options.createError) {
-      throw options.createError(parameterName, value);
-    }
-    throw createDefaultHttpError(
-      options.message ?? `Invalid value for parameter "${parameterName}": "${value}"`
-    );
-  };
-  const middleware = async (argument1, argument2, argument3) => {
-    if (typeof argument1 !== "string") {
-      const context = argument1;
-      const next2 = argument2;
-      const parameterValue = context.params && parameterName in context.params ? context.params[parameterName] : void 0;
-      if (typeof parameterValue !== "string") {
-        throw createDefaultHttpError(
-          options.message ?? `Missing required parameter "${parameterName}" in route params`
-        );
-      }
-      validateValue(parameterValue);
-      return next2();
-    }
-    const value = argument1;
-    const next = argument3;
-    validateValue(value);
-    return next();
-  };
-  return middleware;
-}
-
-// src/router.ts
-import compose2 from "koa-compose";
-import HttpError from "http-errors";
-
-// src/layer.ts
-import { parse as parseUrl, format as formatUrl } from "url";
-
-// src/utils/path-to-regexp-wrapper.ts
-import { pathToRegexp, compile, parse } from "path-to-regexp";
-function compilePathToRegexp(path, options = {}) {
-  const normalizedOptions = { ...options };
-  if ("strict" in normalizedOptions && !("trailing" in normalizedOptions)) {
-    normalizedOptions.trailing = normalizedOptions.strict !== true;
-    delete normalizedOptions.strict;
-  }
-  delete normalizedOptions.pathAsRegExp;
-  delete normalizedOptions.ignoreCaptures;
-  delete normalizedOptions.prefix;
-  const { regexp, keys } = pathToRegexp(path, normalizedOptions);
-  return { regexp, keys };
-}
-function compilePath(path, options = {}) {
-  return compile(path, options);
-}
-function parsePath(path, options) {
-  return parse(path, options);
-}
-function normalizeLayerOptionsToPathToRegexp(options = {}) {
-  const normalized = {
-    sensitive: options.sensitive,
-    end: options.end,
-    strict: options.strict,
-    trailing: options.trailing
-  };
-  if ("strict" in normalized && !("trailing" in normalized)) {
-    normalized.trailing = normalized.strict !== true;
-    delete normalized.strict;
-  }
-  for (const key of Object.keys(normalized)) {
-    if (normalized[key] === void 0) {
-      delete normalized[key];
-    }
-  }
-  return normalized;
-}
-
-// src/utils/safe-decode-uri-components.ts
-function safeDecodeURIComponent(text) {
-  try {
-    return decodeURIComponent(text);
-  } catch {
-    return text;
-  }
-}
-
-// src/layer.ts
-var Layer = class {
-  opts;
-  name;
-  methods;
-  paramNames;
-  stack;
-  path;
-  regexp;
-  /**
-   * Initialize a new routing Layer with given `method`, `path`, and `middleware`.
-   *
-   * @param path - Path string or regular expression
-   * @param methods - Array of HTTP verbs
-   * @param middleware - Layer callback/middleware or series of
-   * @param opts - Layer options
-   * @private
-   */
-  constructor(path, methods, middleware, options = {}) {
-    this.opts = options;
-    this.name = this.opts.name || void 0;
-    this.methods = this._normalizeHttpMethods(methods);
-    this.stack = this._normalizeAndValidateMiddleware(
-      middleware,
-      methods,
-      path
-    );
-    this.path = path;
-    this.paramNames = [];
-    this._configurePathMatching();
-  }
-  /**
-   * Normalize HTTP methods and add automatic HEAD support for GET
-   * @private
-   */
-  _normalizeHttpMethods(methods) {
-    const normalizedMethods = [];
-    for (const method of methods) {
-      const upperMethod = method.toUpperCase();
-      normalizedMethods.push(upperMethod);
-      if (upperMethod === "GET") {
-        normalizedMethods.unshift("HEAD");
-      }
-    }
-    return normalizedMethods;
-  }
-  /**
-   * Normalize middleware to array and validate all are functions
-   * @private
-   */
-  _normalizeAndValidateMiddleware(middleware, methods, path) {
-    const middlewareArray = Array.isArray(middleware) ? middleware : [middleware];
-    for (const middlewareFunction of middlewareArray) {
-      const middlewareType = typeof middlewareFunction;
-      if (middlewareType !== "function") {
-        const routeIdentifier = this.opts.name || path;
-        throw new Error(
-          `${methods.toString()} \`${routeIdentifier}\`: \`middleware\` must be a function, not \`${middlewareType}\``
-        );
-      }
-    }
-    return middlewareArray;
-  }
-  /**
-   * Configure path matching regexp and parameters
-   * @private
-   */
-  _configurePathMatching() {
-    if (this.opts.pathAsRegExp === true) {
-      this.regexp = this.path instanceof RegExp ? this.path : new RegExp(this.path);
-    } else if (this.path) {
-      this._configurePathToRegexp();
-    }
-  }
-  /**
-   * Configure path-to-regexp for string paths
-   * @private
-   */
-  _configurePathToRegexp() {
-    const options = normalizeLayerOptionsToPathToRegexp(this.opts);
-    const { regexp, keys } = compilePathToRegexp(this.path, options);
-    this.regexp = regexp;
-    this.paramNames = keys;
-  }
-  /**
-   * Returns whether request `path` matches route.
-   *
-   * @param path - Request path
-   * @returns Whether path matches
-   * @private
-   */
-  match(path) {
-    return this.regexp.test(path);
-  }
-  /**
-   * Returns map of URL parameters for given `path` and `paramNames`.
-   *
-   * @param _path - Request path (not used, kept for API compatibility)
-   * @param captures - Captured values from regexp
-   * @param existingParams - Existing params to merge with
-   * @returns Parameter map
-   * @private
-   */
-  params(_path, captures, existingParameters = {}) {
-    const parameterValues = { ...existingParameters };
-    for (const [captureIndex, capturedValue] of captures.entries()) {
-      const parameterDefinition = this.paramNames[captureIndex];
-      if (parameterDefinition && capturedValue && capturedValue.length > 0) {
-        const parameterName = parameterDefinition.name;
-        parameterValues[parameterName] = safeDecodeURIComponent(capturedValue);
-      }
-    }
-    return parameterValues;
-  }
-  /**
-   * Returns array of regexp url path captures.
-   *
-   * @param path - Request path
-   * @returns Array of captured values
-   * @private
-   */
-  captures(path) {
-    if (this.opts.ignoreCaptures) {
-      return [];
-    }
-    const match = path.match(this.regexp);
-    return match ? match.slice(1) : [];
-  }
-  /**
-   * Generate URL for route using given `params`.
-   *
-   * @example
-   *
-   * ```javascript
-   * const route = new Layer('/users/:id', ['GET'], fn);
-   *
-   * route.url({ id: 123 }); // => "/users/123"
-   * ```
-   *
-   * @param args - URL parameters (various formats supported)
-   * @returns Generated URL
-   * @throws Error if route path is a RegExp (cannot generate URL from RegExp)
-   * @private
-   */
-  url(...arguments_) {
-    if (this.path instanceof RegExp) {
-      throw new TypeError(
-        "Cannot generate URL for routes defined with RegExp paths. Use string paths with named parameters instead."
-      );
-    }
-    const { params, options } = this._parseUrlArguments(arguments_);
-    const cleanPath = this.path.replaceAll("(.*)", "");
-    const pathCompiler = compilePath(cleanPath, {
-      encode: encodeURIComponent,
-      ...options
-    });
-    const parameterReplacements = this._buildParamReplacements(
-      params,
-      cleanPath
-    );
-    const generatedUrl = pathCompiler(parameterReplacements);
-    if (options && options.query) {
-      return this._addQueryString(generatedUrl, options.query);
-    }
-    return generatedUrl;
-  }
-  /**
-   * Parse url() arguments into params and options
-   * Supports multiple call signatures:
-   * - url({ id: 1 })
-   * - url(1, 2, 3)
-   * - url({ query: {...} })
-   * - url({ id: 1 }, { query: {...} })
-   * @private
-   */
-  _parseUrlArguments(allArguments) {
-    let parameters = allArguments[0] ?? {};
-    let options = allArguments[1];
-    if (typeof parameters !== "object" || parameters === null) {
-      const argumentsList = [...allArguments];
-      const lastArgument = argumentsList.at(-1);
-      if (typeof lastArgument === "object" && lastArgument !== null) {
-        options = lastArgument;
-        parameters = argumentsList.slice(0, -1);
-      } else {
-        parameters = argumentsList;
-      }
-    } else if (parameters && !options) {
-      const parameterKeys = Object.keys(parameters);
-      const isOnlyOptions = parameterKeys.length === 1 && parameterKeys[0] === "query";
-      if (isOnlyOptions) {
-        options = parameters;
-        parameters = {};
-      } else if ("query" in parameters && parameters.query) {
-        const { query, ...restParameters } = parameters;
-        options = { query };
-        parameters = restParameters;
-      }
-    }
-    return { params: parameters, options };
-  }
-  /**
-   * Build parameter replacements for URL generation
-   * @private
-   */
-  _buildParamReplacements(parameters, cleanPath) {
-    const { tokens } = parsePath(cleanPath);
-    const hasNamedParameters = tokens.some(
-      (token) => "name" in token && token.name
-    );
-    const parameterReplacements = {};
-    if (Array.isArray(parameters)) {
-      let parameterIndex = 0;
-      for (const token of tokens) {
-        if ("name" in token && token.name) {
-          parameterReplacements[token.name] = String(
-            parameters[parameterIndex++]
-          );
-        }
-      }
-    } else if (hasNamedParameters && typeof parameters === "object" && !("query" in parameters)) {
-      for (const [parameterName, parameterValue] of Object.entries(
-        parameters
-      )) {
-        parameterReplacements[parameterName] = String(parameterValue);
-      }
-    }
-    return parameterReplacements;
-  }
-  /**
-   * Add query string to URL
-   * @private
-   */
-  _addQueryString(baseUrl, query) {
-    const parsed = parseUrl(baseUrl);
-    const urlObject = {
-      ...parsed,
-      query: parsed.query ?? void 0
-    };
-    if (typeof query === "string") {
-      urlObject.search = query;
-      urlObject.query = void 0;
-    } else {
-      urlObject.search = void 0;
-      urlObject.query = query;
-    }
-    return formatUrl(urlObject);
-  }
-  /**
-   * Run validations on route named parameters.
-   *
-   * @example
-   *
-   * ```javascript
-   * router
-   *   .param('user', function (id, ctx, next) {
-   *     ctx.user = users[id];
-   *     if (!ctx.user) return ctx.status = 404;
-   *     next();
-   *   })
-   *   .get('/users/:user', function (ctx, next) {
-   *     ctx.body = ctx.user;
-   *   });
-   * ```
-   *
-   * @param paramName - Parameter name
-   * @param paramHandler - Middleware function
-   * @returns This layer instance
-   * @private
-   */
-  param(parameterName, parameterHandler) {
-    const middlewareStack = this.stack;
-    const routeParameterNames = this.paramNames;
-    const parameterMiddleware = this._createParamMiddleware(
-      parameterName,
-      parameterHandler
-    );
-    const parameterNamesList = routeParameterNames.map(
-      (parameterDefinition) => parameterDefinition.name
-    );
-    const parameterPosition = parameterNamesList.indexOf(parameterName);
-    if (parameterPosition !== -1) {
-      this._insertParamMiddleware(
-        middlewareStack,
-        parameterMiddleware,
-        parameterNamesList,
-        parameterPosition
-      );
-    }
-    return this;
-  }
-  /**
-   * Create param middleware with deduplication tracking
-   * @private
-   */
-  _createParamMiddleware(parameterName, parameterHandler) {
-    const middleware = ((context, next) => {
-      if (!context._matchedParams) {
-        context._matchedParams = /* @__PURE__ */ new WeakMap();
-      }
-      if (context._matchedParams.has(parameterHandler)) {
-        return next();
-      }
-      context._matchedParams.set(parameterHandler, true);
-      return parameterHandler(context.params[parameterName], context, next);
-    });
-    middleware.param = parameterName;
-    middleware._originalFn = parameterHandler;
-    return middleware;
-  }
-  /**
-   * Insert param middleware at the correct position in the stack
-   * @private
-   */
-  _insertParamMiddleware(middlewareStack, parameterMiddleware, parameterNamesList, currentParameterPosition) {
-    let inserted = false;
-    for (let stackIndex = 0; stackIndex < middlewareStack.length; stackIndex++) {
-      const existingMiddleware = middlewareStack[stackIndex];
-      if (!existingMiddleware.param) {
-        middlewareStack.splice(stackIndex, 0, parameterMiddleware);
-        inserted = true;
-        break;
-      }
-      const existingParameterPosition = parameterNamesList.indexOf(
-        existingMiddleware.param
-      );
-      if (existingParameterPosition > currentParameterPosition) {
-        middlewareStack.splice(stackIndex, 0, parameterMiddleware);
-        inserted = true;
-        break;
-      }
-    }
-    if (!inserted) {
-      middlewareStack.push(parameterMiddleware);
-    }
-  }
-  /**
-   * Prefix route path.
-   *
-   * @param prefixPath - Prefix to prepend
-   * @returns This layer instance
-   * @private
-   */
-  setPrefix(prefixPath) {
-    if (!this.path) {
-      return this;
-    }
-    if (this.path instanceof RegExp) {
-      return this;
-    }
-    this.path = this._applyPrefix(prefixPath);
-    this._reconfigurePathMatching(prefixPath);
-    return this;
-  }
-  /**
-   * Apply prefix to the current path
-   * @private
-   */
-  _applyPrefix(prefixPath) {
-    const isRootPath = this.path === "/";
-    const isStrictMode = this.opts.strict === true;
-    const prefixHasParameters = prefixPath.includes(":");
-    const pathIsRawRegex = this.opts.pathAsRegExp === true && typeof this.path === "string";
-    if (prefixHasParameters && pathIsRawRegex) {
-      const currentPath = this.path;
-      if (currentPath === String.raw`(?:\/|$)` || currentPath === String.raw`(?:\\\/|$)`) {
-        this.path = "{/*rest}";
-        this.opts.pathAsRegExp = false;
-      }
-    }
-    if (isRootPath && !isStrictMode) {
-      return prefixPath;
-    }
-    return `${prefixPath}${this.path}`;
-  }
-  /**
-   * Reconfigure path matching after prefix is applied
-   * @private
-   */
-  _reconfigurePathMatching(prefixPath) {
-    const treatAsRegExp = this.opts.pathAsRegExp === true;
-    const prefixHasParameters = prefixPath && prefixPath.includes(":");
-    if (prefixHasParameters && treatAsRegExp) {
-      const options = normalizeLayerOptionsToPathToRegexp(this.opts);
-      const { regexp, keys } = compilePathToRegexp(
-        this.path,
-        options
-      );
-      this.regexp = regexp;
-      this.paramNames = keys;
-      this.opts.pathAsRegExp = false;
-    } else if (treatAsRegExp) {
-      const pathString = this.path;
-      const anchoredPattern = pathString.startsWith("^") ? pathString : `^${pathString}`;
-      this.regexp = this.path instanceof RegExp ? this.path : new RegExp(anchoredPattern);
-    } else {
-      const options = normalizeLayerOptionsToPathToRegexp(this.opts);
-      const { regexp, keys } = compilePathToRegexp(
-        this.path,
-        options
-      );
-      this.regexp = regexp;
-      this.paramNames = keys;
-    }
-  }
-};
-
-// src/utils/http-methods.ts
-import http from "http";
-function getAllHttpMethods() {
-  return http.METHODS.map((method) => method.toLowerCase());
-}
-var COMMON_HTTP_METHODS = [
-  "get",
-  "post",
-  "put",
-  "patch",
-  "delete",
-  "del",
-  "head",
-  "options"
-];
-
-// src/utils/parameter-helpers.ts
-function normalizeParameterMiddleware(parameterMiddleware) {
-  if (!parameterMiddleware) {
-    return [];
-  }
-  if (Array.isArray(parameterMiddleware)) {
-    return parameterMiddleware;
-  }
-  return [parameterMiddleware];
-}
-function applyParameterMiddlewareToRoute(route, parameterName, parameterMiddleware) {
-  const middlewareList = normalizeParameterMiddleware(
-    parameterMiddleware
-  );
-  for (const middleware of middlewareList) {
-    route.param(parameterName, middleware);
-  }
-}
-function applyAllParameterMiddleware(route, parametersObject) {
-  const parameterNames = Object.keys(parametersObject);
-  for (const parameterName of parameterNames) {
-    const parameterMiddleware = parametersObject[parameterName];
-    applyParameterMiddlewareToRoute(
-      route,
-      parameterName,
-      parameterMiddleware
-    );
-  }
-}
-
-// src/utils/path-helpers.ts
-function hasPathParameters(path, options = {}) {
-  if (!path) {
-    return false;
-  }
-  const { keys } = compilePathToRegexp(path, options);
-  return keys.length > 0;
-}
-function determineMiddlewarePath(explicitPath, hasPrefixParameters) {
-  if (explicitPath !== void 0) {
-    if (typeof explicitPath === "string") {
-      if (explicitPath === "") {
-        return {
-          path: "{/*rest}",
-          pathAsRegExp: false
-        };
-      }
-      if (explicitPath === "/") {
-        return {
-          path: "/",
-          pathAsRegExp: false
-        };
-      }
-      return {
-        path: explicitPath,
-        pathAsRegExp: false
-      };
-    }
-    return {
-      path: explicitPath,
-      pathAsRegExp: true
-    };
-  }
-  if (hasPrefixParameters) {
-    return {
-      path: "{/*rest}",
-      pathAsRegExp: false
-    };
-  }
-  return {
-    path: String.raw`(?:\/|$)`,
-    pathAsRegExp: true
-  };
-}
-
-// src/utils/debug.ts
-import debugModule from "debug";
-var debug = debugModule("koa-router");
-
-// src/router.ts
-var httpMethods = getAllHttpMethods();
-var RouterImplementation = class {
-  opts;
-  methods;
-  exclusive;
-  params;
-  stack;
-  host;
-  /**
-   * Event emitter for router lifecycle events (experimental)
-   * @internal
-   */
-  _events = new RouterEventEmitter();
-  /**
-   * Create a new router.
-   *
-   * @example
-   *
-   * Basic usage:
-   *
-   * ```javascript
-   * const Koa = require('koa');
-   * const Router = require('@koa/router');
-   *
-   * const app = new Koa();
-   * const router = new Router();
-   *
-   * router.get('/', (ctx, next) => {
-   *   // ctx.router available
-   * });
-   *
-   * app
-   *   .use(router.routes())
-   *   .use(router.allowedMethods());
-   * ```
-   *
-   * @alias module:koa-router
-   * @param opts - Router options
-   * @constructor
-   */
-  constructor(options = {}) {
-    this.opts = options;
-    this.methods = this.opts.methods || [
-      "HEAD",
-      "OPTIONS",
-      "GET",
-      "PUT",
-      "PATCH",
-      "POST",
-      "DELETE"
-    ];
-    this.exclusive = Boolean(this.opts.exclusive);
-    this.params = {};
-    this.stack = [];
-    this.host = this.opts.host;
-  }
-  /**
-   * Generate URL from url pattern and given `params`.
-   *
-   * @example
-   *
-   * ```javascript
-   * const url = Router.url('/users/:id', {id: 1});
-   * // => "/users/1"
-   * ```
-   *
-   * @param path - URL pattern
-   * @param args - URL parameters
-   * @returns Generated URL
-   */
-  static url(path, ...arguments_) {
-    const temporaryLayer = new Layer(path, [], () => {
-    });
-    return temporaryLayer.url(...arguments_);
-  }
-  use(...middleware) {
-    let explicitPath;
-    if (this._isPathArray(middleware[0])) {
-      return this._useWithPathArray(middleware);
-    }
-    const hasExplicitPath = this._hasExplicitPath(middleware[0]);
-    if (hasExplicitPath) {
-      explicitPath = middleware.shift();
-    }
-    if (middleware.length === 0) {
-      throw new Error(
-        "You must provide at least one middleware function to router.use()"
-      );
-    }
-    for (const currentMiddleware of middleware) {
-      if (this._isNestedRouter(currentMiddleware)) {
-        this._mountNestedRouter(
-          currentMiddleware,
-          explicitPath
-        );
-      } else {
-        this._registerMiddleware(
-          currentMiddleware,
-          explicitPath,
-          hasExplicitPath
-        );
-      }
-    }
-    return this;
-  }
-  /**
-   * Check if first argument is an array of paths (all elements must be strings)
-   * @private
-   */
-  _isPathArray(firstArgument) {
-    return Array.isArray(firstArgument) && firstArgument.length > 0 && firstArgument.every((item) => typeof item === "string");
-  }
-  /**
-   * Check if first argument is an explicit path (string or RegExp)
-   * Empty string counts as explicit path to enable param capture
-   * @private
-   */
-  _hasExplicitPath(firstArgument) {
-    return typeof firstArgument === "string" || firstArgument instanceof RegExp;
-  }
-  /**
-   * Check if middleware contains a nested router
-   * @private
-   */
-  _isNestedRouter(middleware) {
-    return typeof middleware === "function" && "router" in middleware && middleware.router !== void 0;
-  }
-  /**
-   * Apply middleware to multiple paths
-   * @private
-   */
-  _useWithPathArray(middleware) {
-    const pathArray = middleware[0];
-    const remainingMiddleware = middleware.slice(1);
-    for (const singlePath of pathArray) {
-      Reflect.apply(this.use, this, [singlePath, ...remainingMiddleware]);
-    }
-    return this;
-  }
-  /**
-   * Mount a nested router
-   * @private
-   */
-  _mountNestedRouter(middlewareWithRouter, mountPath) {
-    const nestedRouter = middlewareWithRouter.router;
-    const clonedRouter = this._cloneRouter(nestedRouter);
-    const mountPathHasParameters = mountPath && typeof mountPath === "string" && hasPathParameters(mountPath, this.opts);
-    for (let routeIndex = 0; routeIndex < clonedRouter.stack.length; routeIndex++) {
-      const nestedLayer = clonedRouter.stack[routeIndex];
-      const clonedLayer = this._cloneLayer(nestedLayer);
-      if (mountPath && typeof mountPath === "string") {
-        clonedLayer.setPrefix(mountPath);
-      }
-      if (this.opts.prefix) {
-        clonedLayer.setPrefix(this.opts.prefix);
-      }
-      if (clonedLayer.methods.length === 0 && mountPathHasParameters) {
-        clonedLayer.opts.ignoreCaptures = false;
-      }
-      this.stack.push(clonedLayer);
-      clonedRouter.stack[routeIndex] = clonedLayer;
-    }
-    if (this.params) {
-      this._applyParamMiddlewareToRouter(clonedRouter);
-    }
-  }
-  /**
-   * Clone a router instance
-   * @private
-   */
-  _cloneRouter(sourceRouter) {
-    return Object.assign(
-      Object.create(Object.getPrototypeOf(sourceRouter)),
-      sourceRouter,
-      {
-        stack: [...sourceRouter.stack]
-      }
-    );
-  }
-  /**
-   * Clone a layer instance (deep clone to avoid shared references)
-   * @private
-   */
-  _cloneLayer(sourceLayer) {
-    const cloned = Object.assign(
-      Object.create(Object.getPrototypeOf(sourceLayer)),
-      sourceLayer,
-      {
-        // Deep clone arrays and objects to avoid shared references
-        stack: [...sourceLayer.stack],
-        methods: [...sourceLayer.methods],
-        paramNames: [...sourceLayer.paramNames],
-        opts: { ...sourceLayer.opts }
-      }
-    );
-    return cloned;
-  }
-  /**
-   * Apply this router's param middleware to a nested router
-   * @private
-   */
-  _applyParamMiddlewareToRouter(targetRouter) {
-    const parameterNames = Object.keys(this.params);
-    for (const parameterName of parameterNames) {
-      const parameterMiddleware = this.params[parameterName];
-      applyParameterMiddlewareToRoute(
-        targetRouter,
-        parameterName,
-        parameterMiddleware
-      );
-    }
-  }
-  /**
-   * Register regular middleware (not nested router)
-   * @private
-   */
-  _registerMiddleware(middleware, explicitPath, hasExplicitPath) {
-    const prefixHasParameters = hasPathParameters(
-      this.opts.prefix || "",
-      this.opts
-    );
-    const effectiveExplicitPath = (() => {
-      if (explicitPath !== void 0) return explicitPath;
-      if (prefixHasParameters) return "";
-      return;
-    })();
-    const effectiveHasExplicitPath = hasExplicitPath || explicitPath === void 0 && prefixHasParameters;
-    const { path: middlewarePath, pathAsRegExp } = determineMiddlewarePath(
-      effectiveExplicitPath,
-      prefixHasParameters
-    );
-    let finalPath = middlewarePath;
-    let usePathToRegexp = pathAsRegExp;
-    const isRootPath = effectiveHasExplicitPath && middlewarePath === "/";
-    if (effectiveHasExplicitPath && typeof middlewarePath === "string") {
-      finalPath = middlewarePath;
-      usePathToRegexp = false;
-    }
-    this.register(finalPath, [], middleware, {
-      end: isRootPath,
-      ignoreCaptures: !effectiveHasExplicitPath && !prefixHasParameters,
-      pathAsRegExp: usePathToRegexp
-    });
-  }
-  /**
-   * Set the path prefix for a Router instance that was already initialized.
-   * Note: Calling this method multiple times will replace the prefix, not stack them.
-   *
-   * @example
-   *
-   * ```javascript
-   * router.prefix('/things/:thing_id')
-   * ```
-   *
-   * @param prefixPath - Prefix string
-   * @returns This router instance
-   */
-  prefix(prefixPath) {
-    const normalizedPrefix = prefixPath.replace(/\/$/, "");
-    const previousPrefix = this.opts.prefix || "";
-    this.opts.prefix = normalizedPrefix;
-    for (const route of this.stack) {
-      if (previousPrefix && typeof route.path === "string" && route.path.startsWith(previousPrefix)) {
-        route.path = route.path.slice(previousPrefix.length) || "/";
-      }
-      route.setPrefix(normalizedPrefix);
-    }
-    return this;
-  }
-  /**
-   * Returns router middleware which dispatches a route matching the request.
-   *
-   * @returns Router middleware
-   */
-  middleware() {
-    const dispatchMiddleware = function(context, next) {
-      debug("%s %s", context.method, context.path);
-      if (!this.matchHost(context.host)) {
-        return next();
-      }
-      const requestPath = this._getRequestPath(context);
-      const matchResult = this.match(requestPath, context.method);
-      this._storeMatchedRoutes(context, matchResult);
-      context.router = this;
-      context.routeMatched = matchResult.route;
-      if (!matchResult.route) {
-        return this._events.emit(
-          RouterEvents.NotFound,
-          context,
-          next
-        );
-      }
-      const matchedLayers = matchResult.pathAndMethod;
-      this._setMatchedRouteInfo(context, matchedLayers);
-      const middlewareChain = this._buildMiddlewareChain(
-        matchedLayers,
-        requestPath
-      );
-      return compose2(middlewareChain)(
-        context,
-        next
-      );
-    }.bind(this);
-    dispatchMiddleware.router = this;
-    return dispatchMiddleware;
-  }
-  /**
-   * Get the request path to use for routing
-   * @private
-   */
-  _getRequestPath(context) {
-    const context_ = context;
-    return this.opts.routerPath || context_.newRouterPath || context_.path || context_.routerPath || "";
-  }
-  /**
-   * Store matched routes on context
-   * @private
-   */
-  _storeMatchedRoutes(context, matchResult) {
-    const context_ = context;
-    if (context_.matched) {
-      context_.matched.push(...matchResult.path);
-    } else {
-      context_.matched = matchResult.path;
-    }
-  }
-  /**
-   * Set matched route information on context
-   * @private
-   */
-  _setMatchedRouteInfo(context, matchedLayers) {
-    const context_ = context;
-    const routeLayer = matchedLayers.toReversed().find((layer) => layer.methods.length > 0);
-    if (routeLayer) {
-      context_._matchedRoute = routeLayer.path;
-      if (routeLayer.name) {
-        context_._matchedRouteName = routeLayer.name;
-      }
-    }
-  }
-  /**
-   * Build middleware chain from matched layers
-   * @private
-   */
-  _buildMiddlewareChain(matchedLayers, requestPath) {
-    const layersToExecute = this.opts.exclusive ? [matchedLayers.at(-1)].filter(
-      (layer) => layer !== void 0
-    ) : matchedLayers;
-    const middlewareChain = [];
-    for (const layer of layersToExecute) {
-      middlewareChain.push(
-        (context, next) => {
-          const routerContext = context;
-          routerContext.captures = layer.captures(requestPath);
-          routerContext.request.params = layer.params(
-            requestPath,
-            routerContext.captures || [],
-            routerContext.params
-          );
-          routerContext.params = routerContext.request.params;
-          routerContext.routerPath = layer.path;
-          routerContext.routerName = layer.name || void 0;
-          routerContext._matchedRoute = layer.path;
-          if (layer.name) {
-            routerContext._matchedRouteName = layer.name;
-          }
-          return next();
-        },
-        ...layer.stack
-      );
-    }
-    return middlewareChain;
-  }
-  routes() {
-    return this.middleware();
-  }
-  /**
-   * Register an event handler on the router.
-   *
-   * @experimental This API is experimental and may change in future versions.
-   *
-   * **Active events:**
-   * - `'not-found'` — fires when no route matched path + method. Handlers are
-   *   composed and called instead of `next()`, so they are responsible for
-   *   calling `next()` themselves if they want to pass control downstream.
-   *
-   * @example
-   *
-   * All three forms are equivalent:
-   *
-   * ```javascript
-   * import { RouterEvents } from '@koa/router';
-   *
-   * // Named constant (recommended — autocomplete + refactor safe)
-   * router.on(RouterEvents.NotFound, handler);
-   *
-   * // Selector function (fluent style)
-   * router.on((events) => events.NotFound, handler);
-   *
-   * // Raw string (still accepted)
-   * router.on('not-found', handler);
-   * ```
-   *
-   * Multiple handlers compose in registration order:
-   *
-   * ```javascript
-   * router.on(RouterEvents.NotFound, async (ctx, next) => {
-   *   console.log('no route matched', ctx.path);
-   *   await next();
-   * });
-   * router.on(RouterEvents.NotFound, (ctx) => {
-   *   ctx.status = 404;
-   *   ctx.body = { error: 'Not Found' };
-   * });
-   * ```
-   *
-   * @param event - Event name string, `RouterEvents` constant, or selector
-   *   function `(events) => events.NotFound` (see `RouterEventSelector`)
-   * @param handler - Middleware to run when the event fires
-   * @returns This router instance for chaining
-   */
-  on(event, handler) {
-    this._events.register(resolveEvent(event), handler);
-    return this;
-  }
-  /**
-   * 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
-   * const Koa = require('koa');
-   * const Router = require('@koa/router');
-   *
-   * const app = new Koa();
-   * const router = new Router();
-   *
-   * app.use(router.routes());
-   * app.use(router.allowedMethods());
-   * ```
-   *
-   * **Example with [Boom](https://github.com/hapijs/boom)**
-   *
-   * ```javascript
-   * const Koa = require('koa');
-   * const Router = require('@koa/router');
-   * const Boom = require('boom');
-   *
-   * const app = new Koa();
-   * const router = new Router();
-   *
-   * app.use(router.routes());
-   * app.use(router.allowedMethods({
-   *   throw: true,
-   *   notImplemented: () => new Boom.notImplemented(),
-   *   methodNotAllowed: () => new Boom.methodNotAllowed()
-   * }));
-   * ```
-   *
-   * @param options - Options object
-   * @returns Middleware function
-   */
-  allowedMethods(options = {}) {
-    const implementedMethods = this.methods;
-    return (context, next) => {
-      const routerContext = context;
-      return next().then(() => {
-        if (!this._shouldProcessAllowedMethods(routerContext)) {
-          return;
-        }
-        const matchedRoutes = routerContext.matched || [];
-        const allowedMethods = this._collectAllowedMethods(matchedRoutes);
-        const allowedMethodsList = Object.keys(allowedMethods);
-        const requestMethod = context.method.toUpperCase();
-        if (!implementedMethods.includes(requestMethod)) {
-          this._handleNotImplemented(
-            routerContext,
-            allowedMethodsList,
-            options
-          );
-          return;
-        }
-        if (requestMethod === "OPTIONS" && allowedMethodsList.length > 0) {
-          this._handleOptionsRequest(routerContext, allowedMethodsList);
-          return;
-        }
-        if (allowedMethodsList.length > 0 && !allowedMethods[requestMethod]) {
-          this._handleMethodNotAllowed(
-            routerContext,
-            allowedMethodsList,
-            options
-          );
-        }
-      });
-    };
-  }
-  /**
-   * Check if we should process allowed methods
-   * @private
-   */
-  _shouldProcessAllowedMethods(context) {
-    return !!(context.matched && (!context.status || context.status === 404));
-  }
-  /**
-   * Collect all allowed methods from matched routes
-   * @private
-   */
-  _collectAllowedMethods(matchedRoutes) {
-    const allowedMethods = {};
-    for (const route of matchedRoutes) {
-      for (const method of route.methods) {
-        allowedMethods[method] = method;
-      }
-    }
-    return allowedMethods;
-  }
-  /**
-   * Handle 501 Not Implemented response
-   * @private
-   */
-  _handleNotImplemented(context, allowedMethodsList, options) {
-    if (options.throw) {
-      const error = typeof options.notImplemented === "function" ? options.notImplemented() : new HttpError.NotImplemented();
-      throw error;
-    }
-    context.status = 501;
-    context.set("Allow", allowedMethodsList.join(", "));
-  }
-  /**
-   * Handle OPTIONS request
-   * @private
-   */
-  _handleOptionsRequest(context, allowedMethodsList) {
-    context.status = 200;
-    context.body = "";
-    context.set("Allow", allowedMethodsList.join(", "));
-  }
-  /**
-   * Handle 405 Method Not Allowed response
-   * @private
-   */
-  _handleMethodNotAllowed(context, allowedMethodsList, options) {
-    if (options.throw) {
-      const error = typeof options.methodNotAllowed === "function" ? options.methodNotAllowed() : new HttpError.MethodNotAllowed();
-      throw error;
-    }
-    context.status = 405;
-    context.set("Allow", allowedMethodsList.join(", "));
-  }
-  all(...arguments_) {
-    let name;
-    let path;
-    let middleware;
-    if (arguments_.length >= 2 && (typeof arguments_[1] === "string" || arguments_[1] instanceof RegExp)) {
-      name = arguments_[0];
-      path = arguments_[1];
-      middleware = arguments_.slice(2);
-    } else {
-      name = void 0;
-      path = arguments_[0];
-      middleware = arguments_.slice(1);
-    }
-    if (typeof path !== "string" && !(path instanceof RegExp) && (!Array.isArray(path) || path.length === 0))
-      throw new Error("You have to provide a path when adding an all handler");
-    const routeOptions = {
-      name,
-      pathAsRegExp: path instanceof RegExp
-    };
-    this.register(path, httpMethods, middleware, {
-      ...this.opts,
-      ...routeOptions
-    });
-    return this;
-  }
-  /**
-   * 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 source - URL or route name
-   * @param destination - URL or route name
-   * @param code - HTTP status code (default: 301)
-   * @returns This router instance
-   */
-  redirect(source, destination, code) {
-    let resolvedSource = source;
-    let resolvedDestination = destination;
-    if (typeof source === "symbol" || typeof source === "string" && source[0] !== "/") {
-      const sourceUrl = this.url(source);
-      if (sourceUrl instanceof Error) throw sourceUrl;
-      resolvedSource = sourceUrl;
-    }
-    if (typeof destination === "symbol" || typeof destination === "string" && destination[0] !== "/" && !destination.includes("://")) {
-      const destinationUrl = this.url(destination);
-      if (destinationUrl instanceof Error) throw destinationUrl;
-      resolvedDestination = destinationUrl;
-    }
-    const result = this.all(
-      resolvedSource,
-      (context) => {
-        context.redirect(resolvedDestination);
-        context.status = code || 301;
-      }
-    );
-    return result;
-  }
-  /**
-   * Create and register a route.
-   *
-   * @param path - Path string
-   * @param methods - Array of HTTP verbs
-   * @param middleware - Middleware functions
-   * @param additionalOptions - Additional options
-   * @returns Created layer
-   * @private
-   */
-  register(path, methods, middleware, additionalOptions = {}) {
-    const mergedOptions = { ...this.opts, ...additionalOptions };
-    if (Array.isArray(path)) {
-      return this._registerMultiplePaths(
-        path,
-        methods,
-        middleware,
-        mergedOptions
-      );
-    }
-    const routeLayer = this._createRouteLayer(
-      path,
-      methods,
-      middleware,
-      mergedOptions
-    );
-    if (this.opts.prefix) {
-      routeLayer.setPrefix(this.opts.prefix);
-    }
-    applyAllParameterMiddleware(routeLayer, this.params);
-    this.stack.push(routeLayer);
-    debug("defined route %s %s", routeLayer.methods, routeLayer.path);
-    return routeLayer;
-  }
-  /**
-   * Register multiple paths with the same configuration
-   * @private
-   */
-  _registerMultiplePaths(pathArray, methods, middleware, options) {
-    for (const singlePath of pathArray) {
-      this.register.call(this, singlePath, methods, middleware, options);
-    }
-    return this;
-  }
-  /**
-   * Create a route layer with given configuration
-   * @private
-   */
-  _createRouteLayer(path, methods, middleware, options) {
-    return new Layer(path, methods, middleware, {
-      end: options.end === false ? options.end : true,
-      name: options.name,
-      sensitive: options.sensitive || false,
-      strict: options.strict || false,
-      prefix: options.prefix || "",
-      ignoreCaptures: options.ignoreCaptures,
-      pathAsRegExp: options.pathAsRegExp
-    });
-  }
-  /**
-   * Lookup route with given `name`.
-   *
-   * @param name - Route name
-   * @returns Matched layer or false
-   */
-  route(name) {
-    const matchingRoute = this.stack.find((route) => route.name === name);
-    return matchingRoute || 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"
-   * ```
-   *
-   * @param name - Route name
-   * @param args - URL parameters
-   * @returns Generated URL or Error
-   */
-  url(name, ...arguments_) {
-    const route = this.route(name);
-    if (route) return route.url(...arguments_);
-    return new Error(`No route found for name: ${String(name)}`);
-  }
-  /**
-   * Match given `path` and return corresponding routes.
-   *
-   * @param path - Request path
-   * @param method - HTTP method
-   * @returns Match result with matched layers
-   * @private
-   */
-  match(path, method) {
-    const matchResult = {
-      path: [],
-      pathAndMethod: [],
-      route: false
-    };
-    const normalizedMethod = method.toUpperCase();
-    for (const layer of this.stack) {
-      debug("test %s %s", layer.path, layer.regexp);
-      if (layer.match(path)) {
-        matchResult.path.push(layer);
-        const isMiddleware = layer.methods.length === 0;
-        const matchesMethod = layer.methods.includes(normalizedMethod);
-        if (isMiddleware || matchesMethod) {
-          matchResult.pathAndMethod.push(layer);
-          if (layer.methods.length > 0) {
-            matchResult.route = true;
-          }
-        }
-      }
-    }
-    return matchResult;
-  }
-  /**
-   * Match given `input` to allowed host
-   * @param input - Host to check
-   * @returns Whether host matches
-   */
-  matchHost(input) {
-    const { host } = this;
-    if (!host) {
-      return true;
-    }
-    if (!input) {
-      return false;
-    }
-    if (typeof host === "string") {
-      return input === host;
-    }
-    if (Array.isArray(host)) {
-      return host.includes(input);
-    }
-    if (host instanceof RegExp) {
-      return host.test(input);
-    }
-    return false;
-  }
-  /**
-   * 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 param - Parameter name
-   * @param middleware - Parameter middleware
-   * @returns This router instance
-   */
-  param(parameter, middleware) {
-    if (!this.params[parameter]) {
-      this.params[parameter] = [];
-    }
-    if (!Array.isArray(this.params[parameter])) {
-      this.params[parameter] = [
-        this.params[parameter]
-      ];
-    }
-    this.params[parameter].push(middleware);
-    for (const route of this.stack) {
-      route.param(parameter, middleware);
-    }
-    return this;
-  }
-  /**
-   * Helper method for registering HTTP verb routes
-   * @internal - Used by dynamically added HTTP methods
-   */
-  _registerMethod(method, ...arguments_) {
-    let name;
-    let path;
-    let middleware;
-    if (arguments_.length >= 2 && (typeof arguments_[1] === "string" || arguments_[1] instanceof RegExp)) {
-      name = arguments_[0];
-      path = arguments_[1];
-      middleware = arguments_.slice(2);
-    } else {
-      name = void 0;
-      path = arguments_[0];
-      middleware = arguments_.slice(1);
-    }
-    if (typeof path !== "string" && !(path instanceof RegExp) && (!Array.isArray(path) || path.length === 0))
-      throw new Error(
-        `You have to provide a path when adding a ${method} handler`
-      );
-    const options = {
-      name,
-      pathAsRegExp: path instanceof RegExp
-    };
-    this.register(path, [method], middleware, {
-      ...this.opts,
-      ...options
-    });
-    return this;
-  }
-  get(...arguments_) {
-    return this._registerMethod("get", ...arguments_);
-  }
-  post(...arguments_) {
-    return this._registerMethod("post", ...arguments_);
-  }
-  put(...arguments_) {
-    return this._registerMethod("put", ...arguments_);
-  }
-  patch(...arguments_) {
-    return this._registerMethod("patch", ...arguments_);
-  }
-  delete(...arguments_) {
-    return this._registerMethod("delete", ...arguments_);
-  }
-  del(...arguments_) {
-    return this.delete.apply(
-      this,
-      arguments_
-    );
-  }
-  head(...arguments_) {
-    return this._registerMethod("head", ...arguments_);
-  }
-  options(...arguments_) {
-    return this._registerMethod("options", ...arguments_);
-  }
-};
-var Router = RouterImplementation;
-var router_default = Router;
-for (const httpMethod of httpMethods) {
-  const isAlreadyDefined = COMMON_HTTP_METHODS.includes(httpMethod) || httpMethod in RouterImplementation.prototype;
-  if (!isAlreadyDefined) {
-    Object.defineProperty(RouterImplementation.prototype, httpMethod, {
-      value: function(...arguments_) {
-        return this._registerMethod(httpMethod, ...arguments_);
-      },
-      writable: true,
-      configurable: true,
-      enumerable: false
-    });
-  }
-}
-export {
-  Router,
-  RouterEvents,
-  createParameterValidationMiddleware,
-  router_default as default
-};