hono 3.1.0 → 3.1.1

package/dist/cjs/context.js

@@ -39,6 +39,7 @@ class Context {
       if (options?.append) {
         if (!this._headers) {
           this._headers = new Headers(this._preparedHeaders);
+          this._preparedHeaders = {};
         }
         this._headers.append(name, value);
       } else {
@@ -87,11 +88,9 @@ class Context {
       }
       const status = arg ?? this._status;
       this._preparedHeaders ?? (this._preparedHeaders = {});
-      if (!this._headers) {
-        this._headers = new Headers();
-        for (const [k, v] of Object.entries(this._preparedHeaders)) {
-          this._headers.set(k, v);
-        }
+      this._headers ?? (this._headers = new Headers());
+      for (const [k, v] of Object.entries(this._preparedHeaders)) {
+        this._headers.set(k, v);
       }
       if (this._res) {
         this._res.headers.forEach((v, k) => {

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

@@ -26,12 +26,13 @@ var import_buffer = require("../../utils/buffer");
 var import_encode = require("../../utils/encode");
 const CREDENTIALS_REGEXP = /^ *(?:[Bb][Aa][Ss][Ii][Cc]) +([A-Za-z0-9._~+/-]+=*) *$/;
 const USER_PASS_REGEXP = /^([^:]*):(.*)$/;
+const utf8Decoder = new TextDecoder();
 const auth = (req) => {
   const match = CREDENTIALS_REGEXP.exec(req.headers.get("Authorization") || "");
   if (!match) {
     return void 0;
   }
-  const userPass = USER_PASS_REGEXP.exec((0, import_encode.decodeBase64)(match[1]));
+  const userPass = USER_PASS_REGEXP.exec(utf8Decoder.decode((0, import_encode.decodeBase64)(match[1])));
   if (!userPass) {
     return void 0;
   }

package/dist/cjs/utils/encode.js

@@ -18,65 +18,34 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var encode_exports = {};
 __export(encode_exports, {
-  arrayBufferToBase64: () => arrayBufferToBase64,
-  arrayBufferToBase64URL: () => arrayBufferToBase64URL,
   decodeBase64: () => decodeBase64,
-  decodeBase64URL: () => decodeBase64URL,
+  decodeBase64Url: () => decodeBase64Url,
   encodeBase64: () => encodeBase64,
-  encodeBase64URL: () => encodeBase64URL,
-  utf8ToUint8Array: () => utf8ToUint8Array
+  encodeBase64Url: () => encodeBase64Url
 });
 module.exports = __toCommonJS(encode_exports);
-const encodeBase64 = (str) => {
-  if (str === null) {
-    throw new TypeError('1st argument of "encodeBase64" should not be null.');
-  }
-  const encoder = new TextEncoder();
-  const bytes = encoder.encode(str);
-  return btoa(String.fromCharCode(...bytes));
+const decodeBase64Url = (str) => {
+  return decodeBase64(str.replace(/_|-/g, (m) => ({ _: "/", "-": "+" })[m] ?? m));
+};
+const encodeBase64Url = (buf) => encodeBase64(buf).replace(/\/|\+/g, (m) => ({ "/": "_", "+": "-" })[m] ?? m);
+const encodeBase64 = (buf) => {
+  const binary = String.fromCharCode(...new Uint8Array(buf));
+  return btoa(binary);
 };
 const decodeBase64 = (str) => {
-  if (str === null) {
-    throw new TypeError('1st argument of "decodeBase64" should not be null.');
+  const binary = atob(str);
+  const bytes = new Uint8Array(new ArrayBuffer(binary.length));
+  const half = binary.length / 2;
+  for (let i = 0, j = binary.length - 1; i <= half; i++, j--) {
+    bytes[i] = binary.charCodeAt(i);
+    bytes[j] = binary.charCodeAt(j);
   }
-  const text = atob(str);
-  const bytes = new Uint8Array(text.split("").map((c) => c.charCodeAt(0)));
-  const decoder = new TextDecoder();
-  return decoder.decode(bytes);
-};
-const encodeBase64URL = (str) => {
-  return encodeBase64(str).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
-};
-const decodeBase64URL = (str) => {
-  const pad = (s) => {
-    const diff = s.length % 4;
-    if (diff === 2) {
-      return `${s}==`;
-    }
-    if (diff === 3) {
-      return `${s}=`;
-    }
-    return s;
-  };
-  return decodeBase64(pad(str).replace(/-/g, "+").replace("_", "/"));
-};
-const utf8ToUint8Array = (str) => {
-  const encoder = new TextEncoder();
-  return encoder.encode(str);
-};
-const arrayBufferToBase64 = async (buf) => {
-  return btoa(String.fromCharCode(...new Uint8Array(buf)));
-};
-const arrayBufferToBase64URL = async (buf) => {
-  return (await arrayBufferToBase64(buf)).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+  return bytes;
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  arrayBufferToBase64,
-  arrayBufferToBase64URL,
   decodeBase64,
-  decodeBase64URL,
+  decodeBase64Url,
   encodeBase64,
-  encodeBase64URL,
-  utf8ToUint8Array
+  encodeBase64Url
 });

package/dist/cjs/utils/jwt/jwt.js

@@ -44,6 +44,11 @@ var CryptoKeyUsage = /* @__PURE__ */ ((CryptoKeyUsage2) => {
   CryptoKeyUsage2["UnwrapKey"] = "unwrapKey";
   return CryptoKeyUsage2;
 })(CryptoKeyUsage || {});
+const utf8Encoder = new TextEncoder();
+const utf8Decoder = new TextDecoder();
+const encodeJwtPart = (part) => (0, import_encode.encodeBase64Url)(utf8Encoder.encode(JSON.stringify(part))).replace(/=/g, "");
+const encodeSignaturePart = (buf) => (0, import_encode.encodeBase64Url)(buf).replace(/=/g, "");
+const decodeJwtPart = (part) => JSON.parse(utf8Decoder.decode((0, import_encode.decodeBase64Url)(part)));
 const param = (name) => {
   switch (name.toUpperCase()) {
     case "HS256":
@@ -75,20 +80,22 @@ const signing = async (data, secret, alg = import_types.AlgorithmTypes.HS256) =>
   if (!crypto.subtle || !crypto.subtle.importKey) {
     throw new Error("`crypto.subtle.importKey` is undefined. JWT auth middleware requires it.");
   }
+  const utf8Encoder2 = new TextEncoder();
   const cryptoKey = await crypto.subtle.importKey(
     "raw" /* RAW */,
-    (0, import_encode.utf8ToUint8Array)(secret),
+    utf8Encoder2.encode(secret),
     param(alg),
     false,
     ["sign" /* Sign */]
   );
-  return await crypto.subtle.sign(param(alg), cryptoKey, (0, import_encode.utf8ToUint8Array)(data));
+  return await crypto.subtle.sign(param(alg), cryptoKey, utf8Encoder2.encode(data));
 };
 const sign = async (payload, secret, alg = import_types.AlgorithmTypes.HS256) => {
-  const encodedPayload = await (0, import_encode.encodeBase64URL)(JSON.stringify(payload));
-  const encodedHeader = await (0, import_encode.encodeBase64URL)(JSON.stringify({ alg, typ: "JWT" }));
+  const encodedPayload = encodeJwtPart(payload);
+  const encodedHeader = encodeJwtPart({ alg, typ: "JWT" });
   const partialToken = `${encodedHeader}.${encodedPayload}`;
-  const signature = await (0, import_encode.arrayBufferToBase64URL)(await signing(partialToken, secret, alg));
+  const signaturePart = await signing(partialToken, secret, alg);
+  const signature = encodeSignaturePart(signaturePart);
   return `${partialToken}.${signature}`;
 };
 const verify = async (token, secret, alg = import_types.AlgorithmTypes.HS256) => {
@@ -103,10 +110,10 @@ const verify = async (token, secret, alg = import_types.AlgorithmTypes.HS256) =>
   if (payload.exp && payload.exp <= Math.floor(Date.now() / 1e3)) {
     throw new import_types2.JwtTokenExpired(token);
   }
-  const signature = await (0, import_encode.arrayBufferToBase64URL)(
-    await signing(tokenParts.slice(0, 2).join("."), secret, alg)
-  );
-  if (signature !== tokenParts[2]) {
+  const signaturePart = tokenParts.slice(0, 2).join(".");
+  const signature = await signing(signaturePart, secret, alg);
+  const encodedSignature = encodeSignaturePart(signature);
+  if (encodedSignature !== tokenParts[2]) {
     throw new import_types2.JwtTokenSignatureMismatched(token);
   }
   return true;
@@ -114,8 +121,8 @@ const verify = async (token, secret, alg = import_types.AlgorithmTypes.HS256) =>
 const decode = (token) => {
   try {
     const [h, p] = token.split(".");
-    const header = JSON.parse((0, import_encode.decodeBase64URL)(h));
-    const payload = JSON.parse((0, import_encode.decodeBase64URL)(p));
+    const header = decodeJwtPart(h);
+    const payload = decodeJwtPart(p);
     return {
       header,
       payload

package/dist/context.js

@@ -25,6 +25,7 @@ var Context = class {
       if (options?.append) {
         if (!this._headers) {
           this._headers = new Headers(this._preparedHeaders);
+          this._preparedHeaders = {};
         }
         this._headers.append(name, value);
       } else {
@@ -73,11 +74,9 @@ var Context = class {
       }
       const status = arg ?? this._status;
       this._preparedHeaders ?? (this._preparedHeaders = {});
-      if (!this._headers) {
-        this._headers = new Headers();
-        for (const [k, v] of Object.entries(this._preparedHeaders)) {
-          this._headers.set(k, v);
-        }
+      this._headers ?? (this._headers = new Headers());
+      for (const [k, v] of Object.entries(this._preparedHeaders)) {
+        this._headers.set(k, v);
       }
       if (this._res) {
         this._res.headers.forEach((v, k) => {

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

@@ -4,12 +4,13 @@ import { timingSafeEqual } from "../../utils/buffer.js";
 import { decodeBase64 } from "../../utils/encode.js";
 var CREDENTIALS_REGEXP = /^ *(?:[Bb][Aa][Ss][Ii][Cc]) +([A-Za-z0-9._~+/-]+=*) *$/;
 var USER_PASS_REGEXP = /^([^:]*):(.*)$/;
+var utf8Decoder = new TextDecoder();
 var auth = (req) => {
   const match = CREDENTIALS_REGEXP.exec(req.headers.get("Authorization") || "");
   if (!match) {
     return void 0;
   }
-  const userPass = USER_PASS_REGEXP.exec(decodeBase64(match[1]));
+  const userPass = USER_PASS_REGEXP.exec(utf8Decoder.decode(decodeBase64(match[1])));
   if (!userPass) {
     return void 0;
   }

package/dist/types/hono.d.ts

@@ -31,7 +31,7 @@ export declare class Hono<E extends Env = Env, S = {}, BasePath extends string =
     private clone;
     private notFoundHandler;
     private errorHandler;
-    route<SubPath extends string, SubEnv extends Env, SubSchema>(path: SubPath, app: Hono<SubEnv, SubSchema>): Hono<E, RemoveBlankRecord<MergeSchemaPath<SubSchema, SubPath> | S>, BasePath>;
+    route<SubPath extends string, SubEnv extends Env, SubSchema, SubBasePath extends string>(path: SubPath, app: Hono<SubEnv, SubSchema, SubBasePath>): Hono<E, RemoveBlankRecord<MergeSchemaPath<SubSchema, SubPath> | S>, BasePath>;
     /** @deprecated
      * Use `basePath` instead of `route` with one argument.
      * The `route` with one argument has been removed in v4.

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

@@ -1,7 +1,4 @@
-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>;
+export declare const decodeBase64Url: (str: string) => Uint8Array;
+export declare const encodeBase64Url: (buf: ArrayBufferLike) => string;
+export declare const encodeBase64: (buf: ArrayBufferLike) => string;
+export declare const decodeBase64: (str: string) => Uint8Array;

package/dist/utils/encode.js

@@ -1,53 +1,25 @@
 // src/utils/encode.ts
-var encodeBase64 = (str) => {
-  if (str === null) {
-    throw new TypeError('1st argument of "encodeBase64" should not be null.');
-  }
-  const encoder = new TextEncoder();
-  const bytes = encoder.encode(str);
-  return btoa(String.fromCharCode(...bytes));
+var decodeBase64Url = (str) => {
+  return decodeBase64(str.replace(/_|-/g, (m) => ({ _: "/", "-": "+" })[m] ?? m));
+};
+var encodeBase64Url = (buf) => encodeBase64(buf).replace(/\/|\+/g, (m) => ({ "/": "_", "+": "-" })[m] ?? m);
+var encodeBase64 = (buf) => {
+  const binary = String.fromCharCode(...new Uint8Array(buf));
+  return btoa(binary);
 };
 var decodeBase64 = (str) => {
-  if (str === null) {
-    throw new TypeError('1st argument of "decodeBase64" should not be null.');
+  const binary = atob(str);
+  const bytes = new Uint8Array(new ArrayBuffer(binary.length));
+  const half = binary.length / 2;
+  for (let i = 0, j = binary.length - 1; i <= half; i++, j--) {
+    bytes[i] = binary.charCodeAt(i);
+    bytes[j] = binary.charCodeAt(j);
   }
-  const text = atob(str);
-  const bytes = new Uint8Array(text.split("").map((c) => c.charCodeAt(0)));
-  const decoder = new TextDecoder();
-  return decoder.decode(bytes);
-};
-var encodeBase64URL = (str) => {
-  return encodeBase64(str).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
-};
-var decodeBase64URL = (str) => {
-  const pad = (s) => {
-    const diff = s.length % 4;
-    if (diff === 2) {
-      return `${s}==`;
-    }
-    if (diff === 3) {
-      return `${s}=`;
-    }
-    return s;
-  };
-  return decodeBase64(pad(str).replace(/-/g, "+").replace("_", "/"));
-};
-var utf8ToUint8Array = (str) => {
-  const encoder = new TextEncoder();
-  return encoder.encode(str);
-};
-var arrayBufferToBase64 = async (buf) => {
-  return btoa(String.fromCharCode(...new Uint8Array(buf)));
-};
-var arrayBufferToBase64URL = async (buf) => {
-  return (await arrayBufferToBase64(buf)).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+  return bytes;
 };
 export {
-  arrayBufferToBase64,
-  arrayBufferToBase64URL,
   decodeBase64,
-  decodeBase64URL,
+  decodeBase64Url,
   encodeBase64,
-  encodeBase64URL,
-  utf8ToUint8Array
+  encodeBase64Url
 };

package/dist/utils/jwt/jwt.js

@@ -1,10 +1,5 @@
 // src/utils/jwt/jwt.ts
-import {
-  utf8ToUint8Array,
-  encodeBase64URL,
-  arrayBufferToBase64URL,
-  decodeBase64URL
-} from "../../utils/encode.js";
+import { encodeBase64Url, decodeBase64Url } from "../../utils/encode.js";
 import { AlgorithmTypes } from "./types.js";
 import {
   JwtTokenInvalid,
@@ -13,6 +8,11 @@ import {
   JwtTokenSignatureMismatched,
   JwtAlgorithmNotImplemented
 } from "./types.js";
+var utf8Encoder = new TextEncoder();
+var utf8Decoder = new TextDecoder();
+var encodeJwtPart = (part) => encodeBase64Url(utf8Encoder.encode(JSON.stringify(part))).replace(/=/g, "");
+var encodeSignaturePart = (buf) => encodeBase64Url(buf).replace(/=/g, "");
+var decodeJwtPart = (part) => JSON.parse(utf8Decoder.decode(decodeBase64Url(part)));
 var param = (name) => {
   switch (name.toUpperCase()) {
     case "HS256":
@@ -44,20 +44,22 @@ var signing = async (data, secret, alg = AlgorithmTypes.HS256) => {
   if (!crypto.subtle || !crypto.subtle.importKey) {
     throw new Error("`crypto.subtle.importKey` is undefined. JWT auth middleware requires it.");
   }
+  const utf8Encoder2 = new TextEncoder();
   const cryptoKey = await crypto.subtle.importKey(
     "raw" /* RAW */,
-    utf8ToUint8Array(secret),
+    utf8Encoder2.encode(secret),
     param(alg),
     false,
     ["sign" /* Sign */]
   );
-  return await crypto.subtle.sign(param(alg), cryptoKey, utf8ToUint8Array(data));
+  return await crypto.subtle.sign(param(alg), cryptoKey, utf8Encoder2.encode(data));
 };
 var sign = async (payload, secret, alg = AlgorithmTypes.HS256) => {
-  const encodedPayload = await encodeBase64URL(JSON.stringify(payload));
-  const encodedHeader = await encodeBase64URL(JSON.stringify({ alg, typ: "JWT" }));
+  const encodedPayload = encodeJwtPart(payload);
+  const encodedHeader = encodeJwtPart({ alg, typ: "JWT" });
   const partialToken = `${encodedHeader}.${encodedPayload}`;
-  const signature = await arrayBufferToBase64URL(await signing(partialToken, secret, alg));
+  const signaturePart = await signing(partialToken, secret, alg);
+  const signature = encodeSignaturePart(signaturePart);
   return `${partialToken}.${signature}`;
 };
 var verify = async (token, secret, alg = AlgorithmTypes.HS256) => {
@@ -72,10 +74,10 @@ var verify = async (token, secret, alg = AlgorithmTypes.HS256) => {
   if (payload.exp && payload.exp <= Math.floor(Date.now() / 1e3)) {
     throw new JwtTokenExpired(token);
   }
-  const signature = await arrayBufferToBase64URL(
-    await signing(tokenParts.slice(0, 2).join("."), secret, alg)
-  );
-  if (signature !== tokenParts[2]) {
+  const signaturePart = tokenParts.slice(0, 2).join(".");
+  const signature = await signing(signaturePart, secret, alg);
+  const encodedSignature = encodeSignaturePart(signature);
+  if (encodedSignature !== tokenParts[2]) {
     throw new JwtTokenSignatureMismatched(token);
   }
   return true;
@@ -83,8 +85,8 @@ var verify = async (token, secret, alg = AlgorithmTypes.HS256) => {
 var decode = (token) => {
   try {
     const [h, p] = token.split(".");
-    const header = JSON.parse(decodeBase64URL(h));
-    const payload = JSON.parse(decodeBase64URL(p));
+    const header = decodeJwtPart(h);
+    const payload = decodeJwtPart(p);
     return {
       header,
       payload

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono",
-  "version": "3.1.0",
+  "version": "3.1.1",
   "description": "Ultrafast web framework for the Edge",
   "main": "dist/cjs/index.js",
   "type": "module",