@adonisjs/http-server 8.0.0-next.7 → 8.0.0-next.9

package/build/{chunk-3XEJZ4S4.js → chunk-JD6QW4NQ.js}

@@ -1,12 +1,56 @@
 import {
+  BriskRoute,
+  Route,
+  RouteGroup,
+  RouteResource,
   __export,
   createSignedURL,
   createURL,
+  debug_default,
   default as default2,
   default2 as default3,
+  httpExceptionHandler,
+  httpMiddleware,
+  httpRequest,
+  httpResponseSerializer,
   parseRoute,
-  serializeCookie
-} from "./chunk-NQNHMINZ.js";
+  safeDecodeURI,
+  serializeCookie,
+  toRoutesJSON,
+  trustProxy
+} from "./chunk-CVZAIRWJ.js";
+
+// src/qs.ts
+import { parse, stringify } from "qs";
+var Qs = class {
+  /**
+   * Configuration object containing parse and stringify options for query strings
+   */
+  #config;
+  /**
+   * Creates a new query string parser instance with the provided configuration
+   * @param config - Configuration object with parse and stringify options
+   */
+  constructor(config) {
+    this.#config = config;
+  }
+  /**
+   * Parses a query string into a JavaScript object using the configured options
+   * @param value - Query string to parse (e.g., "foo=bar&baz=qux")
+   * @returns Parsed object representation of the query string
+   */
+  parse = (value) => {
+    return parse(value, this.#config.parse);
+  };
+  /**
+   * Converts a JavaScript object into a query string using the configured options
+   * @param value - Object to convert to query string
+   * @returns Stringified query string representation of the object
+   */
+  stringify = (value) => {
+    return stringify(value, this.#config.stringify);
+  };
+};
 
 // src/errors.ts
 var errors_exports = {};
@@ -112,1282 +156,220 @@ var CookieClient = class {
   /**
    * Private encryption instance used for signing and encrypting cookies
    */
-  #encryption;
-  /**
-   * Create a new instance of CookieClient
-   *
-   * @param encryption - The encryption instance for cookie operations
-   */
-  constructor(encryption) {
-    this.#encryption = encryption;
-  }
-  /**
-   * Encrypt a key value pair to be sent in the cookie header
-   *
-   * @param key - The cookie key
-   * @param value - The value to encrypt
-   * @returns The encrypted cookie string or null if encryption fails
-   */
-  encrypt(key, value) {
-    return pack3(key, value, this.#encryption);
-  }
-  /**
-   * Sign a key value pair to be sent in the cookie header
-   *
-   * @param key - The cookie key
-   * @param value - The value to sign
-   * @returns The signed cookie string or null if signing fails
-   */
-  sign(key, value) {
-    return pack2(key, value, this.#encryption);
-  }
-  /**
-   * Encode a key value pair to be sent in the cookie header
-   *
-   * @param _ - Unused key parameter
-   * @param value - The value to encode
-   * @param stringify - Whether to stringify the value before encoding
-   * @returns The encoded cookie string or null if encoding fails
-   */
-  encode(_, value, stringify2 = true) {
-    return stringify2 ? pack(value) : value;
-  }
-  /**
-   * Unsign a signed cookie value
-   *
-   * @param key - The cookie key
-   * @param value - The signed cookie value to unsign
-   * @returns The original value if valid signature, null otherwise
-   */
-  unsign(key, value) {
-    return canUnpack2(value) ? unpack2(key, value, this.#encryption) : null;
-  }
-  /**
-   * Decrypt an encrypted cookie value
-   *
-   * @param key - The cookie key
-   * @param value - The encrypted cookie value to decrypt
-   * @returns The decrypted value or null if decryption fails
-   */
-  decrypt(key, value) {
-    return canUnpack3(value) ? unpack3(key, value, this.#encryption) : null;
-  }
-  /**
-   * Decode an encoded cookie value
-   *
-   * @param _ - Unused key parameter
-   * @param value - The encoded cookie value to decode
-   * @param stringified - Whether the value was stringified during encoding
-   * @returns The decoded value or null if decoding fails
-   */
-  decode(_, value, stringified = true) {
-    if (!stringified) {
-      return value;
-    }
-    return canUnpack(value) ? unpack(value) : null;
-  }
-  /**
-   * Parse response cookie
-   *
-   * @param key - The cookie key
-   * @param value - The cookie value to parse
-   * @returns The parsed value or undefined if parsing fails
-   */
-  parse(key, value) {
-    if (canUnpack2(value)) {
-      return unpack2(key, value, this.#encryption);
-    }
-    if (canUnpack3(value)) {
-      return unpack3(key, value, this.#encryption);
-    }
-    if (canUnpack(value)) {
-      return unpack(value);
-    }
-  }
-};
-
-// src/cookies/parser.ts
-import cookie from "cookie";
-var CookieParser = class {
-  /**
-   * Cookie client instance for handling cookie operations
-   */
-  #client;
-  /**
-   * A copy of cached cookies, they are cached during a request after
-   * initial decoding, unsigning or decrypting.
-   */
-  #cachedCookies = {
-    signedCookies: {},
-    plainCookies: {},
-    encryptedCookies: {}
-  };
-  /**
-   * An object of key-value pair collected by parsing
-   * the request cookie header.
-   */
-  #cookies;
-  /**
-   * Create a new instance of CookieParser
-   *
-   * @param cookieHeader - The raw cookie header string from the request
-   * @param encryption - The encryption instance for cookie operations
-   */
-  constructor(cookieHeader, encryption) {
-    this.#client = new CookieClient(encryption);
-    this.#cookies = this.#parse(cookieHeader);
-  }
-  /**
-   * Parses the request `cookie` header
-   *
-   * @param cookieHeader - The cookie header string to parse
-   * @returns Parsed cookies as key-value pairs
-   */
-  #parse(cookieHeader) {
-    if (!cookieHeader) {
-      return {};
-    }
-    return cookie.parse(cookieHeader);
-  }
-  /**
-   * Attempts to decode a cookie by the name. When calling this method,
-   * you are assuming that the cookie was just stringified in the first
-   * place and not signed or encrypted.
-   *
-   * @param key - The cookie key to decode
-   * @param stringified - Whether the cookie value was stringified
-   * @returns The decoded cookie value or null if decoding fails
-   */
-  decode(key, stringified = true) {
-    const value = this.#cookies[key];
-    if (value === null || value === void 0) {
-      return null;
-    }
-    const cache = this.#cachedCookies.plainCookies;
-    if (cache[key] !== void 0) {
-      return cache[key];
-    }
-    const parsed = this.#client.decode(key, value, stringified);
-    if (parsed !== null) {
-      cache[key] = parsed;
-    }
-    return parsed;
-  }
-  /**
-   * Attempts to unsign a cookie by the name. When calling this method,
-   * you are assuming that the cookie was signed in the first place.
-   *
-   * @param key - The cookie key to unsign
-   * @returns The original cookie value or null if unsigning fails
-   */
-  unsign(key) {
-    const value = this.#cookies[key];
-    if (value === null || value === void 0) {
-      return null;
-    }
-    const cache = this.#cachedCookies.signedCookies;
-    if (cache[key] !== void 0) {
-      return cache[key];
-    }
-    const parsed = this.#client.unsign(key, value);
-    if (parsed !== null) {
-      cache[key] = parsed;
-    }
-    return parsed;
-  }
-  /**
-   * Attempts to decrypt a cookie by the name. When calling this method,
-   * you are assuming that the cookie was encrypted in the first place.
-   *
-   * @param key - The cookie key to decrypt
-   * @returns The decrypted cookie value or null if decryption fails
-   */
-  decrypt(key) {
-    const value = this.#cookies[key];
-    if (value === null || value === void 0) {
-      return null;
-    }
-    const cache = this.#cachedCookies.encryptedCookies;
-    if (cache[key] !== void 0) {
-      return cache[key];
-    }
-    const parsed = this.#client.decrypt(key, value);
-    if (parsed !== null) {
-      cache[key] = parsed;
-    }
-    return parsed;
-  }
-  /**
-   * Returns an object of cookies key-value pair. Do note, the
-   * cookies are not decoded, unsigned or decrypted inside this
-   * list.
-   *
-   * @returns Raw cookies as key-value pairs
-   */
-  list() {
-    return this.#cookies;
-  }
-};
-
-// src/tracing_channels.ts
-var tracing_channels_exports = {};
-__export(tracing_channels_exports, {
-  httpExceptionHandler: () => httpExceptionHandler,
-  httpMiddleware: () => httpMiddleware,
-  httpRequest: () => httpRequest,
-  httpResponseSerializer: () => httpResponseSerializer,
-  httpRouteHandler: () => httpRouteHandler
-});
-import diagnostics_channel from "diagnostics_channel";
-var httpRequest = diagnostics_channel.tracingChannel("adonisjs.http.request");
-var httpMiddleware = diagnostics_channel.tracingChannel("adonisjs.http.middleware");
-var httpExceptionHandler = diagnostics_channel.tracingChannel(
-  "adonisjs.http.exception.handler"
-);
-var httpRouteHandler = diagnostics_channel.tracingChannel("adonisjs.http.route.handler");
-var httpResponseSerializer = diagnostics_channel.tracingChannel(
-  "adonisjs.http.response.serializer"
-);
-
-// src/router/route.ts
-import is from "@sindresorhus/is";
-import Macroable4 from "@poppinss/macroable";
-import Middleware from "@poppinss/middleware";
-import { RuntimeException as RuntimeException2 } from "@poppinss/utils/exception";
-import { moduleCaller, moduleImporter } from "@adonisjs/fold";
-
-// src/debug.ts
-import { debuglog } from "util";
-var debug_default = debuglog("adonisjs:http");
-
-// src/router/factories/use_return_value.ts
-function canWriteResponseBody(value, ctx) {
-  return value !== void 0 && // Return value is explicitly defined
-  !ctx.response.hasLazyBody && // Lazy body is not set
-  value !== ctx.response;
-}
-function useReturnValue(ctx) {
-  return function(value) {
-    if (canWriteResponseBody(value, ctx)) {
-      ctx.response.send(value);
-    }
-  };
-}
-
-// src/router/executor.ts
-function execute(route, resolver, ctx, errorResponder) {
-  return route.middleware.runner().errorHandler((error) => errorResponder(error, ctx)).finalHandler(() => {
-    if (typeof route.handler === "function") {
-      return httpRouteHandler.tracePromise(
-        ($ctx) => Promise.resolve(route.handler($ctx)),
-        httpRouteHandler.hasSubscribers ? { route } : void 0,
-        void 0,
-        ctx
-      ).then(useReturnValue(ctx));
-    }
-    return httpRouteHandler.tracePromise(
-      route.handler.handle,
-      httpRouteHandler.hasSubscribers ? { route } : void 0,
-      void 0,
-      resolver,
-      ctx
-    ).then(useReturnValue(ctx));
-  }).run(async (middleware, next) => {
-    if (typeof middleware === "function") {
-      return httpMiddleware.tracePromise(
-        middleware,
-        httpMiddleware.hasSubscribers ? { middleware } : void 0,
-        void 0,
-        ctx,
-        next
-      );
-    }
-    return httpMiddleware.tracePromise(
-      middleware.handle,
-      httpMiddleware.hasSubscribers ? { middleware } : void 0,
-      void 0,
-      resolver,
-      ctx,
-      next,
-      middleware.args
-    );
-  });
-}
-
-// src/utils.ts
-import Cache from "tmp-cache";
-import { InvalidArgumentsException } from "@poppinss/utils/exception";
-
-// src/router/group.ts
-import Macroable3 from "@poppinss/macroable";
-
-// src/router/brisk.ts
-import Macroable from "@poppinss/macroable";
-var BriskRoute = class extends Macroable {
-  /**
-   * Route pattern
-   */
-  #pattern;
-  /**
-   * Matchers inherited from the router
-   */
-  #globalMatchers;
-  /**
-   * Reference to the AdonisJS application
-   */
-  #app;
-  /**
-   * Middleware registered on the router
-   */
-  #routerMiddleware;
-  /**
-   * Reference to route instance. Set after `setHandler` is called
-   */
-  route = null;
-  /**
-   * Creates a new BriskRoute instance
-   * @param app - The AdonisJS application instance
-   * @param routerMiddleware - Array of global middleware registered on the router
-   * @param options - Configuration options for the brisk route
-   */
-  constructor(app, routerMiddleware, options) {
-    super();
-    this.#app = app;
-    this.#routerMiddleware = routerMiddleware;
-    this.#pattern = options.pattern;
-    this.#globalMatchers = options.globalMatchers;
-  }
-  /**
-   * Set handler for the brisk route
-   * @param handler - The route handler function
-   * @returns The created route instance
-   */
-  setHandler(handler) {
-    this.route = new Route(this.#app, this.#routerMiddleware, {
-      pattern: this.#pattern,
-      globalMatchers: this.#globalMatchers,
-      methods: ["GET", "HEAD"],
-      handler
-    });
-    return this.route;
-  }
-  /**
-   * Redirects to a given route. Params from the original request will
-   * be used when no custom params are defined.
-   * @param args - Route identifier, parameters, and options for building the redirect URL
-   * @returns The created route instance
-   */
-  redirect(...args) {
-    const [identifier, params, options] = args;
-    function redirectsToRoute(ctx) {
-      const redirector = ctx.response.redirect();
-      if (options?.status) {
-        redirector.status(options.status);
-      }
-      return redirector.toRoute(identifier, params || ctx.params, options);
-    }
-    Object.defineProperty(redirectsToRoute, "listArgs", { value: identifier, writable: false });
-    return this.setHandler(redirectsToRoute);
-  }
-  /**
-   * Redirect request to a fixed URL
-   * @param url - The URL to redirect to
-   * @param options - Optional redirect options including HTTP status code
-   * @returns The created route instance
-   */
-  redirectToPath(url, options) {
-    function redirectsToPath(ctx) {
-      const redirector = ctx.response.redirect();
-      if (options?.status) {
-        redirector.status(options.status);
-      }
-      return redirector.toPath(url);
-    }
-    Object.defineProperty(redirectsToPath, "listArgs", { value: url, writable: false });
-    return this.setHandler(redirectsToPath);
-  }
-};
-
-// src/router/resource.ts
-import string from "@poppinss/utils/string";
-import Macroable2 from "@poppinss/macroable";
-import { RuntimeException } from "@poppinss/utils/exception";
-var RouteResource = class extends Macroable2 {
-  /**
-   * Resource identifier. Nested resources are separated
-   * with a dot notation
-   */
-  #resource;
-  /**
-   * The controller to handle resource routing requests
-   */
-  #controller;
-  /**
-   * Is it a shallow resource? Shallow resources URLs do not have parent
-   * resource name and id once they can be identified with the id.
-   */
-  #shallow = false;
-  /**
-   * Matchers inherited from the router
-   */
-  #globalMatchers;
-  /**
-   * Reference to the AdonisJS application
-   */
-  #app;
-  /**
-   * Middleware registered on the router
-   */
-  #routerMiddleware;
-  /**
-   * Parameter names for the resources. Defaults to `id` for
-   * a singular resource and `resource_id` for nested
-   * resources.
-   */
-  #params = {};
-  /**
-   * Base name for the routes. We suffix action names
-   * on top of the base name
-   */
-  #routesBaseName;
-  /**
-   * A collection of routes instances that belongs to this resource
-   */
-  routes = [];
-  /**
-   * Creates a new RouteResource instance
-   * @param app - The AdonisJS application instance
-   * @param routerMiddleware - Array of global middleware registered on the router
-   * @param options - Configuration options for the route resource
-   */
-  constructor(app, routerMiddleware, options) {
-    super();
-    this.#validateResourceName(options.resource);
-    this.#app = app;
-    this.#shallow = options.shallow;
-    this.#routerMiddleware = routerMiddleware;
-    this.#controller = options.controller;
-    this.#globalMatchers = options.globalMatchers;
-    this.#resource = this.#normalizeResourceName(options.resource);
-    this.#routesBaseName = this.#getRoutesBaseName();
-    this.#buildRoutes();
-  }
-  /**
-   * Normalizes the resource name to dropping leading and trailing
-   * slashes.
-   */
-  #normalizeResourceName(resource) {
-    return resource.replace(/^\//, "").replace(/\/$/, "");
-  }
-  /**
-   * Ensure resource name is not an empty string
-   */
-  #validateResourceName(resource) {
-    if (!resource || resource === "/") {
-      throw new RuntimeException(`Invalid resource name "${resource}"`);
-    }
-  }
-  /**
-   * Converting segments of a resource to snake case to
-   * make the route name.
-   */
-  #getRoutesBaseName() {
-    return this.#resource.split(".").map((token) => string.snakeCase(token)).join(".");
-  }
-  /**
-   * Create a new route for the given pattern, methods and controller action
-   */
-  #createRoute(pattern, methods, action) {
-    const route = new Route(this.#app, this.#routerMiddleware, {
-      pattern,
-      methods,
-      handler: typeof this.#controller === "string" ? `${this.#controller}.${action}` : [this.#controller, action],
-      globalMatchers: this.#globalMatchers
-    });
-    route.as(`${this.#routesBaseName}.${action}`);
-    this.routes.push(route);
-  }
-  /**
-   * Returns the `resource_id` name for a given resource. The
-   * resource name is converted to singular form and
-   * transformed to snake case.
-   *
-   * photos becomes photo_id
-   * users becomes user_id
-   */
-  #getResourceId(resource) {
-    return `${string.snakeCase(string.singular(resource))}_id`;
-  }
-  /**
-   * Build routes for the given resource
-   */
-  #buildRoutes() {
-    const resources = this.#resource.split(".");
-    const mainResource = resources.pop();
-    this.#params[mainResource] = ":id";
-    const baseURI = `${resources.map((resource) => {
-      const paramName = `:${this.#getResourceId(resource)}`;
-      this.#params[resource] = paramName;
-      return `${resource}/${paramName}`;
-    }).join("/")}/${mainResource}`;
-    this.#createRoute(baseURI, ["GET", "HEAD"], "index");
-    this.#createRoute(`${baseURI}/create`, ["GET", "HEAD"], "create");
-    this.#createRoute(baseURI, ["POST"], "store");
-    this.#createRoute(`${this.#shallow ? mainResource : baseURI}/:id`, ["GET", "HEAD"], "show");
-    this.#createRoute(`${this.#shallow ? mainResource : baseURI}/:id/edit`, ["GET", "HEAD"], "edit");
-    this.#createRoute(`${this.#shallow ? mainResource : baseURI}/:id`, ["PUT", "PATCH"], "update");
-    this.#createRoute(`${this.#shallow ? mainResource : baseURI}/:id`, ["DELETE"], "destroy");
-  }
-  /**
-   * Filter the routes based on their partial names
-   */
-  #filter(names, inverse) {
-    const actions = Array.isArray(names) ? names : [names];
-    return this.routes.filter((route) => {
-      const match = actions.find((name) => route.getName().endsWith(name));
-      return inverse ? !match : match;
-    });
-  }
-  /**
-   * Register only given routes and remove others
-   * @param names - Array of action names to keep
-   * @returns Current RouteResource instance with filtered actions
-   */
-  only(names) {
-    this.#filter(names, true).forEach((route) => route.markAsDeleted());
-    return this;
-  }
-  /**
-   * Register all routes, except the one's defined
-   * @param names - Array of action names to exclude
-   * @returns Current RouteResource instance with filtered actions
-   */
-  except(names) {
-    this.#filter(names, false).forEach((route) => route.markAsDeleted());
-    return this;
-  }
-  /**
-   * Register api only routes. The `create` and `edit` routes, which
-   * are meant to show forms will not be registered
-   * @returns Current RouteResource instance without create and edit actions
-   */
-  apiOnly() {
-    return this.except(["create", "edit"]);
-  }
-  /**
-   * Define matcher for params inside the resource
-   * @param key - The parameter name to match
-   * @param matcher - The matcher pattern (RegExp, string, or RouteMatcher)
-   * @returns Current RouteResource instance for method chaining
-   */
-  where(key, matcher) {
-    this.routes.forEach((route) => {
-      route.where(key, matcher);
-    });
-    return this;
-  }
-  tap(actions, callback) {
-    if (typeof actions === "function") {
-      this.routes.forEach((route) => {
-        if (!route.isDeleted()) {
-          actions(route);
-        }
-      });
-      return this;
-    }
-    this.#filter(actions, false).forEach((route) => {
-      if (!route.isDeleted()) {
-        callback(route);
-      }
-    });
-    return this;
-  }
-  /**
-   * Set the param name for a given resource
-   * @param resources - Object mapping resource names to parameter names
-   * @returns Current RouteResource instance for method chaining
-   */
-  params(resources) {
-    Object.keys(resources).forEach((resource) => {
-      const param = resources[resource];
-      const existingParam = this.#params[resource];
-      this.#params[resource] = `:${param}`;
-      this.routes.forEach((route) => {
-        route.setPattern(
-          route.getPattern().replace(`${resource}/${existingParam}`, `${resource}/:${param}`)
-        );
-      });
-    });
-    return this;
-  }
-  /**
-   * Define one or more middleware on the routes created by
-   * the resource.
-   *
-   * Calling this method multiple times will append middleware
-   * to existing list.
-   * @param actions - Action name(s) or '*' for all actions
-   * @param middleware - Middleware function(s) to apply
-   * @returns Current RouteResource instance for method chaining
-   */
-  use(actions, middleware) {
-    if (actions === "*") {
-      this.tap((route) => route.use(middleware));
-    } else {
-      this.tap(actions, (route) => route.use(middleware));
-    }
-    return this;
-  }
-  /**
-   * Alias for {@link RouteResource.use}
-   * @param actions - Action name(s) or '*' for all actions
-   * @param middleware - Middleware function(s) to apply
-   * @returns Current RouteResource instance for method chaining
-   */
-  middleware(actions, middleware) {
-    return this.use(actions, middleware);
-  }
-  /**
-   * Prepend name to all the routes
-   * @param name - The name to prepend to all route names
-   * @param normalizeName - Whether to normalize the name to snake_case
-   * @returns Current RouteResource instance for method chaining
-   */
-  as(name, normalizeName = true) {
-    name = normalizeName ? string.snakeCase(name) : name;
-    this.routes.forEach((route) => {
-      route.as(route.getName().replace(this.#routesBaseName, name), false);
-    });
-    this.#routesBaseName = name;
-    return this;
-  }
-};
-
-// src/router/group.ts
-var RouteGroup = class _RouteGroup extends Macroable3 {
-  /**
-   * Creates a new RouteGroup instance
-   * @param routes - Array of routes that belong to this group
-   */
-  constructor(routes) {
-    super();
-    this.routes = routes;
-  }
-  /**
-   * Array of middleware registered on the group.
-   */
-  #middleware = [];
-  /**
-   * Shares midldeware stack with the routes. The method is invoked recursively
-   * to only register middleware with the route class and not with the
-   * resource or the child group
-   */
-  #shareMiddlewareStackWithRoutes(route) {
-    if (route instanceof _RouteGroup) {
-      route.routes.forEach((child) => this.#shareMiddlewareStackWithRoutes(child));
-      return;
-    }
-    if (route instanceof RouteResource) {
-      route.routes.forEach((child) => child.getMiddleware().unshift(this.#middleware));
-      return;
-    }
-    if (route instanceof BriskRoute) {
-      route.route.getMiddleware().unshift(this.#middleware);
-      return;
-    }
-    route.getMiddleware().unshift(this.#middleware);
-  }
-  /**
-   * Updates the route name. The method is invoked recursively to only update
-   * the name with the route class and not with the resource or the child
-   * group.
-   */
-  #updateRouteName(route, name) {
-    if (route instanceof _RouteGroup) {
-      route.routes.forEach((child) => this.#updateRouteName(child, name));
-      return;
-    }
-    if (route instanceof RouteResource) {
-      route.routes.forEach((child) => child.as(name, true));
-      return;
-    }
-    if (route instanceof BriskRoute) {
-      route.route.as(name, true);
-      return;
-    }
-    route.as(name, true);
-  }
-  /**
-   * Sets prefix on the route. The method is invoked recursively to only set
-   * the prefix with the route class and not with the resource or the
-   * child group.
-   */
-  #setRoutePrefix(route, prefix) {
-    if (route instanceof _RouteGroup) {
-      route.routes.forEach((child) => this.#setRoutePrefix(child, prefix));
-      return;
-    }
-    if (route instanceof RouteResource) {
-      route.routes.forEach((child) => child.prefix(prefix));
-      return;
-    }
-    if (route instanceof BriskRoute) {
-      route.route.prefix(prefix);
-      return;
-    }
-    route.prefix(prefix);
-  }
-  /**
-   * Updates domain on the route. The method is invoked recursively to only update
-   * the domain with the route class and not with the resource or the child
-   * group.
-   */
-  #updateRouteDomain(route, domain) {
-    if (route instanceof _RouteGroup) {
-      route.routes.forEach((child) => this.#updateRouteDomain(child, domain));
-      return;
-    }
-    if (route instanceof RouteResource) {
-      route.routes.forEach((child) => child.domain(domain));
-      return;
-    }
-    if (route instanceof BriskRoute) {
-      route.route.domain(domain, false);
-      return;
-    }
-    route.domain(domain, false);
-  }
-  /**
-   * Updates matchers on the route. The method is invoked recursively to only update
-   * the matchers with the route class and not with the resource or the child
-   * group.
-   */
-  #updateRouteMatchers(route, param, matcher) {
-    if (route instanceof _RouteGroup) {
-      route.routes.forEach((child) => this.#updateRouteMatchers(child, param, matcher));
-      return;
-    }
-    if (route instanceof RouteResource) {
-      route.routes.forEach((child) => child.where(param, matcher));
-      return;
-    }
-    if (route instanceof BriskRoute) {
-      route.route.where(param, matcher);
-      return;
-    }
-    route.where(param, matcher);
-  }
-  /**
-   * Define route param matcher
-   *
-   * ```ts
-   * Route.group(() => {
-   * }).where('id', /^[0-9]+/)
-   * ```
-   * @param param - The parameter name to match
-   * @param matcher - The matcher pattern (RegExp, string, or RouteMatcher)
-   * @returns Current RouteGroup instance for method chaining
-   */
-  where(param, matcher) {
-    this.routes.forEach((route) => this.#updateRouteMatchers(route, param, matcher));
-    return this;
-  }
-  /**
-   * Define prefix all the routes in the group.
-   *
-   * ```ts
-   * Route.group(() => {
-   * }).prefix('v1')
-   * ```
-   * @param prefix - The prefix to add to all routes in the group
-   * @returns Current RouteGroup instance for method chaining
-   */
-  prefix(prefix) {
-    this.routes.forEach((route) => this.#setRoutePrefix(route, prefix));
-    return this;
-  }
-  /**
-   * Define domain for all the routes.
-   *
-   * ```ts
-   * Route.group(() => {
-   * }).domain(':name.adonisjs.com')
-   * ```
-   * @param domain - The domain pattern for all routes in the group
-   * @returns Current RouteGroup instance for method chaining
-   */
-  domain(domain) {
-    this.routes.forEach((route) => this.#updateRouteDomain(route, domain));
-    return this;
-  }
-  /**
-   * Prepend name to the routes name.
-   *
-   * ```ts
-   * Route.group(() => {
-   * }).as('version1')
-   * ```
-   * @param name - The name to prepend to all route names in the group
-   * @returns Current RouteGroup instance for method chaining
-   */
-  as(name) {
-    this.routes.forEach((route) => this.#updateRouteName(route, name));
-    return this;
-  }
-  /**
-   * Prepend an array of middleware to all routes middleware.
-   *
-   * ```ts
-   * Route.group(() => {
-   * }).use(middleware.auth())
-   * ```
-   * @param middleware - Middleware function(s) to apply to all routes in the group
-   * @returns Current RouteGroup instance for method chaining
-   */
-  use(middleware) {
-    if (!this.#middleware.length) {
-      this.routes.forEach((route) => this.#shareMiddlewareStackWithRoutes(route));
-    }
-    if (Array.isArray(middleware)) {
-      for (let one of middleware) {
-        this.#middleware.push(one);
-      }
-    } else {
-      this.#middleware.push(middleware);
-    }
-    return this;
-  }
-  /**
-   * Alias for {@link RouteGroup.use}
-   * @param middleware - Middleware function(s) to apply to all routes in the group
-   * @returns Current RouteGroup instance for method chaining
-   */
-  middleware(middleware) {
-    return this.use(middleware);
-  }
-};
-
-// src/utils.ts
-var proxyCache = new Cache({ max: 200 });
-function dropSlash(input) {
-  if (input === "/") {
-    return "/";
-  }
-  return `/${input.replace(/^\//, "").replace(/\/$/, "")}`;
-}
-function toRoutesJSON(routes) {
-  return routes.reduce((list, route) => {
-    if (route instanceof RouteGroup) {
-      list = list.concat(toRoutesJSON(route.routes));
-      return list;
-    }
-    if (route instanceof RouteResource) {
-      list = list.concat(toRoutesJSON(route.routes));
-      return list;
-    }
-    if (route instanceof BriskRoute) {
-      if (route.route && !route.route.isDeleted()) {
-        list.push(route.route.toJSON());
-      }
-      return list;
-    }
-    if (!route.isDeleted()) {
-      list.push(route.toJSON());
-    }
-    return list;
-  }, []);
-}
-function trustProxy(remoteAddress, proxyFn) {
-  if (proxyCache.has(remoteAddress)) {
-    return proxyCache.get(remoteAddress);
-  }
-  const result = proxyFn(remoteAddress, 0);
-  proxyCache.set(remoteAddress, result);
-  return result;
-}
-function parseRange(range, value) {
-  const parts = range.split("..");
-  const min = Number(parts[0]);
-  const max = Number(parts[1]);
-  if (parts.length === 1 && !Number.isNaN(min)) {
-    return {
-      [min]: value
-    };
-  }
-  if (Number.isNaN(min) || Number.isNaN(max)) {
-    return {};
-  }
-  if (min === max) {
-    return {
-      [min]: value
-    };
-  }
-  if (max < min) {
-    throw new InvalidArgumentsException(`Invalid range "${range}"`);
-  }
-  return [...Array(max - min + 1).keys()].reduce(
-    (result, step) => {
-      result[min + step] = value;
-      return result;
-    },
-    {}
-  );
-}
-function decodeComponentChar(highCharCode, lowCharCode) {
-  if (highCharCode === 50) {
-    if (lowCharCode === 53) return "%";
-    if (lowCharCode === 51) return "#";
-    if (lowCharCode === 52) return "$";
-    if (lowCharCode === 54) return "&";
-    if (lowCharCode === 66) return "+";
-    if (lowCharCode === 98) return "+";
-    if (lowCharCode === 67) return ",";
-    if (lowCharCode === 99) return ",";
-    if (lowCharCode === 70) return "/";
-    if (lowCharCode === 102) return "/";
-    return null;
-  }
-  if (highCharCode === 51) {
-    if (lowCharCode === 65) return ":";
-    if (lowCharCode === 97) return ":";
-    if (lowCharCode === 66) return ";";
-    if (lowCharCode === 98) return ";";
-    if (lowCharCode === 68) return "=";
-    if (lowCharCode === 100) return "=";
-    if (lowCharCode === 70) return "?";
-    if (lowCharCode === 102) return "?";
-    return null;
-  }
-  if (highCharCode === 52 && lowCharCode === 48) {
-    return "@";
-  }
-  return null;
-}
-function safeDecodeURI(path, useSemicolonDelimiter) {
-  let shouldDecode = false;
-  let shouldDecodeParam = false;
-  let querystring = "";
-  for (let i = 1; i < path.length; i++) {
-    const charCode = path.charCodeAt(i);
-    if (charCode === 37) {
-      const highCharCode = path.charCodeAt(i + 1);
-      const lowCharCode = path.charCodeAt(i + 2);
-      if (decodeComponentChar(highCharCode, lowCharCode) === null) {
-        shouldDecode = true;
-      } else {
-        shouldDecodeParam = true;
-        if (highCharCode === 50 && lowCharCode === 53) {
-          shouldDecode = true;
-          path = path.slice(0, i + 1) + "25" + path.slice(i + 1);
-          i += 2;
-        }
-        i += 2;
-      }
-    } else if (charCode === 63 || charCode === 35 || charCode === 59 && useSemicolonDelimiter) {
-      querystring = path.slice(i + 1);
-      path = path.slice(0, i);
-      break;
-    }
-  }
-  const decodedPath = shouldDecode ? decodeURI(path) : path;
-  return { pathname: decodedPath, query: querystring, shouldDecodeParam };
-}
-
-// src/router/route.ts
-import StringBuilder from "@poppinss/utils/string_builder";
-import string2 from "@poppinss/utils/string";
-var Route = class extends Macroable4 {
-  /**
-   * Route pattern
-   */
-  #pattern;
-  /**
-   * HTTP Methods for the route
-   */
-  #methods;
-  /**
-   * A unique name for the route
-   */
-  #name;
-  /**
-   * A boolean to prevent route from getting registered within
-   * the store.
-   *
-   * This flag must be set before "Router.commit" method
-   */
-  #isDeleted = false;
-  /**
-   * Route handler
-   */
-  #handler;
-  /**
-   * Matchers inherited from the router
-   */
-  #globalMatchers;
-  /**
-   * Reference to the AdonisJS application
-   */
-  #app;
-  /**
-   * Middleware registered on the router
-   */
-  #routerMiddleware;
-  /**
-   * By default the route is part of the `root` domain. Root domain is used
-   * when no domain is defined
-   */
-  #routeDomain = "root";
-  /**
-   * An object of matchers to be forwarded to the store. The matchers
-   * list is populated by calling `where` method
-   */
-  #matchers = {};
-  /**
-   * Custom prefixes defined on the route or the route parent
-   * groups
-   */
-  #prefixes = [];
-  /**
-   * Middleware defined directly on the route or the route parent
-   * routes. We mantain an array for each layer of the stack
-   */
-  #middleware = [];
-  /**
-   * Creates a new Route instance
-   * @param app - The AdonisJS application instance
-   * @param routerMiddleware - Array of global middleware registered on the router
-   * @param options - Configuration options for the route
-   */
-  constructor(app, routerMiddleware, options) {
-    super();
-    this.#app = app;
-    this.#routerMiddleware = routerMiddleware;
-    this.#pattern = options.pattern;
-    this.#methods = options.methods;
-    this.#globalMatchers = options.globalMatchers;
-    const { handler, routeName } = this.#resolveRouteHandle(options.handler);
-    this.#handler = handler;
-    this.#name = routeName;
-  }
-  /**
-   * Resolves the route handler string expression to a
-   * handler method object
-   */
-  #resolveRouteHandle(handler) {
-    if (typeof handler === "string") {
-      const parts = handler.split(".");
-      const method = parts.length === 1 ? "handle" : parts.pop();
-      const moduleRefId = parts.join(".");
-      return {
-        handler: {
-          method,
-          reference: handler,
-          importExpression: moduleRefId,
-          ...moduleImporter(() => this.#app.import(moduleRefId), method).toHandleMethod(),
-          name: handler
-        },
-        routeName: `${new StringBuilder(moduleRefId.split("/").pop()).removeSuffix("controller").snakeCase()}.${string2.snakeCase(method)}`
-      };
-    }
-    if (Array.isArray(handler)) {
-      const controller = handler[0];
-      const method = handler[1] ?? "handle";
-      if (is.class(controller)) {
-        return {
-          handler: {
-            method,
-            reference: handler,
-            importExpression: null,
-            ...moduleCaller(controller, method).toHandleMethod()
-          },
-          routeName: `${new StringBuilder(controller.name).removeSuffix("controller").snakeCase()}.${string2.snakeCase(method)}`
-        };
-      }
-      return {
-        handler: {
-          method,
-          reference: handler,
-          importExpression: String(controller),
-          ...moduleImporter(controller, method).toHandleMethod()
-        },
-        routeName: controller.name ? `${new StringBuilder(controller.name).removeSuffix("controller").snakeCase()}.${string2.snakeCase(method)}` : void 0
-      };
-    }
-    return { handler };
-  }
+  #encryption;
   /**
-   * Returns an object of param matchers by merging global and local
-   * matchers. The local copy is given preference over the global
-   * one's
+   * Create a new instance of CookieClient
+   *
+   * @param encryption - The encryption instance for cookie operations
    */
-  #getMatchers() {
-    return { ...this.#globalMatchers, ...this.#matchers };
+  constructor(encryption) {
+    this.#encryption = encryption;
   }
   /**
-   * Returns a normalized pattern string by prefixing the `prefix` (if defined).
+   * Encrypt a key value pair to be sent in the cookie header
+   *
+   * @param key - The cookie key
+   * @param value - The value to encrypt
+   * @returns The encrypted cookie string or null if encryption fails
    */
-  #computePattern() {
-    const pattern = dropSlash(this.#pattern);
-    const prefix = this.#prefixes.slice().reverse().map((one) => dropSlash(one)).join("");
-    return prefix ? `${prefix}${pattern === "/" ? "" : pattern}` : pattern;
+  encrypt(key, value) {
+    return pack3(key, value, this.#encryption);
   }
   /**
-   * Define matcher for a given param. If a matcher exists, then we do not
-   * override that, since the routes inside a group will set matchers
-   * before the group, so they should have priority over the group
-   * matchers.
-   *
-   * ```ts
-   * Route.group(() => {
-   *   Route.get('/:id', 'handler').where('id', /^[0-9]$/)
-   * }).where('id', /[^a-z$]/)
-   * ```
+   * Sign a key value pair to be sent in the cookie header
    *
-   * The `/^[0-9]$/` will win over the matcher defined by the group
+   * @param key - The cookie key
+   * @param value - The value to sign
+   * @returns The signed cookie string or null if signing fails
    */
-  where(param, matcher) {
-    if (this.#matchers[param]) {
-      return this;
-    }
-    if (typeof matcher === "string") {
-      this.#matchers[param] = { match: new RegExp(matcher) };
-    } else if (is.regExp(matcher)) {
-      this.#matchers[param] = { match: matcher };
-    } else {
-      this.#matchers[param] = matcher;
-    }
-    return this;
+  sign(key, value) {
+    return pack2(key, value, this.#encryption);
   }
   /**
-   * Define prefix for the route. Calling this method multiple times
-   * applies multiple prefixes in the reverse order.
-   * @param prefix - The prefix to add to the route
-   * @returns Current Route instance for method chaining
+   * Encode a key value pair to be sent in the cookie header
+   *
+   * @param _ - Unused key parameter
+   * @param value - The value to encode
+   * @param stringify - Whether to stringify the value before encoding
+   * @returns The encoded cookie string or null if encoding fails
    */
-  prefix(prefix) {
-    this.#prefixes.push(prefix);
-    return this;
+  encode(_, value, stringify2 = true) {
+    return stringify2 ? pack(value) : value;
   }
   /**
-   * Define a custom domain for the route. We do not overwrite the domain
-   * unless `overwrite` flag is set to true.
+   * Unsign a signed cookie value
+   *
+   * @param key - The cookie key
+   * @param value - The signed cookie value to unsign
+   * @returns The original value if valid signature, null otherwise
    */
-  domain(domain, overwrite = false) {
-    if (this.#routeDomain === "root" || overwrite) {
-      this.#routeDomain = domain;
-    }
-    return this;
+  unsign(key, value) {
+    return canUnpack2(value) ? unpack2(key, value, this.#encryption) : null;
   }
   /**
-   * Define one or more middleware to be executed before the route
-   * handler.
+   * Decrypt an encrypted cookie value
    *
-   * Named middleware can be referenced using the name registered with
-   * the router middleware store.
+   * @param key - The cookie key
+   * @param value - The encrypted cookie value to decrypt
+   * @returns The decrypted value or null if decryption fails
    */
-  use(middleware) {
-    this.#middleware.push(Array.isArray(middleware) ? middleware : [middleware]);
-    return this;
+  decrypt(key, value) {
+    return canUnpack3(value) ? unpack3(key, value, this.#encryption) : null;
   }
   /**
-   * Alias for {@link Route.use}
+   * Decode an encoded cookie value
+   *
+   * @param _ - Unused key parameter
+   * @param value - The encoded cookie value to decode
+   * @param stringified - Whether the value was stringified during encoding
+   * @returns The decoded value or null if decoding fails
    */
-  middleware(middleware) {
-    return this.use(middleware);
+  decode(_, value, stringified = true) {
+    if (!stringified) {
+      return value;
+    }
+    return canUnpack(value) ? unpack(value) : null;
   }
   /**
-   * Give a unique name to the route. Assinging a new unique removes the
-   * existing name of the route.
+   * Parse response cookie
    *
-   * Setting prepends to true prefixes the name to the existing name.
+   * @param key - The cookie key
+   * @param value - The cookie value to parse
+   * @returns The parsed value or undefined if parsing fails
    */
-  as(name, prepend = false) {
-    if (prepend) {
-      if (!this.#name) {
-        throw new RuntimeException2(
-          `Routes inside a group must have names before calling "router.group.as"`
-        );
-      }
-      this.#name = `${name}.${this.#name}`;
-      return this;
+  parse(key, value) {
+    if (canUnpack2(value)) {
+      return unpack2(key, value, this.#encryption);
+    }
+    if (canUnpack3(value)) {
+      return unpack3(key, value, this.#encryption);
+    }
+    if (canUnpack(value)) {
+      return unpack(value);
     }
-    this.#name = name;
-    return this;
   }
+};
+
+// src/cookies/parser.ts
+import cookie from "cookie";
+var CookieParser = class {
   /**
-   * Check if the route was marked to be deleted
+   * Cookie client instance for handling cookie operations
    */
-  isDeleted() {
-    return this.#isDeleted;
-  }
+  #client;
   /**
-   * Mark route as deleted. Deleted routes are not registered
-   * with the route store
+   * A copy of cached cookies, they are cached during a request after
+   * initial decoding, unsigning or decrypting.
    */
-  markAsDeleted() {
-    this.#isDeleted = true;
-  }
+  #cachedCookies = {
+    signedCookies: {},
+    plainCookies: {},
+    encryptedCookies: {}
+  };
+  /**
+   * An object of key-value pair collected by parsing
+   * the request cookie header.
+   */
+  #cookies;
   /**
-   * Get the route name
+   * Create a new instance of CookieParser
+   *
+   * @param cookieHeader - The raw cookie header string from the request
+   * @param encryption - The encryption instance for cookie operations
    */
-  getName() {
-    return this.#name;
+  constructor(cookieHeader, encryption) {
+    this.#client = new CookieClient(encryption);
+    this.#cookies = this.#parse(cookieHeader);
   }
   /**
-   * Get the route pattern
+   * Parses the request `cookie` header
+   *
+   * @param cookieHeader - The cookie header string to parse
+   * @returns Parsed cookies as key-value pairs
    */
-  getPattern() {
-    return this.#pattern;
+  #parse(cookieHeader) {
+    if (!cookieHeader) {
+      return {};
+    }
+    return cookie.parse(cookieHeader);
   }
   /**
-   * Set the route pattern
+   * Attempts to decode a cookie by the name. When calling this method,
+   * you are assuming that the cookie was just stringified in the first
+   * place and not signed or encrypted.
+   *
+   * @param key - The cookie key to decode
+   * @param stringified - Whether the cookie value was stringified
+   * @returns The decoded cookie value or null if decoding fails
    */
-  setPattern(pattern) {
-    this.#pattern = pattern;
-    return this;
+  decode(key, stringified = true) {
+    const value = this.#cookies[key];
+    if (value === null || value === void 0) {
+      return null;
+    }
+    const cache = this.#cachedCookies.plainCookies;
+    if (cache[key] !== void 0) {
+      return cache[key];
+    }
+    const parsed = this.#client.decode(key, value, stringified);
+    if (parsed !== null) {
+      cache[key] = parsed;
+    }
+    return parsed;
   }
   /**
-   * Returns the stack of middleware registered on the route.
-   * The value is shared by reference.
+   * Attempts to unsign a cookie by the name. When calling this method,
+   * you are assuming that the cookie was signed in the first place.
+   *
+   * @param key - The cookie key to unsign
+   * @returns The original cookie value or null if unsigning fails
    */
-  getMiddleware() {
-    return this.#middleware;
+  unsign(key) {
+    const value = this.#cookies[key];
+    if (value === null || value === void 0) {
+      return null;
+    }
+    const cache = this.#cachedCookies.signedCookies;
+    if (cache[key] !== void 0) {
+      return cache[key];
+    }
+    const parsed = this.#client.unsign(key, value);
+    if (parsed !== null) {
+      cache[key] = parsed;
+    }
+    return parsed;
   }
   /**
-   * Returns the middleware instance for persistence inside the
-   * store
+   * Attempts to decrypt a cookie by the name. When calling this method,
+   * you are assuming that the cookie was encrypted in the first place.
+   *
+   * @param key - The cookie key to decrypt
+   * @returns The decrypted cookie value or null if decryption fails
    */
-  #getMiddlewareForStore() {
-    const middleware = new Middleware();
-    this.#routerMiddleware.forEach((one) => {
-      debug_default("adding global middleware to route %s, %O", this.#pattern, one);
-      middleware.add(one);
-    });
-    this.#middleware.flat().forEach((one) => {
-      debug_default("adding named middleware to route %s, %O", this.#pattern, one);
-      middleware.add(one);
-    });
-    middleware.freeze();
-    return middleware;
+  decrypt(key) {
+    const value = this.#cookies[key];
+    if (value === null || value === void 0) {
+      return null;
+    }
+    const cache = this.#cachedCookies.encryptedCookies;
+    if (cache[key] !== void 0) {
+      return cache[key];
+    }
+    const parsed = this.#client.decrypt(key, value);
+    if (parsed !== null) {
+      cache[key] = parsed;
+    }
+    return parsed;
   }
   /**
-   * Returns JSON representation of the route
+   * Returns an object of cookies key-value pair. Do note, the
+   * cookies are not decoded, unsigned or decrypted inside this
+   * list.
+   *
+   * @returns Raw cookies as key-value pairs
    */
-  toJSON() {
-    const pattern = this.#computePattern();
-    const matchers = this.#getMatchers();
-    return {
-      domain: this.#routeDomain,
-      pattern,
-      matchers,
-      tokens: parseRoute(pattern, matchers),
-      meta: {},
-      name: this.#name,
-      handler: this.#handler,
-      methods: this.#methods,
-      middleware: this.#getMiddlewareForStore(),
-      execute
-    };
+  list() {
+    return this.#cookies;
   }
 };
 
@@ -1396,12 +378,12 @@ import fresh from "fresh";
 import typeIs from "type-is";
 import accepts from "accepts";
 import { isIP } from "net";
-import is2 from "@sindresorhus/is";
+import is from "@sindresorhus/is";
 import proxyaddr from "proxy-addr";
 import { safeEqual } from "@poppinss/utils";
-import Macroable5 from "@poppinss/macroable";
+import Macroable from "@poppinss/macroable";
 import lodash from "@poppinss/utils/lodash";
-var Request = class extends Macroable5 {
+var Request = class extends Macroable {
   /**
    * Creates a new Request instance wrapping the native Node.js HTTP request
    * @param request - Native Node.js incoming message instance
@@ -2231,7 +1213,7 @@ var Request = class extends Macroable5 {
   }
   plainCookie(key, defaultValueOrOptions, encoded) {
     this.#initiateCookieParser();
-    if (is2.object(defaultValueOrOptions)) {
+    if (is.object(defaultValueOrOptions)) {
       return this.#cookieParser.decode(key, defaultValueOrOptions?.encoded) || defaultValueOrOptions.defaultValue;
     }
     return this.#cookieParser.decode(key, encoded) || defaultValueOrOptions;
@@ -2284,7 +1266,6 @@ var Request = class extends Macroable5 {
 };
 
 // src/redirect.ts
-import { parse } from "url";
 var Redirect = class {
   /**
    * Flag indicating whether to forward the existing query string from the current request
@@ -2386,7 +1367,7 @@ var Redirect = class {
   back() {
     let query = {};
     const referrerUrl = this.#getReferrerUrl();
-    const url = parse(referrerUrl);
+    const url = safeDecodeURI(referrerUrl, false);
     debug_default('referrer url "%s"', referrerUrl);
     debug_default('referrer base url "%s"', url.pathname);
     if (this.#forwardQueryString) {
@@ -2415,7 +1396,7 @@ var Redirect = class {
   toPath(url) {
     let query = {};
     if (this.#forwardQueryString) {
-      query = this.#qs.parse(parse(this.#request.url).query || "");
+      query = this.#qs.parse(safeDecodeURI(this.#request.url, false).query || "");
     }
     Object.assign(query, this.#queryString);
     this.#sendResponse(url, query);
@@ -2568,13 +1549,13 @@ import { extname } from "path";
 import { Buffer } from "buffer";
 import onFinished from "on-finished";
 import { stat } from "fs/promises";
-import Macroable6 from "@poppinss/macroable";
+import Macroable2 from "@poppinss/macroable";
 import { createReadStream } from "fs";
 import contentDisposition from "content-disposition";
 import { safeStringify } from "@poppinss/utils/json";
-import { RuntimeException as RuntimeException3 } from "@poppinss/utils/exception";
+import { RuntimeException } from "@poppinss/utils/exception";
 var CACHEABLE_HTTP_METHODS = ["GET", "HEAD"];
-var Response = class extends Macroable6 {
+var Response = class extends Macroable2 {
   /**
    * Creates a new Response instance
    *
@@ -2741,7 +1722,7 @@ var Response = class extends Macroable6 {
       }
       return "object";
     }
-    throw new RuntimeException3(`Cannot serialize "${dataType}" to HTTP response`);
+    throw new RuntimeException(`Cannot serialize "${dataType}" to HTTP response`);
   }
   /**
    * Writes the response body with appropriate headers and content type detection
@@ -3832,13 +2813,13 @@ var Response = class extends Macroable6 {
 };
 
 // src/router/main.ts
-import is3 from "@sindresorhus/is";
-import { moduleImporter as moduleImporter3 } from "@adonisjs/fold";
-import { RuntimeException as RuntimeException5 } from "@poppinss/utils/exception";
+import is2 from "@sindresorhus/is";
+import { moduleImporter as moduleImporter2 } from "@adonisjs/fold";
+import { RuntimeException as RuntimeException3 } from "@poppinss/utils/exception";
 
 // src/router/store.ts
 import matchit from "@poppinss/matchit";
-import { RuntimeException as RuntimeException4 } from "@poppinss/utils/exception";
+import { RuntimeException as RuntimeException2 } from "@poppinss/utils/exception";
 var RoutesStore = class {
   /**
    * A flag to know if routes for explicit domains
@@ -3877,7 +2858,7 @@ var RoutesStore = class {
     for (let token of tokens) {
       if ([1, 3].includes(token.type)) {
         if (collectedParams.has(token.val)) {
-          throw new RuntimeException4(`Duplicate param "${token.val}" found in "${route.pattern}"`);
+          throw new RuntimeException2(`Duplicate param "${token.val}" found in "${route.pattern}"`);
         } else {
           collectedParams.add(token.val);
         }
@@ -3893,7 +2874,7 @@ var RoutesStore = class {
   #registerRoute(domain, method, tokens, route) {
     const methodRoutes = this.#getMethodNode(domain, method);
     if (methodRoutes.routes[route.pattern]) {
-      throw new RuntimeException4(
+      throw new RuntimeException2(
         `Duplicate route found. "${method}: ${route.pattern}" route already exists`
       );
     }
@@ -4171,8 +3152,8 @@ var UrlBuilder = class {
 };
 
 // src/router/matchers.ts
-import Macroable7 from "@poppinss/macroable";
-var RouteMatchers = class extends Macroable7 {
+import Macroable3 from "@poppinss/macroable";
+var RouteMatchers = class extends Macroable3 {
   /**
    * Enforce value to be a number and also casts it to number data
    * type
@@ -4201,9 +3182,9 @@ var RouteMatchers = class extends Macroable7 {
 };
 
 // src/define_middleware.ts
-import { moduleImporter as moduleImporter2 } from "@adonisjs/fold";
+import { moduleImporter } from "@adonisjs/fold";
 function middlewareReferenceBuilder(name, middleware) {
-  const handler = moduleImporter2(middleware, "handle").toHandleMethod();
+  const handler = moduleImporter(middleware, "handle").toHandleMethod();
   return function(...args) {
     return {
       ...handler,
@@ -4424,7 +3405,7 @@ var Router = class {
     middleware.forEach(
       (one) => this.#middleware.push({
         reference: one,
-        ...moduleImporter3(one, "handle").toHandleMethod()
+        ...moduleImporter2(one, "handle").toHandleMethod()
       })
     );
     return this;
@@ -4583,7 +3564,7 @@ var Router = class {
   where(param, matcher) {
     if (typeof matcher === "string") {
       this.#globalMatchers[param] = { match: new RegExp(matcher) };
-    } else if (is3.regExp(matcher)) {
+    } else if (is2.regExp(matcher)) {
       this.#globalMatchers[param] = { match: matcher };
     } else {
       this.#globalMatchers[param] = matcher;
@@ -4606,7 +3587,7 @@ var Router = class {
       }
       const routeNames = routeNamesByDomain.get(route.domain);
       if (route.name && routeNames.has(route.name)) {
-        throw new RuntimeException5(
+        throw new RuntimeException3(
           `A route with name "${route.name}" already exists. It may happen when two routes use the same controller, so make sure to give explicit names to these routes`
         );
       }
@@ -4772,7 +3753,7 @@ var Router = class {
       (domain) => this.routes[domain].forEach((route) => trackRoute.bind(this)(route, domain))
     );
     return Object.keys(routesList).reduce((result, method) => {
-      result.push(`${" ".repeat(indentation)}'${method}': {`);
+      result.push(`${" ".repeat(indentation)}${method}: {`);
       Object.keys(routesList[method]).forEach((identifier) => {
         const key = `'${identifier}'`;
         const { paramsTuple, hasRequiredParams, params } = routesList[method][identifier];
@@ -4780,10 +3761,10 @@ var Router = class {
         const tupleName = hasRequiredParams ? "paramsTuple" : "paramsTuple?";
         const dictValue = `{${params.join(",")}}`;
         const tupleValue = `[${paramsTuple?.join(",")}]`;
-        const value = `{ ${tupleName}: ${tupleValue}, ${dictName}: ${dictValue} }`;
-        result.push(`${" ".repeat(indentation + 2)}${key}: ${value},`);
+        const value = `{ ${tupleName}: ${tupleValue}; ${dictName}: ${dictValue} }`;
+        result.push(`${" ".repeat(indentation + 2)}${key}: ${value}`);
       });
-      result.push(`${" ".repeat(indentation)}},`);
+      result.push(`${" ".repeat(indentation)}}`);
       return result;
     }, []).join("\n");
   }
@@ -4870,8 +3851,8 @@ var Router = class {
 
 // src/http_context/main.ts
 import { inspect } from "util";
-import Macroable8 from "@poppinss/macroable";
-import { RuntimeException as RuntimeException6 } from "@poppinss/utils/exception";
+import Macroable4 from "@poppinss/macroable";
+import { RuntimeException as RuntimeException4 } from "@poppinss/utils/exception";
 
 // src/http_context/local_storage.ts
 import { AsyncLocalStorage } from "async_hooks";
@@ -4890,7 +3871,7 @@ var asyncLocalStorage = {
 };
 
 // src/http_context/main.ts
-var HttpContext = class extends Macroable8 {
+var HttpContext = class extends Macroable4 {
   /**
    * Creates a new HttpContext instance
    *
@@ -4931,13 +3912,13 @@ var HttpContext = class extends Macroable8 {
    */
   static getOrFail() {
     if (!this.usingAsyncLocalStorage || !asyncLocalStorage.storage) {
-      throw new RuntimeException6(
+      throw new RuntimeException4(
         'HTTP context is not available. Enable "useAsyncLocalStorage" inside "config/app.ts" file'
       );
     }
     const store = this.get();
     if (!store) {
-      throw new RuntimeException6("Http context is not available outside of an HTTP request");
+      throw new RuntimeException4("Http context is not available outside of an HTTP request");
     }
     return store;
   }
@@ -4979,40 +3960,8 @@ var HttpContext = class extends Macroable8 {
 
 // src/server/main.ts
 import onFinished2 from "on-finished";
-import Middleware2 from "@poppinss/middleware";
-import { moduleCaller as moduleCaller2, moduleImporter as moduleImporter4 } from "@adonisjs/fold";
-
-// src/qs.ts
-import { parse as parse2, stringify } from "qs";
-var Qs = class {
-  /**
-   * Configuration object containing parse and stringify options for query strings
-   */
-  #config;
-  /**
-   * Creates a new query string parser instance with the provided configuration
-   * @param config - Configuration object with parse and stringify options
-   */
-  constructor(config) {
-    this.#config = config;
-  }
-  /**
-   * Parses a query string into a JavaScript object using the configured options
-   * @param value - Query string to parse (e.g., "foo=bar&baz=qux")
-   * @returns Parsed object representation of the query string
-   */
-  parse = (value) => {
-    return parse2(value, this.#config.parse);
-  };
-  /**
-   * Converts a JavaScript object into a query string using the configured options
-   * @param value - Object to convert to query string
-   * @returns Stringified query string representation of the object
-   */
-  stringify = (value) => {
-    return stringify(value, this.#config.stringify);
-  };
-};
+import Middleware from "@poppinss/middleware";
+import { moduleCaller, moduleImporter as moduleImporter3 } from "@adonisjs/fold";
 
 // src/server/factories/route_finder.ts
 function routeFinder(router, resolver, ctx, errorResponder) {
@@ -5185,7 +4134,7 @@ var Server = class {
    * Compiles registered middleware into a frozen middleware stack for execution
    */
   #createServerMiddlewareStack() {
-    this.#serverMiddlewareStack = new Middleware2();
+    this.#serverMiddlewareStack = new Middleware();
     this.#middleware.forEach((middleware) => this.#serverMiddlewareStack.add(middleware));
     this.#serverMiddlewareStack.freeze();
     this.#middleware = [];
@@ -5210,11 +4159,11 @@ var Server = class {
    * @returns TestingMiddlewarePipeline instance for test execution
    */
   pipeline(middleware) {
-    const middlewareStack = new Middleware2();
+    const middlewareStack = new Middleware();
     middleware.forEach((one) => {
       middlewareStack.add({
         reference: one,
-        ...moduleCaller2(one, "handle").toHandleMethod()
+        ...moduleCaller(one, "handle").toHandleMethod()
       });
     });
     middlewareStack.freeze();
@@ -5245,7 +4194,7 @@ var Server = class {
     middleware.forEach(
       (one) => this.#middleware.push({
         reference: one,
-        ...moduleImporter4(one, "handle").toHandleMethod()
+        ...moduleImporter3(one, "handle").toHandleMethod()
       })
     );
     return this;
@@ -5404,7 +4353,7 @@ var Server = class {
 
 // src/define_config.ts
 import proxyAddr from "proxy-addr";
-import string3 from "@poppinss/utils/string";
+import string from "@poppinss/utils/string";
 import lodash2 from "@poppinss/utils/lodash";
 function defineConfig(config) {
   const { trustProxy: trustProxy2, ...rest } = config;
@@ -5444,7 +4393,7 @@ function defineConfig(config) {
   };
   const normalizedConfig = lodash2.merge({}, defaults, rest);
   if (normalizedConfig.cookie.maxAge) {
-    normalizedConfig.cookie.maxAge = string3.seconds.parse(normalizedConfig.cookie.maxAge);
+    normalizedConfig.cookie.maxAge = string.seconds.parse(normalizedConfig.cookie.maxAge);
   }
   if (typeof trustProxy2 === "boolean") {
     const tpValue = trustProxy2;
@@ -5459,6 +4408,7 @@ function defineConfig(config) {
 }
 
 export {
+  Qs,
   E_ROUTE_NOT_FOUND,
   E_CANNOT_LOOKUP_ROUTE,
   E_HTTP_EXCEPTION,
@@ -5466,19 +4416,11 @@ export {
   errors_exports,
   CookieClient,
   CookieParser,
-  canWriteResponseBody,
-  tracing_channels_exports,
-  Route,
-  BriskRoute,
-  RouteResource,
-  RouteGroup,
-  parseRange,
   Request,
   Redirect,
   ResponseStatus,
   CookieSerializer,
   Response,
-  Qs,
   Router,
   HttpContext,
   Server,