hono 2.3.2 → 2.4.0

package/dist/utils/json.js

@@ -1,83 +1,79 @@
-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());
+// src/utils/json.ts
+var JSONPathCopyInternal = (src, dst, parts, results) => {
+  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;
 };
-export 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;
+var JSONPathCopy = (src, dst, path) => {
+  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;
+  }
+};
+export {
+  JSONPathCopy
 };

package/dist/utils/jwt/index.js

@@ -1 +1,5 @@
-export * as Jwt from './jwt';
+// src/utils/jwt/index.ts
+import * as Jwt from "./jwt.js";
+export {
+  Jwt
+};

package/dist/utils/jwt/jwt.js

@@ -1,95 +1,100 @@
-import { utf8ToUint8Array, encodeBase64URL, arrayBufferToBase64URL, decodeBase64URL, } from '../../utils/encode';
-import { AlgorithmTypes } from './types';
-import { JwtTokenInvalid, JwtTokenNotBefore, JwtTokenExpired, JwtTokenSignatureMismatched, JwtAlgorithmNotImplemented, } from './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 JwtAlgorithmNotImplemented(name);
-    }
+// src/utils/jwt/jwt.ts
+import {
+  utf8ToUint8Array,
+  encodeBase64URL,
+  arrayBufferToBase64URL,
+  decodeBase64URL
+} from "../../utils/encode.js";
+import { AlgorithmTypes } from "./types.js";
+import {
+  JwtTokenInvalid,
+  JwtTokenNotBefore,
+  JwtTokenExpired,
+  JwtTokenSignatureMismatched,
+  JwtAlgorithmNotImplemented
+} from "./types.js";
+var 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 JwtAlgorithmNotImplemented(name);
+  }
 };
-const 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 cryptoKey = await crypto.subtle.importKey(CryptoKeyFormat.RAW, utf8ToUint8Array(secret), param(alg), false, [CryptoKeyUsage.Sign]);
-    return await crypto.subtle.sign(param(alg), cryptoKey, utf8ToUint8Array(data));
+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 cryptoKey = await crypto.subtle.importKey(
+    "raw" /* RAW */,
+    utf8ToUint8Array(secret),
+    param(alg),
+    false,
+    ["sign" /* Sign */]
+  );
+  return await crypto.subtle.sign(param(alg), cryptoKey, utf8ToUint8Array(data));
 };
-export const sign = async (payload, secret, alg = AlgorithmTypes.HS256) => {
-    const encodedPayload = await encodeBase64URL(JSON.stringify(payload));
-    const encodedHeader = await encodeBase64URL(JSON.stringify({ alg, typ: 'JWT' }));
-    const partialToken = `${encodedHeader}.${encodedPayload}`;
-    const signature = await arrayBufferToBase64URL(await signing(partialToken, secret, alg));
-    return `${partialToken}.${signature}`;
+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 partialToken = `${encodedHeader}.${encodedPayload}`;
+  const signature = await arrayBufferToBase64URL(await signing(partialToken, secret, alg));
+  return `${partialToken}.${signature}`;
 };
-export const verify = async (token, secret, alg = AlgorithmTypes.HS256) => {
-    const tokenParts = token.split('.');
-    if (tokenParts.length !== 3) {
-        throw new JwtTokenInvalid(token);
-    }
-    const { payload } = decode(token);
-    if (payload.nbf && payload.nbf > Math.floor(Date.now() / 1000)) {
-        throw new JwtTokenNotBefore(token);
-    }
-    if (payload.exp && payload.exp <= Math.floor(Date.now() / 1000)) {
-        throw new JwtTokenExpired(token);
-    }
-    const signature = await arrayBufferToBase64URL(await signing(tokenParts.slice(0, 2).join('.'), secret, alg));
-    if (signature !== tokenParts[2]) {
-        throw new JwtTokenSignatureMismatched(token);
-    }
-    return true;
+var verify = async (token, secret, alg = AlgorithmTypes.HS256) => {
+  const tokenParts = token.split(".");
+  if (tokenParts.length !== 3) {
+    throw new JwtTokenInvalid(token);
+  }
+  const { payload } = decode(token);
+  if (payload.nbf && payload.nbf > Math.floor(Date.now() / 1e3)) {
+    throw new JwtTokenNotBefore(token);
+  }
+  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]) {
+    throw new JwtTokenSignatureMismatched(token);
+  }
+  return true;
 };
-// eslint-disable-next-line
-export const decode = (token) => {
-    try {
-        const [h, p] = token.split('.');
-        const header = JSON.parse(decodeBase64URL(h));
-        const payload = JSON.parse(decodeBase64URL(p));
-        return {
-            header,
-            payload,
-        };
-    }
-    catch (e) {
-        throw new JwtTokenInvalid(token);
-    }
+var decode = (token) => {
+  try {
+    const [h, p] = token.split(".");
+    const header = JSON.parse(decodeBase64URL(h));
+    const payload = JSON.parse(decodeBase64URL(p));
+    return {
+      header,
+      payload
+    };
+  } catch (e) {
+    throw new JwtTokenInvalid(token);
+  }
+};
+export {
+  decode,
+  sign,
+  verify
 };

package/dist/utils/jwt/types.js

@@ -1,41 +1,47 @@
-export class JwtAlgorithmNotImplemented extends Error {
-    constructor(token) {
-        super(`invalid JWT token: ${token}`);
-        this.name = 'JwtAlgorithmNotImplemented';
-    }
-}
-/**
- * Export for backward compatibility
- * @deprecated Use JwtAlgorithmNotImplemented instead
-**/
-export const JwtAlorithmNotImplemented = JwtAlgorithmNotImplemented;
-export class JwtTokenInvalid extends Error {
-    constructor(token) {
-        super(`invalid JWT token: ${token}`);
-        this.name = 'JwtTokenInvalid';
-    }
-}
-export class JwtTokenNotBefore extends Error {
-    constructor(token) {
-        super(`token (${token}) is being used before it's valid`);
-        this.name = 'JwtTokenNotBefore';
-    }
-}
-export class JwtTokenExpired extends Error {
-    constructor(token) {
-        super(`token (${token}) expired`);
-        this.name = 'JwtTokenExpired';
-    }
-}
-export class JwtTokenSignatureMismatched extends Error {
-    constructor(token) {
-        super(`token(${token}) signature mismatched`);
-        this.name = 'JwtTokenSignatureMismatched';
-    }
-}
-export var AlgorithmTypes;
-(function (AlgorithmTypes) {
-    AlgorithmTypes["HS256"] = "HS256";
-    AlgorithmTypes["HS384"] = "HS384";
-    AlgorithmTypes["HS512"] = "HS512";
-})(AlgorithmTypes || (AlgorithmTypes = {}));
+// src/utils/jwt/types.ts
+var JwtAlgorithmNotImplemented = class extends Error {
+  constructor(token) {
+    super(`invalid JWT token: ${token}`);
+    this.name = "JwtAlgorithmNotImplemented";
+  }
+};
+var JwtAlorithmNotImplemented = JwtAlgorithmNotImplemented;
+var JwtTokenInvalid = class extends Error {
+  constructor(token) {
+    super(`invalid JWT token: ${token}`);
+    this.name = "JwtTokenInvalid";
+  }
+};
+var JwtTokenNotBefore = class extends Error {
+  constructor(token) {
+    super(`token (${token}) is being used before it's valid`);
+    this.name = "JwtTokenNotBefore";
+  }
+};
+var JwtTokenExpired = class extends Error {
+  constructor(token) {
+    super(`token (${token}) expired`);
+    this.name = "JwtTokenExpired";
+  }
+};
+var JwtTokenSignatureMismatched = class extends Error {
+  constructor(token) {
+    super(`token(${token}) signature mismatched`);
+    this.name = "JwtTokenSignatureMismatched";
+  }
+};
+var AlgorithmTypes = /* @__PURE__ */ ((AlgorithmTypes2) => {
+  AlgorithmTypes2["HS256"] = "HS256";
+  AlgorithmTypes2["HS384"] = "HS384";
+  AlgorithmTypes2["HS512"] = "HS512";
+  return AlgorithmTypes2;
+})(AlgorithmTypes || {});
+export {
+  AlgorithmTypes,
+  JwtAlgorithmNotImplemented,
+  JwtAlorithmNotImplemented,
+  JwtTokenExpired,
+  JwtTokenInvalid,
+  JwtTokenNotBefore,
+  JwtTokenSignatureMismatched
+};

package/dist/utils/mime.js

@@ -1,88 +1,92 @@
-export 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;
+// src/utils/mime.ts
+var 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;
 };
-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',
+var 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"
+};
+export {
+  getMimeType
 };