hono 2.3.1 → 2.4.0

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

@@ -1,50 +1,73 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getStatusText = void 0;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var http_status_exports = {};
+__export(http_status_exports, {
+  getStatusText: () => getStatusText
+});
+module.exports = __toCommonJS(http_status_exports);
 const getStatusText = (statusCode) => {
-    const text = statuses[statusCode];
-    return text;
+  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',
+  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"
 };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getStatusText
+});

package/dist/cjs/utils/json.js

@@ -1,87 +1,102 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.JSONPathCopy = void 0;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var json_exports = {};
+__export(json_exports, {
+  JSONPathCopy: () => JSONPathCopy
+});
+module.exports = __toCommonJS(json_exports);
 const JSONPathCopyInternal = (src, dst, parts, results) => {
-    let srcVal = src;
-    let dstVal = dst;
-    const length = parts.length;
-    for (let i = 0; i < length && srcVal !== undefined && dstVal; i++) {
-        const p = parts[i];
-        if (typeof srcVal !== 'object') {
-            return srcVal;
-        }
-        if (srcVal === null) {
-            return undefined;
-        }
-        if (p === '*') {
-            const restParts = parts.slice(i + 1);
-            const restLength = srcVal.length;
-            if (restLength === undefined) {
-                parts = Object.keys(srcVal);
-                for (const p of parts) {
-                    const srcVal2 = srcVal;
-                    const dst2 = {};
-                    JSONPathCopyInternal(srcVal2, dst2, [p], results);
-                    dstVal[p] = dst2[p];
-                }
-            }
-            else {
-                const res = [];
-                for (let i2 = 0; i2 < restLength; i2++) {
-                    if (typeof srcVal[i2] !== 'object' || srcVal[i2] === undefined) {
-                        res.push(srcVal[i2]);
-                    }
-                    else {
-                        const srcVal2 = srcVal[i2];
-                        const dst2 = {};
-                        const res2 = JSONPathCopyInternal(srcVal2, dst2, restParts, results);
-                        if (res2 === undefined)
-                            results.push(undefined);
-                        dstVal[i2] = dst2;
-                    }
-                }
-                if (res.length) {
-                    Object.assign(dstVal, srcVal);
-                    results.push(...res);
-                }
-            }
-            return results;
-        }
-        if (typeof srcVal[p] === 'object') {
-            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-            // @ts-ignore
-            dstVal[p] || (dstVal[p] = new srcVal[p].constructor());
+  let srcVal = src;
+  let dstVal = dst;
+  const length = parts.length;
+  for (let i = 0; i < length && srcVal !== void 0 && dstVal; i++) {
+    const p = parts[i];
+    if (typeof srcVal !== "object") {
+      return srcVal;
+    }
+    if (srcVal === null) {
+      return void 0;
+    }
+    if (p === "*") {
+      const restParts = parts.slice(i + 1);
+      const restLength = srcVal.length;
+      if (restLength === void 0) {
+        parts = Object.keys(srcVal);
+        for (const p2 of parts) {
+          const srcVal2 = srcVal;
+          const dst2 = {};
+          JSONPathCopyInternal(srcVal2, dst2, [p2], results);
+          dstVal[p2] = dst2[p2];
         }
-        else if (typeof srcVal[p] !== 'undefined') {
-            dstVal[p] = srcVal[p];
+      } else {
+        const res = [];
+        for (let i2 = 0; i2 < restLength; i2++) {
+          if (typeof srcVal[i2] !== "object" || srcVal[i2] === void 0) {
+            res.push(srcVal[i2]);
+          } else {
+            const srcVal2 = srcVal[i2];
+            const dst2 = {};
+            const res2 = JSONPathCopyInternal(srcVal2, dst2, restParts, results);
+            if (res2 === void 0)
+              results.push(void 0);
+            dstVal[i2] = dst2;
+          }
         }
-        else {
-            return undefined;
+        if (res.length) {
+          Object.assign(dstVal, srcVal);
+          results.push(...res);
         }
-        srcVal = srcVal[p];
-        dstVal = dstVal[p];
+      }
+      return results;
     }
-    if (typeof srcVal === 'object' && dstVal) {
-        Object.assign(dstVal, srcVal);
+    if (typeof srcVal[p] === "object") {
+      dstVal[p] || (dstVal[p] = new srcVal[p].constructor());
+    } else if (typeof srcVal[p] !== "undefined") {
+      dstVal[p] = srcVal[p];
+    } else {
+      return void 0;
     }
-    results.push(srcVal);
-    return results;
+    srcVal = srcVal[p];
+    dstVal = dstVal[p];
+  }
+  if (typeof srcVal === "object" && dstVal) {
+    Object.assign(dstVal, srcVal);
+  }
+  results.push(srcVal);
+  return results;
 };
 const JSONPathCopy = (src, dst, path) => {
-    const results = [];
-    const parts = path.replace(/\.?\[(.*?)\]/g, '.$1').split(/\./);
-    try {
-        JSONPathCopyInternal(src, dst, parts, results);
-        if (results.length === 0) {
-            return undefined;
-        }
-        else if (results.length === 1 && !parts.includes('*')) {
-            return results[0];
-        }
-        return results;
-    }
-    catch (e) {
-        return undefined;
+  const results = [];
+  const parts = path.replace(/\.?\[(.*?)\]/g, ".$1").split(/\./);
+  try {
+    JSONPathCopyInternal(src, dst, parts, results);
+    if (results.length === 0) {
+      return void 0;
+    } else if (results.length === 1 && !parts.includes("*")) {
+      return results[0];
     }
+    return results;
+  } catch (e) {
+    return void 0;
+  }
 };
-exports.JSONPathCopy = JSONPathCopy;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  JSONPathCopy
+});

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

@@ -1,27 +1,34 @@
 "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;
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Jwt = void 0;
-exports.Jwt = __importStar(require("./jwt"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var jwt_exports = {};
+__export(jwt_exports, {
+  Jwt: () => Jwt
+});
+module.exports = __toCommonJS(jwt_exports);
+var Jwt = __toESM(require("./jwt"), 1);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Jwt
+});

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

@@ -1,101 +1,132 @@
 "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 = {}));
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var jwt_exports = {};
+__export(jwt_exports, {
+  decode: () => decode,
+  sign: () => sign,
+  verify: () => verify
+});
+module.exports = __toCommonJS(jwt_exports);
+var import_encode = require("../../utils/encode");
+var import_types = require("./types");
+var import_types2 = require("./types");
+var CryptoKeyFormat = /* @__PURE__ */ ((CryptoKeyFormat2) => {
+  CryptoKeyFormat2["RAW"] = "raw";
+  CryptoKeyFormat2["PKCS8"] = "pkcs8";
+  CryptoKeyFormat2["SPKI"] = "spki";
+  CryptoKeyFormat2["JWK"] = "jwk";
+  return CryptoKeyFormat2;
+})(CryptoKeyFormat || {});
+var CryptoKeyUsage = /* @__PURE__ */ ((CryptoKeyUsage2) => {
+  CryptoKeyUsage2["Ecrypt"] = "encrypt";
+  CryptoKeyUsage2["Decrypt"] = "decrypt";
+  CryptoKeyUsage2["Sign"] = "sign";
+  CryptoKeyUsage2["Verify"] = "verify";
+  CryptoKeyUsage2["Deriverkey"] = "deriveKey";
+  CryptoKeyUsage2["DeriveBits"] = "deriveBits";
+  CryptoKeyUsage2["WrapKey"] = "wrapKey";
+  CryptoKeyUsage2["UnwrapKey"] = "unwrapKey";
+  return CryptoKeyUsage2;
+})(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);
-    }
+  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 import_types2.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 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 cryptoKey = await crypto.subtle.importKey(
+    "raw" /* RAW */,
+    (0, import_encode.utf8ToUint8Array)(secret),
+    param(alg),
+    false,
+    ["sign" /* Sign */]
+  );
+  return await crypto.subtle.sign(param(alg), cryptoKey, (0, import_encode.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}`;
+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 partialToken = `${encodedHeader}.${encodedPayload}`;
+  const signature = await (0, import_encode.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;
+const verify = async (token, secret, alg = import_types.AlgorithmTypes.HS256) => {
+  const tokenParts = token.split(".");
+  if (tokenParts.length !== 3) {
+    throw new import_types2.JwtTokenInvalid(token);
+  }
+  const { payload } = decode(token);
+  if (payload.nbf && payload.nbf > Math.floor(Date.now() / 1e3)) {
+    throw new import_types2.JwtTokenNotBefore(token);
+  }
+  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]) {
+    throw new import_types2.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);
-    }
+  try {
+    const [h, p] = token.split(".");
+    const header = JSON.parse((0, import_encode.decodeBase64URL)(h));
+    const payload = JSON.parse((0, import_encode.decodeBase64URL)(p));
+    return {
+      header,
+      payload
+    };
+  } catch (e) {
+    throw new import_types2.JwtTokenInvalid(token);
+  }
 };
-exports.decode = decode;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  decode,
+  sign,
+  verify
+});