hono 2.3.1 → 2.4.0

package/dist/cjs/router/trie-router/node.js

@@ -1,174 +1,182 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Node = void 0;
-const router_1 = require("../../router");
-const url_1 = require("../../utils/url");
+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 node_exports = {};
+__export(node_exports, {
+  Node: () => Node
+});
+module.exports = __toCommonJS(node_exports);
+var import_router = require("../../router");
+var import_url = require("../../utils/url");
 function findParam(node, name) {
-    for (let i = 0, len = node.patterns.length; i < len; i++) {
-        if (typeof node.patterns[i] === 'object' && node.patterns[i][1] === name) {
-            return true;
-        }
+  for (let i = 0, len = node.patterns.length; i < len; i++) {
+    if (typeof node.patterns[i] === "object" && node.patterns[i][1] === name) {
+      return true;
     }
-    const nodes = Object.values(node.children);
-    for (let i = 0, len = nodes.length; i < len; i++) {
-        if (findParam(nodes[i], name)) {
-            return true;
-        }
+  }
+  const nodes = Object.values(node.children);
+  for (let i = 0, len = nodes.length; i < len; i++) {
+    if (findParam(nodes[i], name)) {
+      return true;
     }
-    return false;
+  }
+  return false;
 }
 class Node {
-    constructor(method, handler, children) {
-        this.order = 0;
-        this.children = children || {};
-        this.methods = [];
-        this.name = '';
-        if (method && handler) {
-            const m = {};
-            m[method] = { handler: handler, score: 0, name: this.name };
-            this.methods = [m];
-        }
-        this.patterns = [];
-        this.handlerSetCache = {};
+  constructor(method, handler, children) {
+    this.order = 0;
+    this.children = children || {};
+    this.methods = [];
+    this.name = "";
+    if (method && handler) {
+      const m = {};
+      m[method] = { handler, score: 0, name: this.name };
+      this.methods = [m];
     }
-    insert(method, path, handler) {
-        this.name = `${method} ${path}`;
-        this.order = ++this.order;
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
-        let curNode = this;
-        const parts = (0, url_1.splitPath)(path);
-        const parentPatterns = [];
-        const errorMessage = (name) => {
-            return `Duplicate param name, use another name instead of '${name}' - ${method} ${path} <--- '${name}'`;
-        };
-        for (let i = 0, len = parts.length; i < len; i++) {
-            const p = parts[i];
-            if (Object.keys(curNode.children).includes(p)) {
-                parentPatterns.push(...curNode.patterns);
-                curNode = curNode.children[p];
-                continue;
+    this.patterns = [];
+    this.handlerSetCache = {};
+  }
+  insert(method, path, handler) {
+    this.name = `${method} ${path}`;
+    this.order = ++this.order;
+    let curNode = this;
+    const parts = (0, import_url.splitPath)(path);
+    const parentPatterns = [];
+    const errorMessage = (name) => {
+      return `Duplicate param name, use another name instead of '${name}' - ${method} ${path} <--- '${name}'`;
+    };
+    for (let i = 0, len = parts.length; i < len; i++) {
+      const p = parts[i];
+      if (Object.keys(curNode.children).includes(p)) {
+        parentPatterns.push(...curNode.patterns);
+        curNode = curNode.children[p];
+        continue;
+      }
+      curNode.children[p] = new Node();
+      const pattern = (0, import_url.getPattern)(p);
+      if (pattern) {
+        if (typeof pattern === "object") {
+          for (let j = 0, len2 = parentPatterns.length; j < len2; j++) {
+            if (typeof parentPatterns[j] === "object" && parentPatterns[j][1] === pattern[1]) {
+              throw new Error(errorMessage(pattern[1]));
             }
-            curNode.children[p] = new Node();
-            const pattern = (0, url_1.getPattern)(p);
-            if (pattern) {
-                if (typeof pattern === 'object') {
-                    for (let j = 0, len = parentPatterns.length; j < len; j++) {
-                        if (typeof parentPatterns[j] === 'object' && parentPatterns[j][1] === pattern[1]) {
-                            throw new Error(errorMessage(pattern[1]));
-                        }
-                    }
-                    if (Object.values(curNode.children).some((n) => findParam(n, pattern[1]))) {
-                        throw new Error(errorMessage(pattern[1]));
-                    }
-                }
-                curNode.patterns.push(pattern);
-                parentPatterns.push(...curNode.patterns);
-            }
-            parentPatterns.push(...curNode.patterns);
-            curNode = curNode.children[p];
-        }
-        if (!curNode.methods.length) {
-            curNode.methods = [];
+          }
+          if (Object.values(curNode.children).some((n) => findParam(n, pattern[1]))) {
+            throw new Error(errorMessage(pattern[1]));
+          }
         }
-        const m = {};
-        const handlerSet = { handler: handler, name: this.name, score: this.order };
-        m[method] = handlerSet;
-        curNode.methods.push(m);
-        return curNode;
+        curNode.patterns.push(pattern);
+        parentPatterns.push(...curNode.patterns);
+      }
+      parentPatterns.push(...curNode.patterns);
+      curNode = curNode.children[p];
     }
-    getHandlerSets(node, method, wildcard) {
-        var _a, _b;
-        return ((_a = node.handlerSetCache)[_b = `${method}:${wildcard ? '1' : '0'}`] || (_a[_b] = (() => {
-            const handlerSets = [];
-            for (let i = 0, len = node.methods.length; i < len; i++) {
-                const m = node.methods[i];
-                const handlerSet = m[method] || m[router_1.METHOD_NAME_ALL];
-                if (handlerSet !== undefined) {
-                    handlerSets.push(handlerSet);
-                }
-            }
-            return handlerSets;
-        })()));
+    if (!curNode.methods.length) {
+      curNode.methods = [];
     }
-    search(method, path) {
-        const handlerSets = [];
-        const params = {};
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
-        const curNode = this;
-        let curNodes = [curNode];
-        const parts = (0, url_1.splitPath)(path);
-        for (let i = 0, len = parts.length; i < len; i++) {
-            const part = parts[i];
-            const isLast = i === len - 1;
-            const tempNodes = [];
-            let matched = false;
-            for (let j = 0, len2 = curNodes.length; j < len2; j++) {
-                const node = curNodes[j];
-                const nextNode = node.children[part];
-                if (nextNode) {
-                    if (isLast === true) {
-                        // '/hello/*' => match '/hello'
-                        if (nextNode.children['*']) {
-                            handlerSets.push(...this.getHandlerSets(nextNode.children['*'], method, true));
-                        }
-                        handlerSets.push(...this.getHandlerSets(nextNode, method));
-                        matched = true;
-                    }
-                    else {
-                        tempNodes.push(nextNode);
-                    }
-                }
-                for (let k = 0, len3 = node.patterns.length; k < len3; k++) {
-                    const pattern = node.patterns[k];
-                    // Wildcard
-                    // '/hello/*/foo' => match /hello/bar/foo
-                    if (pattern === '*') {
-                        const astNode = node.children['*'];
-                        if (astNode) {
-                            handlerSets.push(...this.getHandlerSets(astNode, method));
-                            tempNodes.push(astNode);
-                        }
-                        continue;
-                    }
-                    if (part === '')
-                        continue;
-                    // Named match
-                    // `/posts/:id` => match /posts/123
-                    const [key, name, matcher] = pattern;
-                    if (matcher === true || (matcher instanceof RegExp && matcher.test(part))) {
-                        if (typeof key === 'string') {
-                            if (isLast === true) {
-                                handlerSets.push(...this.getHandlerSets(node.children[key], method));
-                            }
-                            else {
-                                tempNodes.push(node.children[key]);
-                            }
-                        }
-                        // '/book/a'     => not-slug
-                        // '/book/:slug' => slug
-                        // GET /book/a   ~> no-slug, param['slug'] => undefined
-                        // GET /book/foo ~> slug, param['slug'] => foo
-                        if (typeof name === 'string' && !matched) {
-                            params[name] = part;
-                        }
-                    }
-                }
+    const m = {};
+    const handlerSet = { handler, name: this.name, score: this.order };
+    m[method] = handlerSet;
+    curNode.methods.push(m);
+    return curNode;
+  }
+  getHandlerSets(node, method, wildcard) {
+    var _a, _b;
+    return (_a = node.handlerSetCache)[_b = `${method}:${wildcard ? "1" : "0"}`] || (_a[_b] = (() => {
+      const handlerSets = [];
+      for (let i = 0, len = node.methods.length; i < len; i++) {
+        const m = node.methods[i];
+        const handlerSet = m[method] || m[import_router.METHOD_NAME_ALL];
+        if (handlerSet !== void 0) {
+          handlerSets.push(handlerSet);
+        }
+      }
+      return handlerSets;
+    })());
+  }
+  search(method, path) {
+    const handlerSets = [];
+    const params = {};
+    const curNode = this;
+    let curNodes = [curNode];
+    const parts = (0, import_url.splitPath)(path);
+    for (let i = 0, len2 = parts.length; i < len2; i++) {
+      const part = parts[i];
+      const isLast = i === len2 - 1;
+      const tempNodes = [];
+      let matched = false;
+      for (let j = 0, len22 = curNodes.length; j < len22; j++) {
+        const node = curNodes[j];
+        const nextNode = node.children[part];
+        if (nextNode) {
+          if (isLast === true) {
+            if (nextNode.children["*"]) {
+              handlerSets.push(...this.getHandlerSets(nextNode.children["*"], method, true));
+            }
+            handlerSets.push(...this.getHandlerSets(nextNode, method));
+            matched = true;
+          } else {
+            tempNodes.push(nextNode);
+          }
+        }
+        for (let k = 0, len3 = node.patterns.length; k < len3; k++) {
+          const pattern = node.patterns[k];
+          if (pattern === "*") {
+            const astNode = node.children["*"];
+            if (astNode) {
+              handlerSets.push(...this.getHandlerSets(astNode, method));
+              tempNodes.push(astNode);
+            }
+            continue;
+          }
+          if (part === "")
+            continue;
+          const [key, name, matcher] = pattern;
+          if (matcher === true || matcher instanceof RegExp && matcher.test(part)) {
+            if (typeof key === "string") {
+              if (isLast === true) {
+                handlerSets.push(...this.getHandlerSets(node.children[key], method));
+              } else {
+                tempNodes.push(node.children[key]);
+              }
+            }
+            if (typeof name === "string" && !matched) {
+              params[name] = part;
             }
-            curNodes = tempNodes;
+          }
         }
-        const len = handlerSets.length;
-        if (len === 0)
-            return null;
-        if (len === 1)
-            return { handlers: [handlerSets[0].handler], params };
-        const handlers = handlerSets
-            .sort((a, b) => {
-            return a.score - b.score;
-        })
-            .map((s) => {
-            return s.handler;
-        });
-        return { handlers, params };
+      }
+      curNodes = tempNodes;
     }
+    const len = handlerSets.length;
+    if (len === 0)
+      return null;
+    if (len === 1)
+      return { handlers: [handlerSets[0].handler], params };
+    const handlers = handlerSets.sort((a, b) => {
+      return a.score - b.score;
+    }).map((s) => {
+      return s.handler;
+    });
+    return { handlers, params };
+  }
 }
-exports.Node = Node;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Node
+});

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

@@ -1,24 +1,47 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TrieRouter = void 0;
-const url_1 = require("../../utils/url");
-const node_1 = require("./node");
+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 router_exports = {};
+__export(router_exports, {
+  TrieRouter: () => TrieRouter
+});
+module.exports = __toCommonJS(router_exports);
+var import_url = require("../../utils/url");
+var import_node = require("./node");
 class TrieRouter {
-    constructor() {
-        this.node = new node_1.Node();
-    }
-    add(method, path, handler) {
-        const results = (0, url_1.checkOptionalParameter)(path);
-        if (results) {
-            for (const p of results) {
-                this.node.insert(method, p, handler);
-            }
-            return;
-        }
-        this.node.insert(method, path, handler);
-    }
-    match(method, path) {
-        return this.node.search(method, path);
+  constructor() {
+    this.node = new import_node.Node();
+  }
+  add(method, path, handler) {
+    const results = (0, import_url.checkOptionalParameter)(path);
+    if (results) {
+      for (const p of results) {
+        this.node.insert(method, p, handler);
+      }
+      return;
     }
+    this.node.insert(method, path, handler);
+  }
+  match(method, path) {
+    return this.node.search(method, path);
+  }
 }
-exports.TrieRouter = TrieRouter;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TrieRouter
+});

package/dist/cjs/router.js

@@ -1,9 +1,38 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnsupportedPathError = exports.METHODS = exports.METHOD_NAME_ALL_LOWERCASE = exports.METHOD_NAME_ALL = void 0;
-exports.METHOD_NAME_ALL = 'ALL';
-exports.METHOD_NAME_ALL_LOWERCASE = 'all';
-exports.METHODS = ['get', 'post', 'put', 'delete', 'head', 'options', 'patch'];
+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 router_exports = {};
+__export(router_exports, {
+  METHODS: () => METHODS,
+  METHOD_NAME_ALL: () => METHOD_NAME_ALL,
+  METHOD_NAME_ALL_LOWERCASE: () => METHOD_NAME_ALL_LOWERCASE,
+  UnsupportedPathError: () => UnsupportedPathError
+});
+module.exports = __toCommonJS(router_exports);
+const METHOD_NAME_ALL = "ALL";
+const METHOD_NAME_ALL_LOWERCASE = "all";
+const METHODS = ["get", "post", "put", "delete", "head", "options", "patch"];
 class UnsupportedPathError extends Error {
 }
-exports.UnsupportedPathError = UnsupportedPathError;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  METHODS,
+  METHOD_NAME_ALL,
+  METHOD_NAME_ALL_LOWERCASE,
+  UnsupportedPathError
+});

package/dist/cjs/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/cjs/utils/body.js

@@ -1,18 +1,39 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseBody = 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 body_exports = {};
+__export(body_exports, {
+  parseBody: () => parseBody
+});
+module.exports = __toCommonJS(body_exports);
 async function parseBody(r) {
-    let body = {};
-    const contentType = r.headers.get('Content-Type');
-    if (contentType &&
-        (contentType.startsWith('multipart/form-data') ||
-            contentType === 'application/x-www-form-urlencoded')) {
-        const form = {};
-        body = [...(await r.formData())].reduce((acc, cur) => {
-            acc[cur[0]] = cur[1];
-            return acc;
-        }, form);
-    }
-    return body;
+  let body = {};
+  const contentType = r.headers.get("Content-Type");
+  if (contentType && (contentType.startsWith("multipart/form-data") || contentType === "application/x-www-form-urlencoded")) {
+    const form = {};
+    body = [...await r.formData()].reduce((acc, cur) => {
+      acc[cur[0]] = cur[1];
+      return acc;
+    }, form);
+  }
+  return body;
 }
-exports.parseBody = parseBody;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseBody
+});

package/dist/cjs/utils/buffer.js

@@ -1,39 +1,64 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.bufferToString = exports.timingSafeEqual = exports.equal = void 0;
-const crypto_1 = require("./crypto");
+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 buffer_exports = {};
+__export(buffer_exports, {
+  bufferToString: () => bufferToString,
+  equal: () => equal,
+  timingSafeEqual: () => timingSafeEqual
+});
+module.exports = __toCommonJS(buffer_exports);
+var import_crypto = require("./crypto");
 const equal = (a, b) => {
-    if (a === b) {
-        return true;
-    }
-    if (a.byteLength !== b.byteLength) {
-        return false;
-    }
-    const va = new DataView(a);
-    const vb = new DataView(b);
-    let i = va.byteLength;
-    while (i--) {
-        if (va.getUint8(i) !== vb.getUint8(i)) {
-            return false;
-        }
-    }
+  if (a === b) {
     return true;
+  }
+  if (a.byteLength !== b.byteLength) {
+    return false;
+  }
+  const va = new DataView(a);
+  const vb = new DataView(b);
+  let i = va.byteLength;
+  while (i--) {
+    if (va.getUint8(i) !== vb.getUint8(i)) {
+      return false;
+    }
+  }
+  return true;
 };
-exports.equal = equal;
 const timingSafeEqual = async (a, b, hashFunction) => {
-    if (!hashFunction) {
-        hashFunction = crypto_1.sha256;
-    }
-    const sa = await hashFunction(a);
-    const sb = await hashFunction(b);
-    return sa === sb && a === b;
+  if (!hashFunction) {
+    hashFunction = import_crypto.sha256;
+  }
+  const sa = await hashFunction(a);
+  const sb = await hashFunction(b);
+  return sa === sb && a === b;
 };
-exports.timingSafeEqual = timingSafeEqual;
 const bufferToString = (buffer) => {
-    if (buffer instanceof ArrayBuffer) {
-        const enc = new TextDecoder('utf-8');
-        return enc.decode(buffer);
-    }
-    return buffer;
+  if (buffer instanceof ArrayBuffer) {
+    const enc = new TextDecoder("utf-8");
+    return enc.decode(buffer);
+  }
+  return buffer;
 };
-exports.bufferToString = bufferToString;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  bufferToString,
+  equal,
+  timingSafeEqual
+});