@buenojs/bueno 0.8.3 → 0.8.5

package/dist/router/index.js

@@ -0,0 +1,886 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/router/linear.ts
+function patternToRegex(pattern) {
+  const paramNames = [];
+  let isStatic = true;
+  let hasWildcard = false;
+  const segments = [];
+  let i = 0;
+  while (i < pattern.length) {
+    if (pattern[i] === ":") {
+      i++;
+      let name = "";
+      while (i < pattern.length && /[a-zA-Z0-9_]/.test(pattern[i])) {
+        name += pattern[i];
+        i++;
+      }
+      let optional = false;
+      if (i < pattern.length && pattern[i] === "?") {
+        optional = true;
+        i++;
+      }
+      let customRegex = "";
+      if (i < pattern.length && pattern[i] === "<") {
+        i++;
+        while (i < pattern.length && pattern[i] !== ">") {
+          customRegex += pattern[i];
+          i++;
+        }
+        i++;
+      }
+      paramNames.push(name);
+      isStatic = false;
+      if (optional) {
+        if (segments.length > 0 && segments[segments.length - 1] === "/") {
+          segments.pop();
+        }
+        segments.push("(?:/([^/]*))?");
+      } else if (customRegex) {
+        segments.push(`(${customRegex})`);
+      } else {
+        segments.push("([^/]+)");
+      }
+    } else if (pattern[i] === "*") {
+      hasWildcard = true;
+      isStatic = false;
+      paramNames.push("*");
+      segments.push("(.*)");
+      i++;
+    } else {
+      const char = pattern[i];
+      if (/[.+^${}()|[\]\\]/.test(char)) {
+        segments.push(`\\${char}`);
+      } else {
+        segments.push(char);
+      }
+      i++;
+    }
+  }
+  const regexStr = `^${segments.join("")}/?$`;
+  return {
+    regex: new RegExp(regexStr, "i"),
+    paramNames,
+    isStatic,
+    hasWildcard
+  };
+}
+function extractParams(regex, paramNames, pathname) {
+  const params = {};
+  const match = pathname.match(regex);
+  if (match) {
+    paramNames.forEach((name, index) => {
+      if (match[index + 1] !== undefined) {
+        params[name] = match[index + 1];
+      }
+    });
+  }
+  return params;
+}
+
+class LinearRouter {
+  staticRoutes = new Map;
+  dynamicRoutes = [];
+  groupPrefix = "";
+  groupMiddleware = [];
+  routeCounter = 0;
+  addRoute(method, pattern, handler, options) {
+    const fullPattern = this.groupPrefix + pattern;
+    const { regex, paramNames, isStatic } = patternToRegex(fullPattern);
+    const optsMiddleware = options?.middleware;
+    const routeMiddleware = optsMiddleware ? Array.isArray(optsMiddleware) ? optsMiddleware : [optsMiddleware] : [];
+    const middleware = [...this.groupMiddleware, ...routeMiddleware];
+    if (isStatic) {
+      const normalizedPath = fullPattern.toLowerCase();
+      const key = `${method}:${normalizedPath}`;
+      this.staticRoutes.set(key, { handler, middleware, name: options?.name });
+      if (!normalizedPath.endsWith("/")) {
+        this.staticRoutes.set(`${method}:${normalizedPath}/`, {
+          handler,
+          middleware,
+          name: options?.name
+        });
+      } else if (normalizedPath.length > 1) {
+        this.staticRoutes.set(`${method}:${normalizedPath.slice(0, -1)}`, {
+          handler,
+          middleware,
+          name: options?.name
+        });
+      }
+    } else {
+      this.dynamicRoutes.push({
+        method,
+        pattern: fullPattern,
+        handler,
+        middleware,
+        name: options?.name,
+        regex,
+        paramNames,
+        priority: this.routeCounter++
+      });
+      this.sortDynamicRoutes();
+    }
+  }
+  sortDynamicRoutes() {
+    this.dynamicRoutes.sort((a, b) => {
+      if (a.paramNames.length !== b.paramNames.length) {
+        return a.paramNames.length - b.paramNames.length;
+      }
+      return a.priority - b.priority;
+    });
+  }
+  match(method, pathname) {
+    const normalizedPath = pathname.toLowerCase();
+    const staticKey = `${method}:${normalizedPath}`;
+    const staticRoute = this.staticRoutes.get(staticKey);
+    if (staticRoute) {
+      return {
+        handler: staticRoute.handler,
+        params: {},
+        middleware: staticRoute.middleware,
+        name: staticRoute.name
+      };
+    }
+    const allKey = `ALL:${normalizedPath}`;
+    const allRoute = this.staticRoutes.get(allKey);
+    if (allRoute) {
+      return {
+        handler: allRoute.handler,
+        params: {},
+        middleware: allRoute.middleware,
+        name: allRoute.name
+      };
+    }
+    for (const route of this.dynamicRoutes) {
+      if (route.method !== "ALL" && route.method !== method) {
+        continue;
+      }
+      if (route.regex.test(pathname)) {
+        const params = extractParams(route.regex, route.paramNames, pathname);
+        return {
+          handler: route.handler,
+          params,
+          middleware: route.middleware,
+          name: route.name
+        };
+      }
+    }
+    return;
+  }
+  group(prefix, options) {
+    const childRouter = new LinearRouter;
+    childRouter.staticRoutes = this.staticRoutes;
+    childRouter.dynamicRoutes = this.dynamicRoutes;
+    childRouter.groupPrefix = this.groupPrefix + prefix;
+    const optsMiddleware = options?.middleware;
+    const middlewareArray = optsMiddleware ? Array.isArray(optsMiddleware) ? optsMiddleware : [optsMiddleware] : [];
+    childRouter.groupMiddleware = [...this.groupMiddleware, ...middlewareArray];
+    childRouter.routeCounter = this.routeCounter;
+    return childRouter;
+  }
+  getRoutes() {
+    const routes = [];
+    const seenPatterns = new Set;
+    for (const [key, value] of this.staticRoutes) {
+      const [method, path] = key.split(":");
+      const pattern = path.endsWith("/") && path.length > 1 ? path.slice(0, -1) : path;
+      const dedupeKey = `${method}:${pattern}`;
+      if (!seenPatterns.has(dedupeKey)) {
+        seenPatterns.add(dedupeKey);
+        routes.push({ method, pattern: pattern || "/", name: value.name });
+      }
+    }
+    for (const route of this.dynamicRoutes) {
+      routes.push({
+        method: route.method,
+        pattern: route.pattern,
+        name: route.name
+      });
+    }
+    return routes;
+  }
+  getRouterType() {
+    return "linear";
+  }
+  getRouteCount() {
+    const staticCount = Math.floor(this.staticRoutes.size / 2);
+    return {
+      static: staticCount,
+      dynamic: this.dynamicRoutes.length,
+      total: staticCount + this.dynamicRoutes.length
+    };
+  }
+  get(pattern, handler, options) {
+    this.addRoute("GET", pattern, handler, options);
+  }
+  post(pattern, handler, options) {
+    this.addRoute("POST", pattern, handler, options);
+  }
+  put(pattern, handler, options) {
+    this.addRoute("PUT", pattern, handler, options);
+  }
+  patch(pattern, handler, options) {
+    this.addRoute("PATCH", pattern, handler, options);
+  }
+  delete(pattern, handler, options) {
+    this.addRoute("DELETE", pattern, handler, options);
+  }
+  head(pattern, handler, options) {
+    this.addRoute("HEAD", pattern, handler, options);
+  }
+  options(pattern, handler, options) {
+    this.addRoute("OPTIONS", pattern, handler, options);
+  }
+  all(pattern, handler, options) {
+    this.addRoute("ALL", pattern, handler, options);
+  }
+}
+
+// src/router/regex.ts
+function patternToRegex2(pattern) {
+  const paramNames = [];
+  let isStatic = true;
+  let hasWildcard = false;
+  const segments = [];
+  let i = 0;
+  while (i < pattern.length) {
+    if (pattern[i] === ":") {
+      i++;
+      let name = "";
+      while (i < pattern.length && /[a-zA-Z0-9_]/.test(pattern[i])) {
+        name += pattern[i];
+        i++;
+      }
+      let optional = false;
+      if (i < pattern.length && pattern[i] === "?") {
+        optional = true;
+        i++;
+      }
+      let customRegex = "";
+      if (i < pattern.length && pattern[i] === "<") {
+        i++;
+        while (i < pattern.length && pattern[i] !== ">") {
+          customRegex += pattern[i];
+          i++;
+        }
+        i++;
+      }
+      paramNames.push(name);
+      isStatic = false;
+      if (optional) {
+        if (segments.length > 0 && segments[segments.length - 1] === "/") {
+          segments.pop();
+        }
+        segments.push("(?:/([^/]*))?");
+      } else if (customRegex) {
+        segments.push(`(${customRegex})`);
+      } else {
+        segments.push("([^/]+)");
+      }
+    } else if (pattern[i] === "*") {
+      hasWildcard = true;
+      isStatic = false;
+      paramNames.push("*");
+      segments.push("(.*)");
+      i++;
+    } else {
+      const char = pattern[i];
+      if (/[.+^${}()|[\]\\]/.test(char)) {
+        segments.push(`\\${char}`);
+      } else {
+        segments.push(char);
+      }
+      i++;
+    }
+  }
+  const regexStr = `^${segments.join("")}/?$`;
+  return {
+    regex: new RegExp(regexStr, "i"),
+    paramNames,
+    isStatic,
+    hasWildcard
+  };
+}
+function extractParams2(regex, paramNames, pathname) {
+  const params = {};
+  const match = pathname.match(regex);
+  if (match) {
+    paramNames.forEach((name, index) => {
+      if (match[index + 1] !== undefined) {
+        params[name] = match[index + 1];
+      }
+    });
+  }
+  return params;
+}
+
+class RegexRouter {
+  routes = [];
+  groupPrefix = "";
+  groupMiddleware = [];
+  routeCounter = 0;
+  addRoute(method, pattern, handler, options) {
+    const fullPattern = this.groupPrefix + pattern;
+    const { regex, paramNames, isStatic } = patternToRegex2(fullPattern);
+    const optsMiddleware = options?.middleware;
+    const routeMiddleware = optsMiddleware ? Array.isArray(optsMiddleware) ? optsMiddleware : [optsMiddleware] : [];
+    this.routes.push({
+      method,
+      pattern: fullPattern,
+      handler,
+      middleware: [...this.groupMiddleware, ...routeMiddleware],
+      name: options?.name,
+      regex,
+      paramNames,
+      isStatic,
+      priority: this.routeCounter++
+    });
+    this.sortRoutes();
+  }
+  sortRoutes() {
+    this.routes.sort((a, b) => {
+      if (a.isStatic !== b.isStatic) {
+        return a.isStatic ? -1 : 1;
+      }
+      if (a.paramNames.length !== b.paramNames.length) {
+        return a.paramNames.length - b.paramNames.length;
+      }
+      return a.priority - b.priority;
+    });
+  }
+  match(method, pathname) {
+    for (const route of this.routes) {
+      if (route.method !== "ALL" && route.method !== method) {
+        continue;
+      }
+      if (route.regex.test(pathname)) {
+        const params = extractParams2(route.regex, route.paramNames, pathname);
+        return {
+          handler: route.handler,
+          params,
+          middleware: route.middleware,
+          name: route.name
+        };
+      }
+    }
+    return;
+  }
+  group(prefix, options) {
+    const childRouter = new RegexRouter;
+    childRouter.routes = this.routes;
+    childRouter.groupPrefix = this.groupPrefix + prefix;
+    const optsMiddleware = options?.middleware;
+    const middlewareArray = optsMiddleware ? Array.isArray(optsMiddleware) ? optsMiddleware : [optsMiddleware] : [];
+    childRouter.groupMiddleware = [...this.groupMiddleware, ...middlewareArray];
+    childRouter.routeCounter = this.routeCounter;
+    return childRouter;
+  }
+  getRoutes() {
+    return this.routes.map((r) => ({
+      method: r.method,
+      pattern: r.pattern,
+      name: r.name
+    }));
+  }
+  getRouterType() {
+    return "regex";
+  }
+  getRouteCount() {
+    return this.routes.length;
+  }
+  get(pattern, handler, options) {
+    this.addRoute("GET", pattern, handler, options);
+  }
+  post(pattern, handler, options) {
+    this.addRoute("POST", pattern, handler, options);
+  }
+  put(pattern, handler, options) {
+    this.addRoute("PUT", pattern, handler, options);
+  }
+  patch(pattern, handler, options) {
+    this.addRoute("PATCH", pattern, handler, options);
+  }
+  delete(pattern, handler, options) {
+    this.addRoute("DELETE", pattern, handler, options);
+  }
+  head(pattern, handler, options) {
+    this.addRoute("HEAD", pattern, handler, options);
+  }
+  options(pattern, handler, options) {
+    this.addRoute("OPTIONS", pattern, handler, options);
+  }
+  all(pattern, handler, options) {
+    this.addRoute("ALL", pattern, handler, options);
+  }
+}
+
+// src/router/tree.ts
+class TreeRouter {
+  root;
+  groupPrefix = "";
+  groupMiddleware = [];
+  routeCount = 0;
+  constructor() {
+    this.root = this.createNode("");
+  }
+  createNode(path, paramName, paramRegex, isWildcard = false) {
+    return {
+      path,
+      children: new Map,
+      handlers: new Map,
+      paramName,
+      paramRegex,
+      isWildcard
+    };
+  }
+  addRoute(method, pattern, handler, options) {
+    const fullPattern = this.groupPrefix + pattern;
+    const optsMiddleware = options?.middleware;
+    const routeMiddleware = optsMiddleware ? Array.isArray(optsMiddleware) ? optsMiddleware : [optsMiddleware] : [];
+    const middleware = [...this.groupMiddleware, ...routeMiddleware];
+    const segments = this.parsePattern(fullPattern);
+    const node = this.insertSegments(this.root, segments, 0);
+    node.handlers.set(method, {
+      handler,
+      middleware,
+      name: options?.name
+    });
+    this.routeCount++;
+  }
+  parsePattern(pattern) {
+    const segments = [];
+    let normalized = pattern;
+    if (!normalized.startsWith("/")) {
+      normalized = `/${normalized}`;
+    }
+    if (normalized.length > 1 && normalized.endsWith("/")) {
+      normalized = normalized.slice(0, -1);
+    }
+    if (normalized === "/") {
+      return [{ type: "static", value: "" }];
+    }
+    const parts = normalized.split("/").filter(Boolean);
+    for (const part of parts) {
+      if (part === "*") {
+        segments.push({ type: "wildcard" });
+      } else if (part.startsWith(":")) {
+        let name = part.slice(1);
+        let regex;
+        let optional = false;
+        if (name.endsWith("?")) {
+          optional = true;
+          name = name.slice(0, -1);
+        }
+        const regexMatch = name.match(/^(\w+)<(.+)>$/);
+        if (regexMatch) {
+          name = regexMatch[1];
+          regex = new RegExp(`^(${regexMatch[2]})$`);
+        }
+        segments.push({ type: "param", name, regex, optional });
+      } else {
+        segments.push({ type: "static", value: part.toLowerCase() });
+      }
+    }
+    return segments;
+  }
+  insertSegments(node, segments, index) {
+    if (index >= segments.length) {
+      return node;
+    }
+    const segment = segments[index];
+    if (segment.type === "wildcard") {
+      if (!node.wildcardChild) {
+        node.wildcardChild = this.createNode("*", "*", undefined, true);
+      }
+      return node.wildcardChild;
+    }
+    if (segment.type === "param") {
+      if (!node.paramChild) {
+        node.paramChild = this.createNode(`:${segment.name}`, segment.name, segment.regex);
+      }
+      return this.insertSegments(node.paramChild, segments, index + 1);
+    }
+    const value = segment.value;
+    let child = node.children.get(value);
+    if (!child) {
+      child = this.createNode(value);
+      node.children.set(value, child);
+    }
+    return this.insertSegments(child, segments, index + 1);
+  }
+  match(method, pathname) {
+    const params = {};
+    let normalized = pathname.toLowerCase();
+    if (normalized.length > 1 && normalized.endsWith("/")) {
+      normalized = normalized.slice(0, -1);
+    }
+    const parts = normalized === "/" ? [""] : normalized.split("/").filter(Boolean);
+    const result = this.searchTree(this.root, parts, 0, method, params);
+    return result;
+  }
+  searchTree(node, parts, partIndex, method, params) {
+    if (partIndex >= parts.length) {
+      const handlerEntry = node.handlers.get(method) || node.handlers.get("ALL");
+      if (handlerEntry) {
+        return {
+          handler: handlerEntry.handler,
+          params: { ...params },
+          middleware: handlerEntry.middleware,
+          name: handlerEntry.name
+        };
+      }
+      return;
+    }
+    const part = parts[partIndex];
+    const staticChild = node.children.get(part);
+    if (staticChild) {
+      const result = this.searchTree(staticChild, parts, partIndex + 1, method, params);
+      if (result)
+        return result;
+    }
+    if (node.paramChild) {
+      const paramNode = node.paramChild;
+      if (paramNode.paramRegex) {
+        if (paramNode.paramRegex.test(part)) {
+          params[paramNode.paramName] = part;
+          const result = this.searchTree(paramNode, parts, partIndex + 1, method, params);
+          if (result)
+            return result;
+          delete params[paramNode.paramName];
+        }
+      } else {
+        params[paramNode.paramName] = part;
+        const result = this.searchTree(paramNode, parts, partIndex + 1, method, params);
+        if (result)
+          return result;
+        delete params[paramNode.paramName];
+      }
+    }
+    if (node.wildcardChild) {
+      const wildcardNode = node.wildcardChild;
+      params["*"] = parts.slice(partIndex).join("/");
+      const handlerEntry = wildcardNode.handlers.get(method) || wildcardNode.handlers.get("ALL");
+      if (handlerEntry) {
+        return {
+          handler: handlerEntry.handler,
+          params: { ...params },
+          middleware: handlerEntry.middleware,
+          name: handlerEntry.name
+        };
+      }
+    }
+    return;
+  }
+  group(prefix, options) {
+    const childRouter = new TreeRouter;
+    childRouter.root = this.root;
+    childRouter.groupPrefix = this.groupPrefix + prefix;
+    const optsMiddleware = options?.middleware;
+    const middlewareArray = optsMiddleware ? Array.isArray(optsMiddleware) ? optsMiddleware : [optsMiddleware] : [];
+    childRouter.groupMiddleware = [...this.groupMiddleware, ...middlewareArray];
+    childRouter.routeCount = this.routeCount;
+    return childRouter;
+  }
+  getRoutes() {
+    const routes = [];
+    this.traverseTree(this.root, "", routes);
+    return routes;
+  }
+  traverseTree(node, currentPath, routes) {
+    for (const [method, entry] of node.handlers) {
+      routes.push({
+        method,
+        pattern: currentPath || "/",
+        name: entry.name
+      });
+    }
+    for (const [path, child] of node.children) {
+      const childPath = `${currentPath}/${path}`;
+      this.traverseTree(child, childPath, routes);
+    }
+    if (node.paramChild) {
+      const childPath = `${currentPath}/:${node.paramChild.paramName}`;
+      this.traverseTree(node.paramChild, childPath, routes);
+    }
+    if (node.wildcardChild) {
+      const childPath = `${currentPath}/*`;
+      this.traverseTree(node.wildcardChild, childPath, routes);
+    }
+  }
+  getRouterType() {
+    return "tree";
+  }
+  getRouteCount() {
+    return this.routeCount;
+  }
+  getTreeStats() {
+    return {
+      nodes: this.countNodes(this.root),
+      depth: this.getTreeDepth(this.root),
+      routes: this.routeCount
+    };
+  }
+  countNodes(node) {
+    let count = 1;
+    for (const child of node.children.values()) {
+      count += this.countNodes(child);
+    }
+    if (node.paramChild) {
+      count += this.countNodes(node.paramChild);
+    }
+    if (node.wildcardChild) {
+      count += this.countNodes(node.wildcardChild);
+    }
+    return count;
+  }
+  getTreeDepth(node) {
+    let maxDepth = 0;
+    for (const child of node.children.values()) {
+      maxDepth = Math.max(maxDepth, this.getTreeDepth(child));
+    }
+    if (node.paramChild) {
+      maxDepth = Math.max(maxDepth, this.getTreeDepth(node.paramChild));
+    }
+    if (node.wildcardChild) {
+      maxDepth = Math.max(maxDepth, this.getTreeDepth(node.wildcardChild));
+    }
+    return maxDepth + 1;
+  }
+  get(pattern, handler, options) {
+    this.addRoute("GET", pattern, handler, options);
+  }
+  post(pattern, handler, options) {
+    this.addRoute("POST", pattern, handler, options);
+  }
+  put(pattern, handler, options) {
+    this.addRoute("PUT", pattern, handler, options);
+  }
+  patch(pattern, handler, options) {
+    this.addRoute("PATCH", pattern, handler, options);
+  }
+  delete(pattern, handler, options) {
+    this.addRoute("DELETE", pattern, handler, options);
+  }
+  head(pattern, handler, options) {
+    this.addRoute("HEAD", pattern, handler, options);
+  }
+  options(pattern, handler, options) {
+    this.addRoute("OPTIONS", pattern, handler, options);
+  }
+  all(pattern, handler, options) {
+    this.addRoute("ALL", pattern, handler, options);
+  }
+}
+
+// src/router/index.ts
+var DEFAULT_LINEAR_THRESHOLD = 10;
+var DEFAULT_REGEX_THRESHOLD = 50;
+
+class Router {
+  router;
+  config;
+  pendingRoutes = [];
+  isBuilt = false;
+  groupPrefix = "";
+  groupMiddleware = [];
+  constructor(config = {}) {
+    this.config = {
+      type: config.type ?? "auto",
+      linearThreshold: config.linearThreshold ?? DEFAULT_LINEAR_THRESHOLD,
+      regexThreshold: config.regexThreshold ?? DEFAULT_REGEX_THRESHOLD
+    };
+    if (this.config.type !== "auto") {
+      this.router = this.createRouter(this.config.type);
+    } else {
+      this.router = new LinearRouter;
+    }
+  }
+  createRouter(type) {
+    switch (type) {
+      case "linear":
+        return new LinearRouter;
+      case "regex":
+        return new RegexRouter;
+      case "tree":
+        return new TreeRouter;
+      default:
+        return new LinearRouter;
+    }
+  }
+  getOptimalRouterType(count) {
+    if (count <= this.config.linearThreshold) {
+      return "linear";
+    }
+    if (count <= this.config.regexThreshold) {
+      return "regex";
+    }
+    return "tree";
+  }
+  migrateRouter(newType) {
+    this.router = this.createRouter(newType);
+    for (const route of this.pendingRoutes) {
+      this.addToRouter(route.method, route.pattern, route.handler, route.options);
+    }
+  }
+  addToRouter(method, pattern, handler, options) {
+    switch (method) {
+      case "GET":
+        this.router.get(pattern, handler, options);
+        break;
+      case "POST":
+        this.router.post(pattern, handler, options);
+        break;
+      case "PUT":
+        this.router.put(pattern, handler, options);
+        break;
+      case "PATCH":
+        this.router.patch(pattern, handler, options);
+        break;
+      case "DELETE":
+        this.router.delete(pattern, handler, options);
+        break;
+      case "HEAD":
+        this.router.head(pattern, handler, options);
+        break;
+      case "OPTIONS":
+        this.router.options(pattern, handler, options);
+        break;
+      case "ALL":
+        this.router.all(pattern, handler, options);
+        break;
+    }
+  }
+  addRoute(method, pattern, handler, options) {
+    const fullPattern = this.groupPrefix + pattern;
+    const optsMiddleware = options?.middleware;
+    const routeMiddleware = optsMiddleware ? Array.isArray(optsMiddleware) ? optsMiddleware : [optsMiddleware] : [];
+    const allMiddleware = [...this.groupMiddleware, ...routeMiddleware];
+    const fullOptions = options?.name || allMiddleware.length > 0 ? {
+      name: options?.name,
+      middleware: allMiddleware
+    } : undefined;
+    this.pendingRoutes.push({
+      method,
+      pattern: fullPattern,
+      handler,
+      options: fullOptions
+    });
+    this.addToRouter(method, fullPattern, handler, fullOptions);
+    if (this.config.type === "auto" && !this.isBuilt) {
+      const routeCount = this.pendingRoutes.length;
+      const optimalType = this.getOptimalRouterType(routeCount);
+      const currentType = this.router.getRouterType();
+      if (currentType !== optimalType) {
+        this.migrateRouter(optimalType);
+      }
+    }
+  }
+  match(method, pathname) {
+    this.isBuilt = true;
+    return this.router.match(method, pathname);
+  }
+  group(prefix, options) {
+    const childRouter = new Router(this.config);
+    childRouter.router = this.router;
+    childRouter.pendingRoutes = this.pendingRoutes;
+    childRouter.groupPrefix = this.groupPrefix + prefix;
+    childRouter.isBuilt = this.isBuilt;
+    const optsMiddleware = options?.middleware;
+    const middlewareArray = optsMiddleware ? Array.isArray(optsMiddleware) ? optsMiddleware : [optsMiddleware] : [];
+    childRouter.groupMiddleware = [...this.groupMiddleware, ...middlewareArray];
+    return childRouter;
+  }
+  getRoutes() {
+    return this.router.getRoutes();
+  }
+  getRouterType() {
+    return this.router.getRouterType();
+  }
+  getRouteCount() {
+    return this.pendingRoutes.length;
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  get(pattern, handler, options) {
+    this.addRoute("GET", pattern, handler, options);
+  }
+  post(pattern, handler, options) {
+    this.addRoute("POST", pattern, handler, options);
+  }
+  put(pattern, handler, options) {
+    this.addRoute("PUT", pattern, handler, options);
+  }
+  patch(pattern, handler, options) {
+    this.addRoute("PATCH", pattern, handler, options);
+  }
+  delete(pattern, handler, options) {
+    this.addRoute("DELETE", pattern, handler, options);
+  }
+  head(pattern, handler, options) {
+    this.addRoute("HEAD", pattern, handler, options);
+  }
+  options(pattern, handler, options) {
+    this.addRoute("OPTIONS", pattern, handler, options);
+  }
+  all(pattern, handler, options) {
+    this.addRoute("ALL", pattern, handler, options);
+  }
+}
+function generateUrl(pattern, params = {}) {
+  return pattern.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)\?/g, (_, name) => params[name] ?? "").replace(/:([a-zA-Z_][a-zA-Z0-9_]*)<[^>]+>/g, (_, name) => params[name] ?? "").replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, (_, name) => {
+    if (params[name] === undefined) {
+      throw new Error(`Missing required parameter: ${name}`);
+    }
+    return params[name];
+  }).replace(/\*/g, () => params["*"] ?? "");
+}
+function createRouter(config) {
+  return new Router(config);
+}
+function createLinearRouter() {
+  return new LinearRouter;
+}
+function createRegexRouter() {
+  return new RegexRouter;
+}
+function createTreeRouter() {
+  return new TreeRouter;
+}
+export {
+  generateUrl,
+  createTreeRouter,
+  createRouter,
+  createRegexRouter,
+  createLinearRouter,
+  TreeRouter,
+  Router,
+  RegexRouter,
+  LinearRouter
+};