hono 2.1.4 → 2.2.0

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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStatusText = void 0;
+const getStatusText = (statusCode) => {
+    const text = statuses[statusCode];
+    return text;
+};
+exports.getStatusText = getStatusText;
+const statuses = {
+    100: 'Continue',
+    101: 'Switching Protocols',
+    102: 'Processing',
+    103: 'Early Hints',
+    200: 'OK',
+    201: 'Created',
+    202: 'Accepted',
+    204: 'No Content',
+    206: 'Partial Content',
+    301: 'Moved Permanently',
+    302: 'Moved Temporarily',
+    303: 'See Other',
+    304: 'Not Modified',
+    307: 'Temporary Redirect',
+    308: 'Permanent Redirect',
+    400: 'Bad Request',
+    401: 'Unauthorized',
+    402: 'Payment Required',
+    403: 'Forbidden',
+    404: 'Not Found',
+    405: 'Not Allowed',
+    406: 'Not Acceptable',
+    408: 'Request Time-out',
+    409: 'Conflict',
+    410: 'Gone',
+    411: 'Length Required',
+    412: 'Precondition Failed',
+    413: 'Request Entity Too Large',
+    414: 'Request-URI Too Large',
+    415: 'Unsupported Media Type',
+    416: 'Requested Range Not Satisfiable',
+    421: 'Misdirected Request',
+    429: 'Too Many Requests',
+    500: 'Internal Server Error',
+    501: 'Not Implemented',
+    502: 'Bad Gateway',
+    503: 'Service Temporarily Unavailable',
+    504: 'Gateway Time-out',
+    505: 'HTTP Version Not Supported',
+    507: 'Insufficient Storage',
+};

package/dist/cjs/utils/json.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSONPath = void 0;
+const JSONPath = (data, path) => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let val = data;
+    const parts = path.split('.');
+    const length = parts.length;
+    for (let i = 0; i < length && val !== undefined; i++) {
+        const p = parts[i];
+        if (p !== '') {
+            if (typeof val === 'object') {
+                val = val[p];
+            }
+            else {
+                val = undefined;
+            }
+        }
+    }
+    return val;
+};
+exports.JSONPath = JSONPath;

package/dist/cjs/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/cjs/utils/jwt/jwt.js

@@ -0,0 +1,101 @@
+"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.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));
+};
+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/cjs/utils/jwt/types.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlgorithmTypes = exports.JwtTokenSignatureMismatched = exports.JwtTokenExpired = exports.JwtTokenNotBefore = exports.JwtTokenInvalid = exports.JwtAlorithmNotImplemented = exports.JwtAlgorithmNotImplemented = void 0;
+class JwtAlgorithmNotImplemented extends Error {
+    constructor(token) {
+        super(`invalid JWT token: ${token}`);
+        this.name = 'JwtAlgorithmNotImplemented';
+    }
+}
+exports.JwtAlgorithmNotImplemented = JwtAlgorithmNotImplemented;
+/**
+ * Export for backward compatibility
+ * @deprecated Use JwtAlgorithmNotImplemented instead
+**/
+exports.JwtAlorithmNotImplemented = JwtAlgorithmNotImplemented;
+class JwtTokenInvalid extends Error {
+    constructor(token) {
+        super(`invalid JWT token: ${token}`);
+        this.name = 'JwtTokenInvalid';
+    }
+}
+exports.JwtTokenInvalid = JwtTokenInvalid;
+class JwtTokenNotBefore extends Error {
+    constructor(token) {
+        super(`token (${token}) is being used before it's valid`);
+        this.name = 'JwtTokenNotBefore';
+    }
+}
+exports.JwtTokenNotBefore = JwtTokenNotBefore;
+class JwtTokenExpired extends Error {
+    constructor(token) {
+        super(`token (${token}) expired`);
+        this.name = 'JwtTokenExpired';
+    }
+}
+exports.JwtTokenExpired = JwtTokenExpired;
+class JwtTokenSignatureMismatched extends Error {
+    constructor(token) {
+        super(`token(${token}) signature mismatched`);
+        this.name = 'JwtTokenSignatureMismatched';
+    }
+}
+exports.JwtTokenSignatureMismatched = JwtTokenSignatureMismatched;
+var AlgorithmTypes;
+(function (AlgorithmTypes) {
+    AlgorithmTypes["HS256"] = "HS256";
+    AlgorithmTypes["HS384"] = "HS384";
+    AlgorithmTypes["HS512"] = "HS512";
+})(AlgorithmTypes = exports.AlgorithmTypes || (exports.AlgorithmTypes = {}));

package/dist/cjs/utils/mime.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMimeType = void 0;
+const getMimeType = (filename) => {
+    const regexp = /\.([a-zA-Z0-9]+?)$/;
+    const match = filename.match(regexp);
+    if (!match)
+        return;
+    let mimeType = mimes[match[1]];
+    if ((mimeType && mimeType.startsWith('text')) || mimeType === 'application/json') {
+        mimeType += '; charset=utf-8';
+    }
+    return mimeType;
+};
+exports.getMimeType = getMimeType;
+const mimes = {
+    aac: 'audio/aac',
+    abw: 'application/x-abiword',
+    arc: 'application/x-freearc',
+    avi: 'video/x-msvideo',
+    azw: 'application/vnd.amazon.ebook',
+    bin: 'application/octet-stream',
+    bmp: 'image/bmp',
+    bz: 'application/x-bzip',
+    bz2: 'application/x-bzip2',
+    csh: 'application/x-csh',
+    css: 'text/css',
+    csv: 'text/csv',
+    doc: 'application/msword',
+    docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    eot: 'application/vnd.ms-fontobject',
+    epub: 'application/epub+zip',
+    gz: 'application/gzip',
+    gif: 'image/gif',
+    htm: 'text/html',
+    html: 'text/html',
+    ico: 'image/x-icon',
+    ics: 'text/calendar',
+    jar: 'application/java-archive',
+    jpeg: 'image/jpeg',
+    jpg: 'image/jpeg',
+    js: 'text/javascript',
+    json: 'application/json',
+    jsonld: 'application/ld+json',
+    map: 'application/json',
+    mid: 'audio/x-midi',
+    midi: 'audio/x-midi',
+    mjs: 'text/javascript',
+    mp3: 'audio/mpeg',
+    mpeg: 'video/mpeg',
+    mpkg: 'application/vnd.apple.installer+xml',
+    odp: 'application/vnd.oasis.opendocument.presentation',
+    ods: 'application/vnd.oasis.opendocument.spreadsheet',
+    odt: 'application/vnd.oasis.opendocument.text',
+    oga: 'audio/ogg',
+    ogv: 'video/ogg',
+    ogx: 'application/ogg',
+    opus: 'audio/opus',
+    otf: 'font/otf',
+    png: 'image/png',
+    pdf: 'application/pdf',
+    php: 'application/php',
+    ppt: 'application/vnd.ms-powerpoint',
+    pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+    rar: 'application/vnd.rar',
+    rtf: 'application/rtf',
+    sh: 'application/x-sh',
+    svg: 'image/svg+xml',
+    swf: 'application/x-shockwave-flash',
+    tar: 'application/x-tar',
+    tif: 'image/tiff',
+    tiff: 'image/tiff',
+    ts: 'video/mp2t',
+    ttf: 'font/ttf',
+    txt: 'text/plain',
+    vsd: 'application/vnd.visio',
+    wav: 'audio/wav',
+    weba: 'audio/webm',
+    webm: 'video/webm',
+    webp: 'image/webp',
+    woff: 'font/woff',
+    woff2: 'font/woff2',
+    xhtml: 'application/xhtml+xml',
+    xls: 'application/vnd.ms-excel',
+    xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    xml: 'application/xml',
+    xul: 'application/vnd.mozilla.xul+xml',
+    zip: 'application/zip',
+    '3gp': 'video/3gpp',
+    '3g2': 'video/3gpp2',
+    '7z': 'application/x-7z-compressed',
+};

package/dist/cjs/utils/url.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkOptionalParameter = exports.mergePath = exports.getQueryStringFromURL = exports.getPathFromURL = exports.getPattern = exports.splitPath = void 0;
+const splitPath = (path) => {
+    const paths = path.split(/\//); // faster than path.split('/')
+    if (paths[0] === '') {
+        paths.shift();
+    }
+    return paths;
+};
+exports.splitPath = splitPath;
+const patternCache = {};
+const getPattern = (label) => {
+    // *            => wildcard
+    // :id{[0-9]+}  => ([0-9]+)
+    // :id          => (.+)
+    //const name = ''
+    if (label === '*') {
+        return '*';
+    }
+    const match = label.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
+    if (match) {
+        if (!patternCache[label]) {
+            if (match[2]) {
+                patternCache[label] = [label, match[1], new RegExp('^' + match[2] + '$')];
+            }
+            else {
+                patternCache[label] = [label, match[1], true];
+            }
+        }
+        return patternCache[label];
+    }
+    return null;
+};
+exports.getPattern = getPattern;
+const getPathFromURL = (url, strict = true) => {
+    const queryIndex = url.indexOf('?');
+    const result = url.substring(url.indexOf('/', 8), queryIndex === -1 ? url.length : queryIndex);
+    // if strict routing is false => `/hello/hey/` and `/hello/hey` are treated the same
+    // default is true
+    if (strict === false && result.endsWith('/')) {
+        return result.slice(0, -1);
+    }
+    return result;
+};
+exports.getPathFromURL = getPathFromURL;
+const getQueryStringFromURL = (url) => {
+    const queryIndex = url.indexOf('?');
+    const result = queryIndex !== -1 ? url.substring(queryIndex) : '';
+    return result;
+};
+exports.getQueryStringFromURL = getQueryStringFromURL;
+const mergePath = (...paths) => {
+    let p = '';
+    let endsWithSlash = false;
+    for (let path of paths) {
+        /* ['/hey/','/say'] => ['/hey', '/say'] */
+        if (p.endsWith('/')) {
+            p = p.slice(0, -1);
+            endsWithSlash = true;
+        }
+        /* ['/hey','say'] => ['/hey', '/say'] */
+        if (!path.startsWith('/')) {
+            path = `/${path}`;
+        }
+        /* ['/hey/', '/'] => `/hey/` */
+        if (path === '/' && endsWithSlash) {
+            p = `${p}/`;
+        }
+        else if (path !== '/') {
+            p = `${p}${path}`;
+        }
+        /* ['/', '/'] => `/` */
+        if (path === '/' && p === '') {
+            p = '/';
+        }
+    }
+    return p;
+};
+exports.mergePath = mergePath;
+const checkOptionalParameter = (path) => {
+    /*
+     If path is `/api/animals/:type?` it will return:
+     [`/api/animals`, `/api/animals/:type`]
+     in other cases it will return null
+     */
+    const match = path.match(/(^.+)(\/\:[^\/]+)\?$/);
+    if (!match)
+        return null;
+    const base = match[1];
+    const optional = base + match[2];
+    return [base, optional];
+};
+exports.checkOptionalParameter = checkOptionalParameter;

package/dist/compose.d.ts

@@ -1,7 +1,7 @@
-import type { NotFoundHandler } from './hono';
+import type { Environment, NotFoundHandler } from './hono';
 interface ComposeContext {
     finalized: boolean;
     res: any;
 }
-export declare const compose: <C extends ComposeContext>(middleware: Function[], onNotFound?: NotFoundHandler<import("./hono").Environment> | undefined) => (context: C, next?: Function | undefined) => C | Promise<C>;
+export declare const compose: <C extends ComposeContext, E extends Partial<Environment> = Environment>(middleware: Function[], onNotFound?: NotFoundHandler<E> | undefined) => (context: C, next?: Function) => C | Promise<C>;
 export {};

package/dist/compose.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.compose = void 0;
-const context_1 = require("./context");
+import { HonoContext } from './context';
 // Based on the code in the MIT licensed `koa-compose` package.
-const compose = (middleware, onNotFound) => {
+export const compose = (middleware, onNotFound) => {
     const middlewareLength = middleware.length;
     return (context, next) => {
         let index = -1;
@@ -18,7 +15,7 @@ const compose = (middleware, onNotFound) => {
                 handler = next;
             let res;
             if (!handler) {
-                if (context instanceof context_1.HonoContext && context.finalized === false && onNotFound) {
+                if (context instanceof HonoContext && context.finalized === false && onNotFound) {
                     res = onNotFound(context);
                 }
             }
@@ -45,4 +42,3 @@ const compose = (middleware, onNotFound) => {
         }
     };
 };
-exports.compose = compose;

package/dist/context.d.ts

@@ -1,18 +1,20 @@
 /// <reference types="@cloudflare/workers-types" />
-import type { Environment, NotFoundHandler, ContextVariableMap } from './hono';
+import type { Environment, NotFoundHandler, ContextVariableMap, ValidatedData } from './hono';
 import type { CookieOptions } from './utils/cookie';
 import type { StatusCode } from './utils/http-status';
-declare type Headers = Record<string, string>;
+declare type Headers = Record<string, string | string[]>;
 export declare type Data = string | ArrayBuffer | ReadableStream;
-export interface Context<RequestParamKeyType extends string = string, E extends Partial<Environment> = any> {
-    req: Request<RequestParamKeyType>;
+export interface Context<RequestParamKeyType extends string = string, E extends Partial<Environment> = any, D extends ValidatedData = ValidatedData> {
+    req: Request<RequestParamKeyType, D>;
     env: E['Bindings'];
     event: FetchEvent;
     executionCtx: ExecutionContext;
     finalized: boolean;
     get res(): Response;
     set res(_res: Response);
-    header: (name: string, value: string) => void;
+    header: (name: string, value: string, options?: {
+        append?: boolean;
+    }) => void;
     status: (status: StatusCode) => void;
     set: {
         <Key extends keyof ContextVariableMap>(key: Key, value: ContextVariableMap[Key]): void;
@@ -34,8 +36,8 @@ export interface Context<RequestParamKeyType extends string = string, E extends
     cookie: (name: string, value: string, options?: CookieOptions) => void;
     notFound: () => Response | Promise<Response>;
 }
-export declare class HonoContext<RequestParamKeyType extends string = string, E extends Partial<Environment> = Environment> implements Context<RequestParamKeyType, E> {
-    req: Request<RequestParamKeyType>;
+export declare class HonoContext<RequestParamKeyType extends string = string, E extends Partial<Environment> = Environment, D extends ValidatedData = ValidatedData> implements Context<RequestParamKeyType, E, D> {
+    req: Request<RequestParamKeyType, D>;
     env: E['Bindings'];
     finalized: boolean;
     _status: StatusCode;
@@ -46,12 +48,14 @@ export declare class HonoContext<RequestParamKeyType extends string = string, E
     private _headers;
     private _res;
     private notFoundHandler;
-    constructor(req: Request, env?: E['Bindings'] | undefined, executionCtx?: FetchEvent | ExecutionContext | undefined, notFoundHandler?: NotFoundHandler);
+    constructor(req: Request<RequestParamKeyType>, env?: E['Bindings'] | undefined, executionCtx?: FetchEvent | ExecutionContext | undefined, notFoundHandler?: NotFoundHandler<E>);
     get event(): FetchEvent;
     get executionCtx(): ExecutionContext;
     get res(): Response;
     set res(_res: Response);
-    header(name: string, value: string): void;
+    header(name: string, value: string, options?: {
+        append?: boolean;
+    }): void;
     status(status: StatusCode): void;
     set<Key extends keyof ContextVariableMap>(key: Key, value: ContextVariableMap[Key]): void;
     set<Key extends keyof E['Variables']>(key: Key, value: E['Variables'][Key]): void;
@@ -61,6 +65,7 @@ export declare class HonoContext<RequestParamKeyType extends string = string, E
     get<T = any>(key: string): T;
     pretty(prettyJSON: boolean, space?: number): void;
     newResponse(data: Data | null, status: StatusCode, headers?: Headers): Response;
+    private _finalizeHeaders;
     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;

package/dist/context.js

@@ -1,10 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HonoContext = void 0;
-const hono_1 = require("./hono");
-const cookie_1 = require("./utils/cookie");
-const url_1 = require("./utils/url");
-class HonoContext {
+import { defaultNotFoundMessage } from './hono';
+import { serialize } from './utils/cookie';
+export class HonoContext {
     constructor(req, env = undefined, executionCtx = undefined, notFoundHandler = () => new Response()) {
         this._status = 200;
         this._pretty = false;
@@ -32,17 +28,35 @@ class HonoContext {
         }
     }
     get res() {
-        return (this._res || (this._res = new Response(hono_1.defaultNotFoundMessage, { status: 404 })));
+        return (this._res || (this._res = new Response(defaultNotFoundMessage, { status: 404 })));
     }
     set res(_res) {
         this._res = _res;
         this.finalized = true;
     }
-    header(name, value) {
+    header(name, value, options) {
         this._headers || (this._headers = {});
-        this._headers[name.toLowerCase()] = value;
+        const key = name.toLowerCase();
+        let shouldAppend = false;
+        if (options && options.append) {
+            const vAlreadySet = this._headers[key];
+            if (vAlreadySet && vAlreadySet.length) {
+                shouldAppend = true;
+            }
+        }
+        if (shouldAppend) {
+            this._headers[key].push(value);
+        }
+        else {
+            this._headers[key] = [value];
+        }
         if (this.finalized) {
-            this.res.headers.set(name, value);
+            if (shouldAppend) {
+                this.res.headers.append(name, value);
+            }
+            else {
+                this.res.headers.set(name, value);
+            }
         }
     }
     status(status) {
@@ -63,16 +77,39 @@ class HonoContext {
         this._prettySpace = space;
     }
     newResponse(data, status, headers = {}) {
-        const _headers = { ...this._headers };
+        return new Response(data, {
+            status: status || this._status || 200,
+            headers: this._finalizeHeaders(headers),
+        });
+    }
+    _finalizeHeaders(incomingHeaders) {
+        const finalizedHeaders = [];
+        const headersKv = this._headers || {};
+        // If Response is already set
         if (this._res) {
             this._res.headers.forEach((v, k) => {
-                _headers[k] = v;
+                headersKv[k] = [v];
             });
         }
-        return new Response(data, {
-            status: status || this._status || 200,
-            headers: { ..._headers, ...headers },
-        });
+        for (const key of Object.keys(incomingHeaders)) {
+            const value = incomingHeaders[key];
+            if (typeof value === 'string') {
+                finalizedHeaders.push([key, value]);
+            }
+            else {
+                for (const v of value) {
+                    finalizedHeaders.push([key, v]);
+                }
+            }
+            delete headersKv[key];
+        }
+        for (const key of Object.keys(headersKv)) {
+            for (const value of headersKv[key]) {
+                const kv = [key, value];
+                finalizedHeaders.push(kv);
+            }
+        }
+        return finalizedHeaders;
     }
     body(data, status = this._status, headers = {}) {
         return this.newResponse(data, status, headers);
@@ -93,21 +130,15 @@ class HonoContext {
         return this.body(html, status, headers);
     }
     redirect(location, status = 302) {
-        if (!(0, url_1.isAbsoluteURL)(location)) {
-            const url = new URL(this.req.url);
-            url.pathname = location;
-            location = url.toString();
-        }
         return this.newResponse(null, status, {
             Location: location,
         });
     }
     cookie(name, value, opt) {
-        const cookie = (0, cookie_1.serialize)(name, value, opt);
-        this.header('set-cookie', cookie);
+        const cookie = serialize(name, value, opt);
+        this.header('set-cookie', cookie, { append: true });
     }
     notFound() {
         return this.notFoundHandler(this);
     }
 }
-exports.HonoContext = HonoContext;