@nextrush/router 3.0.0

package/dist/index.js

@@ -0,0 +1,853 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/router.ts
+import { HTTP_METHODS } from "@nextrush/types";
+
+// src/radix-tree.ts
+var NodeType = /* @__PURE__ */ (function(NodeType2) {
+  NodeType2[NodeType2["STATIC"] = 0] = "STATIC";
+  NodeType2[NodeType2["PARAM"] = 1] = "PARAM";
+  NodeType2[NodeType2["WILDCARD"] = 2] = "WILDCARD";
+  return NodeType2;
+})({});
+var RESOLVED_PROMISE = Promise.resolve();
+var NOOP_NEXT = /* @__PURE__ */ __name(() => RESOLVED_PROMISE, "NOOP_NEXT");
+function compileExecutor(handler, middleware) {
+  const len = middleware.length;
+  if (len === 0) {
+    return async (ctx) => {
+      await handler(ctx, NOOP_NEXT);
+    };
+  }
+  if (len === 1) {
+    const mw = middleware[0];
+    if (mw === void 0) throw new Error("middleware length mismatch");
+    return async (ctx) => {
+      await mw(ctx, async () => {
+        await handler(ctx, NOOP_NEXT);
+      });
+    };
+  }
+  if (len === 2) {
+    const mw0 = middleware[0];
+    const mw1 = middleware[1];
+    if (mw0 === void 0 || mw1 === void 0) throw new Error("middleware length mismatch");
+    return async (ctx) => {
+      await mw0(ctx, async () => {
+        await mw1(ctx, async () => {
+          await handler(ctx, NOOP_NEXT);
+        });
+      });
+    };
+  }
+  return async (ctx) => {
+    let index = 0;
+    const dispatch = /* @__PURE__ */ __name(async () => {
+      if (index < len) {
+        const mw = middleware[index++];
+        if (mw === void 0) throw new Error("middleware length mismatch");
+        await mw(ctx, dispatch);
+      } else {
+        await handler(ctx, NOOP_NEXT);
+      }
+    }, "dispatch");
+    await dispatch();
+  };
+}
+__name(compileExecutor, "compileExecutor");
+function createNode(segment, type = 0) {
+  return {
+    segment,
+    type,
+    children: /* @__PURE__ */ new Map(),
+    handlers: /* @__PURE__ */ new Map()
+  };
+}
+__name(createNode, "createNode");
+function parseSegments(path, caseSensitive = true) {
+  const normalized = path.startsWith("/") ? path.slice(1) : path;
+  if (normalized === "") return [];
+  const parts = normalized.split("/");
+  const segments = [];
+  for (const part of parts) {
+    if (part.startsWith(":")) {
+      const paramName = part.slice(1);
+      segments.push({
+        segment: part,
+        type: 1,
+        paramName
+      });
+    } else if (part === "*") {
+      segments.push({
+        segment: "*",
+        type: 2
+      });
+      break;
+    } else {
+      segments.push({
+        segment: caseSensitive ? part : part.toLowerCase(),
+        type: 0
+      });
+    }
+  }
+  return segments;
+}
+__name(parseSegments, "parseSegments");
+
+// src/router.ts
+var EMPTY_PARAMS = Object.freeze(/* @__PURE__ */ Object.create(null));
+var Router = class _Router {
+  static {
+    __name(this, "Router");
+  }
+  root;
+  opts;
+  routerMiddleware = [];
+  /**
+  * Static route hash map for O(1) lookup.
+  * Key: "METHOD path" (e.g. "GET /users"), Value: HandlerEntry
+  */
+  staticRoutes = /* @__PURE__ */ new Map();
+  /** Whether any routes have params or wildcards (disables static-only fast path) */
+  hasParamRoutes = false;
+  constructor(options = {}) {
+    this.root = createNode("");
+    this.opts = {
+      prefix: options.prefix ?? "",
+      caseSensitive: options.caseSensitive ?? false,
+      strict: options.strict ?? false
+    };
+  }
+  /**
+  * Normalize path based on router options
+  */
+  normalizePath(path) {
+    let prefix = this.opts.prefix;
+    if (prefix.endsWith("/") && path.startsWith("/")) {
+      prefix = prefix.slice(0, -1);
+    }
+    let normalized = prefix + path;
+    if (normalized.includes("//")) {
+      normalized = normalized.replace(/\/+/g, "/");
+    }
+    if (!this.opts.strict && normalized.length > 1 && normalized.endsWith("/")) {
+      normalized = normalized.slice(0, -1);
+    }
+    return normalized.startsWith("/") ? normalized : "/" + normalized;
+  }
+  /**
+  * Add a route to the radix tree
+  */
+  addRoute(method, path, handlers, middleware = []) {
+    const normalized = this.normalizePath(path);
+    const segments = parseSegments(normalized, this.opts.caseSensitive);
+    let node = this.root;
+    for (const seg of segments) {
+      if (seg.type === NodeType.PARAM) {
+        if (!node.paramChild) {
+          node.paramChild = createNode(seg.segment, NodeType.PARAM);
+          node.paramChild.paramName = seg.paramName;
+        } else if (node.paramChild.paramName !== seg.paramName) {
+          if (typeof process !== "undefined" && process.env.NODE_ENV !== "production") {
+            const existing = node.paramChild.paramName;
+            console.warn(`[nextrush:router] Route param name conflict at "${normalized}": ":${String(seg.paramName)}" conflicts with existing ":${String(existing)}". The existing name ":${String(existing)}" will be used.`);
+          }
+        }
+        node = node.paramChild;
+      } else if (seg.type === NodeType.WILDCARD) {
+        node.wildcardChild ??= createNode("*", NodeType.WILDCARD);
+        node = node.wildcardChild;
+        break;
+      } else {
+        const key = seg.segment;
+        let child = node.children.get(key);
+        if (!child) {
+          child = createNode(seg.segment, NodeType.STATIC);
+          node.children.set(key, child);
+        }
+        node = child;
+      }
+    }
+    const combinedMiddleware = [
+      ...middleware
+    ];
+    const finalHandler = handlers[handlers.length - 1];
+    if (!finalHandler) {
+      throw new Error("At least one handler is required");
+    }
+    const inlineMiddleware = handlers.slice(0, -1);
+    for (const mw of inlineMiddleware) {
+      combinedMiddleware.push(mw);
+    }
+    const executor = compileExecutor(finalHandler, combinedMiddleware);
+    const entry = {
+      handler: finalHandler,
+      middleware: combinedMiddleware,
+      executor
+    };
+    if (node.handlers.has(method)) {
+      throw new Error(`Route conflict: ${method} ${normalized} is already registered. Remove the duplicate or use a different path.`);
+    }
+    node.handlers.set(method, entry);
+    const hasParams = segments.some((s) => s.type === NodeType.PARAM || s.type === NodeType.WILDCARD);
+    if (hasParams) {
+      this.hasParamRoutes = true;
+    } else {
+      const normalizedKey = this.opts.caseSensitive ? normalized : normalized.toLowerCase();
+      this.staticRoutes.set(`${method} ${normalizedKey}`, entry);
+    }
+  }
+  // ===========================================================================
+  // HTTP Method Shortcuts
+  // ===========================================================================
+  get(path, ...handlers) {
+    this.addRoute("GET", path, handlers);
+    return this;
+  }
+  post(path, ...handlers) {
+    this.addRoute("POST", path, handlers);
+    return this;
+  }
+  put(path, ...handlers) {
+    this.addRoute("PUT", path, handlers);
+    return this;
+  }
+  delete(path, ...handlers) {
+    this.addRoute("DELETE", path, handlers);
+    return this;
+  }
+  patch(path, ...handlers) {
+    this.addRoute("PATCH", path, handlers);
+    return this;
+  }
+  head(path, ...handlers) {
+    this.addRoute("HEAD", path, handlers);
+    return this;
+  }
+  options(path, ...handlers) {
+    this.addRoute("OPTIONS", path, handlers);
+    return this;
+  }
+  all(path, ...handlers) {
+    for (const method of HTTP_METHODS) {
+      this.addRoute(method, path, handlers);
+    }
+    return this;
+  }
+  route(method, path, ...handlers) {
+    this.addRoute(method, path, handlers);
+    return this;
+  }
+  /**
+  * Register a redirect route from one path to another
+  *
+  * @param from - Source path to redirect from
+  * @param to - Target path or URL to redirect to
+  * @param status - HTTP status code (default: 301 permanent redirect)
+  * @returns this for chaining
+  *
+  * @example
+  * ```typescript
+  * // Permanent redirect (301)
+  * router.redirect('/old-page', '/new-page');
+  *
+  * // Temporary redirect (302)
+  * router.redirect('/temp', '/destination', 302);
+  *
+  * // Redirect to external URL
+  * router.redirect('/docs', 'https://docs.example.com');
+  *
+  * // With parameters - redirects /users/:id to /profiles/:id
+  * router.redirect('/users/:id', '/profiles/:id');
+  * ```
+  */
+  redirect(from, to, status = 301) {
+    let compiledParts;
+    {
+      const parts = [];
+      let pos = 0;
+      let found = false;
+      while (pos < to.length) {
+        let idx = -1;
+        for (let i = pos; i < to.length; i++) {
+          if (to[i] === ":" && (i === 0 || to[i - 1] === "/") && i + 1 < to.length && to[i + 1] !== "/") {
+            idx = i;
+            break;
+          }
+        }
+        if (idx === -1) break;
+        found = true;
+        parts.push(to.slice(pos, idx));
+        const end = to.indexOf("/", idx + 1);
+        if (end === -1) {
+          parts.push(to.slice(idx + 1));
+          pos = to.length;
+        } else {
+          parts.push(to.slice(idx + 1, end));
+          pos = end;
+        }
+      }
+      if (found) {
+        parts.push(to.slice(pos));
+        compiledParts = parts;
+      }
+    }
+    const redirectHandler = /* @__PURE__ */ __name((ctx) => {
+      let targetPath;
+      if (compiledParts) {
+        const params = ctx.params;
+        const parts = compiledParts;
+        const head = parts[0];
+        if (head === void 0) {
+          targetPath = to;
+        } else {
+          let result = head;
+          for (let i = 1; i < parts.length - 1; i += 2) {
+            const paramKey = parts[i];
+            const tail = parts[i + 1];
+            if (paramKey === void 0 || tail === void 0) break;
+            result += (params[paramKey] ?? "") + tail;
+          }
+          targetPath = result;
+        }
+      } else {
+        targetPath = to;
+      }
+      ctx.status = status;
+      ctx.set("Location", targetPath);
+      ctx.body = "";
+    }, "redirectHandler");
+    this.addRoute("GET", from, [
+      redirectHandler
+    ]);
+    this.addRoute("HEAD", from, [
+      redirectHandler
+    ]);
+    if (status === 307 || status === 308) {
+      this.addRoute("POST", from, [
+        redirectHandler
+      ]);
+      this.addRoute("PUT", from, [
+        redirectHandler
+      ]);
+      this.addRoute("PATCH", from, [
+        redirectHandler
+      ]);
+      this.addRoute("DELETE", from, [
+        redirectHandler
+      ]);
+    }
+    return this;
+  }
+  // ===========================================================================
+  // Router Composition
+  // ===========================================================================
+  use(pathOrMiddleware, routerOrUndefined) {
+    if (typeof pathOrMiddleware === "function") {
+      this.routerMiddleware.push(pathOrMiddleware);
+    } else if (typeof pathOrMiddleware === "string" && routerOrUndefined instanceof _Router) {
+      this.mountRouter(pathOrMiddleware, routerOrUndefined);
+    } else if (typeof pathOrMiddleware === "string") {
+      throw new Error(`router.use('${pathOrMiddleware}', ...) requires a Router instance as the second argument. Use router.group(prefix, callback) for prefix-scoped middleware, or router.use(middlewareFn) to register middleware without a prefix.`);
+    } else if (pathOrMiddleware instanceof _Router) {
+      this.mountRouter("", pathOrMiddleware);
+    }
+    return this;
+  }
+  /**
+  * Mount a sub-router at a path prefix (Hono-style)
+  *
+  * This is the explicit API for mounting sub-routers.
+  * Equivalent to `router.use(path, subRouter)` but more semantic.
+  *
+  * @param path - Path prefix for the sub-router
+  * @param router - Router instance to mount
+  * @returns this for chaining
+  *
+  * @example
+  * ```typescript
+  * // Create modular routers
+  * const users = createRouter();
+  * users.get('/', listUsers);
+  * users.get('/:id', getUser);
+  *
+  * const posts = createRouter();
+  * posts.get('/', listPosts);
+  *
+  * // Mount sub-routers
+  * const api = createRouter();
+  * api.mount('/users', users);
+  * api.mount('/posts', posts);
+  *
+  * // Or use on main router
+  * const router = createRouter();
+  * router.mount('/api', api);
+  *
+  * app.use(router.routes());
+  * ```
+  */
+  mount(path, router) {
+    this.mountRouter(path, router);
+    return this;
+  }
+  /**
+  * Mount a sub-router (internal)
+  *
+  * Carries the sub-router's own `routerMiddleware` forward so that
+  * `subrouter.use(mw)` middleware applies to every copied route.
+  */
+  mountRouter(prefix, router) {
+    this.copyRoutes(router.root, prefix, [], router.routerMiddleware);
+  }
+  /**
+  * Recursively copy routes from another router
+  */
+  copyRoutes(node, prefix, segments, subRouterMiddleware) {
+    for (const [method, entry] of node.handlers) {
+      const path = prefix + "/" + segments.join("/");
+      const combined = subRouterMiddleware.length > 0 ? [
+        ...subRouterMiddleware,
+        ...entry.middleware
+      ] : entry.middleware;
+      this.addRoute(method, path || "/", [
+        entry.handler
+      ], combined);
+    }
+    for (const [, child] of node.children) {
+      this.copyRoutes(child, prefix, [
+        ...segments,
+        child.segment
+      ], subRouterMiddleware);
+    }
+    if (node.paramChild) {
+      this.copyRoutes(node.paramChild, prefix, [
+        ...segments,
+        node.paramChild.segment
+      ], subRouterMiddleware);
+    }
+    if (node.wildcardChild) {
+      this.copyRoutes(node.wildcardChild, prefix, [
+        ...segments,
+        "*"
+      ], subRouterMiddleware);
+    }
+  }
+  // ===========================================================================
+  // Route Matching
+  // ===========================================================================
+  /**
+  * Match a route and return handler + params
+  */
+  match(method, path) {
+    const isCaseInsensitive = !this.opts.caseSensitive;
+    let normalized = isCaseInsensitive ? path.toLowerCase() : path;
+    if (normalized.includes("//")) {
+      normalized = normalized.replace(/\/+/g, "/");
+    }
+    if (!this.opts.strict && normalized.length > 1 && normalized.endsWith("/")) {
+      normalized = normalized.slice(0, -1);
+    }
+    const staticKey = normalized.length > 1 && normalized.endsWith("/") ? `${method} ${normalized.slice(0, -1)}` : `${method} ${normalized}`;
+    const staticEntry = this.staticRoutes.get(staticKey);
+    if (staticEntry) {
+      return {
+        handler: staticEntry.handler,
+        params: EMPTY_PARAMS,
+        middleware: this.routerMiddleware,
+        executor: staticEntry.executor
+      };
+    }
+    if (!this.hasParamRoutes) return null;
+    const params = {};
+    let originalPath;
+    if (isCaseInsensitive) {
+      originalPath = path;
+      if (originalPath.includes("//")) {
+        originalPath = originalPath.replace(/\/+/g, "/");
+      }
+      if (!this.opts.strict && originalPath.length > 1 && originalPath.endsWith("/")) {
+        originalPath = originalPath.slice(0, -1);
+      }
+    }
+    const result = this.matchNodeIndexed(this.root, normalized, 1, params, method, originalPath);
+    if (!result) return null;
+    let hasParams = false;
+    for (const key of Object.keys(params)) {
+      if (params[key] === void 0) {
+        Reflect.deleteProperty(params, key);
+      } else {
+        hasParams = true;
+      }
+    }
+    return {
+      handler: result.handler,
+      params: hasParams ? params : EMPTY_PARAMS,
+      middleware: this.routerMiddleware,
+      executor: result.executor
+    };
+  }
+  /**
+  * Extract the next segment from path at given position without allocating arrays.
+  * Returns [segment, nextIndex] where nextIndex is position after the trailing '/'.
+  */
+  extractSegment(path, start) {
+    const slashPos = path.indexOf("/", start);
+    if (slashPos === -1) {
+      return [
+        path.slice(start),
+        path.length
+      ];
+    }
+    return [
+      path.slice(start, slashPos),
+      slashPos + 1
+    ];
+  }
+  /**
+  * Index-based recursive node matching (avoids array allocation)
+  */
+  matchNodeIndexed(node, path, pos, params, method, originalPath) {
+    if (pos >= path.length) {
+      return node.handlers.get(method) ?? null;
+    }
+    const [segment, nextPos] = this.extractSegment(path, pos);
+    if (segment === "") return node.handlers.get(method) ?? null;
+    const staticChild = node.children.get(segment);
+    if (staticChild) {
+      const result = this.matchNodeIndexed(staticChild, path, nextPos, params, method, originalPath);
+      if (result) return result;
+    }
+    if (node.paramChild) {
+      const paramName = node.paramChild.paramName;
+      if (paramName === void 0) return null;
+      if (originalPath) {
+        const [origSeg] = this.extractSegment(originalPath, pos);
+        params[paramName] = origSeg;
+      } else {
+        params[paramName] = segment;
+      }
+      const result = this.matchNodeIndexed(node.paramChild, path, nextPos, params, method, originalPath);
+      if (result) return result;
+      Reflect.deleteProperty(params, paramName);
+    }
+    if (node.wildcardChild) {
+      const src = originalPath ?? path;
+      params["*"] = src.slice(pos);
+      return node.wildcardChild.handlers.get(method) ?? null;
+    }
+    return null;
+  }
+  // ===========================================================================
+  // Middleware Generation
+  // ===========================================================================
+  /**
+  * Get routes middleware function
+  * Mount this on the application
+  *
+  * @example
+  * ```typescript
+  * app.use(router.routes());
+  * ```
+  */
+  routes() {
+    const hasRouterMiddleware = this.routerMiddleware.length > 0;
+    if (hasRouterMiddleware) {
+      this.sealRouterMiddleware();
+    }
+    return async (ctx, next) => {
+      const match = this.match(ctx.method, ctx.path);
+      if (!match) {
+        ctx.status = 404;
+        if (next) await next();
+        return;
+      }
+      ctx.params = match.params;
+      if (match.executor) {
+        await match.executor(ctx);
+        return;
+      }
+      await match.handler(ctx, NOOP_NEXT);
+    };
+  }
+  /**
+  * Re-compile all route executors to include router-level middleware.
+  * Called once when routes() is invoked, not per-request.
+  */
+  sealRouterMiddleware() {
+    const routerMw = [
+      ...this.routerMiddleware
+    ];
+    const walk = /* @__PURE__ */ __name((node) => {
+      for (const [method, entry] of node.handlers) {
+        const combinedMw = [
+          ...routerMw,
+          ...entry.middleware
+        ];
+        entry.executor = compileExecutor(entry.handler, combinedMw);
+        node.handlers.set(method, entry);
+      }
+      for (const [, child] of node.children) {
+        walk(child);
+      }
+      if (node.paramChild) walk(node.paramChild);
+      if (node.wildcardChild) walk(node.wildcardChild);
+    }, "walk");
+    walk(this.root);
+    for (const [key, entry] of this.staticRoutes) {
+      const combinedMw = [
+        ...routerMw,
+        ...entry.middleware
+      ];
+      entry.executor = compileExecutor(entry.handler, combinedMw);
+      this.staticRoutes.set(key, entry);
+    }
+  }
+  /**
+  * Generate allowed methods middleware
+  * Responds to OPTIONS and sets Allow header
+  */
+  allowedMethods() {
+    return async (ctx, next) => {
+      if (next) {
+        await next();
+      }
+      if (ctx.status !== 404) return;
+      const allowed = this.findAllowedMethods(ctx.path);
+      if (allowed.length === 0) return;
+      const allowHeader = allowed.join(", ");
+      if (ctx.method === "OPTIONS") {
+        ctx.status = 200;
+        ctx.set("Allow", allowHeader);
+        ctx.body = "";
+        return;
+      }
+      ctx.status = 405;
+      ctx.set("Allow", allowHeader);
+    };
+  }
+  /**
+  * Find all HTTP methods registered for a given path via single tree walk
+  * @internal
+  */
+  findAllowedMethods(path) {
+    let normalized = this.opts.caseSensitive ? path : path.toLowerCase();
+    if (normalized.includes("//")) {
+      normalized = normalized.replace(/\/+/g, "/");
+    }
+    if (!this.opts.strict && normalized.length > 1 && normalized.endsWith("/")) {
+      normalized = normalized.slice(0, -1);
+    }
+    const segments = normalized.split("/").filter(Boolean);
+    const node = this.findNode(this.root, segments, 0);
+    if (!node || node.handlers.size === 0) return [];
+    return Array.from(node.handlers.keys());
+  }
+  /**
+  * Walk the tree to find the node matching a path (ignoring HTTP method)
+  * @internal
+  */
+  findNode(node, segments, index) {
+    if (index === segments.length) {
+      return node;
+    }
+    const segment = segments[index];
+    if (segment === void 0) return null;
+    const staticChild = node.children.get(segment);
+    if (staticChild) {
+      const result = this.findNode(staticChild, segments, index + 1);
+      if (result) return result;
+    }
+    if (node.paramChild) {
+      const result = this.findNode(node.paramChild, segments, index + 1);
+      if (result) return result;
+    }
+    if (node.wildcardChild) {
+      return node.wildcardChild;
+    }
+    return null;
+  }
+  // ===========================================================================
+  // Route Groups
+  // ===========================================================================
+  /**
+  * Create a route group with shared prefix and middleware
+  *
+  * @param prefix - Path prefix for all routes in the group
+  * @param middlewareOrCallback - Middleware array or callback function
+  * @param callback - Callback function if middleware is provided
+  * @returns this for chaining
+  *
+  * @example
+  * ```typescript
+  * // Simple group with prefix
+  * router.group('/api', (r) => {
+  *   r.get('/users', listUsers);
+  *   r.get('/posts', listPosts);
+  * });
+  *
+  * // Group with middleware
+  * router.group('/admin', [authMiddleware], (r) => {
+  *   r.get('/dashboard', dashboard);
+  *   r.post('/settings', updateSettings);
+  * });
+  *
+  * // Nested groups
+  * router.group('/api/v1', (r) => {
+  *   r.group('/users', [rateLimit], (ur) => {
+  *     ur.get('/', listUsers);
+  *     ur.get('/:id', getUser);
+  *   });
+  * });
+  * ```
+  */
+  group(prefix, middlewareOrCallback, callback) {
+    let middleware = [];
+    let cb;
+    if (Array.isArray(middlewareOrCallback)) {
+      middleware = middlewareOrCallback;
+      if (!callback) {
+        throw new Error("Callback function is required when providing middleware array");
+      }
+      cb = callback;
+    } else {
+      cb = middlewareOrCallback;
+    }
+    const groupRouter = new GroupRouter(this, prefix, middleware);
+    cb(groupRouter);
+    return this;
+  }
+  /**
+  * Remove all registered routes and middleware, resetting the router to its initial state.
+  * Useful for plugin `destroy()` to cleanly un-register routes.
+  */
+  reset() {
+    this.root.children.clear();
+    this.root.handlers.clear();
+    this.root.paramChild = void 0;
+    this.root.wildcardChild = void 0;
+    this.staticRoutes.clear();
+    this.routerMiddleware.length = 0;
+    this.hasParamRoutes = false;
+  }
+  /**
+  * Internal method to add route with group context
+  * @internal
+  */
+  _addGroupRoute(method, path, handlers, groupMiddleware) {
+    this.addRoute(method, path, handlers, groupMiddleware);
+  }
+};
+var GroupRouter = class GroupRouter2 {
+  static {
+    __name(this, "GroupRouter");
+  }
+  parent;
+  prefix;
+  middleware;
+  constructor(parent, prefix, middleware) {
+    this.parent = parent;
+    this.prefix = prefix;
+    this.middleware = middleware;
+  }
+  fullPath(path) {
+    if (path === "/" || path === "") {
+      return this.prefix;
+    }
+    const cleanPrefix = this.prefix.endsWith("/") ? this.prefix.slice(0, -1) : this.prefix;
+    const cleanPath = path.startsWith("/") ? path : "/" + path;
+    return cleanPrefix + cleanPath;
+  }
+  get(path, ...handlers) {
+    this.parent._addGroupRoute("GET", this.fullPath(path), handlers, this.middleware);
+    return this;
+  }
+  post(path, ...handlers) {
+    this.parent._addGroupRoute("POST", this.fullPath(path), handlers, this.middleware);
+    return this;
+  }
+  put(path, ...handlers) {
+    this.parent._addGroupRoute("PUT", this.fullPath(path), handlers, this.middleware);
+    return this;
+  }
+  delete(path, ...handlers) {
+    this.parent._addGroupRoute("DELETE", this.fullPath(path), handlers, this.middleware);
+    return this;
+  }
+  patch(path, ...handlers) {
+    this.parent._addGroupRoute("PATCH", this.fullPath(path), handlers, this.middleware);
+    return this;
+  }
+  head(path, ...handlers) {
+    this.parent._addGroupRoute("HEAD", this.fullPath(path), handlers, this.middleware);
+    return this;
+  }
+  options(path, ...handlers) {
+    this.parent._addGroupRoute("OPTIONS", this.fullPath(path), handlers, this.middleware);
+    return this;
+  }
+  all(path, ...handlers) {
+    for (const method of HTTP_METHODS) {
+      this.parent._addGroupRoute(method, this.fullPath(path), handlers, this.middleware);
+    }
+    return this;
+  }
+  /**
+  * Register a redirect within the group
+  */
+  redirect(from, to, status = 301) {
+    const redirectHandler = /* @__PURE__ */ __name((ctx) => {
+      let targetPath = to;
+      if (targetPath.includes(":")) {
+        const entries = Object.entries(ctx.params).sort((a, b) => b[0].length - a[0].length);
+        for (const [key, value] of entries) {
+          targetPath = targetPath.replaceAll(`:${key}`, value);
+        }
+      }
+      ctx.status = status;
+      ctx.set("Location", targetPath);
+      ctx.body = "";
+    }, "redirectHandler");
+    this.parent._addGroupRoute("GET", this.fullPath(from), [
+      redirectHandler
+    ], this.middleware);
+    this.parent._addGroupRoute("HEAD", this.fullPath(from), [
+      redirectHandler
+    ], this.middleware);
+    return this;
+  }
+  /**
+  * Nested group support
+  */
+  group(prefix, middlewareOrCallback, callback) {
+    let nestedMiddleware = [];
+    let cb;
+    if (Array.isArray(middlewareOrCallback)) {
+      nestedMiddleware = middlewareOrCallback;
+      if (!callback) {
+        throw new Error("Callback function is required when providing middleware array");
+      }
+      cb = callback;
+    } else {
+      cb = middlewareOrCallback;
+    }
+    const nestedRouter = new GroupRouter2(this.parent, this.fullPath(prefix), [
+      ...this.middleware,
+      ...nestedMiddleware
+    ]);
+    cb(nestedRouter);
+    return this;
+  }
+};
+function createRouter(options) {
+  return new Router(options);
+}
+__name(createRouter, "createRouter");
+export {
+  NodeType,
+  Router,
+  createNode,
+  createRouter,
+  parseSegments
+};
+//# sourceMappingURL=index.js.map