hono 2.3.1 → 2.4.0

package/dist/cjs/router/reg-exp-router/node.js

@@ -1,108 +1,119 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Node = exports.PATH_ERROR = void 0;
-const LABEL_REG_EXP_STR = '[^/]+';
-const ONLY_WILDCARD_REG_EXP_STR = '.*';
-const TAIL_WILDCARD_REG_EXP_STR = '(?:|/.*)';
-exports.PATH_ERROR = Symbol();
-/**
- * Sort order:
- * 1. literal
- * 2. special pattern (e.g. :label{[0-9]+})
- * 3. common label pattern (e.g. :label)
- * 4. wildcard
- */
+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,
+  PATH_ERROR: () => PATH_ERROR
+});
+module.exports = __toCommonJS(node_exports);
+const LABEL_REG_EXP_STR = "[^/]+";
+const ONLY_WILDCARD_REG_EXP_STR = ".*";
+const TAIL_WILDCARD_REG_EXP_STR = "(?:|/.*)";
+const PATH_ERROR = Symbol();
 function compareKey(a, b) {
-    if (a.length === 1) {
-        return b.length === 1 ? (a < b ? -1 : 1) : -1;
-    }
-    if (b.length === 1) {
-        return 1;
-    }
-    // wildcard
-    if (a === ONLY_WILDCARD_REG_EXP_STR || a === TAIL_WILDCARD_REG_EXP_STR) {
-        return 1;
-    }
-    else if (b === ONLY_WILDCARD_REG_EXP_STR || b === TAIL_WILDCARD_REG_EXP_STR) {
-        return -1;
-    }
-    // label
-    if (a === LABEL_REG_EXP_STR) {
-        return 1;
-    }
-    else if (b === LABEL_REG_EXP_STR) {
-        return -1;
-    }
-    return a.length === b.length ? (a < b ? -1 : 1) : b.length - a.length;
+  if (a.length === 1) {
+    return b.length === 1 ? a < b ? -1 : 1 : -1;
+  }
+  if (b.length === 1) {
+    return 1;
+  }
+  if (a === ONLY_WILDCARD_REG_EXP_STR || a === TAIL_WILDCARD_REG_EXP_STR) {
+    return 1;
+  } else if (b === ONLY_WILDCARD_REG_EXP_STR || b === TAIL_WILDCARD_REG_EXP_STR) {
+    return -1;
+  }
+  if (a === LABEL_REG_EXP_STR) {
+    return 1;
+  } else if (b === LABEL_REG_EXP_STR) {
+    return -1;
+  }
+  return a.length === b.length ? a < b ? -1 : 1 : b.length - a.length;
 }
 class Node {
-    constructor() {
-        this.children = {};
+  constructor() {
+    this.children = {};
+  }
+  insert(tokens, index, paramMap, context) {
+    if (tokens.length === 0) {
+      if (this.index !== void 0) {
+        throw PATH_ERROR;
+      }
+      this.index = index;
+      return;
     }
-    insert(tokens, index, paramMap, context) {
-        if (tokens.length === 0) {
-            if (this.index !== undefined) {
-                throw exports.PATH_ERROR;
-            }
-            this.index = index;
-            return;
+    const [token, ...restTokens] = tokens;
+    const pattern = token === "*" ? restTokens.length === 0 ? ["", "", ONLY_WILDCARD_REG_EXP_STR] : ["", "", LABEL_REG_EXP_STR] : token === "/*" ? ["", "", TAIL_WILDCARD_REG_EXP_STR] : token.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
+    let node;
+    if (pattern) {
+      const name = pattern[1];
+      const regexpStr = pattern[2] || LABEL_REG_EXP_STR;
+      node = this.children[regexpStr];
+      if (!node) {
+        if (Object.keys(this.children).some(
+          (k) => k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR
+        )) {
+          throw PATH_ERROR;
         }
-        const [token, ...restTokens] = tokens;
-        const pattern = token === '*'
-            ? restTokens.length === 0
-                ? ['', '', ONLY_WILDCARD_REG_EXP_STR] // '*' matches to all the trailing paths
-                : ['', '', LABEL_REG_EXP_STR]
-            : token === '/*'
-                ? ['', '', TAIL_WILDCARD_REG_EXP_STR] // '/path/to/*' is /\/path\/to(?:|/.*)$
-                : token.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
-        let node;
-        if (pattern) {
-            const name = pattern[1];
-            const regexpStr = pattern[2] || LABEL_REG_EXP_STR;
-            node = this.children[regexpStr];
-            if (!node) {
-                if (Object.keys(this.children).some((k) => k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR)) {
-                    throw exports.PATH_ERROR;
-                }
-                node = this.children[regexpStr] = new Node();
-                if (name !== '') {
-                    node.varIndex = context.varIndex++;
-                }
-            }
-            if (name !== '') {
-                if (paramMap.some((p) => p[0] === name)) {
-                    throw new Error('Duplicate param name');
-                }
-                paramMap.push([name, node.varIndex]);
-            }
+        node = this.children[regexpStr] = new Node();
+        if (name !== "") {
+          node.varIndex = context.varIndex++;
         }
-        else {
-            node = this.children[token];
-            if (!node) {
-                if (Object.keys(this.children).some((k) => k.length > 1 && k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR)) {
-                    throw exports.PATH_ERROR;
-                }
-                node = this.children[token] = new Node();
-            }
+      }
+      if (name !== "") {
+        if (paramMap.some((p) => p[0] === name)) {
+          throw new Error("Duplicate param name");
         }
-        node.insert(restTokens, index, paramMap, context);
-    }
-    buildRegExpStr() {
-        const childKeys = Object.keys(this.children).sort(compareKey);
-        const strList = childKeys.map((k) => {
-            const c = this.children[k];
-            return (typeof c.varIndex === 'number' ? `(${k})@${c.varIndex}` : k) + c.buildRegExpStr();
-        });
-        if (typeof this.index === 'number') {
-            strList.unshift(`#${this.index}`);
-        }
-        if (strList.length === 0) {
-            return '';
-        }
-        if (strList.length === 1) {
-            return strList[0];
+        paramMap.push([name, node.varIndex]);
+      }
+    } else {
+      node = this.children[token];
+      if (!node) {
+        if (Object.keys(this.children).some(
+          (k) => k.length > 1 && k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR
+        )) {
+          throw PATH_ERROR;
         }
-        return '(?:' + strList.join('|') + ')';
+        node = this.children[token] = new Node();
+      }
+    }
+    node.insert(restTokens, index, paramMap, context);
+  }
+  buildRegExpStr() {
+    const childKeys = Object.keys(this.children).sort(compareKey);
+    const strList = childKeys.map((k) => {
+      const c = this.children[k];
+      return (typeof c.varIndex === "number" ? `(${k})@${c.varIndex}` : k) + c.buildRegExpStr();
+    });
+    if (typeof this.index === "number") {
+      strList.unshift(`#${this.index}`);
+    }
+    if (strList.length === 0) {
+      return "";
+    }
+    if (strList.length === 1) {
+      return strList[0];
     }
+    return "(?:" + strList.join("|") + ")";
+  }
 }
-exports.Node = Node;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Node,
+  PATH_ERROR
+});

package/dist/cjs/router/reg-exp-router/router.js

@@ -1,161 +1,178 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RegExpRouter = void 0;
-const router_1 = require("../../router");
-const url_1 = require("../../utils/url");
-const node_1 = require("./node");
-const trie_1 = require("./trie");
-const METHOD_NAMES = [router_1.METHOD_NAME_ALL, ...router_1.METHODS].map((method) => method.toUpperCase());
+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, {
+  RegExpRouter: () => RegExpRouter
+});
+module.exports = __toCommonJS(router_exports);
+var import_router = require("../../router");
+var import_url = require("../../utils/url");
+var import_node = require("./node");
+var import_trie = require("./trie");
+const METHOD_NAMES = [import_router.METHOD_NAME_ALL, ...import_router.METHODS].map((method) => method.toUpperCase());
 const emptyParam = {};
 const nullMatcher = [/^$/, []];
 function buildWildcardRegExp(path) {
-    return new RegExp(path === '*' ? '' : `^${path.replace(/\/\*/, '(?:|/.*)')}$`);
+  return new RegExp(path === "*" ? "" : `^${path.replace(/\/\*/, "(?:|/.*)")}$`);
 }
 function buildMatcherFromPreprocessedRoutes(routes) {
-    const trie = new trie_1.Trie();
-    const handlers = [];
-    if (routes.length === 0) {
-        return nullMatcher;
+  const trie = new import_trie.Trie();
+  const handlers = [];
+  if (routes.length === 0) {
+    return nullMatcher;
+  }
+  for (let i = 0, len = routes.length; i < len; i++) {
+    let paramMap;
+    try {
+      paramMap = trie.insert(routes[i][0], i);
+    } catch (e) {
+      throw e === import_node.PATH_ERROR ? new import_router.UnsupportedPathError(routes[i][0]) : e;
     }
-    for (let i = 0, len = routes.length; i < len; i++) {
-        let paramMap;
-        try {
-            paramMap = trie.insert(routes[i][0], i);
-        }
-        catch (e) {
-            throw e === node_1.PATH_ERROR ? new router_1.UnsupportedPathError(routes[i][0]) : e;
-        }
-        handlers[i] = [routes[i][1], paramMap.length !== 0 ? paramMap : null];
-    }
-    const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
-    for (let i = 0, len = handlers.length; i < len; i++) {
-        const paramMap = handlers[i][1];
-        if (paramMap) {
-            for (let j = 0, len = paramMap.length; j < len; j++) {
-                paramMap[j][1] = paramReplacementMap[paramMap[j][1]];
-            }
-        }
+    handlers[i] = [routes[i][1], paramMap.length !== 0 ? paramMap : null];
+  }
+  const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
+  for (let i = 0, len = handlers.length; i < len; i++) {
+    const paramMap = handlers[i][1];
+    if (paramMap) {
+      for (let j = 0, len2 = paramMap.length; j < len2; j++) {
+        paramMap[j][1] = paramReplacementMap[paramMap[j][1]];
+      }
     }
-    const handlerMap = [];
-    // using `in` because indexReplacementMap is a sparse array
-    for (const i in indexReplacementMap) {
-        handlerMap[i] = handlers[indexReplacementMap[i]];
-    }
-    return [regexp, handlerMap];
+  }
+  const handlerMap = [];
+  for (const i in indexReplacementMap) {
+    handlerMap[i] = handlers[indexReplacementMap[i]];
+  }
+  return [regexp, handlerMap];
 }
 function findMiddleware(middleware, path) {
-    if (!middleware) {
-        return undefined;
-    }
-    for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) {
-        if (buildWildcardRegExp(k).test(path)) {
-            return [...middleware[k]];
-        }
+  if (!middleware) {
+    return void 0;
+  }
+  for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) {
+    if (buildWildcardRegExp(k).test(path)) {
+      return [...middleware[k]];
     }
-    return undefined;
+  }
+  return void 0;
 }
 class RegExpRouter {
-    constructor() {
-        this.middleware = { [router_1.METHOD_NAME_ALL]: {} };
-        this.routes = { [router_1.METHOD_NAME_ALL]: {} };
+  constructor() {
+    this.middleware = { [import_router.METHOD_NAME_ALL]: {} };
+    this.routes = { [import_router.METHOD_NAME_ALL]: {} };
+  }
+  add(method, path, handler) {
+    var _a;
+    const { middleware, routes } = this;
+    if (!middleware || !routes) {
+      throw new Error("Can not add a route since the matcher is already built.");
     }
-    add(method, path, handler) {
-        var _a;
-        const { middleware, routes } = this;
-        if (!middleware || !routes) {
-            throw new Error('Can not add a route since the matcher is already built.');
-        }
-        if (path === '/*') {
-            path = '*';
-        }
-        if (/\*$/.test(path)) {
-            middleware[method] || (middleware[method] = {});
-            const re = buildWildcardRegExp(path);
-            (_a = middleware[method])[path] || (_a[path] = findMiddleware(middleware[router_1.METHOD_NAME_ALL], path) || []);
-            Object.keys(middleware).forEach((m) => {
-                if (method === router_1.METHOD_NAME_ALL || method === m) {
-                    Object.keys(middleware[m]).forEach((p) => {
-                        ;
-                        (path === '*' || path === p) && middleware[m][p].push(handler);
-                    });
-                }
-            });
-            Object.keys(routes).forEach((m) => {
-                if (method === router_1.METHOD_NAME_ALL || method === m) {
-                    Object.keys(routes[m]).forEach((p) => (path === '*' || re.test(p)) && routes[m][p].push(handler));
-                }
-            });
-            return;
+    if (path === "/*") {
+      path = "*";
+    }
+    if (/\*$/.test(path)) {
+      middleware[method] || (middleware[method] = {});
+      const re = buildWildcardRegExp(path);
+      (_a = middleware[method])[path] || (_a[path] = findMiddleware(middleware[import_router.METHOD_NAME_ALL], path) || []);
+      Object.keys(middleware).forEach((m) => {
+        if (method === import_router.METHOD_NAME_ALL || method === m) {
+          Object.keys(middleware[m]).forEach((p) => {
+            ;
+            (path === "*" || path === p) && middleware[m][p].push(handler);
+          });
         }
-        const paths = (0, url_1.checkOptionalParameter)(path) || [path];
-        for (let i = 0, len = paths.length; i < len; i++) {
-            const path = paths[i];
-            routes[method] || (routes[method] = {});
-            Object.keys(routes).forEach((m) => {
-                var _a;
-                if (method === router_1.METHOD_NAME_ALL || method === m) {
-                    (_a = routes[m])[path] || (_a[path] = [
-                        ...(routes[router_1.METHOD_NAME_ALL][path] ||
-                            findMiddleware(middleware[method], path) ||
-                            findMiddleware(middleware[router_1.METHOD_NAME_ALL], path) ||
-                            []),
-                    ]);
-                    routes[m][path].push(handler);
-                }
-            });
+      });
+      Object.keys(routes).forEach((m) => {
+        if (method === import_router.METHOD_NAME_ALL || method === m) {
+          Object.keys(routes[m]).forEach(
+            (p) => (path === "*" || re.test(p)) && routes[m][p].push(handler)
+          );
         }
+      });
+      return;
     }
-    match(method, path) {
-        const matchers = this.buildAllMatchers();
-        this.match = (method, path) => {
-            const matcher = matchers[method];
-            const match = path.match(matcher[0]);
-            if (!match) {
-                return null;
-            }
-            const index = match.indexOf('', 1);
-            const [handlers, paramMap] = matcher[1][index];
-            if (!paramMap) {
-                return { handlers, params: emptyParam };
-            }
-            const params = {};
-            for (let i = 0, len = paramMap.length; i < len; i++) {
-                params[paramMap[i][0]] = match[paramMap[i][1]];
-            }
-            return { handlers, params };
-        };
-        return this.match(method, path);
-    }
-    buildAllMatchers() {
-        const matchers = {};
-        METHOD_NAMES.forEach((method) => {
-            matchers[method] = this.buildMatcher(method) || matchers[router_1.METHOD_NAME_ALL];
-        });
-        // Release cache
-        this.middleware = this.routes = undefined;
-        return matchers;
-    }
-    buildMatcher(method) {
-        const routes = [];
-        let hasOwnRoute = method === router_1.METHOD_NAME_ALL;
-        [this.middleware, this.routes].forEach((r) => {
-            const ownRoute = r[method]
-                ? Object.keys(r[method]).map((path) => [path, r[method][path]])
-                : [];
-            if (ownRoute.length !== 0) {
-                hasOwnRoute || (hasOwnRoute = true);
-                routes.push(...ownRoute);
-            }
-            else if (method !== router_1.METHOD_NAME_ALL) {
-                routes.push(...Object.keys(r[router_1.METHOD_NAME_ALL]).map((path) => [path, r[router_1.METHOD_NAME_ALL][path]]));
-            }
-        });
-        if (!hasOwnRoute) {
-            return null;
-        }
-        else {
-            return buildMatcherFromPreprocessedRoutes(routes);
+    const paths = (0, import_url.checkOptionalParameter)(path) || [path];
+    for (let i = 0, len = paths.length; i < len; i++) {
+      const path2 = paths[i];
+      routes[method] || (routes[method] = {});
+      Object.keys(routes).forEach((m) => {
+        var _a2;
+        if (method === import_router.METHOD_NAME_ALL || method === m) {
+          (_a2 = routes[m])[path2] || (_a2[path2] = [
+            ...routes[import_router.METHOD_NAME_ALL][path2] || findMiddleware(middleware[method], path2) || findMiddleware(middleware[import_router.METHOD_NAME_ALL], path2) || []
+          ]);
+          routes[m][path2].push(handler);
         }
+      });
+    }
+  }
+  match(method, path) {
+    const matchers = this.buildAllMatchers();
+    this.match = (method2, path2) => {
+      const matcher = matchers[method2];
+      const match = path2.match(matcher[0]);
+      if (!match) {
+        return null;
+      }
+      const index = match.indexOf("", 1);
+      const [handlers, paramMap] = matcher[1][index];
+      if (!paramMap) {
+        return { handlers, params: emptyParam };
+      }
+      const params = {};
+      for (let i = 0, len = paramMap.length; i < len; i++) {
+        params[paramMap[i][0]] = match[paramMap[i][1]];
+      }
+      return { handlers, params };
+    };
+    return this.match(method, path);
+  }
+  buildAllMatchers() {
+    const matchers = {};
+    METHOD_NAMES.forEach((method) => {
+      matchers[method] = this.buildMatcher(method) || matchers[import_router.METHOD_NAME_ALL];
+    });
+    this.middleware = this.routes = void 0;
+    return matchers;
+  }
+  buildMatcher(method) {
+    const routes = [];
+    let hasOwnRoute = method === import_router.METHOD_NAME_ALL;
+    [this.middleware, this.routes].forEach((r) => {
+      const ownRoute = r[method] ? Object.keys(r[method]).map((path) => [path, r[method][path]]) : [];
+      if (ownRoute.length !== 0) {
+        hasOwnRoute || (hasOwnRoute = true);
+        routes.push(...ownRoute);
+      } else if (method !== import_router.METHOD_NAME_ALL) {
+        routes.push(
+          ...Object.keys(r[import_router.METHOD_NAME_ALL]).map((path) => [path, r[import_router.METHOD_NAME_ALL][path]])
+        );
+      }
+    });
+    if (!hasOwnRoute) {
+      return null;
+    } else {
+      return buildMatcherFromPreprocessedRoutes(routes);
     }
+  }
 }
-exports.RegExpRouter = RegExpRouter;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RegExpRouter
+});

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

@@ -1,42 +1,58 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Trie = void 0;
-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 trie_exports = {};
+__export(trie_exports, {
+  Trie: () => Trie
+});
+module.exports = __toCommonJS(trie_exports);
+var import_node = require("./node");
 class Trie {
-    constructor() {
-        this.context = { varIndex: 0 };
-        this.root = new node_1.Node();
-    }
-    insert(path, index) {
-        const paramMap = [];
-        /**
-         *  - pattern (:label, :label{0-9]+}, ...)
-         *  - /* wildcard
-         *  - character
-         */
-        const tokens = path.match(/(?::[^\/]+)|(?:\/\*$)|./g);
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore
-        this.root.insert(tokens, index, paramMap, this.context);
-        return paramMap;
-    }
-    buildRegExp() {
-        let regexp = this.root.buildRegExpStr();
-        let captureIndex = 0;
-        const indexReplacementMap = [];
-        const paramReplacementMap = [];
-        regexp = regexp.replace(/#(\d+)|@(\d+)|\.\*\$/g, (_, handlerIndex, paramIndex) => {
-            if (typeof handlerIndex !== 'undefined') {
-                indexReplacementMap[++captureIndex] = Number(handlerIndex);
-                return '$()';
-            }
-            if (typeof paramIndex !== 'undefined') {
-                paramReplacementMap[Number(paramIndex)] = ++captureIndex;
-                return '';
-            }
-            return '';
-        });
-        return [new RegExp(`^${regexp}`), indexReplacementMap, paramReplacementMap];
-    }
+  constructor() {
+    this.context = { varIndex: 0 };
+    this.root = new import_node.Node();
+  }
+  insert(path, index) {
+    const paramMap = [];
+    const tokens = path.match(/(?::[^\/]+)|(?:\/\*$)|./g);
+    this.root.insert(tokens, index, paramMap, this.context);
+    return paramMap;
+  }
+  buildRegExp() {
+    let regexp = this.root.buildRegExpStr();
+    let captureIndex = 0;
+    const indexReplacementMap = [];
+    const paramReplacementMap = [];
+    regexp = regexp.replace(/#(\d+)|@(\d+)|\.\*\$/g, (_, handlerIndex, paramIndex) => {
+      if (typeof handlerIndex !== "undefined") {
+        indexReplacementMap[++captureIndex] = Number(handlerIndex);
+        return "$()";
+      }
+      if (typeof paramIndex !== "undefined") {
+        paramReplacementMap[Number(paramIndex)] = ++captureIndex;
+        return "";
+      }
+      return "";
+    });
+    return [new RegExp(`^${regexp}`), indexReplacementMap, paramReplacementMap];
+  }
 }
-exports.Trie = Trie;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Trie
+});