acrylblends 0.4.0 → 0.5.0

package/lib/types-CHesD1KG.d.ts

@@ -0,0 +1,195 @@
+import { $ as Acryl, J as Schema, K as ResponseFormat, N as KnownResponseFormat, g as Endpoint, x as ExtractSchema } from "./context-Bm7rI-oK.js";
+import { i as METHOD_NAME_ALL_LOWERCASE, n as METHODS } from "./router-CvUxUTOq.js";
+import { c as StatusCode, l as SuccessStatusCode } from "./http-status-DaAwGAFL.js";
+import { s as HasRequiredKeys } from "./types-CwrQjlaM.js";
+import { t as Acryl$1 } from "./app-CmAYW1Al.js";
+
+//#region ../../plugins/acryl-router/src/core/client/types.d.ts
+/**
+ * Type representing the '$all' method name
+ */
+type MethodNameAll = `$${typeof METHOD_NAME_ALL_LOWERCASE}`;
+/**
+ * Type representing all standard HTTP methods prefixed with '$'
+ * e.g., '$get' | '$post' | '$put' | '$delete' | '$options' | '$patch' | '$query'
+ */
+type StandardMethods = `$${(typeof METHODS)[number]}`;
+/**
+ * Expands '$all' into all standard HTTP methods.
+ * If the schema contains '$all', it creates a type where all standard HTTP methods
+ * point to the same endpoint definition as '$all', while removing '$all' itself.
+ */
+type ExpandAllMethod<S> = MethodNameAll extends keyof S ? { [M in StandardMethods]: S[MethodNameAll] } & Omit<S, MethodNameAll> : S;
+type AcrylRequest = (typeof Acryl$1.prototype)['request'];
+type BuildSearchParamsFn = (query: Record<string, string | string[]>) => URLSearchParams;
+type ClientRequestOptions<T = unknown> = {
+  fetch?: typeof fetch | AcrylRequest;
+  webSocket?: (...args: ConstructorParameters<typeof WebSocket>) => WebSocket;
+  /**
+   * Standard `RequestInit`, caution that this take highest priority
+   * and could be used to overwrite things that Acryl sets for you, like `body | method | headers`.
+   *
+   * If you want to add some headers, use in `headers` instead of `init`
+   */
+  init?: RequestInit;
+  /**
+   * Custom function to serialize query parameters into URLSearchParams.
+   * By default, arrays are serialized as multiple parameters with the same key (e.g., `key=a&key=b`).
+   * You can provide a custom function to change this behavior, for example to use bracket notation (e.g., `key[]=a&key[]=b`).
+   *
+   * @example
+   * ```ts
+   * const client = hc('http://localhost', {
+   *   buildSearchParams: (query) => {
+   *     return new URLSearchParams(qs.stringify(query))
+   *   }
+   * })
+   * ```
+   */
+  buildSearchParams?: BuildSearchParamsFn;
+} & (keyof T extends never ? {
+  headers?: Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>);
+} : {
+  headers: T | (() => T | Promise<T>);
+});
+type ClientRequest<Prefix extends string, Path extends string, S extends Schema> = { [M in keyof ExpandAllMethod<S>]: ExpandAllMethod<S>[M] extends Endpoint & {
+  input: infer R;
+} ? R extends object ? HasRequiredKeys<R> extends true ? (args: R, options?: ClientRequestOptions) => Promise<ClientResponseOfEndpoint<ExpandAllMethod<S>[M]>> : (args?: R, options?: ClientRequestOptions) => Promise<ClientResponseOfEndpoint<ExpandAllMethod<S>[M]>> : never : never } & {
+  $url: <const Arg extends (S[keyof S] extends {
+    input: infer R;
+  } ? R extends {
+    param: infer P;
+  } ? R extends {
+    query: infer Q;
+  } ? {
+    param: P;
+    query: Q;
+  } : {
+    param: P;
+  } : R extends {
+    query: infer Q;
+  } ? {
+    query: Q;
+  } : {} : {}) | undefined = undefined>(arg?: Arg) => AcrylURL<Prefix, Path, Arg>;
+  $path: <const Arg extends (S[keyof S] extends {
+    input: infer R;
+  } ? R extends {
+    param: infer P;
+  } ? R extends {
+    query: infer Q;
+  } ? {
+    param: P;
+    query: Q;
+  } : {
+    param: P;
+  } : R extends {
+    query: infer Q;
+  } ? {
+    query: Q;
+  } : {} : {}) | undefined = undefined>(arg?: Arg) => BuildPath<Path, Arg>;
+} & (S['$get'] extends {
+  outputFormat: 'ws';
+} ? S['$get'] extends {
+  input: infer I;
+} ? {
+  $ws: (args?: I) => WebSocket;
+} : {} : {});
+type ClientResponseOfEndpoint<T extends Endpoint = Endpoint> = T extends {
+  output: infer O;
+  outputFormat: infer F;
+  status: infer S;
+} ? ClientResponse<O, S extends number ? S : never, F extends ResponseFormat ? F : never> : never;
+interface ClientResponse<T, U extends number = StatusCode, F extends ResponseFormat = ResponseFormat> {
+  readonly body: ReadableStream | null;
+  readonly bodyUsed: boolean;
+  ok: U extends SuccessStatusCode ? true : U extends Exclude<StatusCode, SuccessStatusCode> ? false : boolean;
+  redirected: boolean;
+  status: U;
+  statusText: string;
+  type: 'basic' | 'cors' | 'default' | 'error' | 'opaque' | 'opaqueredirect';
+  headers: Headers;
+  url: string;
+  redirect(url: string, status: number): Response;
+  clone(): Response;
+  bytes(): Promise<Uint8Array<ArrayBuffer>>;
+  json(): F extends 'text' ? Promise<never> : F extends 'json' ? Promise<T> : Promise<unknown>;
+  text(): F extends 'text' ? (T extends string ? Promise<T> : Promise<never>) : Promise<string>;
+  blob(): Promise<Blob>;
+  formData(): Promise<FormData>;
+  arrayBuffer(): Promise<ArrayBuffer>;
+}
+type BuildSearch<Arg, Key extends 'query'> = Arg extends { [K in Key]: infer Query } ? IsEmptyObject<Query> extends true ? '' : `?${string}` : '';
+type BuildPathname<P extends string, Arg> = Arg extends {
+  param: infer Param;
+} ? `${ApplyParam<TrimStartSlash<P>, Param>}` : `/${TrimStartSlash<P>}`;
+type BuildPath<P extends string, Arg> = `${BuildPathname<P, Arg>}${BuildSearch<Arg, 'query'>}`;
+type BuildTypedURL<Protocol extends string, Host extends string, Port extends string, P extends string, Arg> = TypedURL<`${Protocol}:`, Host, Port, BuildPathname<P, Arg>, BuildSearch<Arg, 'query'>>;
+type AcrylURL<Prefix extends string, Path extends string, Arg> = IsLiteral<Prefix> extends true ? TrimEndSlash<Prefix> extends `${infer Protocol}://${infer Rest}` ? Rest extends `${infer Hostname}/${infer P}` ? ParseHostName<Hostname> extends [infer Host extends string, infer Port extends string] ? BuildTypedURL<Protocol, Host, Port, P, Arg> : never : ParseHostName<Rest> extends [infer Host extends string, infer Port extends string] ? BuildTypedURL<Protocol, Host, Port, Path, Arg> : never : URL : URL;
+type ParseHostName<T extends string> = T extends `${infer Host}:${infer Port}` ? [Host, Port] : [T, ''];
+type TrimStartSlash<T extends string> = T extends `/${infer R}` ? TrimStartSlash<R> : T;
+type TrimEndSlash<T extends string> = T extends `${infer R}/` ? TrimEndSlash<R> : T;
+type IsLiteral<T extends string> = [T] extends [never] ? false : string extends T ? false : true;
+type ApplyParam<Path extends string, P, Result extends string = ''> = Path extends `${infer Head}/${infer Rest}` ? Head extends `:${infer Param}` ? P extends Record<Param, infer Value extends string> ? IsLiteral<Value> extends true ? ApplyParam<Rest, P, `${Result}/${Value & string}`> : ApplyParam<Rest, P, `${Result}/${Head}`> : ApplyParam<Rest, P, `${Result}/${Head}`> : ApplyParam<Rest, P, `${Result}/${Head}`> : Path extends `:${infer Param}` ? P extends Record<Param, infer Value extends string> ? IsLiteral<Value> extends true ? `${Result}/${Value & string}` : `${Result}/${Path}` : `${Result}/${Path}` : `${Result}/${Path}`;
+type IsEmptyObject<T> = keyof T extends never ? true : false;
+interface TypedURL<Protocol extends string, Hostname extends string, Port extends string, Pathname extends string, Search extends string> extends URL {
+  protocol: Protocol;
+  hostname: Hostname;
+  port: Port;
+  host: Port extends '' ? Hostname : `${Hostname}:${Port}`;
+  origin: `${Protocol}//${Hostname}${Port extends '' ? '' : `:${Port}`}`;
+  pathname: Pathname;
+  search: Search;
+  href: `${Protocol}//${Hostname}${Port extends '' ? '' : `:${Port}`}${Pathname}${Search}`;
+}
+interface Response extends ClientResponse<unknown> {}
+type Fetch<T> = (args?: InferRequestType<T>, opt?: ClientRequestOptions) => Promise<ClientResponseOfEndpoint<InferEndpointType<T>>>;
+type InferEndpointType<T> = T extends ((args: infer R, options: any | undefined) => Promise<infer U>) ? U extends ClientResponse<infer O, infer S, infer F> ? {
+  input: NonNullable<R>;
+  output: O;
+  outputFormat: F;
+  status: S;
+} extends Endpoint ? {
+  input: NonNullable<R>;
+  output: O;
+  outputFormat: F;
+  status: S;
+} : never : never : never;
+type InferResponseType<T, U extends StatusCode = StatusCode> = InferResponseTypeFromEndpoint<InferEndpointType<T>, U>;
+type InferResponseTypeFromEndpoint<T extends Endpoint, U extends StatusCode> = T extends {
+  output: infer O;
+  status: infer S;
+} ? S extends U ? O : never : never;
+type InferRequestType<T> = T extends ((args: infer R, options: any | undefined) => Promise<ClientResponse<unknown>>) ? NonNullable<R> : never;
+/**
+ * Filter a ClientResponse type so it only includes responses of specific status codes.
+ */
+type FilterClientResponseByStatusCode<T extends ClientResponse<any, any, any>, U extends number = StatusCode> = T extends ClientResponse<infer RT, infer RC, infer RF> ? RC extends U ? ClientResponse<RT, RC, RF> : never : never;
+type PathToChain<Prefix extends string, Path extends string, E extends Schema, Original extends string = Path> = Path extends `/${infer P}` ? PathToChain<Prefix, P, E, Path> : Path extends `${infer P}/${infer R}` ? { [K in P]: PathToChain<Prefix, R, E, Original> } : { [K in Path extends '' ? 'index' : Path]: ClientRequest<Prefix, Original, E extends Record<string, unknown> ? E[Original] : never> };
+type Client<T, Prefix extends string> = T extends Acryl<any, infer S, any> ? S extends Record<infer K, Schema> ? K extends string ? PathToChain<Prefix, K, S> : never : never : never;
+type GlobalResponseDefinition = { [S in StatusCode]?: { [F in KnownResponseFormat]?: unknown } };
+type ToEndpoints<Def extends GlobalResponseDefinition, R> = { [S in keyof Def & StatusCode]: { [F in keyof Def[S] & KnownResponseFormat]: Omit<R, 'output' | 'status' | 'outputFormat'> & {
+  output: Def[S][F];
+  status: S;
+  outputFormat: F;
+} }[keyof Def[S] & KnownResponseFormat] }[keyof Def & StatusCode];
+type ModRoute<R, Def extends GlobalResponseDefinition> = R extends Endpoint ? R | ToEndpoints<Def, R> : R;
+type ModSchema<D, Def extends GlobalResponseDefinition> = { [K in keyof D]: { [M in keyof D[K]]: ModRoute<D[K][M], Def> } };
+type ApplyGlobalResponse<App, Def extends GlobalResponseDefinition> = App extends Acryl<infer E, infer _ extends Schema, infer B> ? ModSchema<ExtractSchema<App>, Def> extends infer S extends Schema ? Acryl$1<E, S, B> : never : never;
+type PickRoute<R, U extends StatusCode> = R extends Endpoint ? R extends {
+  status: U;
+} ? R : never : R;
+type PickSchema<D, U extends StatusCode> = { [K in keyof D]: { [M in keyof D[K]]: PickRoute<D[K][M], U> } };
+/**
+ * Keep only specific status code responses from all routes of an app.
+ * Useful when error responses are handled centrally (e.g., via custom fetch)
+ * and you want the client to only expose success response types.
+ *
+ * @example
+ * ```ts
+ * type AppSuccessOnly = PickResponseByStatusCode<typeof app, 200>
+ * const client = hc<AppSuccessOnly>('http://localhost')
+ * ```
+ */
+type PickResponseByStatusCode<App, U extends StatusCode> = App extends Acryl<infer E, infer _ extends Schema, infer B> ? PickSchema<ExtractSchema<App>, U> extends infer S extends Schema ? Acryl$1<E, S, B> : never : never;
+//#endregion
+export { ClientResponse as a, InferRequestType as c, ClientRequestOptions as i, InferResponseType as l, Client as n, Fetch as o, ClientRequest as r, FilterClientResponseByStatusCode as s, ApplyGlobalResponse as t, PickResponseByStatusCode as u };

package/lib/types-CwrQjlaM.d.ts

@@ -0,0 +1,105 @@
+//#region ../../plugins/acryl-router/src/core/utils/types.d.ts
+/**
+ * @module
+ * Types utility.
+ */
+type Expect<T extends true> = T;
+type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;
+type NotEqual<X, Y> = true extends Equal<X, Y> ? false : true;
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+type RemoveBlankRecord<T> = T extends Record<infer K, unknown> ? (K extends string ? T : never) : never;
+type IfAnyThenEmptyObject<T> = 0 extends 1 & T ? {} : T;
+type JSONPrimitive = string | boolean | number | null;
+type JSONArray = (JSONPrimitive | JSONObject | JSONArray)[];
+type JSONObject = {
+  [key: string]: JSONPrimitive | JSONArray | JSONObject | object | InvalidJSONValue;
+};
+type InvalidJSONValue = undefined | symbol | ((...args: unknown[]) => unknown);
+type InvalidToNull<T> = T extends InvalidJSONValue ? null : T;
+type IsInvalid<T> = T extends InvalidJSONValue ? true : false;
+/**
+ * symbol keys are omitted through `JSON.stringify`
+ */
+type OmitSymbolKeys<T> = { [K in keyof T as K extends symbol ? never : K]: T[K] };
+type JSONValue = JSONObject | JSONArray | JSONPrimitive;
+/**
+ * Convert a type to a JSON-compatible type.
+ *
+ * Non-JSON values such as `Date` implement `.toJSON()`,
+ * so they can be transformed to a value assignable to `JSONObject`
+ *
+ * `JSON.stringify()` throws a `TypeError` when it encounters a `bigint` value,
+ * unless a custom `replacer` function or `.toJSON()` method is provided.
+ *
+ * This behavior can be controlled by the `TError` generic type parameter,
+ * which defaults to `bigint | ReadonlyArray<bigint>`.
+ * You can set it to `never` to disable this check.
+ */
+type JSONParsed<T, TError = bigint | ReadonlyArray<bigint>> = T extends {
+  toJSON(): infer J;
+} ? (() => J) extends (() => JSONPrimitive) ? J : (() => J) extends (() => {
+  toJSON(): unknown;
+}) ? {} : JSONParsed<J, TError> : T extends JSONPrimitive ? T : T extends InvalidJSONValue ? never : T extends ReadonlyArray<unknown> ? { [K in keyof T]: JSONParsed<InvalidToNull<T[K]>, TError> } extends infer A ? A extends ReadonlyArray<unknown> ? A : JSONParsed<InvalidToNull<T[number]>, TError>[] : never : T extends Set<unknown> | Map<unknown, unknown> | Record<string, never> ? {} : T extends object ? T[keyof T] extends TError ? never : { [K in keyof OmitSymbolKeys<T> as IsInvalid<T[K]> extends true ? never : K]: boolean extends IsInvalid<T[K]> ? JSONParsed<T[K], TError> | undefined : JSONParsed<T[K], TError> } : T extends unknown ? T extends TError ? never : JSONValue : never;
+/**
+ * Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
+ * @copyright from sindresorhus/type-fest
+ */
+type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
+/**
+ * A simple extension of Simplify that will deeply traverse array elements.
+ */
+type SimplifyDeepArray<T> = T extends any[] ? { [E in keyof T]: SimplifyDeepArray<T[E]> } : Simplify<T>;
+type InterfaceToType<T> = T extends Function ? T : { [K in keyof T]: InterfaceToType<T[K]> };
+type RequiredKeysOf<BaseType extends object> = Exclude<{ [Key in keyof BaseType]: BaseType extends Record<Key, BaseType[Key]> ? Key : never }[keyof BaseType], undefined>;
+type HasRequiredKeys<BaseType extends object> = RequiredKeysOf<BaseType> extends never ? false : true;
+type IsAny<T> = boolean extends (T extends never ? true : false) ? true : false;
+/**
+ * String literal types with auto-completion
+ * @see https://github.com/Microsoft/TypeScript/issues/29729
+ */
+type StringLiteralUnion<T> = T | (string & Record<never, never>);
+/** Bytes a Web Crypto call accepts; declared here so the public types do not need the DOM library. */
+type BufferSource = ArrayBufferView<ArrayBuffer> | ArrayBuffer;
+/** A Web Crypto key, named from the runtime's own `crypto` so the public types do not need the DOM library. */
+type CryptoKey = Awaited<ReturnType<typeof crypto.subtle.importKey>>;
+/** How a WebSocket hands binary data to `onmessage`; declared here so the public types do not need the DOM library. */
+type BinaryType = 'arraybuffer' | 'blob';
+/** The members of a WebSocket `message` event the helpers hand out (the Web `MessageEvent`, whose Node global is not generic); declared here so the public types do not need the DOM library. */
+interface MessageEvent<T = unknown> extends Event {
+  readonly data: T;
+  readonly lastEventId: string;
+  readonly origin: string;
+}
+/** The members of a WebSocket `close` event the helpers hand out (the Web `CloseEvent`, which Node has no global type for); declared here so the public types do not need the DOM library. */
+interface CloseEvent extends Event {
+  readonly code: number;
+  readonly reason: string;
+  readonly wasClean: boolean;
+}
+/** A JSON Web Key (RFC 7517), the same members as the Web Crypto dictionary; declared here so the public types do not need the DOM library. */
+interface JsonWebKey {
+  alg?: string;
+  crv?: string;
+  d?: string;
+  dp?: string;
+  dq?: string;
+  e?: string;
+  ext?: boolean;
+  k?: string;
+  key_ops?: string[];
+  kty?: string;
+  n?: string;
+  oth?: {
+    d?: string;
+    r?: string;
+    t?: string;
+  }[];
+  p?: string;
+  q?: string;
+  qi?: string;
+  use?: string;
+  x?: string;
+  y?: string;
+}
+//#endregion
+export { SimplifyDeepArray as C, Simplify as S, UnionToIntersection as T, JsonWebKey as _, Equal as a, RemoveBlankRecord as b, IfAnyThenEmptyObject as c, IsAny as d, JSONArray as f, JSONValue as g, JSONPrimitive as h, CryptoKey as i, InterfaceToType as l, JSONParsed as m, BufferSource as n, Expect as o, JSONObject as p, CloseEvent as r, HasRequiredKeys as s, BinaryType as t, InvalidJSONValue as u, MessageEvent as v, StringLiteralUnion as w, RequiredKeysOf as x, NotEqual as y };

package/lib/types-DR95J00T.d.ts

@@ -0,0 +1,29 @@
+//#region ../../plugins/acryl-router/src/core/utils/jwt/types.d.ts
+/**
+ * JWT Payload
+ */
+type JWTPayload = {
+  [key: string]: unknown;
+  /**
+   * The token is checked to ensure it has not expired.
+   */
+  exp?: number;
+  /**
+   * The token is checked to ensure it is not being used before a specified time.
+   */
+  nbf?: number;
+  /**
+   * The token is checked to ensure it is not issued in the future.
+   */
+  iat?: number;
+  /**
+   * The token is checked to ensure it has been issued by a trusted issuer.
+   */
+  iss?: string;
+  /**
+   * The token is checked to ensure it is intended for a specific audience.
+   */
+  aud?: string | string[];
+};
+//#endregion
+export { JWTPayload as t };

package/lib/types.d.ts

@@ -0,0 +1,2 @@
+import { A as Input, B as NotFoundResponse, C as FetchEventLike, D as Handler, E as HTTPResponseError, F as MergeSchemaPath, G as RemoveQuestion, H as ParamKeyToRecord, I as MiddlewareHandler, J as Schema, K as ResponseFormat, L as MiddlewareHandlerInterface, M as IntersectNonAnyTypes, N as KnownResponseFormat, O as HandlerInterface, P as MergePath, Q as Variables, R as Next, S as ExtractSchemaForStatusCode, T as H, U as ParamKeys, V as OnHandlerInterface, W as ParsedFormValue, X as TypedResponse, Y as ToSchema, Z as ValidationTargets, _ as Env, b as ExtractInput, d as AddParam, f as Bindings, g as Endpoint, h as BlankSchema, j as InputToDataByTarget, k as HandlerResponse, m as BlankInput, p as BlankEnv, q as RouterRoute, v as ErrorHandler, w as FormValue, x as ExtractSchema, y as ExtractHandlerResponse, z as NotFoundHandler } from "./context-Bm7rI-oK.js";
+export { AddParam, Bindings, BlankEnv, BlankInput, BlankSchema, Endpoint, Env, ErrorHandler, ExtractHandlerResponse, ExtractInput, ExtractSchema, ExtractSchemaForStatusCode, FetchEventLike, FormValue, H, HTTPResponseError, Handler, HandlerInterface, HandlerResponse, Input, InputToDataByTarget, IntersectNonAnyTypes, KnownResponseFormat, MergePath, MergeSchemaPath, MiddlewareHandler, MiddlewareHandlerInterface, Next, NotFoundHandler, NotFoundResponse, OnHandlerInterface, ParamKeyToRecord, ParamKeys, ParsedFormValue, RemoveQuestion, ResponseFormat, RouterRoute, Schema, ToSchema, TypedResponse, ValidationTargets, Variables };

package/lib/types.js

@@ -0,0 +1,4 @@
+//#region ../../plugins/acryl-router/src/core/types.ts
+var FetchEventLike = class {};
+//#endregion
+export { FetchEventLike };

package/lib/utils/accept.d.ts

@@ -0,0 +1,9 @@
+//#region ../../plugins/acryl-router/src/core/utils/accept.d.ts
+interface Accept {
+  type: string;
+  params: Record<string, string>;
+  q: number;
+}
+declare const parseAccept: (acceptHeader: string) => Accept[];
+//#endregion
+export { Accept, parseAccept };

package/lib/utils/accept.js

@@ -0,0 +1,193 @@
+//#region ../../plugins/acryl-router/src/core/utils/accept.ts
+const isWhitespace = (char) => char === 32 || char === 9 || char === 10 || char === 13;
+const consumeWhitespace = (acceptHeader, startIndex) => {
+	while (startIndex < acceptHeader.length) {
+		if (!isWhitespace(acceptHeader.charCodeAt(startIndex))) break;
+		startIndex++;
+	}
+	return startIndex;
+};
+const ignoreTrailingWhitespace = (acceptHeader, startIndex) => {
+	while (startIndex > 0) {
+		if (!isWhitespace(acceptHeader.charCodeAt(startIndex - 1))) break;
+		startIndex--;
+	}
+	return startIndex;
+};
+const skipInvalidParam = (acceptHeader, startIndex) => {
+	while (startIndex < acceptHeader.length) {
+		const char = acceptHeader.charCodeAt(startIndex);
+		if (char === 59) return [startIndex + 1, true];
+		if (char === 44) return [startIndex + 1, false];
+		startIndex++;
+	}
+	return [startIndex, false];
+};
+const skipInvalidAcceptValue = (acceptHeader, startIndex) => {
+	let i = startIndex;
+	let inQuotes = false;
+	while (i < acceptHeader.length) {
+		const char = acceptHeader.charCodeAt(i);
+		if (inQuotes && char === 92) i++;
+		else if (char === 34) inQuotes = !inQuotes;
+		else if (!inQuotes && char === 44) return i + 1;
+		i++;
+	}
+	return i;
+};
+const getNextParam = (acceptHeader, startIndex) => {
+	startIndex = consumeWhitespace(acceptHeader, startIndex);
+	let i = startIndex;
+	let key;
+	let value;
+	let hasNext = false;
+	while (i < acceptHeader.length) {
+		const char = acceptHeader.charCodeAt(i);
+		if (char === 61) {
+			key = acceptHeader.slice(startIndex, ignoreTrailingWhitespace(acceptHeader, i));
+			i++;
+			break;
+		}
+		if (char === 59) return [
+			i + 1,
+			void 0,
+			void 0,
+			true
+		];
+		if (char === 44) return [
+			i + 1,
+			void 0,
+			void 0,
+			false
+		];
+		i++;
+	}
+	if (key === void 0) return [
+		i,
+		void 0,
+		void 0,
+		false
+	];
+	i = consumeWhitespace(acceptHeader, i);
+	if (acceptHeader.charCodeAt(i) === 61) {
+		const skipResult = skipInvalidParam(acceptHeader, i + 1);
+		return [
+			skipResult[0],
+			key,
+			void 0,
+			skipResult[1]
+		];
+	}
+	let inQuotes = false;
+	const paramStartIndex = i;
+	while (i < acceptHeader.length) {
+		const char = acceptHeader.charCodeAt(i);
+		if (inQuotes && char === 92) i++;
+		else if (char === 34) {
+			if (inQuotes) {
+				let nextIndex = consumeWhitespace(acceptHeader, i + 1);
+				const nextChar = acceptHeader.charCodeAt(nextIndex);
+				if (nextIndex < acceptHeader.length && !(nextChar === 59 || nextChar === 44)) {
+					const skipResult = skipInvalidParam(acceptHeader, nextIndex);
+					return [
+						skipResult[0],
+						key,
+						void 0,
+						skipResult[1]
+					];
+				}
+				value = acceptHeader.slice(paramStartIndex + 1, i);
+				if (value.includes("\\")) value = value.replace(/\\(.)/g, "$1");
+				if (nextChar === 44) return [
+					nextIndex + 1,
+					key,
+					value,
+					false
+				];
+				if (nextChar === 59) {
+					hasNext = true;
+					nextIndex++;
+				}
+				i = nextIndex;
+				break;
+			}
+			inQuotes = true;
+		} else if (!inQuotes && (char === 59 || char === 44)) {
+			value = acceptHeader.slice(paramStartIndex, ignoreTrailingWhitespace(acceptHeader, i));
+			if (char === 59) hasNext = true;
+			i++;
+			break;
+		}
+		i++;
+	}
+	return [
+		i,
+		key,
+		value ?? acceptHeader.slice(paramStartIndex, ignoreTrailingWhitespace(acceptHeader, i)),
+		hasNext
+	];
+};
+const getNextAcceptValue = (acceptHeader, startIndex) => {
+	const accept = {
+		type: "",
+		params: Object.create(null),
+		q: 1
+	};
+	startIndex = consumeWhitespace(acceptHeader, startIndex);
+	let i = startIndex;
+	while (i < acceptHeader.length) {
+		const char = acceptHeader.charCodeAt(i);
+		if (char === 59 || char === 44) {
+			accept.type = acceptHeader.slice(startIndex, ignoreTrailingWhitespace(acceptHeader, i));
+			i++;
+			if (char === 44) return [i, accept.type ? accept : void 0];
+			if (!accept.type) return [skipInvalidAcceptValue(acceptHeader, i), void 0];
+			break;
+		}
+		i++;
+	}
+	if (!accept.type) {
+		accept.type = acceptHeader.slice(startIndex, ignoreTrailingWhitespace(acceptHeader, acceptHeader.length));
+		return [acceptHeader.length, accept.type ? accept : void 0];
+	}
+	let param;
+	let value;
+	let hasNext;
+	while (i < acceptHeader.length) {
+		[i, param, value, hasNext] = getNextParam(acceptHeader, i);
+		if (param && value) accept.params[param] = value;
+		if (!hasNext) break;
+	}
+	return [i, accept];
+};
+const parseAccept = (acceptHeader) => {
+	if (!acceptHeader) return [];
+	const values = [];
+	let i = 0;
+	let accept;
+	let requiresSort = false;
+	let lastAccept;
+	while (i < acceptHeader.length) {
+		[i, accept] = getNextAcceptValue(acceptHeader, i);
+		if (accept) {
+			accept.q = parseQuality(accept.params.q ?? accept.params.Q);
+			values.push(accept);
+			if (lastAccept && lastAccept.q < accept.q) requiresSort = true;
+			lastAccept = accept;
+		}
+	}
+	if (requiresSort) values.sort((a, b) => b.q - a.q);
+	return values;
+};
+const parseQuality = (qVal) => {
+	if (qVal === void 0) return 1;
+	if (qVal === "") return 1;
+	if (qVal === "NaN") return 0;
+	const num = Number(qVal);
+	if (Number.isNaN(num)) return 1;
+	if (num < 0) return 0;
+	if (num > 1) return 1;
+	return num;
+};
+//#endregion
+export { parseAccept };

package/lib/utils/basic-auth.d.ts

@@ -0,0 +1,8 @@
+//#region ../../plugins/acryl-router/src/core/utils/basic-auth.d.ts
+type Auth = (req: Request) => {
+  username: string;
+  password: string;
+} | undefined;
+declare const auth: Auth;
+//#endregion
+export { Auth, auth };

package/lib/utils/basic-auth.js

@@ -0,0 +1,20 @@
+import { decodeBase64 } from "./encode.js";
+//#region ../../plugins/acryl-router/src/core/utils/basic-auth.ts
+const CREDENTIALS_REGEXP = /^ *(?:[Bb][Aa][Ss][Ii][Cc]) +([A-Za-z0-9._~+/-]+=*) *$/;
+const USER_PASS_REGEXP = /^([^:]*):(.*)$/;
+const utf8Decoder = new TextDecoder();
+const auth = (req) => {
+	const match = CREDENTIALS_REGEXP.exec(req.headers.get("Authorization") || "");
+	if (!match) return;
+	let userPass = void 0;
+	try {
+		userPass = USER_PASS_REGEXP.exec(utf8Decoder.decode(decodeBase64(match[1])));
+	} catch {}
+	if (!userPass) return;
+	return {
+		username: userPass[1],
+		password: userPass[2]
+	};
+};
+//#endregion
+export { auth };

package/lib/utils/body.d.ts

@@ -0,0 +1,2 @@
+import { c as BodyData, l as ParseBodyOptions, u as parseBody } from "../context-Bm7rI-oK.js";
+export { BodyData, ParseBodyOptions, parseBody };

package/lib/utils/body.js

@@ -0,0 +1,94 @@
+import { bufferToFormData } from "./buffer.js";
+//#region ../../plugins/acryl-router/src/core/utils/body.ts
+const MAX_NESTED_OBJECTS = 1e4;
+const isRawRequest = (request) => "headers" in request;
+const parseBody = async (request, options = Object.create(null)) => {
+	const { all = false, dot = false } = options;
+	const mediaType = (isRawRequest(request) ? request.headers : request.raw.headers).get("Content-Type")?.split(";")[0].trim().toLowerCase();
+	if (mediaType === "multipart/form-data" || mediaType === "application/x-www-form-urlencoded") return parseFormData(request, {
+		all,
+		dot
+	});
+	return {};
+};
+/**
+* Parses form data from a request.
+*
+* @template T - The type of the parsed body data.
+* @param {AcrylRequest | Request} request - The request object containing form data.
+* @param {ParseBodyOptions} options - Options for parsing the form data.
+* @returns {Promise<T>} The parsed body data.
+*/
+async function parseFormData(request, options) {
+	if (!isRawRequest(request) && request.bodyCache.formData) return convertFormDataToBodyData(await request.bodyCache.formData, options);
+	const headers = isRawRequest(request) ? request.headers : request.raw.headers;
+	const formDataPromise = bufferToFormData(await request.arrayBuffer(), headers.get("Content-Type") || "");
+	if (!isRawRequest(request)) request.bodyCache.formData = formDataPromise;
+	const formData = await formDataPromise;
+	if (formData) return convertFormDataToBodyData(formData, options);
+	return {};
+}
+/**
+* Converts form data to body data based on the provided options.
+*
+* @template T - The type of the parsed body data.
+* @param {FormData} formData - The form data to convert.
+* @param {ParseBodyOptions} options - Options for parsing the form data.
+* @returns {T} The converted body data.
+*/
+function convertFormDataToBodyData(formData, options) {
+	const form = Object.create(null);
+	const nestingState = { count: 0 };
+	formData.forEach((value, key) => {
+		if (!(options.all || key.endsWith("[]"))) form[key] = value;
+		else handleParsingAllValues(form, key, value);
+	});
+	if (options.dot) Object.entries(form).forEach(([key, value]) => {
+		if (key.includes(".")) {
+			handleParsingNestedValues(form, key, value, nestingState);
+			delete form[key];
+		}
+	});
+	return form;
+}
+/**
+* Handles parsing all values for a given key, supporting multiple values as arrays.
+*
+* @param {BodyData} form - The form data object.
+* @param {string} key - The key to parse.
+* @param {FormDataEntryValue} value - The value to assign.
+*/
+const handleParsingAllValues = (form, key, value) => {
+	if (form[key] !== void 0) if (Array.isArray(form[key])) form[key].push(value);
+	else form[key] = [form[key], value];
+	else if (!key.endsWith("[]")) form[key] = value;
+	else form[key] = [value];
+};
+/**
+* Handles parsing nested values using dot notation keys.
+*
+* @param {BodyData} form - The form data object.
+* @param {string} key - The dot notation key.
+* @param {BodyDataValue} value - The value to assign.
+*/
+const handleParsingNestedValues = (form, key, value, state) => {
+	if (/(?:^|\.)__proto__\./.test(key)) return;
+	let nestedForm = form;
+	const keys = key.split(".", 34);
+	if (keys.length > 33) throwNestingLimitExceeded();
+	keys.forEach((key, index) => {
+		if (index === keys.length - 1) nestedForm[key] = value;
+		else {
+			if (!nestedForm[key] || typeof nestedForm[key] !== "object" || Array.isArray(nestedForm[key]) || nestedForm[key] instanceof File) {
+				if (state.count++ >= MAX_NESTED_OBJECTS) throwNestingLimitExceeded();
+				nestedForm[key] = Object.create(null);
+			}
+			nestedForm = nestedForm[key];
+		}
+	});
+};
+const throwNestingLimitExceeded = () => {
+	throw new Error("Nesting limit exceeded");
+};
+//#endregion
+export { parseBody };