hono 1.1.1 → 1.2.2

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

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const router_1 = require("./router");
+describe('Basic Usage', () => {
+    const router = new router_1.TrieRouter();
+    router.add('GET', '/hello', 'get hello');
+    router.add('POST', '/hello', 'post hello');
+    it('get, post hello', async () => {
+        let res = router.match('GET', '/hello');
+        expect(res).not.toBeNull();
+        expect(res.handlers).toEqual(['get hello']);
+        res = router.match('POST', '/hello');
+        expect(res).not.toBeNull();
+        expect(res.handlers).toEqual(['post hello']);
+        res = router.match('PUT', '/hello');
+        expect(res).toBeNull();
+        res = router.match('GET', '/');
+        expect(res).toBeNull();
+    });
+});
+describe('Complex', () => {
+    const router = new router_1.TrieRouter();
+    it('Named Param', async () => {
+        router.add('GET', '/entry/:id', 'get entry');
+        const res = router.match('GET', '/entry/123');
+        expect(res).not.toBeNull();
+        expect(res.handlers).toEqual(['get entry']);
+        expect(res.params['id']).toBe('123');
+    });
+    it('Wildcard', async () => {
+        router.add('GET', '/wild/*/card', 'get wildcard');
+        const res = router.match('GET', '/wild/xxx/card');
+        expect(res).not.toBeNull();
+        expect(res.handlers).toEqual(['get wildcard']);
+    });
+    it('Default', async () => {
+        router.add('GET', '/api/abc', 'get api');
+        router.add('GET', '/api/*', 'fallback');
+        let res = router.match('GET', '/api/abc');
+        expect(res).not.toBeNull();
+        expect(res.handlers).toEqual(['fallback', 'get api']);
+        res = router.match('GET', '/api/def');
+        expect(res).not.toBeNull();
+        expect(res.handlers).toEqual(['fallback']);
+    });
+    it('Regexp', async () => {
+        router.add('GET', '/post/:date{[0-9]+}/:title{[a-z]+}', 'get post');
+        let res = router.match('GET', '/post/20210101/hello');
+        expect(res).not.toBeNull();
+        expect(res.handlers).toEqual(['get post']);
+        expect(res.params['date']).toBe('20210101');
+        expect(res.params['title']).toBe('hello');
+        res = router.match('GET', '/post/onetwothree');
+        expect(res).toBeNull();
+        res = router.match('GET', '/post/123/123');
+        expect(res).toBeNull();
+    });
+});
+describe('Multi match', () => {
+    const router = new router_1.TrieRouter();
+    describe('Blog', () => {
+        router.add('ALL', '*', 'middleware a');
+        router.add('GET', '*', 'middleware b');
+        router.add('GET', '/entry', 'get entries');
+        router.add('POST', '/entry/*', 'middleware c');
+        router.add('POST', '/entry', 'post entry');
+        router.add('GET', '/entry/:id', 'get entry');
+        router.add('GET', '/entry/:id/comment/:comment_id', 'get comment');
+        it('GET /', async () => {
+            const res = router.match('GET', '/');
+            expect(res).not.toBeNull();
+            expect(res.handlers).toEqual(['middleware a', 'middleware b']);
+        });
+        it('GET /entry/123', async () => {
+            const res = router.match('GET', '/entry/123');
+            expect(res).not.toBeNull();
+            expect(res.handlers).toEqual(['middleware a', 'middleware b', 'get entry']);
+            expect(res.params['id']).toBe('123');
+        });
+        it('GET /entry/123/comment/456', async () => {
+            const res = router.match('GET', '/entry/123/comment/456');
+            expect(res).not.toBeNull();
+            expect(res.handlers).toEqual(['middleware a', 'middleware b', 'get comment']);
+            expect(res.params['id']).toBe('123');
+            expect(res.params['comment_id']).toBe('456');
+        });
+        it('POST /entry', async () => {
+            const res = router.match('POST', '/entry');
+            expect(res).not.toBeNull();
+            expect(res.handlers).toEqual(['middleware a', 'middleware c', 'post entry']);
+        });
+        it('DELETE /entry', async () => {
+            const res = router.match('DELETE', '/entry');
+            expect(res).not.toBeNull();
+            expect(res.handlers).toEqual(['middleware a']);
+        });
+    });
+});

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/body.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/body.test.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const body_1 = require("./body");
+describe('Parse Body Middleware', () => {
+    it('should parse JSON', async () => {
+        const payload = { message: 'hello hono' };
+        const req = new Request('http://localhost/json', {
+            method: 'POST',
+            body: JSON.stringify(payload),
+            headers: new Headers({ 'Content-Type': 'application/json' }),
+        });
+        expect(await (0, body_1.parseBody)(req)).toEqual(payload);
+    });
+    it('should parse Text', async () => {
+        const payload = 'hello';
+        const req = new Request('http://localhost/text', {
+            method: 'POST',
+            body: 'hello',
+            headers: new Headers({ 'Content-Type': 'application/text' }),
+        });
+        expect(await (0, body_1.parseBody)(req)).toEqual(payload);
+    });
+    it('should parse Form', async () => {
+        const formData = new URLSearchParams();
+        formData.append('message', 'hello');
+        const req = new Request('https://localhost/form', {
+            method: 'POST',
+            body: formData,
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+            },
+        });
+        expect(await (0, body_1.parseBody)(req)).toEqual({ message: 'hello' });
+    });
+    it('should parse Response body ', async () => {
+        const payload = 'hello';
+        const res = new Response(payload, {
+            headers: {
+                'Content-Type': 'text/plain',
+            },
+        });
+        console.log(res.headers.get('Content-Type'));
+        expect(await (0, body_1.parseBody)(res)).toEqual(payload);
+    });
+});

package/dist/utils/buffer.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.bufferToString = exports.timingSafeEqual = exports.equal = void 0;
-const crypto_1 = require("../utils/crypto");
+const crypto_1 = require("./crypto");
 const equal = (a, b) => {
     if (a === b) {
         return true;

package/dist/utils/buffer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/buffer.test.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_js_1 = require("crypto-js");
+const buffer_1 = require("./buffer");
+describe('buffer', () => {
+    it('positive', async () => {
+        expect(await (0, buffer_1.timingSafeEqual)('127e6fbfe24a750e72930c220a8e138275656b8e5d8f48a98c3c92df2caba935', '127e6fbfe24a750e72930c220a8e138275656b8e5d8f48a98c3c92df2caba935')).toBe(true);
+        expect(await (0, buffer_1.timingSafeEqual)('a', 'a')).toBe(true);
+        expect(await (0, buffer_1.timingSafeEqual)('', '')).toBe(true);
+        expect(await (0, buffer_1.timingSafeEqual)(undefined, undefined)).toBe(true);
+        expect(await (0, buffer_1.timingSafeEqual)(true, true)).toBe(true);
+        expect(await (0, buffer_1.timingSafeEqual)(false, false)).toBe(true);
+        expect(await (0, buffer_1.timingSafeEqual)(true, true, (d) => (0, crypto_js_1.SHA256)(d).toString()));
+    });
+    it('negative', async () => {
+        expect(await (0, buffer_1.timingSafeEqual)('a', 'b')).toBe(false);
+        expect(await (0, buffer_1.timingSafeEqual)('a', 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')).toBe(false);
+        expect(await (0, buffer_1.timingSafeEqual)('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', 'a')).toBe(false);
+        expect(await (0, buffer_1.timingSafeEqual)('alpha', 'beta')).toBe(false);
+        expect(await (0, buffer_1.timingSafeEqual)(false, true)).toBe(false);
+        expect(await (0, buffer_1.timingSafeEqual)(false, undefined)).toBe(false);
+        expect(await (0, buffer_1.timingSafeEqual)(() => { }, () => { })).toBe(false);
+        expect(await (0, buffer_1.timingSafeEqual)({}, {})).toBe(false);
+        expect(await (0, buffer_1.timingSafeEqual)({ a: 1 }, { a: 1 })).toBe(false);
+        expect(await (0, buffer_1.timingSafeEqual)({ a: 1 }, { a: 2 })).toBe(false);
+        expect(await (0, buffer_1.timingSafeEqual)([1, 2], [1, 2])).toBe(false);
+        expect(await (0, buffer_1.timingSafeEqual)([1, 2], [1, 2, 3])).toBe(false);
+    });
+});
+describe('bufferToString', () => {
+    it('Should return あいうえお', () => {
+        const bytes = [227, 129, 130, 227, 129, 132, 227, 129, 134, 227, 129, 136, 227, 129, 138];
+        const buffer = Uint8Array.from(bytes).buffer;
+        expect((0, buffer_1.bufferToString)(buffer)).toBe('あいうえお');
+    });
+});

package/dist/utils/cloudflare.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/cloudflare.test.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cloudflare_1 = require("./cloudflare");
+// Mock
+const store = {
+    'index.abcdef.html': 'This is index',
+    'assets/static/plain.abcdef.txt': 'Asset text',
+};
+const manifest = JSON.stringify({
+    'index.html': 'index.abcdef.html',
+    'assets/static/plain.txt': 'assets/static/plain.abcdef.txt',
+});
+Object.assign(global, { __STATIC_CONTENT_MANIFEST: manifest });
+Object.assign(global, {
+    __STATIC_CONTENT: {
+        get: (path) => {
+            return store[path];
+        },
+    },
+});
+describe('Utils for Cloudflare Workers', () => {
+    it('getContentFromKVAsset', async () => {
+        let content = await (0, cloudflare_1.getContentFromKVAsset)('not-found.txt');
+        expect(content).toBeUndefined();
+        content = await (0, cloudflare_1.getContentFromKVAsset)('index.html');
+        expect(content).not.toBeUndefined();
+        expect(content).toBe('This is index');
+        content = await (0, cloudflare_1.getContentFromKVAsset)('assets/static/plain.txt');
+        expect(content).not.toBeUndefined();
+        expect(content).toBe('Asset text');
+    });
+    it('getKVFilePath', async () => {
+        expect((0, cloudflare_1.getKVFilePath)({ filename: 'foo' })).toBe('foo/index.html');
+        expect((0, cloudflare_1.getKVFilePath)({ filename: 'foo.txt' })).toBe('foo.txt');
+        expect((0, cloudflare_1.getKVFilePath)({ filename: 'foo', root: 'bar' })).toBe('bar/foo/index.html');
+        expect((0, cloudflare_1.getKVFilePath)({ filename: 'foo.txt', root: 'bar' })).toBe('bar/foo.txt');
+        expect((0, cloudflare_1.getKVFilePath)({ filename: 'foo', defaultDocument: 'index.txt' })).toBe('foo/index.txt');
+        expect((0, cloudflare_1.getKVFilePath)({ filename: 'foo', root: 'bar', defaultDocument: 'index.txt' })).toBe('bar/foo/index.txt');
+        expect((0, cloudflare_1.getKVFilePath)({ filename: './foo' })).toBe('foo/index.html');
+        expect((0, cloudflare_1.getKVFilePath)({ filename: 'foo', root: './bar' })).toBe('bar/foo/index.html');
+    });
+});

package/dist/utils/crypto.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/crypto.test.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = require("./crypto");
+describe('crypto', () => {
+    it('sha256', async () => {
+        expect(await (0, crypto_1.sha256)('hono')).toBe('8b3dc17add91b7e8f0b5109a389927d66001139cd9b03fa7b95f83126e1b2b23');
+        expect(await (0, crypto_1.sha256)('炎')).toBe('1fddc5a562ee1fbeb4fc6def7d4be4911fcdae4273b02ae3a507b170ba0ea169');
+        expect(await (0, crypto_1.sha256)('abcdedf')).not.toBe('abcdef');
+    });
+    it('sha1', async () => {
+        expect(await (0, crypto_1.sha1)('hono')).toBe('28c7e86f5732391917876b45c06c626c04d77f39');
+        expect(await (0, crypto_1.sha1)('炎')).toBe('d56e09ae2421b2b8a0b5ee5fdceaed663c8c9472');
+        expect(await (0, crypto_1.sha1)('abcdedf')).not.toBe('abcdef');
+    });
+});

package/dist/utils/encode.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/encode.test.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const encode_1 = require("./encode");
+describe('encode', () => {
+    describe('base64', () => {
+        it('encodeBase64', () => {
+            expect((0, encode_1.encodeBase64)('hooooooooo')).toBe('aG9vb29vb29vbw==');
+            expect((0, encode_1.encodeBase64)('炎')).toBe('54KO');
+            expect((0, encode_1.encodeBase64)('abcdef')).not.toBe('abcdedf');
+            expect((0, encode_1.encodeBase64)('')).toBe('');
+            expect(() => {
+                (0, encode_1.encodeBase64)(null);
+            }).toThrow(TypeError);
+        });
+        it('decodeBase64', async () => {
+            expect((0, encode_1.decodeBase64)('aG9vb29vb29vbw==')).toBe('hooooooooo');
+            expect((0, encode_1.decodeBase64)('54KO')).toBe('炎');
+            expect((0, encode_1.decodeBase64)('abcdedf')).not.toBe('abcdef');
+            expect((0, encode_1.decodeBase64)('')).toBe('');
+            expect(() => {
+                (0, encode_1.decodeBase64)(null);
+            }).toThrowError(TypeError);
+        });
+    });
+    describe('base64url', () => {
+        it('encodeBase64URL', () => {
+            expect((0, encode_1.encodeBase64URL)('hooooooooo')).toBe('aG9vb29vb29vbw');
+            expect((0, encode_1.encodeBase64URL)('http://github.com/honojs/hono')).toBe('aHR0cDovL2dpdGh1Yi5jb20vaG9ub2pzL2hvbm8');
+            expect((0, encode_1.encodeBase64URL)('炎')).toBe('54KO');
+            expect((0, encode_1.encodeBase64URL)('abcdef')).not.toBe('abcdedf');
+            expect((0, encode_1.encodeBase64URL)('')).toBe('');
+            expect(() => {
+                (0, encode_1.encodeBase64URL)(null);
+            }).toThrow(TypeError);
+        });
+        it('decodeBase64URL', async () => {
+            expect((0, encode_1.decodeBase64URL)('aG9vb29vb29vbw')).toBe('hooooooooo');
+            expect((0, encode_1.decodeBase64URL)('aHR0cDovL2dpdGh1Yi5jb20vaG9ub2pzL2hvbm8')).toBe('http://github.com/honojs/hono');
+            expect((0, encode_1.decodeBase64URL)('54KO')).toBe('炎');
+            expect((0, encode_1.decodeBase64URL)('abcdedf')).not.toBe('abcdef');
+            expect((0, encode_1.decodeBase64URL)('')).toBe('');
+            expect(() => {
+                (0, encode_1.decodeBase64URL)(null);
+            }).toThrowError(TypeError);
+        });
+    });
+    describe('utf8ToUint8Array', () => {
+        it('should be equal', () => {
+            const k = 'a-secret-key';
+            const arr = (0, encode_1.utf8ToUint8Array)(k);
+            expect(String(arr)).toEqual('97,45,115,101,99,114,101,116,45,107,101,121');
+        });
+    });
+});

package/dist/utils/http-status.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/http-status.test.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const http_status_1 = require("./http-status");
+describe('http-status utility', () => {
+    it('getStatusText', () => {
+        expect((0, http_status_1.getStatusText)(200)).toBe('OK');
+    });
+});

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

@@ -0,0 +1 @@
+export {};

package/dist/utils/jwt/jwt.test.js

@@ -0,0 +1,171 @@
+"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 });
+const JWT = __importStar(require("./jwt"));
+const types_1 = require("./types");
+describe('JWT', () => {
+    it('JwtAlorithmNotImplemented', async () => {
+        const payload = { message: 'hello world' };
+        const secret = 'a-secret';
+        const alg = '';
+        let tok = '';
+        let err;
+        try {
+            tok = await JWT.sign(payload, secret, alg);
+        }
+        catch (e) {
+            err = e;
+        }
+        expect(tok).toBe('');
+        expect(err).toEqual(new types_1.JwtAlorithmNotImplemented(alg));
+    });
+    it('JwtTokenInvalid', async () => {
+        const tok = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJtZXNzYWdlIjoiaGVsbG8gd29ybGQifQ';
+        const secret = 'a-secret';
+        let err;
+        let authorized = false;
+        try {
+            authorized = await JWT.verify(tok, secret, types_1.AlgorithmTypes.HS256);
+        }
+        catch (e) {
+            err = e;
+        }
+        expect(err).toEqual(new types_1.JwtTokenInvalid(tok));
+        expect(authorized).toBe(false);
+    });
+    it('JwtTokenNotBefore', async () => {
+        const tok = 'eyJraWQiOiJFemF7bVZWbnd0TUpUNEFveFVtT0dILWJ0Y2VUVFM3djBYcEJuMm5ZZ2VjIiwiYWxnIjoiSFMyNTYifQ.eyJyb2xlIjoiYXBpX3JvbGUiLCJuYmYiOjE2NjQ1ODI0MDB9.BatadbUj5e41OZ33odEFTAndQFzX0w9aAgpQPgO-zaQ';
+        const secret = 'a-secret';
+        let err;
+        let authorized = false;
+        try {
+            authorized = await JWT.verify(tok, secret, types_1.AlgorithmTypes.HS256);
+        }
+        catch (e) {
+            err = e;
+        }
+        expect(err).toEqual(new types_1.JwtTokenNotBefore(tok));
+        expect(authorized).toBe(false);
+    });
+    it('JwtTokenExpired', async () => {
+        const tok = 'eyJraWQiOiJFemF6bVZWbnd0TUpUNEFveFVtT0dILWJ0Y2VUVFM3djBYcEJuMm5ZZ2VjIiwiYWxnIjoiSFMyNTYifQ.eyJyb2xlIjoiYXBpX3JvbGUiLCJleHAiOjE2MzMwNDY0MDB9.Gmq_dozOnwzqkMUMEm7uny7cMZuF1d0QkCnmRXAbTEk';
+        const secret = 'a-secret';
+        let err;
+        let authorized = false;
+        try {
+            authorized = await JWT.verify(tok, secret, types_1.AlgorithmTypes.HS256);
+        }
+        catch (e) {
+            err = e;
+        }
+        expect(err).toEqual(new types_1.JwtTokenExpired(tok));
+        expect(authorized).toBe(false);
+    });
+    it('HS256 sign & verify & decode', async () => {
+        const payload = { message: 'hello world' };
+        const secret = 'a-secret';
+        const tok = await JWT.sign(payload, secret, types_1.AlgorithmTypes.HS256);
+        const expected = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJtZXNzYWdlIjoiaGVsbG8gd29ybGQifQ.B54pAqIiLbu170tGQ1rY06Twv__0qSHTA0ioQPIOvFE';
+        expect(tok).toEqual(expected);
+        expect(await JWT.verify(tok, secret, types_1.AlgorithmTypes.HS256)).toBe(true);
+        expect(JWT.decode(tok)).toEqual({
+            header: {
+                alg: 'HS256',
+                typ: 'JWT',
+            },
+            payload: {
+                message: 'hello world',
+            },
+        });
+    });
+    it('HS256 sign & verify', async () => {
+        const payload = { message: 'hello world' };
+        const secret = 'a-secret';
+        const tok = await JWT.sign(payload, secret, types_1.AlgorithmTypes.HS256);
+        const expected = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJtZXNzYWdlIjoiaGVsbG8gd29ybGQifQ.B54pAqIiLbu170tGQ1rY06Twv__0qSHTA0ioQPIOvFE';
+        expect(tok).toEqual(expected);
+        let err = null;
+        let authorized = false;
+        try {
+            authorized = await JWT.verify(tok, secret + 'invalid', types_1.AlgorithmTypes.HS256);
+        }
+        catch (e) {
+            err = e;
+        }
+        expect(authorized).toBe(false);
+        expect(err instanceof types_1.JwtTokenSignatureMismatched).toBe(true);
+    });
+    it('HS512 sign & verify & decode', async () => {
+        const payload = { message: 'hello world' };
+        const secret = 'a-secret';
+        const tok = await JWT.sign(payload, secret, types_1.AlgorithmTypes.HS512);
+        const expected = 'eyJhbGciOiJIUzUxMiIsInR5cCI6IkpXVCJ9.eyJtZXNzYWdlIjoiaGVsbG8gd29ybGQifQ.RqVLgExB_GXF1-9T-k4V4HjFmiuQKTEjVSiZd-YL0WERIlywZ7PfzAuTZSJU4gg8cscGamQa030cieEWrYcywg';
+        expect(tok).toEqual(expected);
+        expect(await JWT.verify(tok, secret, types_1.AlgorithmTypes.HS512)).toBe(true);
+        expect(JWT.decode(tok)).toEqual({
+            header: {
+                alg: 'HS512',
+                typ: 'JWT',
+            },
+            payload: {
+                message: 'hello world',
+            },
+        });
+    });
+    it('HS512 sign & verify', async () => {
+        const payload = { message: 'hello world' };
+        const secret = 'a-secret';
+        const tok = await JWT.sign(payload, secret, types_1.AlgorithmTypes.HS512);
+        const expected = 'eyJhbGciOiJIUzUxMiIsInR5cCI6IkpXVCJ9.eyJtZXNzYWdlIjoiaGVsbG8gd29ybGQifQ.RqVLgExB_GXF1-9T-k4V4HjFmiuQKTEjVSiZd-YL0WERIlywZ7PfzAuTZSJU4gg8cscGamQa030cieEWrYcywg';
+        expect(tok).toEqual(expected);
+        let err = null;
+        let authorized = false;
+        try {
+            authorized = await JWT.verify(tok, secret + 'invalid', types_1.AlgorithmTypes.HS256);
+        }
+        catch (e) {
+            err = e;
+        }
+        expect(authorized).toBe(false);
+        expect(err instanceof types_1.JwtTokenSignatureMismatched).toBe(true);
+    });
+    it('HS384 sign & verify', async () => {
+        const payload = { message: 'hello world' };
+        const secret = 'a-secret%你好';
+        const tok = await JWT.sign(payload, secret, types_1.AlgorithmTypes.HS384);
+        const expected = 'eyJhbGciOiJIUzM4NCIsInR5cCI6IkpXVCJ9.eyJtZXNzYWdlIjoiaGVsbG8gd29ybGQifQ.C1Br1183Oy6O7th4NDCOaI9WB75i3FMCuYlv1tCL9HggsU89T-SNutghwhJykD3r';
+        expect(tok).toEqual(expected);
+        let err = null;
+        let authorized = false;
+        try {
+            authorized = await JWT.verify(tok, secret + 'invalid', types_1.AlgorithmTypes.HS256);
+        }
+        catch (e) {
+            err = e;
+        }
+        expect(authorized).toBe(false);
+        expect(err instanceof types_1.JwtTokenSignatureMismatched).toBe(true);
+    });
+});

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

@@ -0,0 +1 @@
+export {};

package/dist/utils/jwt/types.test.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+describe('Types', () => {
+    it('AlgorithmTypes', () => {
+        expect('HS256').toBe(types_1.AlgorithmTypes.HS256);
+        expect('HS384').toBe(types_1.AlgorithmTypes.HS384);
+        expect('HS512').toBe(types_1.AlgorithmTypes.HS512);
+        expect(undefined).toBe(undefined);
+        expect('').toBe('');
+    });
+});

package/dist/utils/mime.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/mime.test.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mime_1 = require("./mime");
+describe('mime', () => {
+    it('getMimeType', () => {
+        expect((0, mime_1.getMimeType)('hello.txt')).toBe('text/plain; charset=utf-8');
+        expect((0, mime_1.getMimeType)('hello.html')).toBe('text/html; charset=utf-8');
+        expect((0, mime_1.getMimeType)('hello.json')).toBe('application/json; charset=utf-8');
+        expect((0, mime_1.getMimeType)('good.morning.hello.gif')).toBe('image/gif');
+        expect((0, mime_1.getMimeType)('goodmorninghellogif')).toBeUndefined();
+        expect((0, mime_1.getMimeType)('indexjs.abcd')).toBeUndefined();
+    });
+});

package/dist/utils/url.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergePath = exports.isAbsoluteURL = exports.getPathFromURL = exports.getPattern = exports.splitPath = void 0;
-const URL_REGEXP = /^(([^:\/?#]+):)?(\/\/([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/;
+const URL_REGEXP = /^https?:\/\/[a-zA-Z0-9\-\.:]+(\/?[^?#]*)/;
 const splitPath = (path) => {
     const paths = path.split(/\//); // faster than path.split('/')
     if (paths[0] === '') {
@@ -37,19 +37,19 @@ exports.getPattern = getPattern;
 const getPathFromURL = (url, params = { strict: true }) => {
     // if strict routing is false => `/hello/hey/` and `/hello/hey` are treated the same
     // default is true
-    if (!params.strict && url.endsWith('/')) {
+    if (params.strict === false && url.endsWith('/')) {
         url = url.slice(0, -1);
     }
     const match = url.match(URL_REGEXP);
     if (match) {
-        return match[5];
+        return match[1];
     }
     return '';
 };
 exports.getPathFromURL = getPathFromURL;
 const isAbsoluteURL = (url) => {
     const match = url.match(URL_REGEXP);
-    if (match && match[1]) {
+    if (match) {
         return true;
     }
     return false;

package/dist/utils/url.test.d.ts

@@ -0,0 +1 @@
+export {};