revojs 0.1.51 → 0.1.52

package/dist/commands/index.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { n as version, t as name } from "../package-DiFpQQya.mjs";
+import { n as version, t as name } from "../package-BezU2VEq.mjs";
 import { resolvePaths } from "../kit/index.mjs";
 import { defineCommand, runMain } from "citty";
 import { copyFileSync, mkdirSync } from "fs";
@@ -25,28 +25,26 @@ var module_default = defineCommand({ subCommands: { build: defineCommand({ async
 	for (const path of resolvePaths([
 		"./src/**/*.*",
 		"!./src/**/*.js",
-		"!./src/**/*.ts",
-		"!./src/**/**.d.ts"
+		"!./src/**/*.ts"
 	])) {
 		const target = join("./dist", relative("./src", path));
 		mkdirSync(dirname(target), { recursive: true });
 		copyFileSync(path, target);
 	}
+	for (const path of resolvePaths(["./src/**/*.d.ts"])) {
+		const target = join("./dist", relative("./src", path));
+		mkdirSync(dirname(target), { recursive: true });
+		copyFileSync(path, target);
+	}
 } }) } });
 //#endregion
-//#region src/commands/run/index.ts
-var run_default = defineCommand({ setup() {} });
-//#endregion
 //#region src/commands/index.ts
 runMain(defineCommand({
 	meta: {
 		name,
 		version
 	},
-	subCommands: {
-		module: module_default,
-		run: run_default
-	}
+	subCommands: { module: module_default }
 }));
 //#endregion
 export {};

package/dist/{index-CZcqzWwl.d.mts → index-B4nGVcLE.d.mts}

@@ -1,17 +1,6 @@
 import { UserConfig } from "vite";
 
-//#region src/shared/index.d.ts
-type Descriptor<T> = string & {
-  [descriptor]: T;
-};
-type Invoke = (...inputs: Array<any>) => any;
-type Context = Record<string, any>;
-type Output<T> = Success<T> | Failure;
-type InferInput<T extends Schema> = NonNullable<T["~standard"]["types"]>["input"];
-type InferOutput<T extends Schema> = NonNullable<T["~standard"]["types"]>["output"];
-type Primitive = string | number | boolean | bigint | symbol | null | undefined;
-type Awaitable<T> = T | PromiseLike<T>;
-type Mergeable<T> = T extends Primitive ? T : T extends Array<infer U> ? Array<Mergeable<U>> : { [K in keyof T]?: Mergeable<T[K]> };
+//#region src/router/index.d.ts
 type Node<T> = PathNode<T> | WildcardNode<T> | OptionalWildcardNode<T> | ParameterNode<T> | OptionalParameterNode<T> | GroupNode<T> | HookNode<T>;
 interface PathNode<T> {
   type: "PATH";
@@ -45,63 +34,26 @@ interface OptionalParameterNode<T> {
 interface GroupNode<T> {
   type: "GROUP";
   label: string;
-  value?: T;
   children: Record<string, Node<T>>;
 }
 interface HookNode<T> {
   type: "HOOK";
-  value?: T;
+  value?: Array<T>;
   children: Record<string, Node<T>>;
 }
 interface RouterContext<T> {
-  route: Node<T>;
+  route?: T;
   segments: Array<string>;
   parameters: Record<string, string>;
   groups: Array<string>;
   hooks: Array<T>;
 }
-interface Issue {
-  readonly message: string;
-}
-interface Success<T> {
-  readonly value: T;
-}
-interface Failure {
-  readonly issues: ReadonlyArray<Issue>;
-}
-interface Schema<T = unknown, TOutput = T> {
-  readonly "~standard": {
-    readonly validate: (value: unknown) => Output<TOutput> | Promise<Output<TOutput>>;
-    readonly types?: {
-      readonly input: T;
-      readonly output: TOutput;
-    };
-  };
-}
-declare class Hookable {
-  private readonly hooks;
-  constructor();
-  registerHook<T extends Invoke>(name: Descriptor<T>, invoke: T): () => void;
-  dispatchHook<T extends Invoke>(name: Descriptor<T>, ...inputs: Parameters<T>): Promise<Awaited<ReturnType<T>>[]>;
-}
-declare class Scope extends Hookable {
-  private parentScope?;
-  private readonly context;
-  constructor(parentScope?: Scope);
-  getContext<T>(input: Descriptor<T>): T;
-  setContext<T>(input: Descriptor<T>, value: T): T;
-}
 declare class Router<T> {
   readonly rootNode: Node<T>;
   constructor(rootNode?: Node<T>);
   use(segments: Array<string>, value: T): Node<T>;
   match(segments: Array<string>): RouterContext<T>;
 }
-declare function defineHook<T extends Invoke>(name: string): Descriptor<T>;
-declare function defineContext<T>(name: string): Descriptor<T>;
-declare function isFailure<T>(result: Output<T>): result is Failure;
-declare function parseSchema<T extends Schema>(scope: Scope, schema: T, value: unknown): InferOutput<T>;
-declare function mergeObjects<TBase, TInput>(base: TBase, input: TInput): TBase & TInput;
 declare const WILDCARD = "@";
 declare const OPTIONAL_WILDCARD = "@@";
 declare const PARAMETER = "@@@";
@@ -114,8 +66,60 @@ declare const PARAMETER_MATCH: RegExp;
 declare const OPTIONAL_PARAMETER_MATCH: RegExp;
 declare const GROUP_MATCH: RegExp;
 declare const HOOK_MATCH: RegExp;
+//#endregion
+//#region src/shared/index.d.ts
+type Descriptor<T> = string & {
+  [descriptor]: T;
+};
+type Invoke = (...inputs: Array<any>) => any;
+type Context = Record<string, any>;
+type Primitive = string | number | boolean | bigint | symbol | null | undefined;
+type Awaitable<T> = T | PromiseLike<T>;
+type Mergeable<T> = T extends Primitive ? T : T extends Array<infer U> ? Array<Mergeable<U>> : { [K in keyof T]?: Mergeable<T[K]> };
+declare class Hookable {
+  private readonly hooks;
+  constructor();
+  registerHook<T extends Invoke>(name: Descriptor<T>, invoke: T): () => void;
+  dispatchHook<T extends Invoke>(name: Descriptor<T>, ...inputs: Parameters<T>): Promise<Awaited<ReturnType<T>>[]>;
+}
+declare class Scope extends Hookable {
+  private parentScope?;
+  private readonly context;
+  constructor(parentScope?: Scope);
+  getContext<T>(input: Descriptor<T>): T;
+  setContext<T>(input: Descriptor<T>, value: T): T;
+}
+declare function defineHook<T extends Invoke>(name: string): Descriptor<T>;
+declare function defineContext<T>(name: string): Descriptor<T>;
+declare function mergeObjects<TBase, TInput>(base: TBase, input: TInput): TBase & TInput;
 declare const descriptor: unique symbol;
 //#endregion
+//#region src/schema/index.d.ts
+type InferInput<T extends Schema> = NonNullable<T["~standard"]["types"]>["input"];
+type InferOutput<T extends Schema> = NonNullable<T["~standard"]["types"]>["output"];
+type Output<T> = Success<T> | Failure;
+interface Issue {
+  readonly message: string;
+}
+interface Success<T> {
+  readonly value: T;
+}
+interface Failure {
+  readonly issues: ReadonlyArray<Issue>;
+}
+interface Schema<T = unknown, TOutput = T> {
+  readonly "~standard": {
+    readonly validate: (value: unknown) => Awaitable<Output<TOutput>>;
+    readonly types?: {
+      readonly input: T;
+      readonly output: TOutput;
+    };
+  };
+}
+declare function isSuccess<T>(result: Output<T>): result is Success<T>;
+declare function isFailure<T>(result: Output<T>): result is Failure;
+declare function parseSchema<T extends Schema>(scope: Scope, schema: T, value: unknown): InferOutput<T>;
+//#endregion
 //#region src/server/index.d.ts
 type CookiePriority = (typeof cookiePriorities)[number];
 type CookieSameSite = (typeof cookieSameSites)[number];
@@ -123,7 +127,7 @@ type HttpMethod = (typeof httpMethods)[number];
 type Encoding = (typeof encodings)[number];
 type StatusCode = (typeof statusCodes)[number];
 type MimeType = (typeof mimeTypes)[keyof typeof mimeTypes];
-type Result = void | Response | Promise<void | Response>;
+type Result = Awaitable<void | Response>;
 interface CookieOptions {
   domain?: string;
   expires?: Date;
@@ -151,10 +155,8 @@ interface Route {
 interface Middleware {
   fetch: (scope: Scope, next?: () => Result) => Result;
 }
-interface Server {
+interface Server extends Route {
   router: Router<Route>;
-  middleware: Array<Middleware>;
-  fetch: (scope: Scope) => Result;
 }
 declare function defineRoute<T extends Route>(route: T): T;
 declare function defineMiddleware<T extends Middleware>(middleware: T): T;
@@ -204,8 +206,7 @@ declare const mimeTypes: Record<string, string>;
 //#endregion
 //#region src/app/index.d.ts
 type Environment = typeof CLIENT | typeof SERVER;
-type Virtual = (environment: Environment) => Awaitable<undefined | string>;
-type Content = () => Awaitable<string>;
+type Content = (environment?: Environment) => Awaitable<undefined | string>;
 interface Asset {
   name: string;
   type: string;
@@ -231,7 +232,7 @@ interface Config {
   variables: Record<string, unknown>;
   development: DevelopmentConfig;
   templates: Record<string, Content>;
-  virtuals: Record<string, Virtual>;
+  virtuals: Record<string, Content>;
   vite: UserConfig;
 }
 interface Module {
@@ -254,8 +255,8 @@ declare const CLOSE_HOOK: Descriptor<() => void>;
 declare function fetch<T>(scope: Scope, input: string | URL, options?: RequestInit): Promise<T>;
 //#endregion
 //#region src/middleware/index.d.ts
-declare function createStaticMiddleware<T>(resolve: (path: string | URL) => T | Promise<T>): {
+declare function createStaticMiddleware(resolve: (path: string | URL) => Awaitable<Blob>): {
   fetch(scope: Scope, next: (() => Result) | undefined): Promise<void | Response>;
 };
 //#endregion
-export { sendResponse as $, isFailure as $t, ServerContext as A, Node as At, invoke as B, ParameterNode as Bt, ResponseConfig as C, HookNode as Ct, SERVER_ROUTER_CONTEXT as D, Invoke as Dt, SERVER_CONTEXT as E, InferOutput as Et, defineMiddleware as F, OptionalParameterNode as Ft, parseCookiePair as G, Schema as Gt, isServer as H, Primitive as Ht, defineRoute as I, OptionalWildcardNode as It, sendForbidden as J, WILDCARD as Jt, sendBadRequest as K, Scope as Kt, encodings as L, Output as Lt, cookiePriorities as M, OPTIONAL_PARAMETER_MATCH as Mt, cookieSameSites as N, OPTIONAL_WILDCARD as Nt, STATES as O, Issue as Ot, createServer as P, OPTIONAL_WILDCARD_MATCH as Pt, sendRedirect as Q, defineHook as Qt, getState as R, PARAMETER as Rt, MimeType as S, HOOK_MATCH as St, Route as T, InferInput as Tt, mimeType as U, Router as Ut, isClient as V, PathNode as Vt, mimeTypes as W, RouterContext as Wt, sendNotFound as X, WildcardNode as Xt, sendNoContent as Y, WILDCARD_MATCH as Yt, sendOk as Z, defineContext as Zt, CookiePriority as _, Failure as _t, CLIENT as a, useCookies as at, HttpMethod as b, GroupNode as bt, Content as c, useQuery as ct, Module as d, useSetCookies as dt, mergeObjects as en, sendUnauthorized as et, SERVER as f, useUrl as ft, CookieOptions as g, Descriptor as gt, Virtual as h, Context as ht, Asset as i, useBody as it, StatusCode as j, OPTIONAL_PARAMETER as jt, Server as k, Mergeable as kt, DevelopmentConfig as l, useRouter as lt, Template as m, Awaitable as mt, fetch as n, setState as nt, CLOSE_HOOK as o, useHeaders as ot, Source as p, withQuery as pt, sendCreated as q, Success as qt, App as r, statusCodes as rt, Config as s, useParameters as st, createStaticMiddleware as t, parseSchema as tn, setCookie as tt, Environment as u, useServer as ut, CookieSameSite as v, GROUP as vt, Result as w, Hookable as wt, Middleware as x, HOOK as xt, Encoding as y, GROUP_MATCH as yt, httpMethods as z, PARAMETER_MATCH as zt };
+export { sendUnauthorized as $, WILDCARD as $t, StatusCode as A, Scope as At, isClient as B, Node as Bt, Result as C, Awaitable as Ct, STATES as D, Invoke as Dt, SERVER_ROUTER_CONTEXT as E, Hookable as Et, defineRoute as F, GROUP_MATCH as Ft, sendBadRequest as G, OptionalParameterNode as Gt, mimeType as H, OPTIONAL_PARAMETER_MATCH as Ht, encodings as I, GroupNode as It, sendNoContent as J, PARAMETER_MATCH as Jt, sendCreated as K, OptionalWildcardNode as Kt, getState as L, HOOK as Lt, cookieSameSites as M, defineHook as Mt, createServer as N, mergeObjects as Nt, Server as O, Mergeable as Ot, defineMiddleware as P, GROUP as Pt, sendResponse as Q, RouterContext as Qt, httpMethods as R, HOOK_MATCH as Rt, ResponseConfig as S, parseSchema as St, SERVER_CONTEXT as T, Descriptor as Tt, mimeTypes as U, OPTIONAL_WILDCARD as Ut, isServer as V, OPTIONAL_PARAMETER as Vt, parseCookiePair as W, OPTIONAL_WILDCARD_MATCH as Wt, sendOk as X, PathNode as Xt, sendNotFound as Y, ParameterNode as Yt, sendRedirect as Z, Router as Zt, CookieSameSite as _, Output as _t, CLIENT as a, useHeaders as at, Middleware as b, isFailure as bt, Content as c, useRouter as ct, Module as d, useUrl as dt, WILDCARD_MATCH as en, setCookie as et, SERVER as f, withQuery as ft, CookiePriority as g, Issue as gt, CookieOptions as h, InferOutput as ht, Asset as i, useCookies as it, cookiePriorities as j, defineContext as jt, ServerContext as k, Primitive as kt, DevelopmentConfig as l, useServer as lt, Template as m, InferInput as mt, fetch as n, statusCodes as nt, CLOSE_HOOK as o, useParameters as ot, Source as p, Failure as pt, sendForbidden as q, PARAMETER as qt, App as r, useBody as rt, Config as s, useQuery as st, createStaticMiddleware as t, WildcardNode as tn, setState as tt, Environment as u, useSetCookies as ut, Encoding as v, Schema as vt, Route as w, Context as wt, MimeType as x, isSuccess as xt, HttpMethod as y, Success as yt, invoke as z, HookNode as zt };

package/dist/index.d.mts

@@ -1,2 +1,2 @@
-import { $ as sendResponse, $t as isFailure, A as ServerContext, At as Node, B as invoke, Bt as ParameterNode, C as ResponseConfig, Ct as HookNode, D as SERVER_ROUTER_CONTEXT, Dt as Invoke, E as SERVER_CONTEXT, Et as InferOutput, F as defineMiddleware, Ft as OptionalParameterNode, G as parseCookiePair, Gt as Schema, H as isServer, Ht as Primitive, I as defineRoute, It as OptionalWildcardNode, J as sendForbidden, Jt as WILDCARD, K as sendBadRequest, Kt as Scope, L as encodings, Lt as Output, M as cookiePriorities, Mt as OPTIONAL_PARAMETER_MATCH, N as cookieSameSites, Nt as OPTIONAL_WILDCARD, O as STATES, Ot as Issue, P as createServer, Pt as OPTIONAL_WILDCARD_MATCH, Q as sendRedirect, Qt as defineHook, R as getState, Rt as PARAMETER, S as MimeType, St as HOOK_MATCH, T as Route, Tt as InferInput, U as mimeType, Ut as Router, V as isClient, Vt as PathNode, W as mimeTypes, Wt as RouterContext, X as sendNotFound, Xt as WildcardNode, Y as sendNoContent, Yt as WILDCARD_MATCH, Z as sendOk, Zt as defineContext, _ as CookiePriority, _t as Failure, a as CLIENT, at as useCookies, b as HttpMethod, bt as GroupNode, c as Content, ct as useQuery, d as Module, dt as useSetCookies, en as mergeObjects, et as sendUnauthorized, f as SERVER, ft as useUrl, g as CookieOptions, gt as Descriptor, h as Virtual, ht as Context, i as Asset, it as useBody, j as StatusCode, jt as OPTIONAL_PARAMETER, k as Server, kt as Mergeable, l as DevelopmentConfig, lt as useRouter, m as Template, mt as Awaitable, n as fetch, nt as setState, o as CLOSE_HOOK, ot as useHeaders, p as Source, pt as withQuery, q as sendCreated, qt as Success, r as App, rt as statusCodes, s as Config, st as useParameters, t as createStaticMiddleware, tn as parseSchema, tt as setCookie, u as Environment, ut as useServer, v as CookieSameSite, vt as GROUP, w as Result, wt as Hookable, x as Middleware, xt as HOOK, y as Encoding, yt as GROUP_MATCH, z as httpMethods, zt as PARAMETER_MATCH } from "./index-CZcqzWwl.mjs";
-export { App, Asset, Awaitable, CLIENT, CLOSE_HOOK, Config, Content, Context, CookieOptions, CookiePriority, CookieSameSite, Descriptor, DevelopmentConfig, Encoding, Environment, Failure, GROUP, GROUP_MATCH, GroupNode, HOOK, HOOK_MATCH, HookNode, Hookable, HttpMethod, InferInput, InferOutput, Invoke, Issue, Mergeable, Middleware, MimeType, Module, Node, OPTIONAL_PARAMETER, OPTIONAL_PARAMETER_MATCH, OPTIONAL_WILDCARD, OPTIONAL_WILDCARD_MATCH, OptionalParameterNode, OptionalWildcardNode, Output, PARAMETER, PARAMETER_MATCH, ParameterNode, PathNode, Primitive, ResponseConfig, Result, Route, Router, RouterContext, SERVER, SERVER_CONTEXT, SERVER_ROUTER_CONTEXT, STATES, Schema, Scope, Server, ServerContext, Source, StatusCode, Success, Template, Virtual, WILDCARD, WILDCARD_MATCH, WildcardNode, cookiePriorities, cookieSameSites, createServer, createStaticMiddleware, defineContext, defineHook, defineMiddleware, defineRoute, encodings, fetch, getState, httpMethods, invoke, isClient, isFailure, isServer, mergeObjects, mimeType, mimeTypes, parseCookiePair, parseSchema, sendBadRequest, sendCreated, sendForbidden, sendNoContent, sendNotFound, sendOk, sendRedirect, sendResponse, sendUnauthorized, setCookie, setState, statusCodes, useBody, useCookies, useHeaders, useParameters, useQuery, useRouter, useServer, useSetCookies, useUrl, withQuery };
+import { $ as sendUnauthorized, $t as WILDCARD, A as StatusCode, At as Scope, B as isClient, Bt as Node, C as Result, Ct as Awaitable, D as STATES, Dt as Invoke, E as SERVER_ROUTER_CONTEXT, Et as Hookable, F as defineRoute, Ft as GROUP_MATCH, G as sendBadRequest, Gt as OptionalParameterNode, H as mimeType, Ht as OPTIONAL_PARAMETER_MATCH, I as encodings, It as GroupNode, J as sendNoContent, Jt as PARAMETER_MATCH, K as sendCreated, Kt as OptionalWildcardNode, L as getState, Lt as HOOK, M as cookieSameSites, Mt as defineHook, N as createServer, Nt as mergeObjects, O as Server, Ot as Mergeable, P as defineMiddleware, Pt as GROUP, Q as sendResponse, Qt as RouterContext, R as httpMethods, Rt as HOOK_MATCH, S as ResponseConfig, St as parseSchema, T as SERVER_CONTEXT, Tt as Descriptor, U as mimeTypes, Ut as OPTIONAL_WILDCARD, V as isServer, Vt as OPTIONAL_PARAMETER, W as parseCookiePair, Wt as OPTIONAL_WILDCARD_MATCH, X as sendOk, Xt as PathNode, Y as sendNotFound, Yt as ParameterNode, Z as sendRedirect, Zt as Router, _ as CookieSameSite, _t as Output, a as CLIENT, at as useHeaders, b as Middleware, bt as isFailure, c as Content, ct as useRouter, d as Module, dt as useUrl, en as WILDCARD_MATCH, et as setCookie, f as SERVER, ft as withQuery, g as CookiePriority, gt as Issue, h as CookieOptions, ht as InferOutput, i as Asset, it as useCookies, j as cookiePriorities, jt as defineContext, k as ServerContext, kt as Primitive, l as DevelopmentConfig, lt as useServer, m as Template, mt as InferInput, n as fetch, nt as statusCodes, o as CLOSE_HOOK, ot as useParameters, p as Source, pt as Failure, q as sendForbidden, qt as PARAMETER, r as App, rt as useBody, s as Config, st as useQuery, t as createStaticMiddleware, tn as WildcardNode, tt as setState, u as Environment, ut as useSetCookies, v as Encoding, vt as Schema, w as Route, wt as Context, x as MimeType, xt as isSuccess, y as HttpMethod, yt as Success, z as invoke, zt as HookNode } from "./index-B4nGVcLE.mjs";
+export { App, Asset, Awaitable, CLIENT, CLOSE_HOOK, Config, Content, Context, CookieOptions, CookiePriority, CookieSameSite, Descriptor, DevelopmentConfig, Encoding, Environment, Failure, GROUP, GROUP_MATCH, GroupNode, HOOK, HOOK_MATCH, HookNode, Hookable, HttpMethod, InferInput, InferOutput, Invoke, Issue, Mergeable, Middleware, MimeType, Module, Node, OPTIONAL_PARAMETER, OPTIONAL_PARAMETER_MATCH, OPTIONAL_WILDCARD, OPTIONAL_WILDCARD_MATCH, OptionalParameterNode, OptionalWildcardNode, Output, PARAMETER, PARAMETER_MATCH, ParameterNode, PathNode, Primitive, ResponseConfig, Result, Route, Router, RouterContext, SERVER, SERVER_CONTEXT, SERVER_ROUTER_CONTEXT, STATES, Schema, Scope, Server, ServerContext, Source, StatusCode, Success, Template, WILDCARD, WILDCARD_MATCH, WildcardNode, cookiePriorities, cookieSameSites, createServer, createStaticMiddleware, defineContext, defineHook, defineMiddleware, defineRoute, encodings, fetch, getState, httpMethods, invoke, isClient, isFailure, isServer, isSuccess, mergeObjects, mimeType, mimeTypes, parseCookiePair, parseSchema, sendBadRequest, sendCreated, sendForbidden, sendNoContent, sendNotFound, sendOk, sendRedirect, sendResponse, sendUnauthorized, setCookie, setState, statusCodes, useBody, useCookies, useHeaders, useParameters, useQuery, useRouter, useServer, useSetCookies, useUrl, withQuery };

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { $ as statusCodes, A as createServer, B as mimeTypes, C as mergeObjects, D as STATES, E as SERVER_ROUTER_CONTEXT, F as httpMethods, G as sendNoContent, H as sendBadRequest, I as invoke, J as sendRedirect, K as sendNotFound, L as isClient, M as defineRoute, N as encodings, O as cookiePriorities, P as getState, Q as setState, R as isServer, S as isFailure, T as SERVER_CONTEXT, U as sendCreated, V as parseCookiePair, W as sendForbidden, X as sendUnauthorized, Y as sendResponse, Z as setCookie, _ as Scope, a as GROUP, at as useRouter, b as defineContext, c as HOOK_MATCH, ct as useUrl, d as OPTIONAL_PARAMETER_MATCH, et as useBody, f as OPTIONAL_WILDCARD, g as Router, h as PARAMETER_MATCH, i as SERVER, it as useQuery, j as defineMiddleware, k as cookieSameSites, l as Hookable, lt as withQuery, m as PARAMETER, n as CLIENT, nt as useHeaders, o as GROUP_MATCH, ot as useServer, p as OPTIONAL_WILDCARD_MATCH, q as sendOk, r as CLOSE_HOOK, rt as useParameters, s as HOOK, st as useSetCookies, t as App, tt as useCookies, u as OPTIONAL_PARAMETER, v as WILDCARD, w as parseSchema, x as defineHook, y as WILDCARD_MATCH, z as mimeType } from "./app-VHSJTEkd.mjs";
+import { $ as Router, A as useBody, B as isFailure, C as sendOk, D as setCookie, E as sendUnauthorized, F as useRouter, G as HOOK, H as parseSchema, I as useServer, J as OPTIONAL_PARAMETER_MATCH, K as HOOK_MATCH, L as useSetCookies, M as useHeaders, N as useParameters, O as setState, P as useQuery, Q as PARAMETER_MATCH, R as useUrl, S as sendNotFound, T as sendResponse, U as GROUP, V as isSuccess, W as GROUP_MATCH, X as OPTIONAL_WILDCARD_MATCH, Y as OPTIONAL_WILDCARD, Z as PARAMETER, _ as parseCookiePair, a as cookieSameSites, at as SERVER, b as sendForbidden, c as defineRoute, ct as defineContext, d as httpMethods, et as WILDCARD, f as invoke, g as mimeTypes, h as mimeType, i as cookiePriorities, it as CLOSE_HOOK, j as useCookies, k as statusCodes, l as encodings, lt as defineHook, m as isServer, n as SERVER_ROUTER_CONTEXT, nt as App, o as createServer, ot as Hookable, p as isClient, q as OPTIONAL_PARAMETER, r as STATES, rt as CLIENT, s as defineMiddleware, st as Scope, t as SERVER_CONTEXT, tt as WILDCARD_MATCH, u as getState, ut as mergeObjects, v as sendBadRequest, w as sendRedirect, x as sendNoContent, y as sendCreated, z as withQuery } from "./server-BKOK-LN2.mjs";
 import assets from "#assets";
 //#region src/client/index.ts
 async function fetch(scope, input, options) {
@@ -52,4 +52,4 @@ function createStaticMiddleware(resolve) {
 	} });
 }
 //#endregion
-export { App, CLIENT, CLOSE_HOOK, GROUP, GROUP_MATCH, HOOK, HOOK_MATCH, Hookable, OPTIONAL_PARAMETER, OPTIONAL_PARAMETER_MATCH, OPTIONAL_WILDCARD, OPTIONAL_WILDCARD_MATCH, PARAMETER, PARAMETER_MATCH, Router, SERVER, SERVER_CONTEXT, SERVER_ROUTER_CONTEXT, STATES, Scope, WILDCARD, WILDCARD_MATCH, cookiePriorities, cookieSameSites, createServer, createStaticMiddleware, defineContext, defineHook, defineMiddleware, defineRoute, encodings, fetch, getState, httpMethods, invoke, isClient, isFailure, isServer, mergeObjects, mimeType, mimeTypes, parseCookiePair, parseSchema, sendBadRequest, sendCreated, sendForbidden, sendNoContent, sendNotFound, sendOk, sendRedirect, sendResponse, sendUnauthorized, setCookie, setState, statusCodes, useBody, useCookies, useHeaders, useParameters, useQuery, useRouter, useServer, useSetCookies, useUrl, withQuery };
+export { App, CLIENT, CLOSE_HOOK, GROUP, GROUP_MATCH, HOOK, HOOK_MATCH, Hookable, OPTIONAL_PARAMETER, OPTIONAL_PARAMETER_MATCH, OPTIONAL_WILDCARD, OPTIONAL_WILDCARD_MATCH, PARAMETER, PARAMETER_MATCH, Router, SERVER, SERVER_CONTEXT, SERVER_ROUTER_CONTEXT, STATES, Scope, WILDCARD, WILDCARD_MATCH, cookiePriorities, cookieSameSites, createServer, createStaticMiddleware, defineContext, defineHook, defineMiddleware, defineRoute, encodings, fetch, getState, httpMethods, invoke, isClient, isFailure, isServer, isSuccess, mergeObjects, mimeType, mimeTypes, parseCookiePair, parseSchema, sendBadRequest, sendCreated, sendForbidden, sendNoContent, sendNotFound, sendOk, sendRedirect, sendResponse, sendUnauthorized, setCookie, setState, statusCodes, useBody, useCookies, useHeaders, useParameters, useQuery, useRouter, useServer, useSetCookies, useUrl, withQuery };

package/dist/kit/index.d.mts

@@ -1,14 +1,13 @@
-import { c as Content, h as Virtual, r as App } from "../index-CZcqzWwl.mjs";
+import { c as Content, r as App } from "../index-B4nGVcLE.mjs";
 
 //#region src/kit/index.d.ts
 declare function useKit(source: string | URL): {
   fromModule(...paths: Array<string>): string;
 };
 declare function addTemplate(app: App, name: string, content: Content): void;
-declare function addVirtual(app: App, name: string, virtual: Virtual): void;
+declare function addVirtual(app: App, name: string, content: Content): void;
 declare function addRoutes(app: App, path: string): void;
-declare function addMiddleware(app: App, path: string): void;
 declare function addTypes(app: App, name: string, content: Content): void;
 declare function resolvePaths(path: string | Array<string>, cwd?: string): string[];
 //#endregion
-export { addMiddleware, addRoutes, addTemplate, addTypes, addVirtual, resolvePaths, useKit };
+export { addRoutes, addTemplate, addTypes, addVirtual, resolvePaths, useKit };

package/dist/kit/index.mjs

@@ -12,15 +12,12 @@ function useKit(source) {
 function addTemplate(app, name, content) {
 	app.config.templates[name] = content;
 }
-function addVirtual(app, name, virtual) {
-	app.config.virtuals["#" + name] = virtual;
+function addVirtual(app, name, content) {
+	app.config.virtuals[name] = content;
 }
 function addRoutes(app, path) {
 	app.config.sources.routes?.entries.push(path);
 }
-function addMiddleware(app, path) {
-	app.config.sources.middleware?.entries.push(path);
-}
 function addTypes(app, name, content) {
 	addTemplate(app, `types/${name}.d.ts`, content);
 }
@@ -49,4 +46,4 @@ function resolvePaths(path, cwd) {
 	return Array.from(entries);
 }
 //#endregion
-export { addMiddleware, addRoutes, addTemplate, addTypes, addVirtual, resolvePaths, useKit };
+export { addRoutes, addTemplate, addTypes, addVirtual, resolvePaths, useKit };

package/dist/{package-DiFpQQya.mjs → package-BezU2VEq.mjs}

@@ -1,5 +1,5 @@
 //#region package.json
 var name = "revojs";
-var version = "0.1.51";
+var version = "0.1.52";
 //#endregion
 export { version as n, name as t };