@versori/run 0.0.1-alpha.5 → 0.0.1-alpha.6

package/script/deps/deno.land/x/oak@v17.1.4/response.js

@@ -1,299 +0,0 @@
-"use strict";
-// Copyright 2018-2025 the oak authors. All rights reserved. MIT license.
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var _Response_instances, _Response_body, _Response_bodySet, _Response_domResponse, _Response_headers, _Response_jsonBodyReplacer, _Response_request, _Response_resources, _Response_status, _Response_type, _Response_writable, _Response_getBodyInit, _Response_setContentType;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Response = exports.REDIRECT_BACK = void 0;
-/**
- * Contains the {@linkcode Response} abstraction used by oak.
- *
- * Most end users would not need to directly access this module.
- *
- * @module
- */
-const deps_js_1 = require("./deps.js");
-const http_server_native_request_js_1 = require("./http_server_native_request.js");
-const type_guards_js_1 = require("./utils/type_guards.js");
-const consts_js_1 = require("./utils/consts.js");
-const encode_url_js_1 = require("./utils/encode_url.js");
-const streams_js_1 = require("./utils/streams.js");
-/** A symbol that indicates to `response.redirect()` to attempt to redirect
- * back to the request referrer.  For example:
- *
- * ```ts
- * import { Application, REDIRECT_BACK } from "jsr:@oak/oak/";
- *
- * const app = new Application();
- *
- * app.use((ctx) => {
- *   if (ctx.request.url.pathName === "/back") {
- *     ctx.response.redirect(REDIRECT_BACK, "/");
- *   }
- * });
- *
- * await app.listen({ port: 80 });
- * ```
- */
-exports.REDIRECT_BACK = Symbol("redirect backwards");
-async function convertBodyToBodyInit(body, type, jsonBodyReplacer) {
-    let result;
-    if (consts_js_1.BODY_TYPES.includes(typeof body)) {
-        result = String(body);
-        type = type ?? ((0, type_guards_js_1.isHtml)(result) ? "html" : "text/plain");
-    }
-    else if ((0, type_guards_js_1.isFsFile)(body)) {
-        result = body.readable;
-    }
-    else if (ArrayBuffer.isView(body) || body instanceof ArrayBuffer ||
-        body instanceof Blob || body instanceof URLSearchParams) {
-        // deno-lint-ignore no-explicit-any
-        result = body;
-    }
-    else if (body instanceof ReadableStream) {
-        result = body.pipeThrough(new streams_js_1.Uint8ArrayTransformStream());
-    }
-    else if (body instanceof FormData) {
-        result = body;
-        type = undefined;
-    }
-    else if ((0, type_guards_js_1.isAsyncIterable)(body)) {
-        result = (0, streams_js_1.readableStreamFromAsyncIterable)(body);
-    }
-    else if (body && typeof body === "object") {
-        result = JSON.stringify(body, jsonBodyReplacer);
-        type = type ?? "json";
-    }
-    else if (typeof body === "function") {
-        const result = body.call(null);
-        return convertBodyToBodyInit(await result, type, jsonBodyReplacer);
-    }
-    else if (body) {
-        throw new TypeError("Response body was set but could not be converted.");
-    }
-    return [result, type];
-}
-/** An interface to control what response will be sent when the middleware
- * finishes processing the request.
- *
- * The response is usually accessed via the context's `.response` property.
- *
- * ### Example
- *
- * ```ts
- * import { Application, Status } from "jsr:@oak/oak/";
- *
- * const app = new Application();
- *
- * app.use((ctx) => {
- *   ctx.response.body = { hello: "oak" };
- *   ctx.response.type = "json";
- *   ctx.response.status = Status.OK;
- * });
- * ```
- */
-class Response {
-    /** The body of the response.  The body will be automatically processed when
-     * the response is being sent and converted to a `Uint8Array` or a
-     * `Deno.Reader`.
-     *
-     * Automatic conversion to a `Deno.Reader` occurs for async iterables. */
-    get body() {
-        return __classPrivateFieldGet(this, _Response_body, "f");
-    }
-    /** The body of the response.  The body will be automatically processed when
-     * the response is being sent and converted to a `Uint8Array` or a
-     * `Deno.Reader`.
-     *
-     * Automatic conversion to a `Deno.Reader` occurs for async iterables. */
-    set body(value) {
-        if (!__classPrivateFieldGet(this, _Response_writable, "f")) {
-            throw new Error("The response is not writable.");
-        }
-        __classPrivateFieldSet(this, _Response_bodySet, true, "f");
-        __classPrivateFieldSet(this, _Response_body, value, "f");
-    }
-    /** Headers that will be returned in the response. */
-    get headers() {
-        return __classPrivateFieldGet(this, _Response_headers, "f");
-    }
-    /** Headers that will be returned in the response. */
-    set headers(value) {
-        if (!__classPrivateFieldGet(this, _Response_writable, "f")) {
-            throw new Error("The response is not writable.");
-        }
-        __classPrivateFieldSet(this, _Response_headers, value, "f");
-    }
-    /** The HTTP status of the response.  If this has not been explicitly set,
-     * reading the value will return what would be the value of status if the
-     * response were sent at this point in processing the middleware.  If the body
-     * has been set, the status will be `200 OK`.  If a value for the body has
-     * not been set yet, the status will be `404 Not Found`. */
-    get status() {
-        if (__classPrivateFieldGet(this, _Response_status, "f")) {
-            return __classPrivateFieldGet(this, _Response_status, "f");
-        }
-        return this.body != null
-            ? deps_js_1.Status.OK
-            : __classPrivateFieldGet(this, _Response_bodySet, "f")
-                ? deps_js_1.Status.NoContent
-                : deps_js_1.Status.NotFound;
-    }
-    /** The HTTP status of the response.  If this has not been explicitly set,
-     * reading the value will return what would be the value of status if the
-     * response were sent at this point in processing the middleware.  If the body
-     * has been set, the status will be `200 OK`.  If a value for the body has
-     * not been set yet, the status will be `404 Not Found`. */
-    set status(value) {
-        if (!__classPrivateFieldGet(this, _Response_writable, "f")) {
-            throw new Error("The response is not writable.");
-        }
-        __classPrivateFieldSet(this, _Response_status, value, "f");
-    }
-    /** The media type, or extension of the response.  Setting this value will
-     * ensure an appropriate `Content-Type` header is added to the response. */
-    get type() {
-        return __classPrivateFieldGet(this, _Response_type, "f");
-    }
-    /** The media type, or extension of the response.  Setting this value will
-     * ensure an appropriate `Content-Type` header is added to the response. */
-    set type(value) {
-        if (!__classPrivateFieldGet(this, _Response_writable, "f")) {
-            throw new Error("The response is not writable.");
-        }
-        __classPrivateFieldSet(this, _Response_type, value, "f");
-    }
-    /** A read-only property which determines if the response is writable or not.
-     * Once the response has been processed, this value is set to `false`. */
-    get writable() {
-        return __classPrivateFieldGet(this, _Response_writable, "f");
-    }
-    constructor(request, jsonBodyReplacer) {
-        _Response_instances.add(this);
-        _Response_body.set(this, void 0);
-        _Response_bodySet.set(this, false);
-        _Response_domResponse.set(this, void 0);
-        _Response_headers.set(this, new Headers());
-        _Response_jsonBodyReplacer.set(this, void 0);
-        _Response_request.set(this, void 0);
-        _Response_resources.set(this, []);
-        _Response_status.set(this, void 0);
-        _Response_type.set(this, void 0);
-        _Response_writable.set(this, true);
-        __classPrivateFieldSet(this, _Response_request, request, "f");
-        __classPrivateFieldSet(this, _Response_jsonBodyReplacer, jsonBodyReplacer, "f");
-    }
-    /** Add a resource to the list of resources that will be closed when the
-     * request is destroyed. */
-    addResource(resource) {
-        __classPrivateFieldGet(this, _Response_resources, "f").push(resource);
-    }
-    /** Release any resources that are being tracked by the response.
-     *
-     * @param closeResources close any resource IDs registered with the response
-     */
-    destroy(closeResources = true) {
-        __classPrivateFieldSet(this, _Response_writable, false, "f");
-        __classPrivateFieldSet(this, _Response_body, undefined, "f");
-        __classPrivateFieldSet(this, _Response_domResponse, undefined, "f");
-        if (closeResources) {
-            for (const resource of __classPrivateFieldGet(this, _Response_resources, "f")) {
-                try {
-                    resource.close();
-                }
-                catch {
-                    // we don't care about errors here
-                }
-            }
-        }
-    }
-    redirect(url, alt = "/") {
-        if (url === exports.REDIRECT_BACK) {
-            url = __classPrivateFieldGet(this, _Response_request, "f").headers.get("Referer") ?? String(alt);
-        }
-        else if (typeof url === "object") {
-            url = String(url);
-        }
-        this.headers.set("Location", (0, encode_url_js_1.encodeUrl)(url));
-        if (!this.status || !(0, deps_js_1.isRedirectStatus)(this.status)) {
-            this.status = deps_js_1.Status.Found;
-        }
-        if (__classPrivateFieldGet(this, _Response_request, "f").accepts("html")) {
-            url = encodeURI(url);
-            this.type = "text/html; charset=UTF-8";
-            this.body = `Redirecting to <a href="${url}">${url}</a>.`;
-            return;
-        }
-        this.type = "text/plain; charset=UTF-8";
-        this.body = `Redirecting to ${url}.`;
-    }
-    async toDomResponse() {
-        if (__classPrivateFieldGet(this, _Response_domResponse, "f")) {
-            return __classPrivateFieldGet(this, _Response_domResponse, "f");
-        }
-        const bodyInit = await __classPrivateFieldGet(this, _Response_instances, "m", _Response_getBodyInit).call(this);
-        __classPrivateFieldGet(this, _Response_instances, "m", _Response_setContentType).call(this);
-        const { headers } = this;
-        // If there is no body and no content type and no set length, then set the
-        // content length to 0
-        if (!(bodyInit ||
-            headers.has("Content-Type") ||
-            headers.has("Content-Length"))) {
-            headers.append("Content-Length", "0");
-        }
-        __classPrivateFieldSet(this, _Response_writable, false, "f");
-        const status = this.status;
-        const responseInit = {
-            headers,
-            status,
-            statusText: deps_js_1.STATUS_TEXT[status],
-        };
-        return __classPrivateFieldSet(this, _Response_domResponse, new http_server_native_request_js_1.DomResponse(bodyInit, responseInit), "f");
-    }
-    with(responseOrBody, init) {
-        if (__classPrivateFieldGet(this, _Response_domResponse, "f") || !__classPrivateFieldGet(this, _Response_writable, "f")) {
-            throw new Error("A response has already been finalized.");
-        }
-        __classPrivateFieldSet(this, _Response_writable, false, "f");
-        __classPrivateFieldSet(this, _Response_domResponse, responseOrBody instanceof http_server_native_request_js_1.DomResponse
-            ? responseOrBody
-            : new http_server_native_request_js_1.DomResponse(responseOrBody, init), "f");
-    }
-    [(_Response_body = new WeakMap(), _Response_bodySet = new WeakMap(), _Response_domResponse = new WeakMap(), _Response_headers = new WeakMap(), _Response_jsonBodyReplacer = new WeakMap(), _Response_request = new WeakMap(), _Response_resources = new WeakMap(), _Response_status = new WeakMap(), _Response_type = new WeakMap(), _Response_writable = new WeakMap(), _Response_instances = new WeakSet(), _Response_getBodyInit = async function _Response_getBodyInit() {
-        const [body, type] = await convertBodyToBodyInit(this.body, this.type, __classPrivateFieldGet(this, _Response_jsonBodyReplacer, "f"));
-        this.type = type;
-        return body;
-    }, _Response_setContentType = function _Response_setContentType() {
-        if (this.type) {
-            const contentTypeString = (0, deps_js_1.contentType)(this.type);
-            if (contentTypeString && !this.headers.has("Content-Type")) {
-                this.headers.append("Content-Type", contentTypeString);
-            }
-        }
-    }, Symbol.for("Deno.customInspect"))](inspect) {
-        const { body, headers, status, type, writable } = this;
-        return `${this.constructor.name} ${inspect({ body, headers, status, type, writable })}`;
-    }
-    [Symbol.for("nodejs.util.inspect.custom")](depth, 
-    // deno-lint-ignore no-explicit-any
-    options, inspect) {
-        if (depth < 0) {
-            return options.stylize(`[${this.constructor.name}]`, "special");
-        }
-        const newOptions = Object.assign({}, options, {
-            depth: options.depth === null ? null : options.depth - 1,
-        });
-        const { body, headers, status, type, writable } = this;
-        return `${options.stylize(this.constructor.name, "special")} ${inspect({ body, headers, status, type, writable }, newOptions)}`;
-    }
-}
-exports.Response = Response;

package/script/deps/deno.land/x/oak@v17.1.4/router.d.ts

@@ -1,363 +0,0 @@
-/**
- * Contains the router of oak. Typical usage is the creation of an application
- * instance, the creation of a router instance, registration of route
- * middleware, registration of router with the application, and then starting to
- * listen for requests.
- *
- * # Example
- *
- * ```ts
- * import { Application } from "jsr:@oak/oak/application";
- * import { Router } from "jsr:@oak/oak/router";
- *
- * const app = new Application();
- * const router = new Router();
- * router.get("/", (ctx) => {
- *   ctx.response.body = "hello world!";
- * });
- * app.use(router.routes());
- * app.use(router.allowedMethods());
- *
- * app.listen();
- * ```
- *
- * @module
- */
-/**
- * Adapted directly from @koa/router at
- * https://github.com/koajs/router/ which is licensed as:
- *
- * The MIT License (MIT)
- *
- * Copyright (c) 2015 Alexander C. Mingoia
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-import type { State } from "./application.js";
-import type { Context } from "./context.js";
-import { type HTTPMethods, type ParseOptions, type RedirectStatus, type TokensToRegexpOptions } from "./deps.js";
-import { type Middleware } from "./middleware.js";
-/** Options which can be specified when calling the `.allowedMethods()` method
- * on a {@linkcode Router} instance. */
-export interface RouterAllowedMethodsOptions {
-    /** Use the value returned from this function instead of an HTTP error
-     * `MethodNotAllowed`. */
-    methodNotAllowed?(): any;
-    /** Use the value returned from this function instead of an HTTP error
-     * `NotImplemented`. */
-    notImplemented?(): any;
-    /** When dealing with a non-implemented method or a method not allowed, throw
-     * an error instead of setting the status and header for the response. */
-    throw?: boolean;
-}
-/** The internal abstraction of a route used by the oak {@linkcode Router}. */
-export interface Route<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = Record<string, any>> {
-    /** The HTTP methods that this route handles. */
-    methods: HTTPMethods[];
-    /** The middleware that will be applied to this route. */
-    middleware: RouterMiddleware<R, P, S>[];
-    /** An optional name for the route. */
-    name?: string;
-    /** Options that were used to create the route. */
-    options: LayerOptions;
-    /** The parameters that are identified in the route that will be parsed out
-     * on matched requests. */
-    paramNames: (keyof P)[];
-    /** The path that this route manages. */
-    path: string;
-    /** The regular expression used for matching and parsing parameters for the
-     * route. */
-    regexp: RegExp;
-}
-/** The context passed router middleware.  */
-export interface RouterContext<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = Record<string, any>> extends Context<S> {
-    /** When matching the route, an array of the capturing groups from the regular
-     * expression. */
-    captures: string[];
-    /** The routes that were matched for this request. */
-    matched?: Layer<R, P, S>[];
-    /** Any parameters parsed from the route when matched. */
-    params: P;
-    /** A reference to the router instance. */
-    router: Router;
-    /** If the matched route has a `name`, the matched route name is provided
-     * here. */
-    routeName?: string;
-    /** Overrides the matched path for future route middleware, when a
-     * `routerPath` option is not defined on the `Router` options. */
-    routerPath?: string;
-}
-/** The interface that {@linkcode Router} middleware should adhere to. */
-export interface RouterMiddleware<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = Record<string, any>> {
-    (context: RouterContext<R, P, S>, next: () => Promise<unknown>): Promise<unknown> | unknown;
-    /** For route parameter middleware, the `param` key for this parameter will
-     * be set. */
-    param?: keyof P;
-    router?: Router<any>;
-}
-/** Options which can be specified when creating a new instance of a
- * {@linkcode Router}. */
-export interface RouterOptions {
-    /** Override the default set of methods supported by the router. */
-    methods?: HTTPMethods[];
-    /** Only handle routes where the requested path starts with the prefix. */
-    prefix?: string;
-    /** Override the `request.url.pathname` when matching middleware to run. */
-    routerPath?: string;
-    /** Determines if routes are matched in a case sensitive way.  Defaults to
-     * `false`. */
-    sensitive?: boolean;
-    /** Determines if routes are matched strictly, where the trailing `/` is not
-     * optional.  Defaults to `false`. */
-    strict?: boolean;
-}
-/** Middleware that will be called by the router when handling a specific
- * parameter, which the middleware will be called when a request matches the
- * route parameter. */
-export interface RouterParamMiddleware<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = Record<string, any>> {
-    (param: string, context: RouterContext<R, P, S>, next: () => Promise<unknown>): Promise<unknown> | unknown;
-    router?: Router<any>;
-}
-interface ParamsDictionary {
-    [key: string]: string;
-}
-type RemoveTail<S extends string, Tail extends string> = S extends `${infer P}${Tail}` ? P : S;
-type GetRouteParams<S extends string> = RemoveTail<RemoveTail<RemoveTail<S, `/${string}`>, `-${string}`>, `.${string}`>;
-/** A dynamic type which attempts to determine the route params based on
- * matching the route string. */
-export type RouteParams<Route extends string> = string extends Route ? ParamsDictionary : Route extends `${string}(${string}` ? ParamsDictionary : Route extends `${string}:${infer Rest}` ? (GetRouteParams<Rest> extends never ? ParamsDictionary : GetRouteParams<Rest> extends `${infer ParamName}?` ? {
-    [P in ParamName]?: string;
-} : {
-    [P in GetRouteParams<Rest>]: string;
-}) & (Rest extends `${GetRouteParams<Rest>}${infer Next}` ? RouteParams<Next> : unknown) : Record<string | number, string | undefined>;
-type LayerOptions = TokensToRegexpOptions & ParseOptions & {
-    ignoreCaptures?: boolean;
-    name?: string;
-};
-type UrlOptions = TokensToRegexpOptions & ParseOptions & {
-    /** When generating a URL from a route, add the query to the URL.  If an
-     * object */
-    query?: URLSearchParams | Record<string, string> | string;
-};
-/** An internal class used to group together middleware when using multiple
- * middlewares with a router. */
-export declare class Layer<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = Record<string, any>> {
-    #private;
-    methods: HTTPMethods[];
-    name?: string;
-    path: string;
-    stack: RouterMiddleware<R, P, S>[];
-    constructor(path: string, methods: HTTPMethods[], middleware: RouterMiddleware<R, P, S> | RouterMiddleware<R, P, S>[], { name, ...opts }?: LayerOptions);
-    clone(): Layer<R, P, S>;
-    match(path: string): boolean;
-    params(captures: string[], existingParams?: RouteParams<R>): RouteParams<R>;
-    captures(path: string): string[];
-    url(params?: RouteParams<R>, options?: UrlOptions): string;
-    param(param: string, fn: RouterParamMiddleware<any, any, any>): this;
-    setPrefix(prefix: string): this;
-    toJSON(): Route<any, any, any>;
-}
-/** An interface for registering middleware that will run when certain HTTP
- * methods and paths are requested, as well as provides a way to parameterize
- * parts of the requested path.
- *
- * ### Basic example
- *
- * ```ts
- * import { Application, Router } from "jsr:@oak/oak/";
- *
- * const router = new Router();
- * router.get("/", (ctx, next) => {
- *   // handle the GET endpoint here
- * });
- * router.all("/item/:item", (ctx, next) => {
- *   // called for all HTTP verbs/requests
- *   ctx.params.item; // contains the value of `:item` from the parsed URL
- * });
- *
- * const app = new Application();
- * app.use(router.routes());
- * app.use(router.allowedMethods());
- *
- * app.listen({ port: 8080 });
- * ```
- */
-export declare class Router<RS extends State = Record<string, any>> {
-    #private;
-    constructor(opts?: RouterOptions);
-    /** Register named middleware for the specified routes when specified methods
-     * are requested. */
-    add<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = RS>(methods: HTTPMethods[] | HTTPMethods, name: string, path: R, middleware: RouterMiddleware<R, P, S>, ...middlewares: RouterMiddleware<R, P, S>[]): Router<S extends RS ? S : (S & RS)>;
-    /** Register middleware for the specified routes when the specified methods is
-     * requested. */
-    add<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = RS>(methods: HTTPMethods[] | HTTPMethods, path: R, middleware: RouterMiddleware<R, P, S>, ...middlewares: RouterMiddleware<R, P, S>[]): Router<S extends RS ? S : (S & RS)>;
-    /** Register middleware for the specified routes when the specified methods
-     * are requested with explicit path parameters. */
-    add<P extends RouteParams<string>, S extends State = RS>(methods: HTTPMethods[] | HTTPMethods, nameOrPath: string, pathOrMiddleware: string | RouterMiddleware<string, P, S>, ...middleware: RouterMiddleware<string, P, S>[]): Router<S extends RS ? S : (S & RS)>;
-    /** Register named middleware for the specified routes when the `DELETE`,
-     * `GET`, `POST`, or `PUT` method is requested. */
-    all<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = RS>(name: string, path: R, middleware: RouterMiddleware<R, P, S>, ...middlewares: RouterMiddleware<R, P, S>[]): Router<S extends RS ? S : (S & RS)>;
-    /** Register middleware for the specified routes when the `DELETE`,
-     * `GET`, `POST`, or `PUT` method is requested. */
-    all<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = RS>(path: R, middleware: RouterMiddleware<R, P, S>, ...middlewares: RouterMiddleware<R, P, S>[]): Router<S extends RS ? S : (S & RS)>;
-    /** Register middleware for the specified routes when the `DELETE`,
-     * `GET`, `POST`, or `PUT` method is requested with explicit path parameters.
-     */
-    all<P extends RouteParams<string>, S extends State = RS>(nameOrPath: string, pathOrMiddleware: string | RouterMiddleware<string, P, S>, ...middleware: RouterMiddleware<string, P, S>[]): Router<S extends RS ? S : (S & RS)>;
-    /** Middleware that handles requests for HTTP methods registered with the
-     * router.  If none of the routes handle a method, then "not allowed" logic
-     * will be used.  If a method is supported by some routes, but not the
-     * particular matched router, then "not implemented" will be returned.
-     *
-     * The middleware will also automatically handle the `OPTIONS` method,
-     * responding with a `200 OK` when the `Allowed` header sent to the allowed
-     * methods for a given route.
-     *
-     * By default, a "not allowed" request will respond with a `405 Not Allowed`
-     * and a "not implemented" will respond with a `501 Not Implemented`. Setting
-     * the option `.throw` to `true` will cause the middleware to throw an
-     * `HTTPError` instead of setting the response status.  The error can be
-     * overridden by providing a `.notImplemented` or `.notAllowed` method in the
-     * options, of which the value will be returned will be thrown instead of the
-     * HTTP error. */
-    allowedMethods(options?: RouterAllowedMethodsOptions): Middleware;
-    /** Register named middleware for the specified routes when the `DELETE`,
-     *  method is requested. */
-    delete<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = RS>(name: string, path: R, middleware: RouterMiddleware<R, P, S>, ...middlewares: RouterMiddleware<R, P, S>[]): Router<S extends RS ? S : (S & RS)>;
-    /** Register middleware for the specified routes when the `DELETE`,
-     * method is requested. */
-    delete<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = RS>(path: R, middleware: RouterMiddleware<R, P, S>, ...middlewares: RouterMiddleware<R, P, S>[]): Router<S extends RS ? S : (S & RS)>;
-    /** Register middleware for the specified routes when the `DELETE`,
-     * method is requested with explicit path parameters. */
-    delete<P extends RouteParams<string>, S extends State = RS>(nameOrPath: string, pathOrMiddleware: string | RouterMiddleware<string, P, S>, ...middleware: RouterMiddleware<string, P, S>[]): Router<S extends RS ? S : (S & RS)>;
-    /** Iterate over the routes currently added to the router.  To be compatible
-     * with the iterable interfaces, both the key and value are set to the value
-     * of the route. */
-    entries(): IterableIterator<[Route<string>, Route<string>]>;
-    /** Iterate over the routes currently added to the router, calling the
-     * `callback` function for each value. */
-    forEach(callback: (value1: Route<string>, value2: Route<string>, router: this) => void, thisArg?: any): void;
-    /** Register named middleware for the specified routes when the `GET`,
-     *  method is requested. */
-    get<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = RS>(name: string, path: R, middleware: RouterMiddleware<R, P, S>, ...middlewares: RouterMiddleware<R, P, S>[]): Router<S extends RS ? S : (S & RS)>;
-    /** Register middleware for the specified routes when the `GET`,
-     * method is requested. */
-    get<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = RS>(path: R, middleware: RouterMiddleware<R, P, S>, ...middlewares: RouterMiddleware<R, P, S>[]): Router<S extends RS ? S : (S & RS)>;
-    /** Register middleware for the specified routes when the `GET`,
-     * method is requested with explicit path parameters. */
-    get<P extends RouteParams<string>, S extends State = RS>(nameOrPath: string, pathOrMiddleware: string | RouterMiddleware<string, P, S>, ...middleware: RouterMiddleware<string, P, S>[]): Router<S extends RS ? S : (S & RS)>;
-    /** Register named middleware for the specified routes when the `HEAD`,
-     *  method is requested. */
-    head<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = RS>(name: string, path: R, middleware: RouterMiddleware<R, P, S>, ...middlewares: RouterMiddleware<R, P, S>[]): Router<S extends RS ? S : (S & RS)>;
-    /** Register middleware for the specified routes when the `HEAD`,
-     * method is requested. */
-    head<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = RS>(path: R, middleware: RouterMiddleware<R, P, S>, ...middlewares: RouterMiddleware<R, P, S>[]): Router<S extends RS ? S : (S & RS)>;
-    /** Register middleware for the specified routes when the `HEAD`,
-     * method is requested with explicit path parameters. */
-    head<P extends RouteParams<string>, S extends State = RS>(nameOrPath: string, pathOrMiddleware: string | RouterMiddleware<string, P, S>, ...middleware: RouterMiddleware<string, P, S>[]): Router<S extends RS ? S : (S & RS)>;
-    /** Iterate over the routes currently added to the router.  To be compatible
-     * with the iterable interfaces, the key is set to the value of the route. */
-    keys(): IterableIterator<Route<string>>;
-    /** Register named middleware for the specified routes when the `OPTIONS`,
-     * method is requested. */
-    options<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = RS>(name: string, path: R, middleware: RouterMiddleware<R, P, S>, ...middlewares: RouterMiddleware<R, P, S>[]): Router<S extends RS ? S : (S & RS)>;
-    /** Register middleware for the specified routes when the `OPTIONS`,
-     * method is requested. */
-    options<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = RS>(path: R, middleware: RouterMiddleware<R, P, S>, ...middlewares: RouterMiddleware<R, P, S>[]): Router<S extends RS ? S : (S & RS)>;
-    /** Register middleware for the specified routes when the `OPTIONS`,
-     * method is requested with explicit path parameters. */
-    options<P extends RouteParams<string>, S extends State = RS>(nameOrPath: string, pathOrMiddleware: string | RouterMiddleware<string, P, S>, ...middleware: RouterMiddleware<string, P, S>[]): Router<S extends RS ? S : (S & RS)>;
-    /** Register param middleware, which will be called when the particular param
-     * is parsed from the route. */
-    param<R extends string, S extends State = RS>(param: keyof RouteParams<R>, middleware: RouterParamMiddleware<R, RouteParams<R>, S>): Router<S>;
-    /** Register named middleware for the specified routes when the `PATCH`,
-     * method is requested. */
-    patch<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = RS>(name: string, path: R, middleware: RouterMiddleware<R, P, S>, ...middlewares: RouterMiddleware<R, P, S>[]): Router<S extends RS ? S : (S & RS)>;
-    /** Register middleware for the specified routes when the `PATCH`,
-     * method is requested. */
-    patch<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = RS>(path: R, middleware: RouterMiddleware<R, P, S>, ...middlewares: RouterMiddleware<R, P, S>[]): Router<S extends RS ? S : (S & RS)>;
-    /** Register middleware for the specified routes when the `PATCH`,
-     * method is requested with explicit path parameters. */
-    patch<P extends RouteParams<string>, S extends State = RS>(nameOrPath: string, pathOrMiddleware: string | RouterMiddleware<string, P, S>, ...middleware: RouterMiddleware<string, P, S>[]): Router<S extends RS ? S : (S & RS)>;
-    /** Register named middleware for the specified routes when the `POST`,
-     * method is requested. */
-    post<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = RS>(name: string, path: R, middleware: RouterMiddleware<R, P, S>, ...middlewares: RouterMiddleware<R, P, S>[]): Router<S extends RS ? S : (S & RS)>;
-    /** Register middleware for the specified routes when the `POST`,
-     * method is requested. */
-    post<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = RS>(path: R, middleware: RouterMiddleware<R, P, S>, ...middlewares: RouterMiddleware<R, P, S>[]): Router<S extends RS ? S : (S & RS)>;
-    /** Register middleware for the specified routes when the `POST`,
-     * method is requested with explicit path parameters. */
-    post<P extends RouteParams<string>, S extends State = RS>(nameOrPath: string, pathOrMiddleware: string | RouterMiddleware<string, P, S>, ...middleware: RouterMiddleware<string, P, S>[]): Router<S extends RS ? S : (S & RS)>;
-    /** Set the router prefix for this router. */
-    prefix(prefix: string): this;
-    /** Register named middleware for the specified routes when the `PUT`
-     * method is requested. */
-    put<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = RS>(name: string, path: R, middleware: RouterMiddleware<R, P, S>, ...middlewares: RouterMiddleware<R, P, S>[]): Router<S extends RS ? S : (S & RS)>;
-    /** Register middleware for the specified routes when the `PUT`
-     * method is requested. */
-    put<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = RS>(path: R, middleware: RouterMiddleware<R, P, S>, ...middlewares: RouterMiddleware<R, P, S>[]): Router<S extends RS ? S : (S & RS)>;
-    /** Register middleware for the specified routes when the `PUT`
-     * method is requested with explicit path parameters. */
-    put<P extends RouteParams<string>, S extends State = RS>(nameOrPath: string, pathOrMiddleware: string | RouterMiddleware<string, P, S>, ...middleware: RouterMiddleware<string, P, S>[]): Router<S extends RS ? S : (S & RS)>;
-    /** Register a direction middleware, where when the `source` path is matched
-     * the router will redirect the request to the `destination` path.  A `status`
-     * of `302 Found` will be set by default.
-     *
-     * The `source` and `destination` can be named routes. */
-    redirect(source: string, destination: string | URL, status?: RedirectStatus): this;
-    /** Return middleware that will do all the route processing that the router
-     * has been configured to handle.  Typical usage would be something like this:
-     *
-     * ```ts
-     * import { Application, Router } from "jsr:@oak/oak/";
-     *
-     * const app = new Application();
-     * const router = new Router();
-     *
-     * // register routes
-     *
-     * app.use(router.routes());
-     * app.use(router.allowedMethods());
-     * await app.listen({ port: 80 });
-     * ```
-     */
-    routes(): Middleware;
-    /** Generate a URL pathname for a named route, interpolating the optional
-     * params provided.  Also accepts an optional set of options. */
-    url<P extends RouteParams<string> = RouteParams<string>>(name: string, params?: P, options?: UrlOptions): string | undefined;
-    /** Register middleware to be used on every matched route. */
-    use<P extends RouteParams<string> = RouteParams<string>, S extends State = RS>(middleware: RouterMiddleware<string, P, S>, ...middlewares: RouterMiddleware<string, P, S>[]): Router<S extends RS ? S : (S & RS)>;
-    /** Register middleware to be used on every route that matches the supplied
-     * `path`. */
-    use<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = RS>(path: R, middleware: RouterMiddleware<R, P, S>, ...middlewares: RouterMiddleware<R, P, S>[]): Router<S extends RS ? S : (S & RS)>;
-    /** Register middleware to be used on every route that matches the supplied
-     * `path` with explicit path parameters. */
-    use<P extends RouteParams<string>, S extends State = RS>(path: string, middleware: RouterMiddleware<string, P, S>, ...middlewares: RouterMiddleware<string, P, S>[]): Router<S extends RS ? S : (S & RS)>;
-    use<P extends RouteParams<string> = RouteParams<string>, S extends State = RS>(path: string[], middleware: RouterMiddleware<string, P, S>, ...middlewares: RouterMiddleware<string, P, S>[]): Router<S extends RS ? S : (S & RS)>;
-    /** Iterate over the routes currently added to the router. */
-    values(): IterableIterator<Route<string, RouteParams<string>, RS>>;
-    /** Provide an iterator interface that iterates over the routes registered
-     * with the router. */
-    [Symbol.iterator](): IterableIterator<Route<string, RouteParams<string>, RS>>;
-    /** Generate a URL pathname based on the provided path, interpolating the
-     * optional params provided.  Also accepts an optional set of options. */
-    static url<R extends string>(path: R, params?: RouteParams<R>, options?: UrlOptions): string;
-}
-export {};
-//# sourceMappingURL=router.d.ts.map