1 files changed, 168 insertions, 0 deletions
diff --git a/cli/bench/testdata/npm/hono/dist/router/trie-router/node.js b/cli/bench/testdata/npm/hono/dist/router/trie-router/node.js
new file mode 100644
index 000000000..d40f604e7
--- /dev/null
+++ b/cli/bench/testdata/npm/hono/dist/router/trie-router/node.js
@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Node = void 0;
+const router_1 = require("../../router");
+const url_1 = 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;
+        }
+    }
+    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;
+}
+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 = {};
+    }
+    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;
+            }
+            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 = [];
+        }
+        const m = {};
+        const handlerSet = { handler: 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 = [];
+            node.methods.map((m) => {
+                const handlerSet = m[method] || m[router_1.METHOD_NAME_ALL];
+                if (handlerSet !== undefined) {
+                    const hs = { ...handlerSet };
+                    handlerSets.push(hs);
+                    return;
+                }
+            });
+            return handlerSets;
+        })()));
+    }
+    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;
+                    }
+                    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));
+                            }
+                            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;
+                        }
+                    }
+                }
+            }
+            curNodes = tempNodes;
+        }
+        if (handlerSets.length <= 0)
+            return null;
+        const handlers = handlerSets
+            .sort((a, b) => {
+            return a.score - b.score;
+        })
+            .map((s) => {
+            return s.handler;
+        });
+        return { handlers, params };
+    }
+}
+exports.Node = Node;