hono 1.0.0 → 1.2.0

package/dist/router/trie-router/node.js

@@ -3,96 +3,164 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Node = void 0;
 const router_1 = require("../../router");
 const url_1 = require("../../utils/url");
-const noRoute = () => {
-    return null;
-};
+function findParam(node, name) {
+    for (let i = 0, len = node.patterns.length; i < len; i++) {
+        if (typeof node.patterns[i] === 'object' && node.patterns[i][1] === name) {
+            return true;
+        }
+    }
+    const nodes = Object.values(node.children);
+    for (let i = 0, len = nodes.length; i < len; i++) {
+        if (findParam(nodes[i], name)) {
+            return true;
+        }
+    }
+    return false;
+}
 class Node {
     constructor(method, handler, children) {
         this.children = children || {};
-        this.method = {};
+        this.methods = [];
         if (method && handler) {
-            this.method[method] = handler;
+            const m = {};
+            m[method] = handler;
+            this.methods = [m];
         }
-        this.middlewares = [];
         this.patterns = [];
     }
     insert(method, path, handler) {
         // eslint-disable-next-line @typescript-eslint/no-this-alias
         let curNode = this;
         const parts = (0, url_1.splitPath)(path);
+        const parentPatterns = [];
+        const errorMessage = (name) => {
+            return `Duplicate param name, use another name instead of '${name}' - ${method} ${path} <--- '${name}'`;
+        };
         for (let i = 0, len = parts.length; i < len; i++) {
             const p = parts[i];
             if (Object.keys(curNode.children).includes(p)) {
+                parentPatterns.push(...curNode.patterns);
                 curNode = curNode.children[p];
                 continue;
             }
             curNode.children[p] = new Node();
             const pattern = (0, url_1.getPattern)(p);
             if (pattern) {
+                if (typeof pattern === 'object') {
+                    for (let j = 0, len = parentPatterns.length; j < len; j++) {
+                        if (typeof parentPatterns[j] === 'object' && parentPatterns[j][1] === pattern[1]) {
+                            throw new Error(errorMessage(pattern[1]));
+                        }
+                    }
+                    if (Object.values(curNode.children).some((n) => findParam(n, pattern[1]))) {
+                        throw new Error(errorMessage(pattern[1]));
+                    }
+                }
                 curNode.patterns.push(pattern);
+                parentPatterns.push(...curNode.patterns);
             }
+            parentPatterns.push(...curNode.patterns);
             curNode = curNode.children[p];
         }
-        curNode.method[method] = handler;
+        if (!curNode.methods.length) {
+            curNode.methods = [];
+        }
+        const m = {};
+        m[method] = handler;
+        curNode.methods.push(m);
         return curNode;
     }
-    search(method, path) {
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
-        let curNode = this;
-        const params = {};
-        const parts = (0, url_1.splitPath)(path);
-        for (let i = 0, len = parts.length; i < len; i++) {
-            const p = parts[i];
-            // '*' => match any path
-            // /api/* => default wildcard match
-            if (curNode.children['*'] && !curNode.children[p]) {
-                const astNode = curNode.children['*'];
-                if (Object.keys(astNode.children).length === 0) {
-                    curNode = astNode;
-                    break;
-                }
+    getHandlers(node, method) {
+        const handlers = [];
+        node.methods.map((m) => {
+            let handler = m[method];
+            if (handler !== undefined) {
+                handlers.push(handler);
+                return;
             }
-            const nextNode = curNode.children[p];
-            if (nextNode) {
-                curNode = nextNode;
-                // '/hello/*' => match '/hello'
-                if (!(i == len - 1 && nextNode.children['*'])) {
-                    continue;
+            handler = m[router_1.METHOD_NAME_ALL];
+            if (handler !== undefined) {
+                handlers.push(handler);
+                return;
+            }
+        });
+        return handlers;
+    }
+    next(node, part, method, isLast) {
+        const handlers = [];
+        const nextNodes = [];
+        const params = {};
+        for (let j = 0, len = node.patterns.length; j < len; j++) {
+            const pattern = node.patterns[j];
+            // Wildcard
+            // '/hello/*/foo' => match /hello/bar/foo
+            if (pattern === '*') {
+                const astNode = node.children['*'];
+                if (astNode) {
+                    handlers.push(...this.getHandlers(astNode, method));
+                    nextNodes.push(astNode);
                 }
             }
-            let isWildcard = false;
-            let isParamMatch = false;
-            for (let j = 0, len = curNode.patterns.length; j < len; j++) {
-                const pattern = curNode.patterns[j];
-                // Wildcard
-                // '/hello/*/foo' => match /hello/bar/foo
-                if (pattern === '*') {
-                    curNode = curNode.children['*'];
-                    isWildcard = true;
-                    break;
+            if (part === '')
+                continue;
+            // Named match
+            // `/posts/:id` => match /posts/123
+            const [key, name, matcher] = pattern;
+            if (matcher === true || (matcher instanceof RegExp && matcher.test(part))) {
+                if (typeof key === 'string') {
+                    if (isLast === true) {
+                        handlers.push(...this.getHandlers(node.children[key], method));
+                    }
+                    nextNodes.push(node.children[key]);
                 }
-                // Named match
-                const [key, name, matcher] = pattern;
-                if (p !== '' && (matcher === true || matcher.test(p))) {
-                    params[name] = p;
-                    curNode = curNode.children[key];
-                    isParamMatch = true;
-                    break;
+                if (typeof name === 'string') {
+                    params[name] = part;
                 }
-                return noRoute();
-            }
-            if (isWildcard && i === len - 1) {
-                break;
             }
-            if (isWildcard === false && isParamMatch === false) {
-                return noRoute();
+        }
+        const nextNode = node.children[part];
+        if (nextNode) {
+            if (isLast === true) {
+                // '/hello/*' => match '/hello'
+                if (nextNode.children['*'] !== undefined) {
+                    handlers.push(...this.getHandlers(nextNode.children['*'], method));
+                }
+                handlers.push(...this.getHandlers(nextNode, method));
             }
+            nextNodes.push(nextNode);
         }
-        const handler = curNode.method[router_1.METHOD_NAME_OF_ALL] || curNode.method[method];
-        if (!handler) {
-            return noRoute();
+        const next = {
+            nodes: nextNodes,
+            handlers: handlers,
+            params: params,
+        };
+        return next;
+    }
+    search(method, path) {
+        const handlers = [];
+        let params = {};
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const curNode = this;
+        let curNodes = [curNode];
+        const parts = (0, url_1.splitPath)(path);
+        for (let i = 0, len = parts.length; i < len; i++) {
+            const p = parts[i];
+            const isLast = i === len - 1;
+            const tempNodes = [];
+            for (let j = 0, len2 = curNodes.length; j < len2; j++) {
+                const res = this.next(curNodes[j], p, method, isLast);
+                if (res.nodes.length === 0) {
+                    continue;
+                }
+                handlers.push(...res.handlers);
+                params = Object.assign(params, res.params);
+                tempNodes.push(...res.nodes);
+            }
+            curNodes = tempNodes;
         }
-        return new router_1.Result(handler, params);
+        if (handlers.length <= 0)
+            return null;
+        return new router_1.Result(handlers, params);
     }
 }
 exports.Node = Node;

package/dist/router/trie-router/router.d.ts

@@ -5,5 +5,5 @@ export declare class TrieRouter<T> extends Router<T> {
     node: Node<T>;
     constructor();
     add(method: string, path: string, handler: T): void;
-    match(method: string, path: string): Result<T> | null;
+    match(method: string, path: string): Result<T>;
 }

package/dist/router.d.ts

@@ -1,10 +1,11 @@
-export declare const METHOD_NAME_OF_ALL = "ALL";
+export declare const METHOD_NAME_ALL: "ALL";
+export declare const METHOD_NAME_ALL_LOWERCASE: "all";
 export declare abstract class Router<T> {
     abstract add(method: string, path: string, handler: T): void;
     abstract match(method: string, path: string): Result<T> | null;
 }
 export declare class Result<T> {
-    handler: T;
+    handlers: T[];
     params: Record<string, string>;
-    constructor(handler: T, params: Record<string, string>);
+    constructor(handlers: T[], params: Record<string, string>);
 }

package/dist/router.js

@@ -1,13 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Result = exports.Router = exports.METHOD_NAME_OF_ALL = void 0;
-exports.METHOD_NAME_OF_ALL = 'ALL';
+exports.Result = exports.Router = exports.METHOD_NAME_ALL_LOWERCASE = exports.METHOD_NAME_ALL = void 0;
+exports.METHOD_NAME_ALL = 'ALL';
+exports.METHOD_NAME_ALL_LOWERCASE = 'all';
 class Router {
 }
 exports.Router = Router;
 class Result {
-    constructor(handler, params) {
-        this.handler = handler;
+    constructor(handlers, params) {
+        this.handlers = handlers;
         this.params = params;
     }
 }

package/dist/utils/body.js

@@ -7,10 +7,10 @@ const parseBody = async (r) => {
         return await r.json();
     }
     else if (contentType.includes('application/text')) {
-        return r.text();
+        return await r.text();
     }
     else if (contentType.startsWith('text')) {
-        return r.text();
+        return await r.text();
     }
     else if (contentType.includes('form')) {
         const form = {};

package/dist/utils/buffer.d.ts

@@ -1,2 +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) => Promise<boolean>;
+export declare const bufferToString: (buffer: ArrayBuffer) => string;

package/dist/utils/buffer.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.timingSafeEqual = exports.equal = void 0;
+exports.bufferToString = exports.timingSafeEqual = exports.equal = void 0;
 const crypto_1 = require("../utils/crypto");
 const equal = (a, b) => {
     if (a === b) {
@@ -29,3 +29,11 @@ const timingSafeEqual = async (a, b, hashFunction) => {
     return sa === sb && a === b;
 };
 exports.timingSafeEqual = timingSafeEqual;
+const bufferToString = (buffer) => {
+    if (buffer instanceof ArrayBuffer) {
+        const enc = new TextDecoder('utf-8');
+        return enc.decode(buffer);
+    }
+    return buffer;
+};
+exports.bufferToString = bufferToString;

package/dist/utils/crypto.d.ts

@@ -6,6 +6,4 @@ declare type Data = string | object | boolean;
 export declare const sha256: (data: Data) => Promise<string>;
 export declare const sha1: (data: Data) => Promise<string>;
 export declare const createHash: (data: Data, algorithm: Algorithm) => Promise<string>;
-export declare const encodeBase64: (str: string) => string;
-export declare const decodeBase64: (str: string) => string;
 export {};

package/dist/utils/crypto.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.decodeBase64 = exports.encodeBase64 = exports.createHash = exports.sha1 = exports.sha256 = void 0;
+exports.createHash = exports.sha1 = exports.sha256 = void 0;
 const sha256 = async (data) => {
     const algorithm = { name: 'SHA-256', alias: 'sha256' };
     const hash = await (0, exports.createHash)(data, algorithm);
@@ -34,53 +34,3 @@ const createHash = async (data, algorithm) => {
     }
 };
 exports.createHash = createHash;
-const encodeBase64 = (str) => {
-    if (str === null) {
-        throw new TypeError('1st argument of "encodeBase64" should not be null.');
-    }
-    try {
-        const encoder = new TextEncoder();
-        const bytes = encoder.encode(str);
-        const length = bytes.byteLength;
-        let binary = '';
-        for (let i = 0; i < length; i++) {
-            binary += String.fromCharCode(bytes[i]);
-        }
-        return btoa(binary);
-    }
-    catch (_a) { }
-    try {
-        const { Buffer } = require('buffer');
-        return Buffer.from(str).toString('base64');
-    }
-    catch (e) {
-        console.error('If you want to do "encodeBase64", polyfill "buffer" module.');
-        throw e;
-    }
-};
-exports.encodeBase64 = encodeBase64;
-const decodeBase64 = (str) => {
-    if (str === null) {
-        throw new TypeError('1st argument of "decodeBase64" should not be null.');
-    }
-    try {
-        const text = atob(str);
-        const length = text.length;
-        const bytes = new Uint8Array(length);
-        for (let i = 0; i < length; i++) {
-            bytes[i] = text.charCodeAt(i);
-        }
-        const decoder = new TextDecoder();
-        return decoder.decode(bytes);
-    }
-    catch (_a) { }
-    try {
-        const { Buffer } = require('buffer');
-        return Buffer.from(str, 'base64').toString();
-    }
-    catch (e) {
-        console.error('If you want to do "decodeBase64", polyfill "buffer" module.');
-        throw e;
-    }
-};
-exports.decodeBase64 = decodeBase64;

package/dist/utils/encode.d.ts

@@ -0,0 +1,7 @@
+export declare const encodeBase64: (str: string) => string;
+export declare const decodeBase64: (str: string) => string;
+export declare const encodeBase64URL: (str: string) => string;
+export declare const decodeBase64URL: (str: string) => string;
+export declare const utf8ToUint8Array: (str: string) => Uint8Array;
+export declare const arrayBufferToBase64: (buf: ArrayBuffer) => Promise<string>;
+export declare const arrayBufferToBase64URL: (buf: ArrayBuffer) => Promise<string>;

package/dist/utils/encode.js

@@ -0,0 +1,105 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayBufferToBase64URL = exports.arrayBufferToBase64 = exports.utf8ToUint8Array = exports.decodeBase64URL = exports.encodeBase64URL = exports.decodeBase64 = exports.encodeBase64 = void 0;
+const encodeBase64 = (str) => {
+    if (str === null) {
+        throw new TypeError('1st argument of "encodeBase64" should not be null.');
+    }
+    try {
+        const encoder = new TextEncoder();
+        const bytes = encoder.encode(str);
+        return btoa(String.fromCharCode(...bytes));
+    }
+    catch (_a) { }
+    try {
+        const { Buffer } = require('buffer');
+        return Buffer.from(str).toString('base64');
+    }
+    catch (e) {
+        console.error('If you want to do "encodeBase64", polyfill "buffer" module.');
+        throw e;
+    }
+};
+exports.encodeBase64 = encodeBase64;
+const decodeBase64 = (str) => {
+    if (str === null) {
+        throw new TypeError('1st argument of "decodeBase64" should not be null.');
+    }
+    try {
+        const text = atob(str);
+        const bytes = new Uint8Array(text.split('').map((c) => c.charCodeAt(0)));
+        const decoder = new TextDecoder();
+        return decoder.decode(bytes);
+    }
+    catch (_a) { }
+    try {
+        const { Buffer } = require('buffer');
+        return Buffer.from(str, 'base64').toString();
+    }
+    catch (e) {
+        console.error('If you want to do "decodeBase64", polyfill "buffer" module.');
+        throw e;
+    }
+};
+exports.decodeBase64 = decodeBase64;
+const encodeBase64URL = (str) => {
+    return (0, exports.encodeBase64)(str).replace(/=/g, '').replace(/\+/g, '-').replace(/\//g, '_');
+};
+exports.encodeBase64URL = encodeBase64URL;
+const decodeBase64URL = (str) => {
+    const pad = (s) => {
+        const diff = s.length % 4;
+        if (diff === 2) {
+            return `${s}==`;
+        }
+        if (diff === 3) {
+            return `${s}=`;
+        }
+        return s;
+    };
+    return (0, exports.decodeBase64)(pad(str).replace(/-/g, '+').replace('_', '/'));
+};
+exports.decodeBase64URL = decodeBase64URL;
+const utf8ToUint8Array = (str) => {
+    const encoder = new TextEncoder();
+    return encoder.encode(str);
+};
+exports.utf8ToUint8Array = utf8ToUint8Array;
+const arrayBufferToBase64 = async (buf) => {
+    if (typeof btoa === 'function') {
+        return btoa(String.fromCharCode(...new Uint8Array(buf)));
+    }
+    try {
+        const { Buffer } = await Promise.resolve().then(() => __importStar(require('buffer')));
+        return Buffer.from(String.fromCharCode(...new Uint8Array(buf))).toString('base64');
+    }
+    catch (e) { }
+};
+exports.arrayBufferToBase64 = arrayBufferToBase64;
+const arrayBufferToBase64URL = async (buf) => {
+    return (await (0, exports.arrayBufferToBase64)(buf)).replace(/=/g, '').replace(/\+/g, '-').replace(/\//g, '_');
+};
+exports.arrayBufferToBase64URL = arrayBufferToBase64URL;

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

@@ -0,0 +1 @@
+export * as Jwt from './jwt';

package/dist/utils/jwt/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Jwt = void 0;
+exports.Jwt = __importStar(require("./jwt"));

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

@@ -0,0 +1,7 @@
+import { AlgorithmTypes } from './types';
+export declare const sign: (payload: unknown, secret: string, alg?: AlgorithmTypes) => Promise<string>;
+export declare const verify: (token: string, secret: string, alg?: AlgorithmTypes) => Promise<boolean>;
+export declare const decode: (token: string) => {
+    header: any;
+    payload: any;
+};

package/dist/utils/jwt/jwt.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decode = exports.verify = exports.sign = void 0;
+const encode_1 = require("../../utils/encode");
+const types_1 = require("./types");
+const types_2 = require("./types");
+var CryptoKeyFormat;
+(function (CryptoKeyFormat) {
+    CryptoKeyFormat["RAW"] = "raw";
+    CryptoKeyFormat["PKCS8"] = "pkcs8";
+    CryptoKeyFormat["SPKI"] = "spki";
+    CryptoKeyFormat["JWK"] = "jwk";
+})(CryptoKeyFormat || (CryptoKeyFormat = {}));
+var CryptoKeyUsage;
+(function (CryptoKeyUsage) {
+    CryptoKeyUsage["Ecrypt"] = "encrypt";
+    CryptoKeyUsage["Decrypt"] = "decrypt";
+    CryptoKeyUsage["Sign"] = "sign";
+    CryptoKeyUsage["Verify"] = "verify";
+    CryptoKeyUsage["Deriverkey"] = "deriveKey";
+    CryptoKeyUsage["DeriveBits"] = "deriveBits";
+    CryptoKeyUsage["WrapKey"] = "wrapKey";
+    CryptoKeyUsage["UnwrapKey"] = "unwrapKey";
+})(CryptoKeyUsage || (CryptoKeyUsage = {}));
+const param = (name) => {
+    switch (name.toUpperCase()) {
+        case 'HS256':
+            return {
+                name: 'HMAC',
+                hash: {
+                    name: 'SHA-256',
+                },
+            };
+        case 'HS384':
+            return {
+                name: 'HMAC',
+                hash: {
+                    name: 'SHA-384',
+                },
+            };
+        case 'HS512':
+            return {
+                name: 'HMAC',
+                hash: {
+                    name: 'SHA-512',
+                },
+            };
+        default:
+            throw new types_2.JwtAlorithmNotImplemented(name);
+    }
+};
+const signing = async (data, secret, alg = types_1.AlgorithmTypes.HS256) => {
+    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));
+};
+const sign = async (payload, secret, alg = types_1.AlgorithmTypes.HS256) => {
+    const encodedPayload = await (0, encode_1.encodeBase64URL)(JSON.stringify(payload));
+    const encodedHeader = await (0, encode_1.encodeBase64URL)(JSON.stringify({ alg, typ: 'JWT' }));
+    const partialToken = `${encodedHeader}.${encodedPayload}`;
+    const signature = await (0, encode_1.arrayBufferToBase64URL)(await signing(partialToken, secret, alg));
+    return `${partialToken}.${signature}`;
+};
+exports.sign = sign;
+const verify = async (token, secret, alg = types_1.AlgorithmTypes.HS256) => {
+    const tokenParts = token.split('.');
+    if (tokenParts.length !== 3) {
+        throw new types_2.JwtTokenInvalid(token);
+    }
+    const { payload } = (0, exports.decode)(token);
+    if (payload.nbf && payload.nbf > Math.floor(Date.now() / 1000)) {
+        throw new types_2.JwtTokenNotBefore(token);
+    }
+    if (payload.exp && payload.exp <= Math.floor(Date.now() / 1000)) {
+        throw new types_2.JwtTokenExpired(token);
+    }
+    const signature = await (0, encode_1.arrayBufferToBase64URL)(await signing(tokenParts.slice(0, 2).join('.'), secret, alg));
+    if (signature !== tokenParts[2]) {
+        throw new types_2.JwtTokenSignatureMismatched(token);
+    }
+    return true;
+};
+exports.verify = verify;
+// eslint-disable-next-line
+const decode = (token) => {
+    try {
+        const [h, p] = token.split('.');
+        const header = JSON.parse((0, encode_1.decodeBase64URL)(h));
+        const payload = JSON.parse((0, encode_1.decodeBase64URL)(p));
+        return {
+            header,
+            payload,
+        };
+    }
+    catch (e) {
+        throw new types_2.JwtTokenInvalid(token);
+    }
+};
+exports.decode = decode;

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

@@ -0,0 +1,20 @@
+export declare class JwtAlorithmNotImplemented extends Error {
+    constructor(token: string);
+}
+export declare class JwtTokenInvalid extends Error {
+    constructor(token: string);
+}
+export declare class JwtTokenNotBefore extends Error {
+    constructor(token: string);
+}
+export declare class JwtTokenExpired extends Error {
+    constructor(token: string);
+}
+export declare class JwtTokenSignatureMismatched extends Error {
+    constructor(token: string);
+}
+export declare enum AlgorithmTypes {
+    HS256 = "HS256",
+    HS384 = "HS384",
+    HS512 = "HS512"
+}