@kevisual/router 0.2.4 → 0.2.5

package/dist/router-simple.js

@@ -30,7 +30,7 @@ var __toESM = (mod, isNodeMode, target) => {
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 
-// node_modules/path-to-regexp/dist/index.js
+// ../../node_modules/.pnpm/path-to-regexp@8.4.0/node_modules/path-to-regexp/dist/index.js
 var require_dist = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.PathError = exports.TokenData = undefined;
@@ -43,17 +43,8 @@ var require_dist = __commonJS((exports) => {
   var NOOP_VALUE = (value) => value;
   var ID_START = /^[$_\p{ID_Start}]$/u;
   var ID_CONTINUE = /^[$\u200c\u200d\p{ID_Continue}]$/u;
-  var SIMPLE_TOKENS = {
-    "{": "{",
-    "}": "}",
-    "(": "(",
-    ")": ")",
-    "[": "[",
-    "]": "]",
-    "+": "+",
-    "?": "?",
-    "!": "!"
-  };
+  var ID = /^[$_\p{ID_Start}][$\u200c\u200d\p{ID_Continue}]*$/u;
+  var SIMPLE_TOKENS = "{}()[]+?!";
   function escapeText(str) {
     return str.replace(/[{}()\[\]+?!:*\\]/g, "\\$&");
   }
@@ -94,8 +85,8 @@ var require_dist = __commonJS((exports) => {
         } while (ID_CONTINUE.test(chars[index]));
       } else if (chars[index] === '"') {
         let quoteStart = index;
-        while (index++ < chars.length) {
-          if (chars[index] === '"') {
+        while (index < chars.length) {
+          if (chars[++index] === '"') {
             index++;
             quoteStart = 0;
             break;
@@ -114,18 +105,17 @@ var require_dist = __commonJS((exports) => {
       return value;
     }
     while (index < chars.length) {
-      const value = chars[index];
-      const type = SIMPLE_TOKENS[value];
-      if (type) {
-        tokens.push({ type, index: index++, value });
+      const value = chars[index++];
+      if (SIMPLE_TOKENS.includes(value)) {
+        tokens.push({ type: value, index, value });
       } else if (value === "\\") {
-        tokens.push({ type: "escape", index: index++, value: chars[index++] });
+        tokens.push({ type: "escape", index, value: chars[index++] });
       } else if (value === ":") {
-        tokens.push({ type: "param", index: index++, value: name() });
+        tokens.push({ type: "param", index, value: name() });
       } else if (value === "*") {
-        tokens.push({ type: "wildcard", index: index++, value: name() });
+        tokens.push({ type: "wildcard", index, value: name() });
       } else {
-        tokens.push({ type: "char", index: index++, value });
+        tokens.push({ type: "char", index, value });
       }
     }
     tokens.push({ type: "end", index, value: "" });
@@ -261,107 +251,159 @@ var require_dist = __commonJS((exports) => {
   }
   function pathToRegexp(path, options = {}) {
     const { delimiter = DEFAULT_DELIMITER, end = true, sensitive = false, trailing = true } = options;
-    const keys = [];
-    const flags = sensitive ? "" : "i";
-    const sources = [];
-    for (const input of pathsToArray(path, [])) {
-      const data = typeof input === "object" ? input : parse(input, options);
-      for (const tokens of flatten(data.tokens, 0, [])) {
-        sources.push(toRegExpSource(tokens, delimiter, keys, data.originalPath));
+    const root = new SourceNode("^");
+    const paths = [path];
+    let combinations = 0;
+    while (paths.length) {
+      const path2 = paths.shift();
+      if (Array.isArray(path2)) {
+        paths.push(...path2);
+        continue;
       }
+      const data = typeof path2 === "object" ? path2 : parse(path2, options);
+      flatten(data.tokens, 0, [], (tokens) => {
+        if (combinations++ >= 256) {
+          throw new PathError("Too many path combinations", data.originalPath);
+        }
+        let node = root;
+        for (const part of toRegExpSource(tokens, delimiter, data.originalPath)) {
+          node = node.add(part.source, part.key);
+        }
+        node.add("");
+      });
     }
-    let pattern = `^(?:${sources.join("|")})`;
+    const keys = [];
+    let pattern = toRegExp(root, keys);
     if (trailing)
-      pattern += `(?:${escape(delimiter)}$)?`;
-    pattern += end ? "$" : `(?=${escape(delimiter)}|$)`;
-    const regexp = new RegExp(pattern, flags);
-    return { regexp, keys };
-  }
-  function pathsToArray(paths, init) {
-    if (Array.isArray(paths)) {
-      for (const p of paths)
-        pathsToArray(p, init);
-    } else {
-      init.push(paths);
-    }
-    return init;
+      pattern += "(?:" + escape(delimiter) + "$)?";
+    pattern += end ? "$" : "(?=" + escape(delimiter) + "|$)";
+    return { regexp: new RegExp(pattern, sensitive ? "" : "i"), keys };
   }
-  function* flatten(tokens, index, init) {
-    if (index === tokens.length) {
-      return yield init;
+  function toRegExp(node, keys) {
+    if (node.key)
+      keys.push(node.key);
+    const children = Object.keys(node.children);
+    const text = children.map((id) => toRegExp(node.children[id], keys)).join("|");
+    return node.source + (children.length < 2 ? text : `(?:${text})`);
+  }
+
+  class SourceNode {
+    constructor(source, key) {
+      this.source = source;
+      this.key = key;
+      this.children = Object.create(null);
     }
-    const token = tokens[index];
-    if (token.type === "group") {
-      for (const seq of flatten(token.tokens, 0, init.slice())) {
-        yield* flatten(tokens, index + 1, seq);
+    add(source, key) {
+      var _a;
+      const id = source + ":" + (key ? key.name : "");
+      return (_a = this.children)[id] || (_a[id] = new SourceNode(source, key));
+    }
+  }
+  function flatten(tokens, index, result, callback) {
+    while (index < tokens.length) {
+      const token = tokens[index++];
+      if (token.type === "group") {
+        flatten(token.tokens, 0, result.slice(), (seq) => flatten(tokens, index, seq, callback));
+        continue;
       }
-    } else {
-      init.push(token);
+      result.push(token);
     }
-    yield* flatten(tokens, index + 1, init);
+    callback(result);
   }
-  function toRegExpSource(tokens, delimiter, keys, originalPath) {
-    let result = "";
+  function toRegExpSource(tokens, delimiter, originalPath) {
+    let result = [];
     let backtrack = "";
-    let isSafeSegmentParam = true;
-    for (const token of tokens) {
+    let wildcardBacktrack = "";
+    let prevCaptureType = 0;
+    let hasSegmentCapture = 0;
+    let index = 0;
+    function hasInSegment(index2, type) {
+      while (index2 < tokens.length) {
+        const token = tokens[index2++];
+        if (token.type === type)
+          return true;
+        if (token.type === "text") {
+          if (token.value.includes(delimiter))
+            break;
+        }
+      }
+      return false;
+    }
+    function peekText(index2) {
+      let result2 = "";
+      while (index2 < tokens.length) {
+        const token = tokens[index2++];
+        if (token.type !== "text")
+          break;
+        result2 += token.value;
+      }
+      return result2;
+    }
+    while (index < tokens.length) {
+      const token = tokens[index++];
       if (token.type === "text") {
-        result += escape(token.value);
+        result.push({ source: escape(token.value) });
         backtrack += token.value;
-        isSafeSegmentParam || (isSafeSegmentParam = token.value.includes(delimiter));
+        if (prevCaptureType === 2)
+          wildcardBacktrack += token.value;
+        if (token.value.includes(delimiter))
+          hasSegmentCapture = 0;
         continue;
       }
       if (token.type === "param" || token.type === "wildcard") {
-        if (!isSafeSegmentParam && !backtrack) {
+        if (prevCaptureType && !backtrack) {
           throw new PathError(`Missing text before "${token.name}" ${token.type}`, originalPath);
         }
         if (token.type === "param") {
-          result += `(${negate(delimiter, isSafeSegmentParam ? "" : backtrack)}+)`;
+          result.push({
+            source: hasSegmentCapture ? `(${negate(delimiter, backtrack)}+?)` : hasInSegment(index, "wildcard") ? `(${negate(delimiter, peekText(index))}+?)` : `(${negate(delimiter, "")}+?)`,
+            key: token
+          });
+          hasSegmentCapture |= prevCaptureType = 1;
         } else {
-          result += `([\\s\\S]+)`;
+          result.push({
+            source: hasSegmentCapture & 2 ? `(${negate(backtrack, "")}+?)` : hasSegmentCapture & 1 ? `(${negate(wildcardBacktrack, "")}+?)` : wildcardBacktrack ? `(${negate(wildcardBacktrack, "")}+?|${negate(delimiter, "")}+?)` : `([^]+?)`,
+            key: token
+          });
+          wildcardBacktrack = "";
+          hasSegmentCapture |= prevCaptureType = 2;
         }
-        keys.push(token);
         backtrack = "";
-        isSafeSegmentParam = false;
         continue;
       }
+      throw new TypeError(`Unknown token type: ${token.type}`);
     }
     return result;
   }
-  function negate(delimiter, backtrack) {
-    if (backtrack.length < 2) {
-      if (delimiter.length < 2)
-        return `[^${escape(delimiter + backtrack)}]`;
-      return `(?:(?!${escape(delimiter)})[^${escape(backtrack)}])`;
-    }
-    if (delimiter.length < 2) {
-      return `(?:(?!${escape(backtrack)})[^${escape(delimiter)}])`;
-    }
-    return `(?:(?!${escape(backtrack)}|${escape(delimiter)})[\\s\\S])`;
-  }
-  function stringifyTokens(tokens) {
+  function negate(a, b) {
+    if (b.length > a.length)
+      return negate(b, a);
+    if (a === b)
+      b = "";
+    if (b.length > 1)
+      return `(?:(?!${escape(a)}|${escape(b)})[^])`;
+    if (a.length > 1)
+      return `(?:(?!${escape(a)})[^${escape(b)}])`;
+    return `[^${escape(a + b)}]`;
+  }
+  function stringifyTokens(tokens, index) {
     let value = "";
-    let i = 0;
-    function name(value2) {
-      const isSafe = isNameSafe(value2) && isNextNameSafe(tokens[i]);
-      return isSafe ? value2 : JSON.stringify(value2);
-    }
-    while (i < tokens.length) {
-      const token = tokens[i++];
+    while (index < tokens.length) {
+      const token = tokens[index++];
       if (token.type === "text") {
         value += escapeText(token.value);
         continue;
       }
       if (token.type === "group") {
-        value += `{${stringifyTokens(token.tokens)}}`;
+        value += "{" + stringifyTokens(token.tokens, 0) + "}";
         continue;
       }
       if (token.type === "param") {
-        value += `:${name(token.name)}`;
+        value += ":" + stringifyName(token.name, tokens[index]);
         continue;
       }
       if (token.type === "wildcard") {
-        value += `*${name(token.name)}`;
+        value += "*" + stringifyName(token.name, tokens[index]);
         continue;
       }
       throw new TypeError(`Unknown token type: ${token.type}`);
@@ -369,16 +411,15 @@ var require_dist = __commonJS((exports) => {
     return value;
   }
   function stringify(data) {
-    return stringifyTokens(data.tokens);
+    return stringifyTokens(data.tokens, 0);
   }
-  function isNameSafe(name) {
-    const [first, ...rest] = name;
-    return ID_START.test(first) && rest.every((char) => ID_CONTINUE.test(char));
-  }
-  function isNextNameSafe(token) {
-    if (token && token.type === "text")
-      return !ID_CONTINUE.test(token.value[0]);
-    return true;
+  function stringifyName(name, next) {
+    if (!ID.test(name))
+      return JSON.stringify(name);
+    if ((next === null || next === undefined ? undefined : next.type) === "text" && ID_CONTINUE.test(next.value[0])) {
+      return JSON.stringify(name);
+    }
+    return name;
   }
 });