hono 1.6.3 → 2.0.1

package/dist/compose.d.ts

@@ -1,2 +1,2 @@
 import type { ErrorHandler, NotFoundHandler } from './hono';
-export declare const compose: <C>(middleware: Function[], onError?: ErrorHandler<import("./context").Env> | undefined, onNotFound?: NotFoundHandler<import("./context").Env> | undefined) => (context: C, next?: Function | undefined) => Promise<C>;
+export declare const compose: <C>(middleware: Function[], onError?: ErrorHandler, onNotFound?: NotFoundHandler) => (context: C, next?: Function) => Promise<C>;

package/dist/compose.js

@@ -4,7 +4,7 @@ exports.compose = void 0;
 const context_1 = require("./context");
 // Based on the code in the MIT licensed `koa-compose` package.
 const compose = (middleware, onError, onNotFound) => {
-    return async (context, next) => {
+    return (context, next) => {
         let index = -1;
         return dispatch(0);
         async function dispatch(i) {
@@ -16,21 +16,21 @@ const compose = (middleware, onError, onNotFound) => {
             if (i === middleware.length && next)
                 handler = next;
             if (!handler) {
-                if (context instanceof context_1.Context && context.finalized === false && onNotFound) {
+                if (context instanceof context_1.HonoContext && context.finalized === false && onNotFound) {
                     context.res = await onNotFound(context);
                 }
                 return Promise.resolve(context);
             }
             return Promise.resolve(handler(context, () => dispatch(i + 1)))
-                .then(async (res) => {
+                .then((res) => {
                 // If handler return Response like `return c.text('foo')`
-                if (res && context instanceof context_1.Context) {
+                if (res && context instanceof context_1.HonoContext) {
                     context.res = res;
                 }
                 return context;
             })
                 .catch((err) => {
-                if (context instanceof context_1.Context && onError) {
+                if (context instanceof context_1.HonoContext && onError) {
                     if (err instanceof Error) {
                         context.res = onError(err, context);
                     }

package/dist/context.d.ts

@@ -1,23 +1,47 @@
 /// <reference types="@cloudflare/workers-types" />
 import type { NotFoundHandler } from './hono';
+import type { CookieOptions } from './utils/cookie';
 import type { StatusCode } from './utils/http-status';
 declare type Headers = Record<string, string>;
 export declare type Data = string | ArrayBuffer | ReadableStream;
-export declare type Env = Record<string, any>;
-export declare class Context<RequestParamKeyType extends string = string, E = Env> {
+declare type Env = Record<string, any>;
+export interface Context<RequestParamKeyType extends string = string, E = Env> {
     req: Request<RequestParamKeyType>;
     env: E;
-    event: FetchEvent | undefined;
-    executionCtx: ExecutionContext | undefined;
+    event: FetchEvent;
+    executionCtx: ExecutionContext;
     finalized: boolean;
-    private _status;
+    get res(): Response;
+    set res(_res: Response);
+    header: (name: string, value: string) => void;
+    status: (status: StatusCode) => void;
+    set: (key: string, value: any) => void;
+    get: (key: string) => any;
+    pretty: (prettyJSON: boolean, space?: number) => void;
+    newResponse: (data: Data | null, status: StatusCode, headers: Headers) => Response;
+    body: (data: Data | null, status?: StatusCode, headers?: Headers) => Response;
+    text: (text: string, status?: StatusCode, headers?: Headers) => Response;
+    json: <T>(object: T, status?: StatusCode, headers?: Headers) => Response;
+    html: (html: string, status?: StatusCode, headers?: Headers) => Response;
+    redirect: (location: string, status?: StatusCode) => Response;
+    cookie: (name: string, value: string, options?: CookieOptions) => void;
+    notFound: () => Response | Promise<Response>;
+}
+export declare class HonoContext<RequestParamKeyType extends string = string, E = Env> implements Context<RequestParamKeyType, E> {
+    req: Request<RequestParamKeyType>;
+    env: E;
+    finalized: boolean;
+    _status: StatusCode;
+    private _executionCtx;
     private _pretty;
     private _prettySpace;
     private _map;
     private _headers;
     private _res;
     private notFoundHandler;
-    constructor(req: Request, env?: E | undefined, eventOrExecutionCtx?: FetchEvent | ExecutionContext | undefined, notFoundHandler?: NotFoundHandler);
+    constructor(req: Request, env?: E | undefined, executionCtx?: FetchEvent | ExecutionContext | undefined, notFoundHandler?: NotFoundHandler);
+    get event(): FetchEvent;
+    get executionCtx(): ExecutionContext;
     get res(): Response;
     set res(_res: Response);
     header(name: string, value: string): void;
@@ -31,6 +55,7 @@ export declare class Context<RequestParamKeyType extends string = string, E = En
     json<T>(object: T, status?: StatusCode, headers?: Headers): Response;
     html(html: string, status?: StatusCode, headers?: Headers): Response;
     redirect(location: string, status?: StatusCode): Response;
+    cookie(name: string, value: string, opt?: CookieOptions): void;
     notFound(): Response | Promise<Response>;
 }
 export {};

package/dist/context.js

@@ -1,22 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Context = void 0;
+exports.HonoContext = void 0;
+const cookie_1 = require("./utils/cookie");
 const url_1 = require("./utils/url");
-class Context {
-    constructor(req, env = undefined, eventOrExecutionCtx = undefined, notFoundHandler = () => new Response()) {
+class HonoContext {
+    constructor(req, env = undefined, executionCtx = undefined, notFoundHandler = () => new Response()) {
         this._status = 200;
         this._pretty = false;
         this._prettySpace = 2;
+        this._executionCtx = executionCtx;
         this.req = req;
         this.env = env ? env : {};
-        if (eventOrExecutionCtx && 'respondWith' in eventOrExecutionCtx) {
-            this.event = eventOrExecutionCtx;
+        this.notFoundHandler = notFoundHandler;
+        this.finalized = false;
+    }
+    get event() {
+        if (this._executionCtx instanceof FetchEvent) {
+            return this._executionCtx;
         }
         else {
-            this.executionCtx = eventOrExecutionCtx;
+            throw Error('This context has no FetchEvent');
+        }
+    }
+    get executionCtx() {
+        if (this._executionCtx) {
+            return this._executionCtx;
+        }
+        else {
+            throw Error('This context has no ExecutionContext');
         }
-        this.notFoundHandler = notFoundHandler;
-        this.finalized = false;
     }
     get res() {
         return (this._res || (this._res = new Response()));
@@ -89,8 +101,12 @@ class Context {
             Location: location,
         });
     }
+    cookie(name, value, opt) {
+        const cookie = (0, cookie_1.serialize)(name, value, opt);
+        this.header('Set-Cookie', cookie);
+    }
     notFound() {
         return this.notFoundHandler(this);
     }
 }
-exports.Context = Context;
+exports.HonoContext = HonoContext;

package/dist/hono.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="@cloudflare/workers-types" />
-import { Context } from './context';
-import type { Env } from './context';
+import type { Context } from './context';
 import type { Router } from './router';
+declare type Env = Record<string, any>;
 export declare type Handler<RequestParamKeyType extends string = string, E = Env> = (c: Context<RequestParamKeyType, E>, next: Next) => Response | Promise<Response> | Promise<void> | Promise<Response | undefined>;
 export declare type NotFoundHandler<E = Env> = (c: Context<string, E>) => Response | Promise<Response>;
 export declare type ErrorHandler<E = Env> = (err: Error, c: Context<string, E>) => Response;
@@ -48,7 +48,7 @@ export declare class Hono<E extends Env = Env, P extends string = '/'> extends H
     private matchRoute;
     private dispatch;
     handleEvent(event: FetchEvent): Promise<Response>;
-    fetch: (request: Request, env?: E | undefined, executionCtx?: ExecutionContext | undefined) => Promise<Response>;
+    fetch: (request: Request, env?: E, executionCtx?: ExecutionContext) => Promise<Response>;
     request(input: RequestInfo, requestInit?: RequestInit): Promise<Response>;
 }
 export {};

package/dist/hono.js

@@ -29,7 +29,7 @@ class Hono extends defineDynamicClass() {
             const message = 'Internal Server Error';
             return c.text(message, 500);
         };
-        this.fetch = async (request, env, executionCtx) => {
+        this.fetch = (request, env, executionCtx) => {
             return this.dispatch(request, executionCtx, env);
         };
         (0, request_1.extendRequestPrototype)();
@@ -100,7 +100,7 @@ class Hono extends defineDynamicClass() {
         const result = this.matchRoute(method, path);
         request.paramData = result?.params;
         const handlers = result ? result.handlers : [this.notFoundHandler];
-        const c = new context_1.Context(request, env, eventOrExecutionCtx, this.notFoundHandler);
+        const c = new context_1.HonoContext(request, env, eventOrExecutionCtx, this.notFoundHandler);
         const composed = (0, compose_1.compose)(handlers, this.errorHandler, this.notFoundHandler);
         let context;
         try {
@@ -117,7 +117,7 @@ class Hono extends defineDynamicClass() {
         }
         return context.res;
     }
-    async handleEvent(event) {
+    handleEvent(event) {
         return this.dispatch(event.request, event);
     }
     request(input, requestInit) {

package/dist/index.d.ts

@@ -1,8 +1,7 @@
 /// <reference path="request.d.ts" />
 import { Hono } from './hono';
 export type { Handler, Next } from './hono';
-export { Context } from './context';
-export type { Env } from './context';
+export type { Context } from './context';
 declare module './hono' {
     interface Hono {
         fire(): void;

package/dist/index.js

@@ -1,12 +1,11 @@
 "use strict";
+// @denoify-ignore
 // eslint-disable-next-line @typescript-eslint/triple-slash-reference
 /// <reference path="./request.ts" /> Import "declare global" for the Request interface.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Hono = exports.Context = void 0;
+exports.Hono = void 0;
 const hono_1 = require("./hono");
 Object.defineProperty(exports, "Hono", { enumerable: true, get: function () { return hono_1.Hono; } });
-var context_1 = require("./context");
-Object.defineProperty(exports, "Context", { enumerable: true, get: function () { return context_1.Context; } });
 hono_1.Hono.prototype.fire = function () {
     addEventListener('fetch', (event) => {
         void event.respondWith(this.handleEvent(event));

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

@@ -6,15 +6,6 @@ const encode_1 = require("../../utils/encode");
 const CREDENTIALS_REGEXP = /^ *(?:[Bb][Aa][Ss][Ii][Cc]) +([A-Za-z0-9._~+/-]+=*) *$/;
 const USER_PASS_REGEXP = /^([^:]*):(.*)$/;
 const auth = (req) => {
-    if (!req) {
-        throw new TypeError('argument req is required');
-    }
-    if (typeof req !== 'object') {
-        throw new TypeError('argument req is required to be an object');
-    }
-    if (!req.headers || typeof req.headers !== 'object') {
-        throw new TypeError('argument req is required to have headers property');
-    }
     const match = CREDENTIALS_REGEXP.exec(req.headers.get('Authorization') || '');
     if (!match) {
         return undefined;

package/dist/middleware/compress/index.d.ts

@@ -0,0 +1,8 @@
+import type { Context } from '../../context';
+import type { Next } from '../../hono';
+declare type EncodingType = 'gzip' | 'deflate';
+interface CompressionOptions {
+    encoding?: EncodingType;
+}
+export declare const compress: (options?: CompressionOptions) => (ctx: Context, next: Next) => Promise<void>;
+export {};

package/dist/middleware/compress/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compress = void 0;
+const compress = (options) => {
+    return async (ctx, next) => {
+        await next();
+        const accepted = ctx.req.headers.get('Accept-Encoding');
+        const pattern = options?.encoding ?? /gzip|deflate/;
+        const match = accepted?.match(pattern);
+        if (!accepted || !match || !ctx.res.body) {
+            return;
+        }
+        const encoding = match[0];
+        const stream = new CompressionStream(encoding);
+        ctx.res = new Response(ctx.res.body.pipeThrough(stream), ctx.res.clone());
+        ctx.res.headers.set('Content-Encoding', encoding);
+    };
+};
+exports.compress = compress;

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

@@ -8,5 +8,5 @@ declare type CORSOptions = {
     credentials?: boolean;
     exposeHeaders?: string[];
 };
-export declare const cors: (options?: CORSOptions | undefined) => (c: Context, next: Next) => Promise<void>;
+export declare const cors: (options?: CORSOptions) => (c: Context, next: Next) => Promise<void>;
 export {};

package/dist/middleware/jsx/index.js

@@ -2,6 +2,23 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Fragment = exports.memo = exports.jsx = void 0;
 const html_1 = require("../../utils/html");
+const emptyTags = [
+    'area',
+    'base',
+    'br',
+    'col',
+    'embed',
+    'hr',
+    'img',
+    'input',
+    'keygen',
+    'link',
+    'meta',
+    'param',
+    'source',
+    'track',
+    'wbr',
+];
 const jsx = (tag, props, ...children) => {
     if (typeof tag === 'function') {
         return tag.call(null, { ...props, children: children.length <= 1 ? children[0] : children });
@@ -25,6 +42,9 @@ const jsx = (tag, props, ...children) => {
         result += ` ${propsKeys[i]}="${(0, html_1.escape)(v.toString())}"`;
     }
     if (tag !== '') {
+        if (emptyTags.includes(tag)) {
+            result += '/';
+        }
         result += '>';
     }
     const flattenChildren = children.flat(Infinity);
@@ -40,7 +60,7 @@ const jsx = (tag, props, ...children) => {
             result += (0, html_1.escape)(child.toString());
         }
     }
-    if (tag !== '') {
+    if (tag !== '' && !emptyTags.includes(tag)) {
         result += `</${tag}>`;
     }
     const escapedString = new String(result);

package/dist/middleware/jwt/index.js

@@ -6,6 +6,9 @@ const jwt = (options) => {
     if (!options) {
         throw new Error('JWT auth middleware requires options for "secret');
     }
+    if (!crypto.subtle || !crypto.subtle.importKey) {
+        throw new Error('`crypto.subtle.importKey` is undefined. JWT auth middleware requires it.');
+    }
     return async (ctx, next) => {
         const credentials = ctx.req.headers.get('Authorization');
         if (!credentials) {

package/dist/middleware/logger/index.d.ts

@@ -1,7 +1,5 @@
 import type { Context } from '../../context';
 import type { Next } from '../../hono';
-export declare const logger: (fn?: {
-    (...data: any[]): void;
-    (...data: any[]): void;
-    (message?: any, ...optionalParams: any[]): void;
-}) => (c: Context, next: Next) => Promise<void>;
+declare type PrintFunc = (str: string, ...rest: string[]) => void;
+export declare const logger: (fn: PrintFunc) => (c: Context, next: Next) => Promise<void>;
+export {};

package/dist/middleware/logger/index.js

@@ -2,24 +2,22 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.logger = void 0;
 const url_1 = require("../../utils/url");
-const humanize = (n, opts) => {
-    const options = opts || {};
-    const d = options.delimiter || ',';
-    const s = options.separator || '.';
-    n = n.toString().split('.');
-    n[0] = n[0].replace(/(\d)(?=(\d\d\d)+(?!\d))/g, '$1' + d);
-    return n.join(s);
+var LogPrefix;
+(function (LogPrefix) {
+    LogPrefix["Outgoing"] = "-->";
+    LogPrefix["Incoming"] = "<--";
+    LogPrefix["Error"] = "xxx";
+})(LogPrefix || (LogPrefix = {}));
+const humanize = (times) => {
+    const [delimiter, separator] = [',', '.'];
+    const orderTimes = times.map((v) => v.replace(/(\d)(?=(\d\d\d)+(?!\d))/g, '$1' + delimiter));
+    return orderTimes.join(separator);
 };
 const time = (start) => {
     const delta = Date.now() - start;
-    return humanize([delta < 10000 ? delta + 'ms' : Math.round(delta / 1000) + 's']);
+    return humanize([delta < 1000 ? delta + 'ms' : Math.round(delta / 1000) + 's']);
 };
-const LogPrefix = {
-    Outgoing: '-->',
-    Incoming: '<--',
-    Error: 'xxx',
-};
-const colorStatus = (status = 0) => {
+const colorStatus = (status) => {
     const out = {
         7: `\x1b[35m${status}\x1b[0m`,
         5: `\x1b[31m${status}\x1b[0m`,
@@ -29,15 +27,16 @@ const colorStatus = (status = 0) => {
         1: `\x1b[32m${status}\x1b[0m`,
         0: `\x1b[33m${status}\x1b[0m`,
     };
-    return out[(status / 100) | 0];
+    const calculateStatus = (status / 100) | 0;
+    return out[calculateStatus];
 };
-function log(fn, prefix, method, path, status, elapsed) {
+function log(fn, prefix, method, path, status = 0, elapsed) {
     const out = prefix === LogPrefix.Incoming
         ? `  ${prefix} ${method} ${path}`
         : `  ${prefix} ${method} ${path} ${colorStatus(status)} ${elapsed}`;
     fn(out);
 }
-const logger = (fn = console.log) => {
+const logger = (fn) => {
     return async (c, next) => {
         const { method } = c.req;
         const path = (0, url_1.getPathFromURL)(c.req.url);

package/dist/middleware/serve-static/bun.d.ts

@@ -0,0 +1,7 @@
+import type { Context } from '../../context';
+import type { Next } from '../../hono';
+export declare type ServeStaticOptions = {
+    root?: string;
+    path?: string;
+};
+export declare const serveStatic: (options?: ServeStaticOptions) => (c: Context, next: Next) => Promise<Response | undefined>;

package/dist/middleware/serve-static/bun.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serveStatic = void 0;
+const filepath_1 = require("../../utils/filepath");
+const mime_1 = require("../../utils/mime");
+// @ts-ignore
+const { file } = Bun;
+const DEFAULT_DOCUMENT = 'index.html';
+const serveStatic = (options = { root: '' }) => {
+    return async (c, next) => {
+        // Do nothing if Response is already set
+        if (c.res && c.finalized) {
+            await next();
+        }
+        const url = new URL(c.req.url);
+        let path = (0, filepath_1.getFilePath)({
+            filename: options.path ?? url.pathname,
+            root: options.root,
+            defaultDocument: DEFAULT_DOCUMENT,
+        });
+        path = `./${path}`;
+        const content = file(path);
+        if (content) {
+            const mimeType = (0, mime_1.getMimeType)(path);
+            if (mimeType) {
+                c.header('Content-Type', mimeType);
+            }
+            // Return Response object
+            return c.body(content);
+        }
+        else {
+            console.warn(`Static file: ${path} is not found`);
+            await next();
+        }
+        return;
+    };
+};
+exports.serveStatic = serveStatic;

package/dist/middleware/serve-static/module.d.mts

@@ -1,3 +1,5 @@
 import type { ServeStaticOptions } from './serve-static';
-declare const module: (options?: ServeStaticOptions) => import("../../hono").Handler<string, import("../../context").Env>;
+declare const module: (options?: ServeStaticOptions) => import("../../hono").Handler<string, {
+    [x: string]: any;
+}>;
 export { module as serveStatic };

package/dist/middleware/serve-static/serve-static.d.ts

@@ -1,5 +1,4 @@
 /// <reference types="@cloudflare/workers-types" />
-import type { Env } from '../../context';
 import type { Handler } from '../../hono';
 export declare type ServeStaticOptions = {
     root?: string;
@@ -7,4 +6,4 @@ export declare type ServeStaticOptions = {
     manifest?: object | string;
     namespace?: KVNamespace;
 };
-export declare const serveStatic: (options?: ServeStaticOptions) => Handler<string, Env>;
+export declare const serveStatic: (options?: ServeStaticOptions) => Handler;

package/dist/request.d.ts

@@ -1,3 +1,4 @@
+import type { Cookie } from './utils/cookie';
 declare global {
     interface Request<ParamKeyType extends string = string> {
         param: {
@@ -17,6 +18,14 @@ declare global {
             (name: string): string;
             (): Record<string, string>;
         };
+        cookie: {
+            (name: string): string;
+            (): Cookie;
+        };
+        parsedBody?: Promise<any>;
+        parseBody: {
+            (): Promise<any>;
+        };
     }
 }
 export declare function extendRequestPrototype(): void;

package/dist/request.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extendRequestPrototype = void 0;
+const body_1 = require("./utils/body");
+const cookie_1 = require("./utils/cookie");
 function extendRequestPrototype() {
     if (!!Request.prototype.param) {
         // already extended
@@ -55,5 +57,22 @@ function extendRequestPrototype() {
             return result;
         }
     };
+    Request.prototype.cookie = function (key) {
+        const cookie = this.headers.get('Cookie') || '';
+        const obj = (0, cookie_1.parse)(cookie);
+        if (key) {
+            const value = obj[key];
+            return value;
+        }
+        else {
+            return obj;
+        }
+    };
+    Request.prototype.parseBody = function () {
+        if (!this.parsedBody) {
+            this.parsedBody = (0, body_1.parseBody)(this);
+        }
+        return this.parsedBody;
+    };
 }
 exports.extendRequestPrototype = extendRequestPrototype;

package/dist/utils/buffer.d.ts

@@ -1,3 +1,3 @@
 export declare const equal: (a: ArrayBuffer, b: ArrayBuffer) => boolean;
-export declare const timingSafeEqual: (a: string | object | boolean, b: string | object | boolean, hashFunction?: Function | undefined) => Promise<boolean>;
+export declare const timingSafeEqual: (a: string | object | boolean, b: string | object | boolean, hashFunction?: Function) => Promise<boolean>;
 export declare const bufferToString: (buffer: ArrayBuffer) => string;

package/dist/utils/cloudflare.d.ts

@@ -3,4 +3,4 @@ export declare type KVAssetOptions = {
     manifest?: object | string;
     namespace?: KVNamespace;
 };
-export declare const getContentFromKVAsset: (path: string, options?: KVAssetOptions | undefined) => Promise<ArrayBuffer | null>;
+export declare const getContentFromKVAsset: (path: string, options?: KVAssetOptions) => Promise<ArrayBuffer | null>;

package/dist/utils/cookie.d.ts

@@ -0,0 +1,13 @@
+export declare type Cookie = Record<string, string>;
+export declare type CookieOptions = {
+    domain?: string;
+    expires?: Date;
+    httpOnly?: boolean;
+    maxAge?: number;
+    path?: string;
+    secure?: boolean;
+    signed?: boolean;
+    sameSite?: 'Strict' | 'Lax' | 'None';
+};
+export declare const parse: (cookie: string) => Cookie;
+export declare const serialize: (name: string, value: string, opt?: CookieOptions) => string;

package/dist/{middleware/cookie/index.js → utils/cookie.js}

@@ -1,27 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.cookie = void 0;
-const cookie = () => {
-    return async (c, next) => {
-        c.req.cookie = ((name) => {
-            const cookie = c.req.headers.get('Cookie') || '';
-            const obj = parse(cookie);
-            if (name) {
-                const value = obj[name];
-                return value;
-            }
-            else {
-                return obj;
-            }
-        });
-        c.cookie = (name, value, opt) => {
-            const cookie = serialize(name, value, opt);
-            c.header('Set-Cookie', cookie);
-        };
-        await next();
-    };
-};
-exports.cookie = cookie;
+exports.serialize = exports.parse = void 0;
 const parse = (cookie) => {
     const pairs = cookie.split(/;\s*/g);
     const parsedCookie = {};
@@ -31,6 +10,7 @@ const parse = (cookie) => {
     }
     return parsedCookie;
 };
+exports.parse = parse;
 const serialize = (name, value, opt = {}) => {
     value = encodeURIComponent(value);
     let cookie = `${name}=${value}`;
@@ -57,3 +37,4 @@ const serialize = (name, value, opt = {}) => {
     }
     return cookie;
 };
+exports.serialize = serialize;

package/dist/utils/jwt/jwt.js

@@ -46,10 +46,13 @@ const param = (name) => {
                 },
             };
         default:
-            throw new types_2.JwtAlorithmNotImplemented(name);
+            throw new types_2.JwtAlgorithmNotImplemented(name);
     }
 };
 const signing = async (data, secret, alg = types_1.AlgorithmTypes.HS256) => {
+    if (!crypto.subtle || !crypto.subtle.importKey) {
+        throw new Error('`crypto.subtle.importKey` is undefined. JWT auth middleware requires it.');
+    }
     const cryptoKey = await crypto.subtle.importKey(CryptoKeyFormat.RAW, (0, encode_1.utf8ToUint8Array)(secret), param(alg), false, [CryptoKeyUsage.Sign]);
     return await crypto.subtle.sign(param(alg), cryptoKey, (0, encode_1.utf8ToUint8Array)(data));
 };

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

@@ -1,6 +1,11 @@
-export declare class JwtAlorithmNotImplemented extends Error {
+export declare class JwtAlgorithmNotImplemented extends Error {
     constructor(token: string);
 }
+/**
+ * Export for backward compatibility
+ * @deprecated Use JwtAlgorithmNotImplemented instead
+**/
+export declare const JwtAlorithmNotImplemented: typeof JwtAlgorithmNotImplemented;
 export declare class JwtTokenInvalid extends Error {
     constructor(token: string);
 }