pome-sh 0.6.6

package/node_modules/hono/dist/types/jsx/jsx-dev-runtime.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @module
+ * This module provides Hono's JSX dev runtime.
+ */
+import type { JSXNode } from './base';
+export { Fragment } from './base';
+export type { JSX } from './base';
+export declare function jsxDEV(tag: string | Function, props: Record<string, unknown>, key?: string): JSXNode;

package/node_modules/hono/dist/types/jsx/jsx-runtime.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @module
+ * This module provides Hono's JSX runtime.
+ */
+export { jsxDEV as jsx, Fragment } from './jsx-dev-runtime';
+export { jsxDEV as jsxs } from './jsx-dev-runtime';
+export type { JSX } from './jsx-dev-runtime';
+import { html } from '../helper/html';
+import type { HtmlEscapedString } from '../utils/html';
+export { html as jsxTemplate };
+export declare const jsxAttr: (key: string, v: string | Promise<string> | Record<string, string | number | null | undefined | boolean>) => HtmlEscapedString | Promise<HtmlEscapedString>;
+export declare const jsxEscape: (value: string) => string;

package/node_modules/hono/dist/types/jsx/streaming.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @module
+ * This module enables JSX to supports streaming Response.
+ */
+import type { HtmlEscapedString } from '../utils/html';
+import { JSXNode } from './base';
+import type { FC, PropsWithChildren, Context as JSXContext } from './';
+/**
+ * Used to specify nonce for scripts generated by `Suspense` and `ErrorBoundary`.
+ *
+ * @example
+ * ```tsx
+ * <StreamingContext.Provider value={{ scriptNonce: 'test-nonce' }}>
+ *   <Suspense fallback={<p>Loading...</p>}>
+ *     <Content />
+ *   </Suspense>
+ * </StreamingContext.Provider>
+ * ```
+ */
+export declare const StreamingContext: JSXContext<{
+    scriptNonce: string;
+} | null>;
+/**
+ * @experimental
+ * `Suspense` is an experimental feature.
+ * The API might be changed.
+ */
+export declare const Suspense: FC<PropsWithChildren<{
+    fallback: any;
+}>>;
+/**
+ * @experimental
+ * `renderToReadableStream()` is an experimental feature.
+ * The API might be changed.
+ */
+export declare const renderToReadableStream: (content: HtmlEscapedString | JSXNode | Promise<HtmlEscapedString>, onError?: (e: unknown) => string | void) => ReadableStream<Uint8Array>;

package/node_modules/hono/dist/types/jsx/types.d.ts

@@ -0,0 +1,35 @@
+/**
+ * All types exported from "hono/jsx" are in this file.
+ */
+import type { Child, JSXNode } from './base';
+import type { JSX } from './intrinsic-elements';
+export type { Child, JSXNode, FC } from './base';
+export type { RefObject } from './hooks';
+export type { Context } from './context';
+export type PropsWithChildren<P = unknown> = P & {
+    children?: Child | undefined;
+};
+export type CSSProperties = JSX.CSSProperties;
+/**
+ * React types
+ */
+type ReactElement<P = any, T = string | Function> = JSXNode & {
+    type: T;
+    props: P;
+    key: string | null;
+};
+type ReactNode = ReactElement | string | number | boolean | null | undefined;
+type ComponentClass<_P = {}, _S = {}> = unknown;
+export type { ReactElement, ReactNode, ComponentClass };
+export type Event = globalThis.Event;
+export type MouseEvent = globalThis.MouseEvent;
+export type KeyboardEvent = globalThis.KeyboardEvent;
+export type FocusEvent = globalThis.FocusEvent;
+export type ClipboardEvent = globalThis.ClipboardEvent;
+export type InputEvent = globalThis.InputEvent;
+export type PointerEvent = globalThis.PointerEvent;
+export type TouchEvent = globalThis.TouchEvent;
+export type WheelEvent = globalThis.WheelEvent;
+export type AnimationEvent = globalThis.AnimationEvent;
+export type TransitionEvent = globalThis.TransitionEvent;
+export type DragEvent = globalThis.DragEvent;

package/node_modules/hono/dist/types/jsx/utils.d.ts

@@ -0,0 +1,4 @@
+export declare const normalizeIntrinsicElementKey: (key: string) => string;
+export declare const isValidTagName: (name: unknown) => name is string;
+export declare const isValidAttributeName: (name: string) => boolean;
+export declare const styleObjectForEach: (style: Record<string, unknown>, fn: (key: string, value: string | null) => void) => void;

package/node_modules/hono/dist/types/middleware/basic-auth/index.d.ts

@@ -0,0 +1,75 @@
+/**
+ * @module
+ * Basic Auth Middleware for Hono.
+ */
+import type { Context } from '../../context';
+import type { MiddlewareHandler } from '../../types';
+type MessageFunction = (c: Context) => string | object | Promise<string | object>;
+type BasicAuthOptions = {
+    username: string;
+    password: string;
+    realm?: string;
+    hashFunction?: Function;
+    invalidUserMessage?: string | object | MessageFunction;
+    onAuthSuccess?: (c: Context, username: string) => void | Promise<void>;
+} | {
+    verifyUser: (username: string, password: string, c: Context) => boolean | Promise<boolean>;
+    realm?: string;
+    hashFunction?: Function;
+    invalidUserMessage?: string | object | MessageFunction;
+    onAuthSuccess?: (c: Context, username: string) => void | Promise<void>;
+};
+/**
+ * Basic Auth Middleware for Hono.
+ *
+ * @see {@link https://hono.dev/docs/middleware/builtin/basic-auth}
+ *
+ * @param {BasicAuthOptions} options - The options for the basic authentication middleware.
+ * @param {string} options.username - The username for authentication.
+ * @param {string} options.password - The password for authentication.
+ * @param {string} [options.realm="Secure Area"] - The realm attribute for the WWW-Authenticate header.
+ * @param {Function} [options.hashFunction] - The hash function used for secure comparison.
+ * @param {Function} [options.verifyUser] - The function to verify user credentials.
+ * @param {string | object | MessageFunction} [options.invalidUserMessage="Unauthorized"] - The invalid user message.
+ * @param {Function} [options.onAuthSuccess] - Callback function called on successful authentication.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ * @throws {HTTPException} If neither "username and password" nor "verifyUser" options are provided.
+ *
+ * @example
+ * ```ts
+ * const app = new Hono()
+ *
+ * app.use(
+ *   '/auth/*',
+ *   basicAuth({
+ *     username: 'hono',
+ *     password: 'ahotproject',
+ *   })
+ * )
+ *
+ * app.get('/auth/page', (c) => {
+ *   return c.text('You are authorized')
+ * })
+ * ```
+ *
+ * @example
+ * ```ts
+ * // With onAuthSuccess callback
+ * app.use(
+ *   '/auth/*',
+ *   basicAuth({
+ *     username: 'hono',
+ *     password: 'ahotproject',
+ *     onAuthSuccess: (c, username) => {
+ *       c.set('user', { name: username, role: 'admin' })
+ *       console.log(`User ${username} authenticated`)
+ *     },
+ *   })
+ * )
+ * ```
+ */
+export declare const basicAuth: (options: BasicAuthOptions, ...users: {
+    username: string;
+    password: string;
+}[]) => MiddlewareHandler;
+export {};

package/node_modules/hono/dist/types/middleware/bearer-auth/index.d.ts

@@ -0,0 +1,92 @@
+/**
+ * @module
+ * Bearer Auth Middleware for Hono.
+ */
+import type { Context } from '../../context';
+import type { Env, MiddlewareHandler } from '../../types';
+type MessageFunction = (c: Context) => string | object | Promise<string | object>;
+type CustomizedErrorResponseOptions = {
+    wwwAuthenticateHeader?: string | object | MessageFunction;
+    message?: string | object | MessageFunction;
+};
+type BearerAuthOptions<E extends Env = Env> = {
+    token: string | string[];
+    realm?: string;
+    prefix?: string;
+    headerName?: string;
+    hashFunction?: Function;
+    /**
+     * @deprecated Use noAuthenticationHeader.message instead
+     */
+    noAuthenticationHeaderMessage?: string | object | MessageFunction;
+    noAuthenticationHeader?: CustomizedErrorResponseOptions;
+    /**
+     * @deprecated Use invalidAuthenticationHeader.message instead
+     */
+    invalidAuthenticationHeaderMessage?: string | object | MessageFunction;
+    invalidAuthenticationHeader?: CustomizedErrorResponseOptions;
+    /**
+     * @deprecated Use invalidToken.message instead
+     */
+    invalidTokenMessage?: string | object | MessageFunction;
+    invalidToken?: CustomizedErrorResponseOptions;
+} | {
+    realm?: string;
+    prefix?: string;
+    headerName?: string;
+    verifyToken: (token: string, c: Context<E>) => boolean | Promise<boolean>;
+    hashFunction?: Function;
+    /**
+     * @deprecated Use noAuthenticationHeader.message instead
+     */
+    noAuthenticationHeaderMessage?: string | object | MessageFunction;
+    noAuthenticationHeader?: CustomizedErrorResponseOptions;
+    /**
+     * @deprecated Use invalidAuthenticationHeader.message instead
+     */
+    invalidAuthenticationHeaderMessage?: string | object | MessageFunction;
+    invalidAuthenticationHeader?: CustomizedErrorResponseOptions;
+    /**
+     * @deprecated Use invalidToken.message instead
+     */
+    invalidTokenMessage?: string | object | MessageFunction;
+    invalidToken?: CustomizedErrorResponseOptions;
+};
+/**
+ * Bearer Auth Middleware for Hono.
+ *
+ * @see {@link https://hono.dev/docs/middleware/builtin/bearer-auth}
+ *
+ * @template E - The environment type.
+ * @param {BearerAuthOptions} options - The options for the bearer authentication middleware.
+ * @param {string | string[]} [options.token] - The string or array of strings to validate the incoming bearer token against.
+ * @param {Function} [options.verifyToken] - The function to verify the token.
+ * @param {string} [options.realm=""] - The domain name of the realm, as part of the returned WWW-Authenticate challenge header.
+ * @param {string} [options.prefix="Bearer"] - The prefix (or known as `schema`) for the Authorization header value. If set to the empty string, no prefix is expected.
+ * @param {string} [options.headerName=Authorization] - The header name.
+ * @param {Function} [options.hashFunction] - A function to handle hashing for safe comparison of authentication tokens.
+ * @param {string | object | MessageFunction} [options.noAuthenticationHeader.message="Unauthorized"] - The no authentication header message.
+ * @param {string | object | MessageFunction} [options.noAuthenticationHeader.wwwAuthenticateHeader="Bearer realm=\"\""] - The response header value for the WWW-Authenticate header when no authentication header is provided.
+ * @param {string | object | MessageFunction} [options.invalidAuthenticationHeader.message="Bad Request"] - The invalid authentication header message.
+ * @param {string | object | MessageFunction} [options.invalidAuthenticationHeader.wwwAuthenticateHeader="Bearer error=\"invalid_request\""] - The response header value for the WWW-Authenticate header when authentication header is invalid.
+ * @param {string | object | MessageFunction} [options.invalidToken.message="Unauthorized"] - The invalid token message.
+ * @param {string | object | MessageFunction} [options.invalidToken.wwwAuthenticateHeader="Bearer error=\"invalid_token\""] - The response header value for the WWW-Authenticate header when token is invalid.
+ * @returns {MiddlewareHandler<E>} The middleware handler function.
+ * @throws {Error} If neither "token" nor "verifyToken" options are provided.
+ * @throws {HTTPException} If authentication fails, with 401 status code for missing or invalid token, or 400 status code for invalid request.
+ *
+ * @example
+ * ```ts
+ * const app = new Hono()
+ *
+ * const token = 'honoishot'
+ *
+ * app.use('/api/*', bearerAuth({ token }))
+ *
+ * app.get('/api/page', (c) => {
+ *   return c.json({ message: 'You are authorized' })
+ * })
+ * ```
+ */
+export declare const bearerAuth: <E extends Env = Env>(options: BearerAuthOptions<E>) => MiddlewareHandler<E>;
+export {};

package/node_modules/hono/dist/types/middleware/body-limit/index.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @module
+ * Body Limit Middleware for Hono.
+ */
+import type { Context } from '../../context';
+import type { MiddlewareHandler } from '../../types';
+type OnError = (c: Context) => Response | Promise<Response>;
+type BodyLimitOptions = {
+    maxSize: number;
+    onError?: OnError;
+};
+/**
+ * Body Limit Middleware for Hono.
+ *
+ * @see {@link https://hono.dev/docs/middleware/builtin/body-limit}
+ *
+ * @param {BodyLimitOptions} options - The options for the body limit middleware.
+ * @param {number} options.maxSize - The maximum body size allowed.
+ * @param {OnError} [options.onError] - The error handler to be invoked if the specified body size is exceeded.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * const app = new Hono()
+ *
+ * app.post(
+ *   '/upload',
+ *   bodyLimit({
+ *     maxSize: 50 * 1024, // 50kb
+ *     onError: (c) => {
+ *       return c.text('overflow :(', 413)
+ *     },
+ *   }),
+ *   async (c) => {
+ *     const body = await c.req.parseBody()
+ *     if (body['file'] instanceof File) {
+ *       console.log(`Got file sized: ${body['file'].size}`)
+ *     }
+ *     return c.text('pass :)')
+ *   }
+ * )
+ * ```
+ */
+export declare const bodyLimit: (options: BodyLimitOptions) => MiddlewareHandler;
+export {};

package/node_modules/hono/dist/types/middleware/cache/index.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @module
+ * Cache Middleware for Hono.
+ */
+import type { Context } from '../../context';
+import type { MiddlewareHandler } from '../../types';
+import type { StatusCode } from '../../utils/http-status';
+/**
+ * Cache Middleware for Hono.
+ *
+ * @see {@link https://hono.dev/docs/middleware/builtin/cache}
+ *
+ * @param {Object} options - The options for the cache middleware.
+ * @param {string | Function} options.cacheName - The name of the cache. Can be used to store multiple caches with different identifiers.
+ * @param {boolean} [options.wait=false] - A boolean indicating if Hono should wait for the Promise of the `cache.put` function to resolve before continuing with the request. Required to be true for the Deno environment.
+ * @param {string} [options.cacheControl] - A string of directives for the `Cache-Control` header.
+ * @param {string | string[]} [options.vary] - Adds the configured request headers to the cache key variants and sets the `Vary` header in the response. If the original response header already contains a `Vary` header, the values are merged, removing any duplicates.
+ * @param {Function} [options.keyGenerator] - Generates keys for every request in the `cacheName` store. This can be used to cache data based on request parameters or context parameters.
+ * @param {number[]} [options.cacheableStatusCodes=[200]] - An array of status codes that can be cached.
+ * @param {Function | false} [options.onCacheNotAvailable] - A callback invoked when `globalThis.caches` is not available. By default, a message is logged to the console. Set to `false` to suppress the log, or provide a custom function.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ * @throws {Error} If the `vary` option includes "*".
+ *
+ * @example
+ * ```ts
+ * app.get(
+ *   '*',
+ *   cache({
+ *     cacheName: 'my-app',
+ *     cacheControl: 'max-age=3600',
+ *   })
+ * )
+ * ```
+ */
+export declare const cache: (options: {
+    cacheName: string | ((c: Context) => Promise<string> | string);
+    wait?: boolean;
+    cacheControl?: string;
+    vary?: string | string[];
+    keyGenerator?: (c: Context) => Promise<string> | string;
+    cacheableStatusCodes?: StatusCode[];
+    onCacheNotAvailable?: (() => void) | false;
+}) => MiddlewareHandler;

package/node_modules/hono/dist/types/middleware/combine/index.d.ts

@@ -0,0 +1,85 @@
+/**
+ * @module
+ * Combine Middleware for Hono.
+ */
+import type { Context } from '../../context';
+import type { MiddlewareHandler } from '../../types';
+type Condition = (c: Context) => boolean;
+/**
+ * Create a composed middleware that runs the first middleware that returns true.
+ *
+ * @param middleware - An array of MiddlewareHandler or Condition functions.
+ * Middleware is applied in the order it is passed, and if any middleware exits without returning
+ * an exception first, subsequent middleware will not be executed.
+ * You can also pass a condition function that returns a boolean value. If returns true
+ * the evaluation will be halted, and rest of the middleware will not be executed.
+ * @returns A composed middleware.
+ *
+ * @example
+ * ```ts
+ * import { some } from 'hono/combine'
+ * import { bearerAuth } from 'hono/bearer-auth'
+ * import { myRateLimit } from '@/rate-limit'
+ *
+ * // If client has a valid token, then skip rate limiting.
+ * // Otherwise, apply rate limiting.
+ * app.use('/api/*', some(
+ *   bearerAuth({ token }),
+ *   myRateLimit({ limit: 100 }),
+ * ));
+ * ```
+ */
+export declare const some: (...middleware: (MiddlewareHandler | Condition)[]) => MiddlewareHandler;
+/**
+ * Create a composed middleware that runs all middleware and throws an error if any of them fail.
+ *
+ * @param middleware - An array of MiddlewareHandler or Condition functions.
+ * Middleware is applied in the order it is passed, and if any middleware throws an error,
+ * subsequent middleware will not be executed.
+ * You can also pass a condition function that returns a boolean value. If returns false
+ * the evaluation will be halted, and rest of the middleware will not be executed.
+ * @returns A composed middleware.
+ *
+ * @example
+ * ```ts
+ * import { some, every } from 'hono/combine'
+ * import { bearerAuth } from 'hono/bearer-auth'
+ * import { myCheckLocalNetwork } from '@/check-local-network'
+ * import { myRateLimit } from '@/rate-limit'
+ *
+ * // If client is in local network, then skip authentication and rate limiting.
+ * // Otherwise, apply authentication and rate limiting.
+ * app.use('/api/*', some(
+ *   myCheckLocalNetwork(),
+ *   every(
+ *     bearerAuth({ token }),
+ *     myRateLimit({ limit: 100 }),
+ *   ),
+ * ));
+ * ```
+ */
+export declare const every: (...middleware: (MiddlewareHandler | Condition)[]) => MiddlewareHandler;
+/**
+ * Create a composed middleware that runs all middleware except when the condition is met.
+ *
+ * @param condition - A string or Condition function.
+ * If there are multiple targets to match any of them, they can be passed as an array.
+ * If a string is passed, it will be treated as a path pattern to match.
+ * If a Condition function is passed, it will be evaluated against the request context.
+ * @param middleware - A composed middleware
+ *
+ * @example
+ * ```ts
+ * import { except } from 'hono/combine'
+ * import { bearerAuth } from 'hono/bearer-auth
+ *
+ * // If client is accessing public API, then skip authentication.
+ * // Otherwise, require a valid token.
+ * app.use('/api/*', except(
+ *   '/api/public/*',
+ *   bearerAuth({ token }),
+ * ));
+ * ```
+ */
+export declare const except: (condition: string | Condition | (string | Condition)[], ...middleware: MiddlewareHandler[]) => MiddlewareHandler;
+export {};

package/node_modules/hono/dist/types/middleware/compress/index.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @module
+ * Compress Middleware for Hono.
+ */
+import type { MiddlewareHandler } from '../../types';
+import { COMPRESSIBLE_CONTENT_TYPE_REGEX } from '../../utils/compress';
+export { COMPRESSIBLE_CONTENT_TYPE_REGEX };
+declare const ENCODING_TYPES: readonly ["gzip", "deflate"];
+type Encoding = (typeof ENCODING_TYPES)[number];
+type ContentTypeFilter = RegExp | ((contentType: string) => boolean);
+interface CompressionOptions {
+    encoding?: Encoding;
+    threshold?: number;
+    contentTypeFilter?: ContentTypeFilter;
+}
+/**
+ * Compress Middleware for Hono.
+ *
+ * @see {@link https://hono.dev/docs/middleware/builtin/compress}
+ *
+ * @param {CompressionOptions} [options] - The options for the compress middleware.
+ * @param {'gzip' | 'deflate'} [options.encoding] - The compression scheme to allow for response compression. Either 'gzip' or 'deflate'. If not defined, both are allowed and will be used based on the Accept-Encoding header. 'gzip' is prioritized if this option is not provided and the client provides both in the Accept-Encoding header.
+ * @param {number} [options.threshold=1024] - The minimum size in bytes to compress. Defaults to 1024 bytes.
+ * @param {RegExp | Function} [options.contentTypeFilter=COMPRESSIBLE_CONTENT_TYPE_REGEX] - A RegExp or function to determine if the response Content-Type should be compressed.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * const app = new Hono()
+ *
+ * app.use(compress())
+ *
+ * // Compress only JSON responses
+ * app.use(compress({ contentTypeFilter: /^application\/json/ }))
+ *
+ * // Compress based on custom Content-Type logic
+ * app.use(compress({ contentTypeFilter: (type) => COMPRESSIBLE_CONTENT_TYPE_REGEX.test(type) || type === "application/x-myformat" }))
+ * ```
+ */
+export declare const compress: (options?: CompressionOptions) => MiddlewareHandler;

package/node_modules/hono/dist/types/middleware/context-storage/index.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @module
+ * Context Storage Middleware for Hono.
+ */
+import type { Context } from '../../context';
+import type { Env, MiddlewareHandler } from '../../types';
+/**
+ * Context Storage Middleware for Hono.
+ *
+ * @see {@link https://hono.dev/docs/middleware/builtin/context-storage}
+ *
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * type Env = {
+ *   Variables: {
+ *     message: string
+ *   }
+ * }
+ *
+ * const app = new Hono<Env>()
+ *
+ * app.use(contextStorage())
+ *
+ * app.use(async (c, next) => {
+ *   c.set('message', 'Hono is hot!!)
+ *   await next()
+ * })
+ *
+ * app.get('/', async (c) => { c.text(getMessage()) })
+ *
+ * const getMessage = () => {
+ *   return getContext<Env>().var.message
+ * }
+ * ```
+ */
+export declare const contextStorage: () => MiddlewareHandler;
+export declare const tryGetContext: <E extends Env = Env>() => Context<E> | undefined;
+export declare const getContext: <E extends Env = Env>() => Context<E>;

package/node_modules/hono/dist/types/middleware/cors/index.d.ts

@@ -0,0 +1,55 @@
+/**
+ * @module
+ * CORS Middleware for Hono.
+ */
+import type { Context } from '../../context';
+import type { MiddlewareHandler } from '../../types';
+type CORSOptions = {
+    origin?: string | string[] | ((origin: string, c: Context) => Promise<string | undefined | null> | string | undefined | null);
+    allowMethods?: string[] | ((origin: string, c: Context) => Promise<string[]> | string[]);
+    allowHeaders?: string[];
+    maxAge?: number;
+    credentials?: boolean;
+    exposeHeaders?: string[];
+};
+/**
+ * CORS Middleware for Hono.
+ *
+ * @see {@link https://hono.dev/docs/middleware/builtin/cors}
+ *
+ * @param {CORSOptions} [options] - The options for the CORS middleware.
+ * @param {string | string[] | ((origin: string, c: Context) => Promise<string | undefined | null> | string | undefined | null)} [options.origin='*'] - The value of "Access-Control-Allow-Origin" CORS header.
+ * @param {string[] | ((origin: string, c: Context) => Promise<string[]> | string[])} [options.allowMethods=['GET', 'HEAD', 'PUT', 'POST', 'DELETE', 'PATCH']] - The value of "Access-Control-Allow-Methods" CORS header.
+ * @param {string[]} [options.allowHeaders=[]] - The value of "Access-Control-Allow-Headers" CORS header.
+ * @param {number} [options.maxAge] - The value of "Access-Control-Max-Age" CORS header.
+ * @param {boolean} [options.credentials] - The value of "Access-Control-Allow-Credentials" CORS header.
+ * @param {string[]} [options.exposeHeaders=[]] - The value of "Access-Control-Expose-Headers" CORS header.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * const app = new Hono()
+ *
+ * app.use('/api/*', cors())
+ * app.use(
+ *   '/api2/*',
+ *   cors({
+ *     origin: 'http://example.com',
+ *     allowHeaders: ['X-Custom-Header', 'Upgrade-Insecure-Requests'],
+ *     allowMethods: ['POST', 'GET', 'OPTIONS'],
+ *     exposeHeaders: ['Content-Length', 'X-Kuma-Revision'],
+ *     maxAge: 600,
+ *     credentials: true,
+ *   })
+ * )
+ *
+ * app.all('/api/abc', (c) => {
+ *   return c.json({ success: true })
+ * })
+ * app.all('/api2/abc', (c) => {
+ *   return c.json({ success: true })
+ * })
+ * ```
+ */
+export declare const cors: (options?: CORSOptions) => MiddlewareHandler;
+export {};

package/node_modules/hono/dist/types/middleware/csrf/index.d.ts

@@ -0,0 +1,78 @@
+/**
+ * @module
+ * CSRF Protection Middleware for Hono.
+ */
+import type { Context } from '../../context';
+import type { MiddlewareHandler } from '../../types';
+type IsAllowedOriginHandler = (origin: string, context: Context) => boolean | Promise<boolean>;
+declare const secFetchSiteValues: readonly ["same-origin", "same-site", "none", "cross-site"];
+type SecFetchSite = (typeof secFetchSiteValues)[number];
+type IsAllowedSecFetchSiteHandler = (secFetchSite: SecFetchSite, context: Context) => boolean | Promise<boolean>;
+interface CSRFOptions {
+    origin?: string | string[] | IsAllowedOriginHandler;
+    secFetchSite?: SecFetchSite | SecFetchSite[] | IsAllowedSecFetchSiteHandler;
+}
+/**
+ * CSRF Protection Middleware for Hono.
+ *
+ * Protects against Cross-Site Request Forgery attacks by validating request origins
+ * and sec-fetch-site headers. The request is allowed if either validation passes.
+ *
+ * @see {@link https://hono.dev/docs/middleware/builtin/csrf}
+ *
+ * @param {CSRFOptions} [options] - The options for the CSRF protection middleware.
+ * @param {string|string[]|(origin: string, context: Context) => boolean} [options.origin] -
+ *   Allowed origins for requests.
+ *   - string: Single allowed origin (e.g., 'https://example.com')
+ *   - string[]: Multiple allowed origins
+ *   - function: Custom validation logic
+ *   - Default: Only same origin as the request URL
+ * @param {string|string[]|(secFetchSite: string, context: Context) => boolean} [options.secFetchSite] -
+ *   Sec-Fetch-Site header validation. Standard values include 'same-origin', 'same-site', 'cross-site', 'none'.
+ *   - string: Single allowed value (e.g., 'same-origin')
+ *   - string[]: Multiple allowed values (e.g., ['same-origin', 'same-site'])
+ *   - function: Custom validation with access to context
+ *   - Default: Only allows 'same-origin'
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * const app = new Hono()
+ *
+ * // Default: both origin and sec-fetch-site validation
+ * app.use('*', csrf())
+ *
+ * // Allow specific origins
+ * app.use('*', csrf({ origin: 'https://example.com' }))
+ * app.use('*', csrf({ origin: ['https://app.com', 'https://api.com'] }))
+ *
+ * // Allow specific sec-fetch-site values
+ * app.use('*', csrf({ secFetchSite: 'same-origin' }))
+ * app.use('*', csrf({ secFetchSite: ['same-origin', 'same-site'] }))
+ *
+ * // Dynamic sec-fetch-site validation
+ * app.use('*', csrf({
+ *   secFetchSite: (secFetchSite, c) => {
+ *     // Always allow same-origin
+ *     if (secFetchSite === 'same-origin') return true
+ *     // Allow cross-site for webhook endpoints
+ *     if (secFetchSite === 'cross-site' && c.req.path.startsWith('/webhook/')) {
+ *       return true
+ *     }
+ *     return false
+ *   }
+ * }))
+ *
+ * // Dynamic origin validation
+ * app.use('*', csrf({
+ *   origin: (origin, c) => {
+ *     // Allow same origin
+ *     if (origin === new URL(c.req.url).origin) return true
+ *     // Allow specific trusted domains
+ *     return ['https://app.example.com', 'https://admin.example.com'].includes(origin)
+ *   }
+ * }))
+ * ```
+ */
+export declare const csrf: (options?: CSRFOptions) => MiddlewareHandler;
+export {};

package/node_modules/hono/dist/types/middleware/etag/digest.d.ts

@@ -0,0 +1 @@
+export declare const generateDigest: (stream: ReadableStream<Uint8Array<ArrayBuffer>> | null, generator: (body: Uint8Array<ArrayBuffer>) => ArrayBuffer | Promise<ArrayBuffer>) => Promise<string | null>;