acrylblends 0.8.1 → 0.9.0

package/plugins/acryl-router/src/core/utils/accept.d.ts

@@ -0,0 +1,6 @@
+export interface Accept {
+    type: string;
+    params: Record<string, string>;
+    q: number;
+}
+export declare const parseAccept: (acceptHeader: string) => Accept[];

package/plugins/acryl-router/src/core/utils/body.d.ts

@@ -0,0 +1,79 @@
+/**
+ * @module
+ * Body utility.
+ */
+import type { AcrylRequest } from '../request.ts';
+type BodyDataValueDot = {
+    [x: string]: string | File | BodyDataValueDot;
+};
+type BodyDataValueDotAll = {
+    [x: string]: string | File | (string | File)[] | BodyDataValueDotAll;
+};
+type SimplifyBodyData<T> = {
+    [K in keyof T]: string | File | (string | File)[] | BodyDataValueDotAll extends T[K] ? string | File | (string | File)[] | BodyDataValueDotAll : string | File | BodyDataValueDot extends T[K] ? string | File | BodyDataValueDot : string | File | (string | File)[] extends T[K] ? string | File | (string | File)[] : string | File;
+} & {};
+type BodyDataValueComponent<T> = string | File | (T extends {
+    all: false;
+} ? never : T extends {
+    all: true;
+} | {
+    all: boolean;
+} ? (string | File)[] : never);
+type BodyDataValueObject<T> = {
+    [key: string]: BodyDataValueComponent<T> | BodyDataValueObject<T>;
+};
+type BodyDataValue<T> = BodyDataValueComponent<T> | (T extends {
+    dot: false;
+} ? never : T extends {
+    dot: true;
+} | {
+    dot: boolean;
+} ? BodyDataValueObject<T> : never);
+export type BodyData<T extends Partial<ParseBodyOptions> = {}> = SimplifyBodyData<Record<string, BodyDataValue<T>>>;
+export type ParseBodyOptions = {
+    /**
+     * Determines whether all fields with multiple values should be parsed as arrays.
+     * @default false
+     * @example
+     * const data = new FormData()
+     * data.append('file', 'aaa')
+     * data.append('file', 'bbb')
+     * data.append('message', 'hello')
+     *
+     * If all is false:
+     * parseBody should return { file: 'bbb', message: 'hello' }
+     *
+     * If all is true:
+     * parseBody should return { file: ['aaa', 'bbb'], message: 'hello' }
+     */
+    all: boolean;
+    /**
+     * Determines whether all fields with dot notation should be parsed as nested objects.
+     * @default false
+     * @example
+     * const data = new FormData()
+     * data.append('obj.key1', 'value1')
+     * data.append('obj.key2', 'value2')
+     *
+     * If dot is false:
+     * parseBody should return { 'obj.key1': 'value1', 'obj.key2': 'value2' }
+     *
+     * If dot is true:
+     * parseBody should return { obj: { key1: 'value1', key2: 'value2' } }
+     */
+    dot: boolean;
+};
+/**
+ * Parses the body of a request based on the provided options.
+ *
+ * @template T - The type of the parsed body data.
+ * @param {AcrylRequest | Request} request - The request object to parse.
+ * @param {Partial<ParseBodyOptions>} [options] - Options for parsing the body.
+ * @returns {Promise<T>} The parsed body data.
+ */
+interface ParseBody {
+    <Options extends Partial<ParseBodyOptions>, T extends BodyData<Options>>(request: AcrylRequest | Request, options?: Options): Promise<T>;
+    <T extends BodyData>(request: AcrylRequest | Request, options?: Partial<ParseBodyOptions>): Promise<T>;
+}
+export declare const parseBody: ParseBody;
+export {};

package/plugins/acryl-router/src/core/utils/buffer.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @module
+ * Buffer utility.
+ */
+export declare const equal: (a: ArrayBuffer, b: ArrayBuffer) => boolean;
+type StringHashFunction = (input: string) => string | null | Promise<string | null>;
+type TimingSafeEqual = {
+    (a: string, b: string, hashFunction?: StringHashFunction): Promise<boolean>;
+    /**
+     * @deprecated object and boolean signatures that take boolean as first and second arguments, and functions with signatures that take non-string arguments have been deprecated
+     */
+    (a: string | object | boolean, b: string | object | boolean, hashFunction?: Function): Promise<boolean>;
+};
+export declare const timingSafeEqual: TimingSafeEqual;
+export declare const bufferToString: (buffer: ArrayBuffer) => string;
+export declare const bufferToFormData: (arrayBuffer: ArrayBuffer, contentType: string) => Promise<FormData>;
+export {};

package/plugins/acryl-router/src/core/utils/color.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @module
+ * Color utility.
+ */
+/**
+ * Get whether color change on terminal is enabled or disabled.
+ * If `NO_COLOR` environment variable is set, this function returns `false`.
+ * Unlike getColorEnabledAsync(), this cannot check Cloudflare environment variables.
+ * @see {@link https://no-color.org/}
+ *
+ * @returns {boolean}
+ */
+export declare function getColorEnabled(): boolean;
+/**
+ * Get whether color change on terminal is enabled or disabled.
+ * If `NO_COLOR` environment variable is set, this function returns `false`.
+ * @see {@link https://no-color.org/}
+ *
+ * @returns {boolean}
+ */
+export declare function getColorEnabledAsync(): Promise<boolean>;

package/plugins/acryl-router/src/core/utils/concurrent.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @module
+ * Concurrent utility.
+ */
+export interface Pool {
+    run<T>(fn: () => T): Promise<T>;
+}
+export declare const createPool: ({ concurrency, interval, }?: {
+    concurrency?: number;
+    interval?: number;
+}) => Pool;

package/plugins/acryl-router/src/core/utils/constants.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Constant used to mark a composed handler.
+ */
+export declare const COMPOSED_HANDLER = "__COMPOSED_HANDLER";

package/plugins/acryl-router/src/core/utils/cookie.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @module
+ * Cookie utility.
+ */
+import type { BufferSource } from './types.ts';
+export type Cookie = Record<string, string>;
+export type SignedCookie = Record<string, string | false>;
+type PartitionedCookieConstraint = {
+    partitioned: true;
+    secure: true;
+} | {
+    partitioned?: boolean;
+    secure?: boolean;
+};
+type SecureCookieConstraint = {
+    secure: true;
+};
+type HostCookieConstraint = {
+    secure: true;
+    path: '/';
+    domain?: undefined;
+};
+export type CookieOptions = {
+    domain?: string;
+    expires?: Date;
+    httpOnly?: boolean;
+    maxAge?: number;
+    path?: string;
+    secure?: boolean;
+    sameSite?: 'Strict' | 'Lax' | 'None' | 'strict' | 'lax' | 'none';
+    partitioned?: boolean;
+    priority?: 'Low' | 'Medium' | 'High' | 'low' | 'medium' | 'high';
+    prefix?: CookiePrefixOptions;
+} & PartitionedCookieConstraint;
+export type CookiePrefixOptions = 'host' | 'secure';
+export type CookieConstraint<Name> = Name extends `__Secure-${string}` ? CookieOptions & SecureCookieConstraint : Name extends `__Host-${string}` ? CookieOptions & HostCookieConstraint : CookieOptions;
+export declare const parse: (cookie: string, name?: string) => Cookie;
+export declare const parseSigned: (cookie: string, secret: string | BufferSource, name?: string) => Promise<SignedCookie>;
+export declare const serialize: <Name extends string>(name: Name, value: string, opt?: CookieConstraint<Name>) => string;
+export declare const serializeSigned: (name: string, value: string, secret: string | BufferSource, opt?: CookieOptions) => Promise<string>;
+export {};

package/plugins/acryl-router/src/core/utils/crypto.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @module
+ * Crypto utility.
+ */
+import type { JSONValue } from './types.ts';
+type Algorithm = {
+    name: string;
+    alias: string;
+};
+type Data = string | boolean | number | JSONValue | ArrayBufferView | ArrayBuffer;
+export declare const sha256: (data: Data) => Promise<string | null>;
+export declare const sha1: (data: Data) => Promise<string | null>;
+export declare const md5: (data: Data) => Promise<string | null>;
+export declare const createHash: (data: Data, algorithm: Algorithm) => Promise<string | null>;
+export {};

package/plugins/acryl-router/src/core/utils/handler.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @module
+ * Handler utility.
+ */
+export declare const isMiddleware: (handler: Function) => boolean;
+export declare const findTargetHandler: (handler: Function) => Function;

package/plugins/acryl-router/src/core/utils/headers.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @module
+ * HTTP Headers utility.
+ */
+export type RequestHeader = 'A-IM' | 'Accept' | 'Accept-Additions' | 'Accept-CH' | 'Accept-Charset' | 'Accept-Datetime' | 'Accept-Encoding' | 'Accept-Features' | 'Accept-Language' | 'Accept-Patch' | 'Accept-Post' | 'Accept-Query' | 'Accept-Ranges' | 'Accept-Signature' | 'Access-Control' | 'Access-Control-Allow-Credentials' | 'Access-Control-Allow-Headers' | 'Access-Control-Allow-Methods' | 'Access-Control-Allow-Origin' | 'Access-Control-Expose-Headers' | 'Access-Control-Max-Age' | 'Access-Control-Request-Headers' | 'Access-Control-Request-Method' | 'Activate-Storage-Access' | 'Age' | 'Allow' | 'ALPN' | 'Alt-Svc' | 'Alt-Used' | 'Alternates' | 'AMP-Cache-Transform' | 'Apply-To-Redirect-Ref' | 'Authentication-Control' | 'Authentication-Info' | 'Authorization' | 'Available-Dictionary' | 'C-Ext' | 'C-Man' | 'C-Opt' | 'C-PEP' | 'C-PEP-Info' | 'Cache-Control' | 'Cache-Group-Invalidation' | 'Cache-Groups' | 'Cache-Status' | 'Cal-Managed-ID' | 'CalDAV-Timezones' | 'Capsule-Protocol' | 'CDN-Cache-Control' | 'CDN-Loop' | 'Cert-Not-After' | 'Cert-Not-Before' | 'Clear-Site-Data' | 'Client-Cert' | 'Client-Cert-Chain' | 'Close' | 'CMCD-Object' | 'CMCD-Request' | 'CMCD-Session' | 'CMCD-Status' | 'CMSD-Dynamic' | 'CMSD-Static' | 'Concealed-Auth-Export' | 'Configuration-Context' | 'Connection' | 'Content-Base' | 'Content-Digest' | 'Content-Disposition' | 'Content-Encoding' | 'Content-ID' | 'Content-Language' | 'Content-Length' | 'Content-Location' | 'Content-MD5' | 'Content-Range' | 'Content-Script-Type' | 'Content-Security-Policy' | 'Content-Security-Policy-Report-Only' | 'Content-Style-Type' | 'Content-Type' | 'Content-Version' | 'Cookie' | 'Cookie2' | 'Cross-Origin-Embedder-Policy' | 'Cross-Origin-Embedder-Policy-Report-Only' | 'Cross-Origin-Opener-Policy' | 'Cross-Origin-Opener-Policy-Report-Only' | 'Cross-Origin-Resource-Policy' | 'CTA-Common-Access-Token' | 'DASL' | 'Date' | 'DAV' | 'Default-Style' | 'Delta-Base' | 'Deprecation' | 'Depth' | 'Derived-From' | 'Destination' | 'Detached-JWS' | 'Differential-ID' | 'Dictionary-ID' | 'Digest' | 'DPoP' | 'DPoP-Nonce' | 'Early-Data' | 'EDIINT-Features' | 'ETag' | 'Expect' | 'Expect-CT' | 'Expires' | 'Ext' | 'Forwarded' | 'From' | 'GetProfile' | 'Hobareg' | 'Host' | 'HTTP2-Settings' | 'If' | 'If-Match' | 'If-Modified-Since' | 'If-None-Match' | 'If-Range' | 'If-Schedule-Tag-Match' | 'If-Unmodified-Since' | 'IM' | 'Include-Referred-Token-Binding-ID' | 'Incremental' | 'Isolation' | 'Keep-Alive' | 'Label' | 'Last-Event-ID' | 'Last-Modified' | 'Link' | 'Link-Template' | 'Location' | 'Lock-Token' | 'Man' | 'Max-Forwards' | 'Memento-Datetime' | 'Meter' | 'Method-Check' | 'Method-Check-Expires' | 'MIME-Version' | 'Negotiate' | 'NEL' | 'OData-EntityId' | 'OData-Isolation' | 'OData-MaxVersion' | 'OData-Version' | 'Opt' | 'Optional-WWW-Authenticate' | 'Ordering-Type' | 'Origin' | 'Origin-Agent-Cluster' | 'OSCORE' | 'OSLC-Core-Version' | 'Overwrite' | 'P3P' | 'PEP' | 'PEP-Info' | 'Permissions-Policy' | 'PICS-Label' | 'Ping-From' | 'Ping-To' | 'Position' | 'Pragma' | 'Prefer' | 'Preference-Applied' | 'Priority' | 'ProfileObject' | 'Protocol' | 'Protocol-Info' | 'Protocol-Query' | 'Protocol-Request' | 'Proxy-Authenticate' | 'Proxy-Authentication-Info' | 'Proxy-Authorization' | 'Proxy-Features' | 'Proxy-Instruction' | 'Proxy-Status' | 'Public' | 'Public-Key-Pins' | 'Public-Key-Pins-Report-Only' | 'Range' | 'Redirect-Ref' | 'Referer' | 'Referer-Root' | 'Referrer-Policy' | 'Refresh' | 'Repeatability-Client-ID' | 'Repeatability-First-Sent' | 'Repeatability-Request-ID' | 'Repeatability-Result' | 'Replay-Nonce' | 'Reporting-Endpoints' | 'Repr-Digest' | 'Retry-After' | 'Safe' | 'Schedule-Reply' | 'Schedule-Tag' | 'Sec-Fetch-Dest' | 'Sec-Fetch-Mode' | 'Sec-Fetch-Site' | 'Sec-Fetch-Storage-Access' | 'Sec-Fetch-User' | 'Sec-GPC' | 'Sec-Purpose' | 'Sec-Token-Binding' | 'Sec-WebSocket-Accept' | 'Sec-WebSocket-Extensions' | 'Sec-WebSocket-Key' | 'Sec-WebSocket-Protocol' | 'Sec-WebSocket-Version' | 'Security-Scheme' | 'Server' | 'Server-Timing' | 'Set-Cookie' | 'Set-Cookie2' | 'Set-Txn' | 'SetProfile' | 'Signature' | 'Signature-Input' | 'SLUG' | 'SoapAction' | 'Status-URI' | 'Strict-Transport-Security' | 'Sunset' | 'Surrogate-Capability' | 'Surrogate-Control' | 'TCN' | 'TE' | 'Timeout' | 'Timing-Allow-Origin' | 'Topic' | 'Traceparent' | 'Tracestate' | 'Trailer' | 'Transfer-Encoding' | 'TTL' | 'Unencoded-Digest' | 'Upgrade' | 'Urgency' | 'URI' | 'Use-As-Dictionary' | 'User-Agent' | 'Variant-Vary' | 'Vary' | 'Via' | 'Want-Content-Digest' | 'Want-Digest' | 'Want-Repr-Digest' | 'Want-Unencoded-Digest' | 'Warning' | 'WWW-Authenticate' | 'X-Content-Type-Options' | 'X-Frame-Options';
+export type ResponseHeader = 'Accept-Query' | 'Access-Control-Allow-Credentials' | 'Access-Control-Allow-Headers' | 'Access-Control-Allow-Methods' | 'Access-Control-Allow-Origin' | 'Access-Control-Expose-Headers' | 'Access-Control-Max-Age' | 'Activate-Storage-Access' | 'Age' | 'Allow' | 'Cache-Control' | 'Cache-Group-Invalidation' | 'Cache-Groups' | 'Clear-Site-Data' | 'Content-Disposition' | 'Content-Encoding' | 'Content-Language' | 'Content-Length' | 'Content-Location' | 'Content-Range' | 'Content-Security-Policy' | 'Content-Security-Policy-Report-Only' | 'Content-Type' | 'Cookie' | 'Cross-Origin-Embedder-Policy' | 'Cross-Origin-Opener-Policy' | 'Cross-Origin-Resource-Policy' | 'Date' | 'ETag' | 'Expires' | 'Incremental' | 'Last-Modified' | 'Location' | 'Permissions-Policy' | 'Pragma' | 'Retry-After' | 'Save-Data' | 'Sec-CH-Prefers-Color-Scheme' | 'Sec-CH-Prefers-Reduced-Motion' | 'Sec-CH-UA' | 'Sec-CH-UA-Arch' | 'Sec-CH-UA-Bitness' | 'Sec-CH-UA-Form-Factor' | 'Sec-CH-UA-Full-Version' | 'Sec-CH-UA-Full-Version-List' | 'Sec-CH-UA-Mobile' | 'Sec-CH-UA-Model' | 'Sec-CH-UA-Platform' | 'Sec-CH-UA-Platform-Version' | 'Sec-CH-UA-WoW64' | 'Sec-Fetch-Dest' | 'Sec-Fetch-Mode' | 'Sec-Fetch-Site' | 'Sec-Fetch-User' | 'Sec-GPC' | 'Server' | 'Server-Timing' | 'Service-Worker-Navigation-Preload' | 'Set-Cookie' | 'Set-Txn' | 'Strict-Transport-Security' | 'Timing-Allow-Origin' | 'Trailer' | 'Transfer-Encoding' | 'Unencoded-Digest' | 'Upgrade' | 'Vary' | 'Want-Unencoded-Digest' | 'Warning' | 'WWW-Authenticate' | 'X-Content-Type-Options' | 'X-DNS-Prefetch-Control' | 'X-Frame-Options' | 'X-Permitted-Cross-Domain-Policies' | 'X-Powered-By' | 'X-Robots-Tag' | 'X-XSS-Protection';
+export type AcceptHeader = 'Accept' | 'Accept-Charset' | 'Accept-Encoding' | 'Accept-Language' | 'Accept-Patch' | 'Accept-Post' | 'Accept-Ranges';
+export type CustomHeader = string & {};

package/plugins/acryl-router/src/core/utils/html.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @module
+ * HTML utility.
+ */
+export declare const HtmlEscapedCallbackPhase: {
+    readonly Stringify: 1;
+    readonly BeforeStream: 2;
+    readonly Stream: 3;
+};
+type HtmlEscapedCallbackOpts = {
+    buffer?: [string];
+    phase: (typeof HtmlEscapedCallbackPhase)[keyof typeof HtmlEscapedCallbackPhase];
+    context: Readonly<object>;
+};
+export type HtmlEscapedCallback = (opts: HtmlEscapedCallbackOpts) => Promise<string> | undefined;
+export type HtmlEscaped = {
+    isEscaped: true;
+    callbacks?: HtmlEscapedCallback[];
+};
+export type HtmlEscapedString = string & HtmlEscaped;
+/**
+ * StringBuffer contains string and Promise<string> alternately
+ * The length of the array will be odd, the odd numbered element will be a string,
+ * and the even numbered element will be a Promise<string>.
+ * When concatenating into a single string, it must be processed from the tail.
+ * @example
+ * [
+ *   'framework.',
+ *   Promise.resolve('ultra fast'),
+ *   'a ',
+ *   Promise.resolve('is '),
+ *   'Acryl',
+ * ]
+ */
+export type StringBuffer = (string | Promise<string>)[];
+export type StringBufferWithCallbacks = StringBuffer & {
+    callbacks: HtmlEscapedCallback[];
+};
+export declare const raw: (value: unknown, callbacks?: HtmlEscapedCallback[]) => HtmlEscapedString;
+export declare const stringBufferToString: (buffer: StringBuffer, callbacks: HtmlEscapedCallback[] | undefined) => Promise<HtmlEscapedString>;
+export declare const escapeToBuffer: (str: string, buffer: StringBuffer) => void;
+export declare const resolveCallbackSync: (str: string | HtmlEscapedString) => string;
+export declare const resolveCallback: (str: string | HtmlEscapedString | Promise<string>, phase: (typeof HtmlEscapedCallbackPhase)[keyof typeof HtmlEscapedCallbackPhase], preserveCallbacks: boolean, context: object, buffer?: [string]) => Promise<string>;
+export {};

package/plugins/acryl-router/src/core/utils/http-status.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @module
+ * HTTP Status utility.
+ */
+export type InfoStatusCode = 100 | 101 | 102 | 103;
+export type SuccessStatusCode = 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 226;
+export type DeprecatedStatusCode = 305 | 306;
+export type RedirectStatusCode = 300 | 301 | 302 | 303 | 304 | DeprecatedStatusCode | 307 | 308;
+export type ClientErrorStatusCode = 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 421 | 422 | 423 | 424 | 425 | 426 | 428 | 429 | 431 | 451;
+export type ServerErrorStatusCode = 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511;
+/**
+ * `UnofficialStatusCode` can be used to specify an unofficial status code.
+ * @example
+ *
+ * ```ts
+ * app.get('/unknown', (c) => {
+ *   return c.text("Unknown Error", 520 as UnofficialStatusCode)
+ * })
+ * ```
+ */
+export type UnofficialStatusCode = -1;
+/**
+ * @deprecated
+ * Use `UnofficialStatusCode` instead.
+ */
+export type UnOfficalStatusCode = UnofficialStatusCode;
+/**
+ * If you want to use an unofficial status, use `UnofficialStatusCode`.
+ */
+export type StatusCode = InfoStatusCode | SuccessStatusCode | RedirectStatusCode | ClientErrorStatusCode | ServerErrorStatusCode | UnofficialStatusCode;
+export type ContentlessStatusCode = 101 | 204 | 205 | 304;
+export type ContentfulStatusCode = Exclude<StatusCode, ContentlessStatusCode>;

package/plugins/acryl-router/src/core/utils/mime.d.ts

@@ -0,0 +1,70 @@
+/**
+ * @module
+ * MIME utility.
+ */
+export declare const getMimeType: (filename: string, mimes?: Record<string, string>) => string | undefined;
+export declare const getExtension: (mimeType: string) => string | undefined;
+export { baseMimes as mimes };
+/**
+ * Union types for BaseMime
+ */
+export type BaseMime = (typeof _baseMimes)[keyof typeof _baseMimes];
+declare const _baseMimes: {
+    readonly aac: "audio/aac";
+    readonly avi: "video/x-msvideo";
+    readonly avif: "image/avif";
+    readonly av1: "video/av1";
+    readonly bin: "application/octet-stream";
+    readonly bmp: "image/bmp";
+    readonly css: "text/css; charset=utf-8";
+    readonly csv: "text/csv; charset=utf-8";
+    readonly eot: "application/vnd.ms-fontobject";
+    readonly epub: "application/epub+zip";
+    readonly gif: "image/gif";
+    readonly gz: "application/gzip";
+    readonly htm: "text/html; charset=utf-8";
+    readonly html: "text/html; charset=utf-8";
+    readonly ico: "image/x-icon";
+    readonly ics: "text/calendar; charset=utf-8";
+    readonly jpeg: "image/jpeg";
+    readonly jpg: "image/jpeg";
+    readonly js: "text/javascript; charset=utf-8";
+    readonly json: "application/json";
+    readonly jsonld: "application/ld+json";
+    readonly map: "application/json";
+    readonly mid: "audio/x-midi";
+    readonly midi: "audio/x-midi";
+    readonly mjs: "text/javascript; charset=utf-8";
+    readonly mp3: "audio/mpeg";
+    readonly mp4: "video/mp4";
+    readonly mpeg: "video/mpeg";
+    readonly oga: "audio/ogg";
+    readonly ogv: "video/ogg";
+    readonly ogx: "application/ogg";
+    readonly opus: "audio/opus";
+    readonly otf: "font/otf";
+    readonly pdf: "application/pdf";
+    readonly png: "image/png";
+    readonly rtf: "application/rtf";
+    readonly svg: "image/svg+xml; charset=utf-8";
+    readonly tif: "image/tiff";
+    readonly tiff: "image/tiff";
+    readonly ts: "video/mp2t";
+    readonly ttf: "font/ttf";
+    readonly txt: "text/plain; charset=utf-8";
+    readonly wasm: "application/wasm";
+    readonly webm: "video/webm";
+    readonly weba: "audio/webm";
+    readonly webmanifest: "application/manifest+json";
+    readonly webp: "image/webp";
+    readonly woff: "font/woff";
+    readonly woff2: "font/woff2";
+    readonly xhtml: "application/xhtml+xml; charset=utf-8";
+    readonly xml: "application/xml; charset=utf-8";
+    readonly zip: "application/zip";
+    readonly '3gp': "video/3gpp";
+    readonly '3g2': "video/3gpp2";
+    readonly gltf: "model/gltf+json";
+    readonly glb: "model/gltf-binary";
+};
+declare const baseMimes: Record<string, BaseMime>;

package/plugins/acryl-router/src/core/utils/stream.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @module
+ * Stream utility.
+ */
+export declare class StreamingApi {
+    private writer;
+    private encoder;
+    private writable;
+    private abortSubscribers;
+    responseReadable: ReadableStream;
+    /**
+     * Whether the stream has been aborted.
+     */
+    aborted: boolean;
+    /**
+     * Whether the stream has been closed normally.
+     */
+    closed: boolean;
+    constructor(writable: WritableStream, _readable: ReadableStream);
+    write(input: Uint8Array | string): Promise<StreamingApi>;
+    writeln(input: string): Promise<StreamingApi>;
+    sleep(ms: number): Promise<unknown>;
+    close(): Promise<void>;
+    pipe(body: ReadableStream): Promise<void>;
+    onAbort(listener: () => void | Promise<void>): void;
+    /**
+     * Abort the stream.
+     * You can call this method when stream is aborted by external event.
+     */
+    abort(): void;
+}

package/plugins/acryl-router/src/core/utils/types.d.ts

@@ -0,0 +1,128 @@
+/**
+ * @module
+ * Types utility.
+ */
+export type Expect<T extends true> = T;
+export type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
+export type NotEqual<X, Y> = true extends Equal<X, Y> ? false : true;
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+export type RemoveBlankRecord<T> = T extends Record<infer K, unknown> ? (K extends string ? T : never) : never;
+export type IfAnyThenEmptyObject<T> = 0 extends 1 & T ? {} : T;
+export type JSONPrimitive = string | boolean | number | null;
+export type JSONArray = (JSONPrimitive | JSONObject | JSONArray)[];
+export type JSONObject = {
+    [key: string]: JSONPrimitive | JSONArray | JSONObject | object | InvalidJSONValue;
+};
+export 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];
+};
+export 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.
+ */
+export 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
+ */
+export type Simplify<T> = {
+    [KeyType in keyof T]: T[KeyType];
+} & {};
+/**
+ * A simple extension of Simplify that will deeply traverse array elements.
+ */
+export type SimplifyDeepArray<T> = T extends any[] ? {
+    [E in keyof T]: SimplifyDeepArray<T[E]>;
+} : Simplify<T>;
+export type InterfaceToType<T> = T extends Function ? T : {
+    [K in keyof T]: InterfaceToType<T[K]>;
+};
+export type RequiredKeysOf<BaseType extends object> = Exclude<{
+    [Key in keyof BaseType]: BaseType extends Record<Key, BaseType[Key]> ? Key : never;
+}[keyof BaseType], undefined>;
+export type HasRequiredKeys<BaseType extends object> = RequiredKeysOf<BaseType> extends never ? false : true;
+export 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
+ */
+export 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. */
+export 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. */
+export type CryptoKey = Awaited<ReturnType<typeof crypto.subtle.importKey>>;
+/** What the Web `Headers` constructor accepts, named from the runtime's own `Headers` so the public types do not need the DOM library. */
+export type HeadersInit = NonNullable<ConstructorParameters<typeof Headers>[0]>;
+/** How a WebSocket hands binary data to `onmessage`; declared here so the public types do not need the DOM library. */
+export 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. */
+export 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. */
+export 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. */
+export 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;
+}
+/**
+ * A DOM event type by its global name: the DOM library's own type when it is loaded (a browser project), otherwise the runtime's `Event`,
+ * so the JSX types (event handler props) do not need the DOM library on a server.
+ */
+export type DomEvent<Name extends string> = typeof globalThis extends {
+    readonly [K in Name]: {
+        readonly prototype: infer E;
+    };
+} ? E : Event;
+export {};

package/plugins/acryl-router/src/core/utils/url.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @module
+ * URL utility.
+ */
+export type Pattern = readonly [string, string, RegExp | true] | '*';
+export declare const splitPath: (path: string) => string[];
+export declare const splitRoutingPath: (routePath: string) => string[];
+export declare const getPattern: (label: string, next?: string) => Pattern | null;
+type Decoder = (str: string) => string;
+export declare const tryDecode: (str: string, decoder: Decoder) => string;
+/**
+ * Try to apply decodeURI() to given string.
+ * If it fails, skip invalid percent encoding or invalid UTF-8 sequences, and apply decodeURI() to the rest as much as possible.
+ * @param str The string to decode.
+ * @returns The decoded string that sometimes contains undecodable percent encoding.
+ * @example
+ * tryDecodeURI('Hello%20World') // 'Hello World'
+ * tryDecodeURI('Hello%20World/%A4%A2') // 'Hello World/%A4%A2'
+ */
+export declare const tryDecodeURI: (str: string) => string;
+export declare const getPath: (request: Request) => string;
+/**
+ * @deprecated
+ * Use the `URL` API instead.
+ */
+export declare const getQueryStrings: (url: string) => string;
+export declare const getPathNoStrict: (request: Request) => string;
+/**
+ * Merge paths.
+ * @param {string[]} ...paths - The paths to merge.
+ * @returns {string} The merged path.
+ * @example
+ * mergePath('/api', '/users') // '/api/users'
+ * mergePath('/api/', '/users') // '/api/users'
+ * mergePath('/api', '/') // '/api'
+ * mergePath('/api/', '/') // '/api/'
+ */
+export declare const mergePath: (...paths: string[]) => string;
+export declare const checkOptionalParameter: (path: string) => string[] | null;
+export declare const tryDecodeURIComponent: (str: string) => string;
+export declare const getQueryParam: (url: string, key?: string) => string | undefined | Record<string, string>;
+export declare const getQueryParams: (url: string, key?: string) => string[] | undefined | Record<string, string[]>;
+export declare const decodeURIComponent_: typeof decodeURIComponent;
+export {};

package/plugins/acryl-router/src/core/validator/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @module
+ * Validator for Acryl.
+ */
+export { validator } from './validator.ts';
+export type { ValidationFunction } from './validator.ts';
+export type { InferInput } from './utils.ts';

package/plugins/acryl-router/src/core/validator/utils.d.ts

@@ -0,0 +1,29 @@
+import type { FormValue, ParsedFormValue, ValidationTargets } from '../types.ts';
+import type { UnionToIntersection } from '../utils/types.ts';
+/**
+ * Checks if T is a literal union type (e.g., 'asc' | 'desc')
+ * that should be preserved in input types.
+ * Returns true for union literals, false for single literals or wide types.
+ */
+export type IsLiteralUnion<T, Base> = [Exclude<T, undefined>] extends [Base] ? [Exclude<T, undefined>] extends [UnionToIntersection<Exclude<T, undefined>>] ? false : true : false;
+type IsOptionalUnion<T> = [unknown] extends [T] ? false : undefined extends T ? true : false;
+type SimplifyDeep<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type InferInputInner<Output, Target extends keyof ValidationTargets, T extends FormValue> = SimplifyDeep<{
+    [K in keyof Output]: IsLiteralUnion<Output[K], string> extends true ? Output[K] : IsOptionalUnion<Output[K]> extends true ? Output[K] : Target extends 'form' ? T | T[] : Target extends 'query' ? string | string[] : Target extends 'param' ? string : Target extends 'header' ? string : Target extends 'cookie' ? string : unknown;
+}>;
+/**
+ * Utility type to infer input types for validation targets.
+ * Preserves literal union types (e.g., 'asc' | 'desc') while using
+ * the default ValidationTargets type for other values.
+ *
+ * @example
+ * ```ts
+ * // In @acryl-router/zod-validator or similar:
+ * type Input = InferInput<z.input<Schema>, 'query'>
+ * // { orderBy: 'asc' | 'desc', page: string | string[] }
+ * ```
+ */
+export type InferInput<Output, Target extends keyof ValidationTargets, T extends FormValue = ParsedFormValue> = [Exclude<Output, undefined>] extends [never] ? {} : [Exclude<Output, undefined>] extends [object] ? undefined extends Output ? SimplifyDeep<InferInputInner<Exclude<Output, undefined>, Target, T>> | undefined : SimplifyDeep<InferInputInner<Output, Target, T>> : {};
+export {};

package/plugins/acryl-router/src/core/validator/validator.d.ts

@@ -0,0 +1,16 @@
+import type { Context } from '../context.ts';
+import type { Env, MiddlewareHandler, TypedResponse, ValidationTargets, FormValue } from '../types.ts';
+import type { InferInput } from './utils.ts';
+type ValidationTargetKeysWithBody = 'form' | 'json';
+type ValidationTargetByMethod<M> = M extends 'get' | 'head' ? Exclude<keyof ValidationTargets, ValidationTargetKeysWithBody> : keyof ValidationTargets;
+export type ValidationFunction<InputType, OutputType, E extends Env = {}, P extends string = string> = (value: InputType, c: Context<E, P>) => OutputType | TypedResponse | Promise<OutputType> | Promise<TypedResponse>;
+export type ExtractValidationResponse<VF> = VF extends (value: any, c: any) => infer R ? R extends Promise<infer PR> ? PR extends TypedResponse<infer T, infer S, infer F> ? TypedResponse<T, S, F> : PR extends Response ? PR : PR extends undefined ? never : never : R extends TypedResponse<infer T, infer S, infer F> ? TypedResponse<T, S, F> : R extends Response ? R : R extends undefined ? never : never : never;
+export declare const validator: <InputType, P extends string, M extends string, U extends ValidationTargetByMethod<M>, P2 extends string = P, VF extends (value: unknown extends InputType ? ValidationTargets[U] : InputType, c: Context<any, P2>) => any = (value: unknown extends InputType ? ValidationTargets[U] : InputType, c: Context<any, P2>) => any, V extends {
+    in: { [K in U]: K extends "json" ? unknown extends InputType ? ExtractValidatorOutput<VF> : InputType : InferInput<ExtractValidatorOutput<VF>, K, FormValue>; };
+    out: { [K in U]: ExtractValidatorOutput<VF>; };
+} = {
+    in: { [K in U]: K extends "json" ? unknown extends InputType ? ExtractValidatorOutput<VF> : InputType : InferInput<ExtractValidatorOutput<VF>, K, FormValue>; };
+    out: { [K in U]: ExtractValidatorOutput<VF>; };
+}, E extends Env = any>(target: U, validationFunc: VF) => MiddlewareHandler<E, P, V, ExtractValidationResponse<VF>>;
+export type ExtractValidatorOutput<VF> = VF extends (value: any, c: any) => infer R ? R extends Promise<infer PR> ? PR extends Response | TypedResponse<any, any, any> ? never : PR : R extends Response | TypedResponse<any, any, any> ? never : R : never;
+export {};