hono 4.1.7 → 4.2.0

package/dist/middleware/bearer-auth/index.js

@@ -4,7 +4,7 @@ import { timingSafeEqual } from "../../utils/buffer.js";
 var TOKEN_STRINGS = "[A-Za-z0-9._~+/-]+=*";
 var PREFIX = "Bearer";
 var bearerAuth = (options) => {
-  if (!options.token) {
+  if (!("token" in options || "verifyToken" in options)) {
     throw new Error('bearer auth middleware requires options for "token"');
   }
   if (!options.realm) {
@@ -37,7 +37,9 @@ var bearerAuth = (options) => {
         throw new HTTPException(400, { res });
       } else {
         let equal = false;
-        if (typeof options.token === "string") {
+        if ("verifyToken" in options) {
+          equal = await options.verifyToken(match[1], c);
+        } else if (typeof options.token === "string") {
           equal = await timingSafeEqual(options.token, match[1], options.hashFunction);
         } else if (Array.isArray(options.token) && options.token.length > 0) {
           for (const token of options.token) {

package/dist/middleware/cache/index.js

@@ -7,11 +7,17 @@ var cache = (options) => {
   if (options.wait === void 0) {
     options.wait = false;
   }
-  const directives = options.cacheControl?.split(",").map((directive) => directive.toLowerCase());
+  const cacheControlDirectives = options.cacheControl?.split(",").map((directive) => directive.toLowerCase());
+  const varyDirectives = Array.isArray(options.vary) ? options.vary : options.vary?.split(",").map((directive) => directive.trim());
+  if (options.vary?.includes("*")) {
+    throw new Error(
+      'Middleware vary configuration cannot include "*", as it disallows effective caching.'
+    );
+  }
   const addHeader = (c) => {
-    if (directives) {
+    if (cacheControlDirectives) {
       const existingDirectives = c.res.headers.get("Cache-Control")?.split(",").map((d) => d.trim().split("=", 1)[0]) ?? [];
-      for (const directive of directives) {
+      for (const directive of cacheControlDirectives) {
         let [name, value] = directive.trim().split("=", 2);
         name = name.toLowerCase();
         if (!existingDirectives.includes(name)) {
@@ -19,6 +25,19 @@ var cache = (options) => {
         }
       }
     }
+    if (varyDirectives) {
+      const existingDirectives = c.res.headers.get("Vary")?.split(",").map((d) => d.trim()) ?? [];
+      const vary = Array.from(
+        new Set(
+          [...existingDirectives, ...varyDirectives].map((directive) => directive.toLowerCase())
+        )
+      ).sort();
+      if (vary.includes("*")) {
+        c.header("Vary", "*");
+      } else {
+        c.header("Vary", vary.join(", "));
+      }
+    }
   };
   return async function cache2(c, next) {
     const key = c.req.url;

package/dist/middleware/cors/index.js

@@ -23,7 +23,7 @@ var cors = (options) => {
     function set(key, value) {
       c.res.headers.set(key, value);
     }
-    const allowOrigin = findAllowOrigin(c.req.header("origin") || "");
+    const allowOrigin = findAllowOrigin(c.req.header("origin") || "", c);
     if (allowOrigin) {
       set("Access-Control-Allow-Origin", allowOrigin);
     }

package/dist/middleware/jwt/index.js

@@ -16,11 +16,13 @@ var jwt = (options) => {
     if (credentials) {
       const parts = credentials.split(/\s+/);
       if (parts.length !== 2) {
+        const errDescription = "invalid credentials structure";
         throw new HTTPException(401, {
+          message: errDescription,
           res: unauthorizedResponse({
             ctx,
             error: "invalid_request",
-            errDescription: "invalid credentials structure"
+            errDescription
           })
         });
       } else {
@@ -30,29 +32,33 @@ var jwt = (options) => {
       token = getCookie(ctx)[options.cookie];
     }
     if (!token) {
+      const errDescription = "no authorization included in request";
       throw new HTTPException(401, {
+        message: errDescription,
         res: unauthorizedResponse({
           ctx,
           error: "invalid_request",
-          errDescription: "no authorization included in request"
+          errDescription
         })
       });
     }
     let payload;
-    let msg = "";
+    let cause;
     try {
       payload = await Jwt.verify(token, options.secret, options.alg);
     } catch (e) {
-      msg = `${e}`;
+      cause = e;
     }
     if (!payload) {
       throw new HTTPException(401, {
+        message: "Unauthorized",
         res: unauthorizedResponse({
           ctx,
           error: "invalid_token",
-          statusText: msg,
+          statusText: "Unauthorized",
           errDescription: "token verification failure"
-        })
+        }),
+        cause
       });
     }
     ctx.set("jwtPayload", payload);

package/dist/middleware/method-override/index.js

@@ -0,0 +1,83 @@
+// src/middleware/method-override/index.ts
+import { URLSearchParams } from "url";
+import { parseBody } from "../../utils/body.js";
+var DEFAULT_METHOD_FORM_NAME = "_method";
+var methodOverride = (options) => async function methodOverride2(c, next) {
+  if (c.req.method === "GET") {
+    return await next();
+  }
+  const app = options.app;
+  if (!(options.header || options.query)) {
+    const contentType = c.req.header("content-type");
+    const methodFormName = options.form || DEFAULT_METHOD_FORM_NAME;
+    const clonedRequest = c.req.raw.clone();
+    const newRequest = clonedRequest.clone();
+    if (contentType?.startsWith("multipart/form-data")) {
+      const form = await clonedRequest.formData();
+      const method = form.get(methodFormName);
+      if (method) {
+        const newForm = await newRequest.formData();
+        newForm.delete(methodFormName);
+        const newHeaders = new Headers(clonedRequest.headers);
+        newHeaders.delete("content-type");
+        newHeaders.delete("content-length");
+        const request = new Request(c.req.url, {
+          body: newForm,
+          headers: newHeaders,
+          method
+        });
+        return app.fetch(request, c.env, getExecutionCtx(c));
+      }
+    }
+    if (contentType === "application/x-www-form-urlencoded") {
+      const params = await parseBody(clonedRequest);
+      const method = params[methodFormName];
+      if (method) {
+        delete params[methodFormName];
+        const newParams = new URLSearchParams(params);
+        const request = new Request(newRequest, {
+          body: newParams,
+          method
+        });
+        return app.fetch(request, c.env, getExecutionCtx(c));
+      }
+    }
+  } else if (options.header) {
+    const headerName = options.header;
+    const method = c.req.header(headerName);
+    if (method) {
+      const newHeaders = new Headers(c.req.raw.headers);
+      newHeaders.delete(headerName);
+      const request = new Request(c.req.raw, {
+        headers: newHeaders,
+        method
+      });
+      return app.fetch(request, c.env, getExecutionCtx(c));
+    }
+  } else if (options.query) {
+    const queryName = options.query;
+    const method = c.req.query(queryName);
+    if (method) {
+      const url = new URL(c.req.url);
+      url.searchParams.delete(queryName);
+      const request = new Request(url.toString(), {
+        body: c.req.raw.body,
+        headers: c.req.raw.headers,
+        method
+      });
+      return app.fetch(request, c.env, getExecutionCtx(c));
+    }
+  }
+  await next();
+};
+var getExecutionCtx = (c) => {
+  let executionCtx;
+  try {
+    executionCtx = c.executionCtx;
+  } catch {
+  }
+  return executionCtx;
+};
+export {
+  methodOverride
+};

package/dist/middleware/trailing-slash/index.js

@@ -0,0 +1,25 @@
+// src/middleware/trailing-slash/index.ts
+var trimTrailingSlash = () => {
+  return async function trimTrailingSlash2(c, next) {
+    await next();
+    if (c.res.status === 404 && c.req.method === "GET" && c.req.path !== "/" && c.req.path[c.req.path.length - 1] === "/") {
+      const url = new URL(c.req.url);
+      url.pathname = url.pathname.substring(0, url.pathname.length - 1);
+      c.res = c.redirect(url.toString(), 301);
+    }
+  };
+};
+var appendTrailingSlash = () => {
+  return async function appendTrailingSlash2(c, next) {
+    await next();
+    if (c.res.status === 404 && c.req.method === "GET" && c.req.path[c.req.path.length - 1] !== "/") {
+      const url = new URL(c.req.url);
+      url.pathname += "/";
+      c.res = c.redirect(url.toString(), 301);
+    }
+  };
+};
+export {
+  appendTrailingSlash,
+  trimTrailingSlash
+};

package/dist/request.js

@@ -66,10 +66,19 @@ var HonoRequest = class {
     if (cachedBody) {
       return cachedBody;
     }
-    if (bodyCache.arrayBuffer) {
-      return (async () => {
-        return await new Response(bodyCache.arrayBuffer)[key]();
-      })();
+    if (!bodyCache[key]) {
+      for (const keyOfBodyCache of Object.keys(bodyCache)) {
+        if (keyOfBodyCache === "parsedBody") {
+          continue;
+        }
+        return (async () => {
+          let body = await bodyCache[keyOfBodyCache];
+          if (keyOfBodyCache === "json") {
+            body = JSON.stringify(body);
+          }
+          return await new Response(body)[key]();
+        })();
+      }
     }
     return bodyCache[key] = raw[key]();
   };

package/dist/test-utils/setup-vitest.js

@@ -1,7 +1,10 @@
 // src/test-utils/setup-vitest.ts
-import crypto from "node:crypto";
+import * as nodeCrypto from "node:crypto";
 import { vi } from "vitest";
-vi.stubGlobal("crypto", crypto);
+if (!globalThis.crypto) {
+  vi.stubGlobal("crypto", nodeCrypto);
+  vi.stubGlobal("CryptoKey", nodeCrypto.webcrypto.CryptoKey);
+}
 var MockCache = class {
   name;
   store;

package/dist/types/helper/ssg/ssg.d.ts

@@ -21,6 +21,7 @@ export interface ToSSGResult {
     files: string[];
     error?: Error;
 }
+export declare const defaultExtensionMap: Record<string, string>;
 export type BeforeRequestHook = (req: Request) => Request | false | Promise<Request | false>;
 export type AfterResponseHook = (res: Response) => Response | false | Promise<Response | false>;
 export type AfterGenerateHook = (result: ToSSGResult) => void | Promise<void>;
@@ -30,6 +31,7 @@ export interface ToSSGOptions {
     afterResponseHook?: AfterResponseHook;
     afterGenerateHook?: AfterGenerateHook;
     concurrency?: number;
+    extensionMap?: Record<string, string>;
 }
 /**
  * @experimental
@@ -45,7 +47,7 @@ export declare const saveContentToFile: (data: Promise<{
     routePath: string;
     content: string | ArrayBuffer;
     mimeType: string;
-} | undefined>, fsModule: FileSystemModule, outDir: string) => Promise<string | undefined>;
+} | undefined>, fsModule: FileSystemModule, outDir: string, extensionMap?: Record<string, string>) => Promise<string | undefined>;
 /**
  * @experimental
  * `ToSSGInterface` is an experimental feature.

package/dist/types/helper.d.ts

@@ -0,0 +1,12 @@
+export * from './helper/accepts';
+export * from './helper/adapter';
+export * from './helper/cookie';
+export * from './helper/css';
+export * from './helper/factory';
+export * from './helper/html';
+export * from './helper/streaming';
+export * from './helper/testing';
+export * from './helper/dev';
+export * from './adapter/deno/ssg';
+export * from './adapter/deno/websocket';
+export { decode as jwtDecode, sign as jwtSign, verify as jwtVerify } from './middleware/jwt';

package/dist/types/jsx/dom/index.d.ts

@@ -1,13 +1,13 @@
 import type { Props, Child, JSXNode } from '../base';
 import { memo, isValidElement } from '../base';
 import { useContext } from '../context';
-import { useState, useEffect, useRef, useCallback, use, startTransition, useTransition, useDeferredValue, startViewTransition, useViewTransition, useMemo, useLayoutEffect, useReducer, useDebugValue } from '../hooks';
+import { useState, useEffect, useRef, useCallback, use, startTransition, useTransition, useDeferredValue, startViewTransition, useViewTransition, useMemo, useLayoutEffect, useReducer, useId, useDebugValue } from '../hooks';
 import { Suspense, ErrorBoundary } from './components';
 import { createContext } from './context';
 export { render } from './render';
 declare const createElement: (tag: string | ((props: Props) => JSXNode), props: Props, ...children: Child[]) => JSXNode;
 declare const cloneElement: <T extends JSXNode | JSX.Element>(element: T, props: Props, ...children: Child[]) => T;
-export { createElement as jsx, useState, useEffect, useRef, useCallback, use, startTransition, useTransition, useDeferredValue, startViewTransition, useViewTransition, useMemo, useLayoutEffect, useReducer, useDebugValue, Suspense, ErrorBoundary, createContext, useContext, memo, isValidElement, createElement, cloneElement, };
+export { createElement as jsx, useState, useEffect, useRef, useCallback, use, startTransition, useTransition, useDeferredValue, startViewTransition, useViewTransition, useMemo, useLayoutEffect, useReducer, useId, useDebugValue, Suspense, ErrorBoundary, createContext, useContext, memo, isValidElement, createElement, cloneElement, };
 declare const _default: {
     useState: <T>(initialState: T | (() => T)) => [T, (newState: T | ((currentState: T) => T)) => void];
     useEffect: (effect: () => void | (() => void), deps?: readonly unknown[] | undefined) => void;
@@ -22,6 +22,7 @@ declare const _default: {
     useMemo: <T_5>(factory: () => T_5, deps: readonly unknown[]) => T_5;
     useLayoutEffect: (effect: () => void | (() => void), deps?: readonly unknown[] | undefined) => void;
     useReducer: <T_6, A>(reducer: (state: T_6, action: A) => T_6, initialArg: T_6, init?: ((initialState: T_6) => T_6) | undefined) => [T_6, (action: A) => void];
+    useId: () => string;
     useDebugValue: (_value: unknown, _formatter?: ((value: unknown) => string) | undefined) => void;
     Suspense: import("../base").FC<import("..").PropsWithChildren<{
         fallback: any;

package/dist/types/jsx/hooks/index.d.ts

@@ -25,5 +25,6 @@ export type RefObject<T> = {
 export declare const useRef: <T>(initialValue: T | null) => RefObject<T>;
 export declare const use: <T>(promise: Promise<T>) => T;
 export declare const useMemo: <T>(factory: () => T, deps: readonly unknown[]) => T;
+export declare const useId: () => string;
 export declare const useDebugValue: (_value: unknown, _formatter?: ((value: unknown) => string) | undefined) => void;
 export {};

package/dist/types/jsx/index.d.ts

@@ -1,9 +1,9 @@
 import { jsx, memo, Fragment, isValidElement, cloneElement } from './base';
 import { ErrorBoundary } from './components';
 import { createContext, useContext } from './context';
-import { useState, useEffect, useRef, useCallback, use, startTransition, useTransition, useDeferredValue, startViewTransition, useViewTransition, useMemo, useLayoutEffect, useReducer, useDebugValue } from './hooks';
+import { useState, useEffect, useRef, useCallback, use, startTransition, useTransition, useDeferredValue, startViewTransition, useViewTransition, useMemo, useLayoutEffect, useReducer, useId, useDebugValue } from './hooks';
 import { Suspense } from './streaming';
-export { jsx, memo, Fragment, isValidElement, jsx as createElement, cloneElement, ErrorBoundary, createContext, useContext, useState, useEffect, useRef, useCallback, useReducer, useDebugValue, use, startTransition, useTransition, useDeferredValue, startViewTransition, useViewTransition, useMemo, useLayoutEffect, Suspense, };
+export { jsx, memo, Fragment, isValidElement, jsx as createElement, cloneElement, ErrorBoundary, createContext, useContext, useState, useEffect, useRef, useCallback, useReducer, useId, useDebugValue, use, startTransition, useTransition, useDeferredValue, startViewTransition, useViewTransition, useMemo, useLayoutEffect, Suspense, };
 declare const _default: {
     memo: <T>(component: import("./base").FC<T>, propsAreEqual?: (prevProps: Readonly<T>, nextProps: Readonly<T>) => boolean) => import("./base").FC<T>;
     Fragment: ({ children, }: {
@@ -25,6 +25,7 @@ declare const _default: {
     useRef: <T_5>(initialValue: T_5 | null) => import("./hooks").RefObject<T_5>;
     useCallback: <T_6 extends (...args: unknown[]) => unknown>(callback: T_6, deps: readonly unknown[]) => T_6;
     useReducer: <T_7, A>(reducer: (state: T_7, action: A) => T_7, initialArg: T_7, init?: ((initialState: T_7) => T_7) | undefined) => [T_7, (action: A) => void];
+    useId: () => string;
     useDebugValue: (_value: unknown, _formatter?: ((value: unknown) => string) | undefined) => void;
     use: <T_8>(promise: Promise<T_8>) => T_8;
     startTransition: (callback: () => void) => void;

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

@@ -1,10 +1,17 @@
+import type { Context } from '../../context';
 import type { MiddlewareHandler } from '../../types';
-export declare const basicAuth: (options: {
+type BasicAuthOptions = {
     username: string;
     password: string;
     realm?: string;
     hashFunction?: Function;
-}, ...users: {
+} | {
+    verifyUser: (username: string, password: string, c: Context) => boolean | Promise<boolean>;
+    realm?: string;
+    hashFunction?: Function;
+};
+export declare const basicAuth: (options: BasicAuthOptions, ...users: {
     username: string;
     password: string;
 }[]) => MiddlewareHandler;
+export {};

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

@@ -1,7 +1,15 @@
+import type { Context } from '../../context';
 import type { MiddlewareHandler } from '../../types';
-export declare const bearerAuth: (options: {
+type BearerAuthOptions = {
     token: string | string[];
     realm?: string;
     prefix?: string;
     hashFunction?: Function;
-}) => MiddlewareHandler;
+} | {
+    realm?: string;
+    prefix?: string;
+    verifyToken: (token: string, c: Context) => boolean | Promise<boolean>;
+    hashFunction?: Function;
+};
+export declare const bearerAuth: (options: BearerAuthOptions) => MiddlewareHandler;
+export {};

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

@@ -3,4 +3,5 @@ export declare const cache: (options: {
     cacheName: string;
     wait?: boolean;
     cacheControl?: string;
+    vary?: string | string[];
 }) => MiddlewareHandler;

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

@@ -1,6 +1,7 @@
+import type { Context } from '../../context';
 import type { MiddlewareHandler } from '../../types';
 type CORSOptions = {
-    origin: string | string[] | ((origin: string) => string | undefined | null);
+    origin: string | string[] | ((origin: string, c: Context) => string | undefined | null);
     allowMethods?: string[];
     allowHeaders?: string[];
     maxAge?: number;

package/dist/types/middleware/jwt/index.d.ts

@@ -1,5 +1,6 @@
 import type { MiddlewareHandler } from '../../types';
 import '../../context';
+import type { SignatureAlgorithm } from '../../utils/jwt/jwa';
 declare module '../../context' {
     interface ContextVariableMap {
         jwtPayload: any;
@@ -8,11 +9,11 @@ declare module '../../context' {
 export declare const jwt: (options: {
     secret: string;
     cookie?: string;
-    alg?: string;
+    alg?: SignatureAlgorithm;
 }) => MiddlewareHandler;
-export declare const verify: (token: string, secret: string, alg?: "HS256" | "HS384" | "HS512") => Promise<any>;
+export declare const verify: (token: string, publicKey: import("../../utils/jwt/jws").SignatureKey, alg?: "HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "PS256" | "PS384" | "PS512" | "ES256" | "ES384" | "ES512" | "EdDSA") => Promise<any>;
 export declare const decode: (token: string) => {
     header: any;
     payload: any;
 };
-export declare const sign: (payload: unknown, secret: string, alg?: "HS256" | "HS384" | "HS512") => Promise<string>;
+export declare const sign: (payload: import("../../utils/jwt/types").JWTPayload, privateKey: import("../../utils/jwt/jws").SignatureKey, alg?: "HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "PS256" | "PS384" | "PS512" | "ES256" | "ES384" | "ES512" | "EdDSA") => Promise<string>;

package/dist/types/middleware/method-override/index.d.ts

@@ -0,0 +1,36 @@
+import type { Hono } from '../../hono';
+import type { MiddlewareHandler } from '../../types';
+type MethodOverrideOptions = {
+    app: Hono<any, any, any>;
+} & ({
+    form?: string;
+    header?: never;
+    query?: never;
+} | {
+    form?: never;
+    header: string;
+    query?: never;
+} | {
+    form?: never;
+    header?: never;
+    query: string;
+});
+/**
+ * Method Override Middleware
+ *
+ * @example
+ * // with form input method
+ * const app = new Hono()
+ * app.use('/books/*', methodOverride({ app })) // the default `form` value is `_method`
+ * app.use('/authors/*', methodOverride({ app, form: 'method' }))
+ *
+ * @example
+ * // with custom header
+ * app.use('/books/*', methodOverride({ app, header: 'X-HTTP-METHOD-OVERRIDE' }))
+ *
+ * @example
+ * // with query parameter
+ * app.use('/books/*', methodOverride({ app, query: '_method' }))
+ */
+export declare const methodOverride: (options: MethodOverrideOptions) => MiddlewareHandler;
+export {};

package/dist/types/middleware/trailing-slash/index.d.ts

@@ -0,0 +1,13 @@
+import type { MiddlewareHandler } from '../../types';
+/**
+ * Trim the trailing slash from the URL if it does have one. For example, `/path/to/page/` will be redirected to `/path/to/page`.
+ * @access public
+ * @example app.use(trimTrailingSlash())
+ */
+export declare const trimTrailingSlash: () => MiddlewareHandler;
+/**
+ * Append a trailing slash to the URL if it doesn't have one. For example, `/path/to/page` will be redirected to `/path/to/page/`.
+ * @access public
+ * @example app.use(appendTrailingSlash())
+ */
+export declare const appendTrailingSlash: () => MiddlewareHandler;

package/dist/types/utils/jwt/index.d.ts

@@ -1 +1,8 @@
-export * as Jwt from './jwt';
+export declare const Jwt: {
+    sign: (payload: import("./types").JWTPayload, privateKey: import("./jws").SignatureKey, alg?: "HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "PS256" | "PS384" | "PS512" | "ES256" | "ES384" | "ES512" | "EdDSA") => Promise<string>;
+    verify: (token: string, publicKey: import("./jws").SignatureKey, alg?: "HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "PS256" | "PS384" | "PS512" | "ES256" | "ES384" | "ES512" | "EdDSA") => Promise<any>;
+    decode: (token: string) => {
+        header: any;
+        payload: any;
+    };
+};

package/dist/types/utils/jwt/jwa.d.ts

@@ -0,0 +1,16 @@
+export declare enum AlgorithmTypes {
+    HS256 = "HS256",
+    HS384 = "HS384",
+    HS512 = "HS512",
+    RS256 = "RS256",
+    RS384 = "RS384",
+    RS512 = "RS512",
+    PS256 = "PS256",
+    PS384 = "PS384",
+    PS512 = "PS512",
+    ES256 = "ES256",
+    ES384 = "ES384",
+    ES512 = "ES512",
+    EdDSA = "EdDSA"
+}
+export type SignatureAlgorithm = keyof typeof AlgorithmTypes;

package/dist/types/utils/jwt/jws.d.ts

@@ -0,0 +1,4 @@
+import type { SignatureAlgorithm } from './jwa';
+export type SignatureKey = string | JsonWebKey | CryptoKey;
+export declare function signing(privateKey: SignatureKey, alg: SignatureAlgorithm, data: BufferSource): Promise<ArrayBuffer>;
+export declare function verifying(publicKey: SignatureKey, alg: SignatureAlgorithm, signature: BufferSource, data: BufferSource): Promise<boolean>;

package/dist/types/utils/jwt/jwt.d.ts

@@ -1,9 +1,14 @@
-import type { AlgorithmTypes } from './types';
-type AlgorithmTypeName = keyof typeof AlgorithmTypes;
-export declare const sign: (payload: unknown, secret: string, alg?: AlgorithmTypeName) => Promise<string>;
-export declare const verify: (token: string, secret: string, alg?: AlgorithmTypeName) => Promise<any>;
+import type { SignatureAlgorithm } from './jwa';
+import type { SignatureKey } from './jws';
+import { type JWTPayload } from './types';
+export interface TokenHeader {
+    alg: SignatureAlgorithm;
+    typ: 'JWT';
+}
+export declare function isTokenHeader(obj: any): obj is TokenHeader;
+export declare const sign: (payload: JWTPayload, privateKey: SignatureKey, alg?: SignatureAlgorithm) => Promise<string>;
+export declare const verify: (token: string, publicKey: SignatureKey, alg?: SignatureAlgorithm) => Promise<any>;
 export declare const decode: (token: string) => {
     header: any;
     payload: any;
 };
-export {};

package/dist/types/utils/jwt/types.d.ts

@@ -13,11 +13,37 @@ export declare class JwtTokenExpired extends Error {
 export declare class JwtTokenIssuedAt extends Error {
     constructor(currentTimestamp: number, iat: number);
 }
+export declare class JwtHeaderInvalid extends Error {
+    constructor(header: object);
+}
 export declare class JwtTokenSignatureMismatched extends Error {
     constructor(token: string);
 }
-export declare enum AlgorithmTypes {
-    HS256 = "HS256",
-    HS384 = "HS384",
-    HS512 = "HS512"
+export declare enum CryptoKeyUsage {
+    Encrypt = "encrypt",
+    Decrypt = "decrypt",
+    Sign = "sign",
+    Verify = "verify",
+    DeriveKey = "deriveKey",
+    DeriveBits = "deriveBits",
+    WrapKey = "wrapKey",
+    UnwrapKey = "unwrapKey"
 }
+/**
+ * JWT Payload
+ */
+export type JWTPayload = (unknown & {}) | {
+    [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;
+};

package/dist/types/utils/jwt/utf8.d.ts

@@ -0,0 +1,2 @@
+export declare const utf8Encoder: TextEncoder;
+export declare const utf8Decoder: TextDecoder;

package/dist/utils/jwt/index.js

@@ -1,5 +1,6 @@
 // src/utils/jwt/index.ts
-import * as Jwt from "./jwt.js";
+import { sign, verify, decode } from "./jwt.js";
+var Jwt = { sign, verify, decode };
 export {
   Jwt
 };

package/dist/utils/jwt/jwa.js

@@ -0,0 +1,20 @@
+// src/utils/jwt/jwa.ts
+var AlgorithmTypes = /* @__PURE__ */ ((AlgorithmTypes2) => {
+  AlgorithmTypes2["HS256"] = "HS256";
+  AlgorithmTypes2["HS384"] = "HS384";
+  AlgorithmTypes2["HS512"] = "HS512";
+  AlgorithmTypes2["RS256"] = "RS256";
+  AlgorithmTypes2["RS384"] = "RS384";
+  AlgorithmTypes2["RS512"] = "RS512";
+  AlgorithmTypes2["PS256"] = "PS256";
+  AlgorithmTypes2["PS384"] = "PS384";
+  AlgorithmTypes2["PS512"] = "PS512";
+  AlgorithmTypes2["ES256"] = "ES256";
+  AlgorithmTypes2["ES384"] = "ES384";
+  AlgorithmTypes2["ES512"] = "ES512";
+  AlgorithmTypes2["EdDSA"] = "EdDSA";
+  return AlgorithmTypes2;
+})(AlgorithmTypes || {});
+export {
+  AlgorithmTypes
+};