@kevisual/router 0.0.71 → 0.0.73

package/dist/router-simple.js

@@ -1,788 +1,694 @@
-import url from 'node:url';
-
-var dist = {};
-
-var hasRequiredDist;
-
-function requireDist () {
-	if (hasRequiredDist) return dist;
-	hasRequiredDist = 1;
-	Object.defineProperty(dist, "__esModule", { value: true });
-	dist.PathError = dist.TokenData = void 0;
-	dist.parse = parse;
-	dist.compile = compile;
-	dist.match = match;
-	dist.pathToRegexp = pathToRegexp;
-	dist.stringify = stringify;
-	const DEFAULT_DELIMITER = "/";
-	const NOOP_VALUE = (value) => value;
-	const ID_START = /^[$_\p{ID_Start}]$/u;
-	const ID_CONTINUE = /^[$\u200c\u200d\p{ID_Continue}]$/u;
-	const SIMPLE_TOKENS = {
-	    // Groups.
-	    "{": "{",
-	    "}": "}",
-	    // Reserved.
-	    "(": "(",
-	    ")": ")",
-	    "[": "[",
-	    "]": "]",
-	    "+": "+",
-	    "?": "?",
-	    "!": "!",
-	};
-	/**
-	 * Escape text for stringify to path.
-	 */
-	function escapeText(str) {
-	    return str.replace(/[{}()\[\]+?!:*\\]/g, "\\$&");
-	}
-	/**
-	 * Escape a regular expression string.
-	 */
-	function escape(str) {
-	    return str.replace(/[.+*?^${}()[\]|/\\]/g, "\\$&");
-	}
-	/**
-	 * Tokenized path instance.
-	 */
-	class TokenData {
-	    constructor(tokens, originalPath) {
-	        this.tokens = tokens;
-	        this.originalPath = originalPath;
-	    }
-	}
-	dist.TokenData = TokenData;
-	/**
-	 * ParseError is thrown when there is an error processing the path.
-	 */
-	class PathError extends TypeError {
-	    constructor(message, originalPath) {
-	        let text = message;
-	        if (originalPath)
-	            text += `: ${originalPath}`;
-	        text += `; visit https://git.new/pathToRegexpError for info`;
-	        super(text);
-	        this.originalPath = originalPath;
-	    }
-	}
-	dist.PathError = PathError;
-	/**
-	 * Parse a string for the raw tokens.
-	 */
-	function parse(str, options = {}) {
-	    const { encodePath = NOOP_VALUE } = options;
-	    const chars = [...str];
-	    const tokens = [];
-	    let index = 0;
-	    let pos = 0;
-	    function name() {
-	        let value = "";
-	        if (ID_START.test(chars[index])) {
-	            do {
-	                value += chars[index++];
-	            } while (ID_CONTINUE.test(chars[index]));
-	        }
-	        else if (chars[index] === '"') {
-	            let quoteStart = index;
-	            while (index++ < chars.length) {
-	                if (chars[index] === '"') {
-	                    index++;
-	                    quoteStart = 0;
-	                    break;
-	                }
-	                // Increment over escape characters.
-	                if (chars[index] === "\\")
-	                    index++;
-	                value += chars[index];
-	            }
-	            if (quoteStart) {
-	                throw new PathError(`Unterminated quote at index ${quoteStart}`, str);
-	            }
-	        }
-	        if (!value) {
-	            throw new PathError(`Missing parameter name at index ${index}`, str);
-	        }
-	        return value;
-	    }
-	    while (index < chars.length) {
-	        const value = chars[index];
-	        const type = SIMPLE_TOKENS[value];
-	        if (type) {
-	            tokens.push({ type, index: index++, value });
-	        }
-	        else if (value === "\\") {
-	            tokens.push({ type: "escape", index: index++, value: chars[index++] });
-	        }
-	        else if (value === ":") {
-	            tokens.push({ type: "param", index: index++, value: name() });
-	        }
-	        else if (value === "*") {
-	            tokens.push({ type: "wildcard", index: index++, value: name() });
-	        }
-	        else {
-	            tokens.push({ type: "char", index: index++, value });
-	        }
-	    }
-	    tokens.push({ type: "end", index, value: "" });
-	    function consumeUntil(endType) {
-	        const output = [];
-	        while (true) {
-	            const token = tokens[pos++];
-	            if (token.type === endType)
-	                break;
-	            if (token.type === "char" || token.type === "escape") {
-	                let path = token.value;
-	                let cur = tokens[pos];
-	                while (cur.type === "char" || cur.type === "escape") {
-	                    path += cur.value;
-	                    cur = tokens[++pos];
-	                }
-	                output.push({
-	                    type: "text",
-	                    value: encodePath(path),
-	                });
-	                continue;
-	            }
-	            if (token.type === "param" || token.type === "wildcard") {
-	                output.push({
-	                    type: token.type,
-	                    name: token.value,
-	                });
-	                continue;
-	            }
-	            if (token.type === "{") {
-	                output.push({
-	                    type: "group",
-	                    tokens: consumeUntil("}"),
-	                });
-	                continue;
-	            }
-	            throw new PathError(`Unexpected ${token.type} at index ${token.index}, expected ${endType}`, str);
-	        }
-	        return output;
-	    }
-	    return new TokenData(consumeUntil("end"), str);
-	}
-	/**
-	 * Compile a string to a template function for the path.
-	 */
-	function compile(path, options = {}) {
-	    const { encode = encodeURIComponent, delimiter = DEFAULT_DELIMITER } = options;
-	    const data = typeof path === "object" ? path : parse(path, options);
-	    const fn = tokensToFunction(data.tokens, delimiter, encode);
-	    return function path(params = {}) {
-	        const [path, ...missing] = fn(params);
-	        if (missing.length) {
-	            throw new TypeError(`Missing parameters: ${missing.join(", ")}`);
-	        }
-	        return path;
-	    };
-	}
-	function tokensToFunction(tokens, delimiter, encode) {
-	    const encoders = tokens.map((token) => tokenToFunction(token, delimiter, encode));
-	    return (data) => {
-	        const result = [""];
-	        for (const encoder of encoders) {
-	            const [value, ...extras] = encoder(data);
-	            result[0] += value;
-	            result.push(...extras);
-	        }
-	        return result;
-	    };
-	}
-	/**
-	 * Convert a single token into a path building function.
-	 */
-	function tokenToFunction(token, delimiter, encode) {
-	    if (token.type === "text")
-	        return () => [token.value];
-	    if (token.type === "group") {
-	        const fn = tokensToFunction(token.tokens, delimiter, encode);
-	        return (data) => {
-	            const [value, ...missing] = fn(data);
-	            if (!missing.length)
-	                return [value];
-	            return [""];
-	        };
-	    }
-	    const encodeValue = encode || NOOP_VALUE;
-	    if (token.type === "wildcard" && encode !== false) {
-	        return (data) => {
-	            const value = data[token.name];
-	            if (value == null)
-	                return ["", token.name];
-	            if (!Array.isArray(value) || value.length === 0) {
-	                throw new TypeError(`Expected "${token.name}" to be a non-empty array`);
-	            }
-	            return [
-	                value
-	                    .map((value, index) => {
-	                    if (typeof value !== "string") {
-	                        throw new TypeError(`Expected "${token.name}/${index}" to be a string`);
-	                    }
-	                    return encodeValue(value);
-	                })
-	                    .join(delimiter),
-	            ];
-	        };
-	    }
-	    return (data) => {
-	        const value = data[token.name];
-	        if (value == null)
-	            return ["", token.name];
-	        if (typeof value !== "string") {
-	            throw new TypeError(`Expected "${token.name}" to be a string`);
-	        }
-	        return [encodeValue(value)];
-	    };
-	}
-	/**
-	 * Transform a path into a match function.
-	 */
-	function match(path, options = {}) {
-	    const { decode = decodeURIComponent, delimiter = DEFAULT_DELIMITER } = options;
-	    const { regexp, keys } = pathToRegexp(path, options);
-	    const decoders = keys.map((key) => {
-	        if (decode === false)
-	            return NOOP_VALUE;
-	        if (key.type === "param")
-	            return decode;
-	        return (value) => value.split(delimiter).map(decode);
-	    });
-	    return function match(input) {
-	        const m = regexp.exec(input);
-	        if (!m)
-	            return false;
-	        const path = m[0];
-	        const params = Object.create(null);
-	        for (let i = 1; i < m.length; i++) {
-	            if (m[i] === undefined)
-	                continue;
-	            const key = keys[i - 1];
-	            const decoder = decoders[i - 1];
-	            params[key.name] = decoder(m[i]);
-	        }
-	        return { path, params };
-	    };
-	}
-	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));
-	        }
-	    }
-	    let pattern = `^(?:${sources.join("|")})`;
-	    if (trailing)
-	        pattern += `(?:${escape(delimiter)}$)?`;
-	    pattern += end ? "$" : `(?=${escape(delimiter)}|$)`;
-	    const regexp = new RegExp(pattern, flags);
-	    return { regexp, keys };
-	}
-	/**
-	 * Convert a path or array of paths into a flat array.
-	 */
-	function pathsToArray(paths, init) {
-	    if (Array.isArray(paths)) {
-	        for (const p of paths)
-	            pathsToArray(p, init);
-	    }
-	    else {
-	        init.push(paths);
-	    }
-	    return init;
-	}
-	/**
-	 * Generate a flat list of sequence tokens from the given tokens.
-	 */
-	function* flatten(tokens, index, init) {
-	    if (index === tokens.length) {
-	        return yield init;
-	    }
-	    const token = tokens[index];
-	    if (token.type === "group") {
-	        for (const seq of flatten(token.tokens, 0, init.slice())) {
-	            yield* flatten(tokens, index + 1, seq);
-	        }
-	    }
-	    else {
-	        init.push(token);
-	    }
-	    yield* flatten(tokens, index + 1, init);
-	}
-	/**
-	 * Transform a flat sequence of tokens into a regular expression.
-	 */
-	function toRegExpSource(tokens, delimiter, keys, originalPath) {
-	    let result = "";
-	    let backtrack = "";
-	    let isSafeSegmentParam = true;
-	    for (const token of tokens) {
-	        if (token.type === "text") {
-	            result += escape(token.value);
-	            backtrack += token.value;
-	            isSafeSegmentParam || (isSafeSegmentParam = token.value.includes(delimiter));
-	            continue;
-	        }
-	        if (token.type === "param" || token.type === "wildcard") {
-	            if (!isSafeSegmentParam && !backtrack) {
-	                throw new PathError(`Missing text before "${token.name}" ${token.type}`, originalPath);
-	            }
-	            if (token.type === "param") {
-	                result += `(${negate(delimiter, isSafeSegmentParam ? "" : backtrack)}+)`;
-	            }
-	            else {
-	                result += `([\\s\\S]+)`;
-	            }
-	            keys.push(token);
-	            backtrack = "";
-	            isSafeSegmentParam = false;
-	            continue;
-	        }
-	    }
-	    return result;
-	}
-	/**
-	 * Block backtracking on previous text and ignore delimiter string.
-	 */
-	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])`;
-	}
-	/**
-	 * Stringify an array of tokens into a path string.
-	 */
-	function stringifyTokens(tokens) {
-	    let value = "";
-	    let i = 0;
-	    function name(value) {
-	        const isSafe = isNameSafe(value) && isNextNameSafe(tokens[i]);
-	        return isSafe ? value : JSON.stringify(value);
-	    }
-	    while (i < tokens.length) {
-	        const token = tokens[i++];
-	        if (token.type === "text") {
-	            value += escapeText(token.value);
-	            continue;
-	        }
-	        if (token.type === "group") {
-	            value += `{${stringifyTokens(token.tokens)}}`;
-	            continue;
-	        }
-	        if (token.type === "param") {
-	            value += `:${name(token.name)}`;
-	            continue;
-	        }
-	        if (token.type === "wildcard") {
-	            value += `*${name(token.name)}`;
-	            continue;
-	        }
-	        throw new TypeError(`Unknown token type: ${token.type}`);
-	    }
-	    return value;
-	}
-	/**
-	 * Stringify token data into a path string.
-	 */
-	function stringify(data) {
-	    return stringifyTokens(data.tokens);
-	}
-	/**
-	 * Validate the parameter name contains valid ID characters.
-	 */
-	function isNameSafe(name) {
-	    const [first, ...rest] = name;
-	    return ID_START.test(first) && rest.every((char) => ID_CONTINUE.test(char));
-	}
-	/**
-	 * Validate the next token does not interfere with the current param name.
-	 */
-	function isNextNameSafe(token) {
-	    if (token && token.type === "text")
-	        return !ID_CONTINUE.test(token.value[0]);
-	    return true;
-	}
-	
-	return dist;
-}
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 
-var distExports = requireDist();
+// node_modules/.pnpm/path-to-regexp@8.3.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;
+  exports.parse = parse;
+  exports.compile = compile;
+  exports.match = match;
+  exports.pathToRegexp = pathToRegexp;
+  exports.stringify = stringify;
+  var DEFAULT_DELIMITER = "/";
+  var NOOP_VALUE = (value) => value;
+  var ID_START = /^[$_\p{ID_Start}]$/u;
+  var ID_CONTINUE = /^[$\u200c\u200d\p{ID_Continue}]$/u;
+  var SIMPLE_TOKENS = {
+    "{": "{",
+    "}": "}",
+    "(": "(",
+    ")": ")",
+    "[": "[",
+    "]": "]",
+    "+": "+",
+    "?": "?",
+    "!": "!"
+  };
+  function escapeText(str) {
+    return str.replace(/[{}()\[\]+?!:*\\]/g, "\\$&");
+  }
+  function escape(str) {
+    return str.replace(/[.+*?^${}()[\]|/\\]/g, "\\$&");
+  }
 
-typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
-// @ts-ignore
-typeof Deno !== 'undefined' && typeof Deno.version === 'object' && typeof Deno.version.deno === 'string';
-// @ts-ignore
-const isBun = typeof Bun !== 'undefined' && typeof Bun.version === 'string';
+  class TokenData {
+    constructor(tokens, originalPath) {
+      this.tokens = tokens;
+      this.originalPath = originalPath;
+    }
+  }
+  exports.TokenData = TokenData;
 
-const parseBody = async (req) => {
-    const resolveBody = (body) => {
-        // 获取 Content-Type 头信息
-        const contentType = req.headers['content-type'] || '';
-        const resolve = (data) => {
-            return data;
-        };
-        // 处理 application/json
-        if (contentType.includes('application/json')) {
-            return resolve(JSON.parse(body));
+  class PathError extends TypeError {
+    constructor(message, originalPath) {
+      let text = message;
+      if (originalPath)
+        text += `: ${originalPath}`;
+      text += `; visit https://git.new/pathToRegexpError for info`;
+      super(text);
+      this.originalPath = originalPath;
+    }
+  }
+  exports.PathError = PathError;
+  function parse(str, options = {}) {
+    const { encodePath = NOOP_VALUE } = options;
+    const chars = [...str];
+    const tokens = [];
+    let index = 0;
+    let pos = 0;
+    function name() {
+      let value = "";
+      if (ID_START.test(chars[index])) {
+        do {
+          value += chars[index++];
+        } while (ID_CONTINUE.test(chars[index]));
+      } else if (chars[index] === '"') {
+        let quoteStart = index;
+        while (index++ < chars.length) {
+          if (chars[index] === '"') {
+            index++;
+            quoteStart = 0;
+            break;
+          }
+          if (chars[index] === "\\")
+            index++;
+          value += chars[index];
         }
-        // 处理 application/x-www-form-urlencoded
-        if (contentType.includes('application/x-www-form-urlencoded')) {
-            const formData = new URLSearchParams(body);
-            const result = {};
-            formData.forEach((value, key) => {
-                // 尝试将值解析为 JSON，如果失败则保留原始字符串
-                try {
-                    result[key] = JSON.parse(value);
-                }
-                catch {
-                    result[key] = value;
-                }
-            });
-            return resolve(result);
+        if (quoteStart) {
+          throw new PathError(`Unterminated quote at index ${quoteStart}`, str);
         }
-        // 默认尝试 JSON 解析
-        try {
-            return resolve(JSON.parse(body));
+      }
+      if (!value) {
+        throw new PathError(`Missing parameter name at index ${index}`, str);
+      }
+      return value;
+    }
+    while (index < chars.length) {
+      const value = chars[index];
+      const type = SIMPLE_TOKENS[value];
+      if (type) {
+        tokens.push({ type, index: index++, value });
+      } else if (value === "\\") {
+        tokens.push({ type: "escape", index: index++, value: chars[index++] });
+      } else if (value === ":") {
+        tokens.push({ type: "param", index: index++, value: name() });
+      } else if (value === "*") {
+        tokens.push({ type: "wildcard", index: index++, value: name() });
+      } else {
+        tokens.push({ type: "char", index: index++, value });
+      }
+    }
+    tokens.push({ type: "end", index, value: "" });
+    function consumeUntil(endType) {
+      const output = [];
+      while (true) {
+        const token = tokens[pos++];
+        if (token.type === endType)
+          break;
+        if (token.type === "char" || token.type === "escape") {
+          let path = token.value;
+          let cur = tokens[pos];
+          while (cur.type === "char" || cur.type === "escape") {
+            path += cur.value;
+            cur = tokens[++pos];
+          }
+          output.push({
+            type: "text",
+            value: encodePath(path)
+          });
+          continue;
         }
-        catch {
-            return resolve({});
+        if (token.type === "param" || token.type === "wildcard") {
+          output.push({
+            type: token.type,
+            name: token.value
+          });
+          continue;
         }
-    };
-    if (isBun) {
-        // @ts-ignore
-        const body = req.body;
-        if (body) {
-            return resolveBody(body);
+        if (token.type === "{") {
+          output.push({
+            type: "group",
+            tokens: consumeUntil("}")
+          });
+          continue;
         }
-        return {};
+        throw new PathError(`Unexpected ${token.type} at index ${token.index}, expected ${endType}`, str);
+      }
+      return output;
     }
-    return new Promise((resolve, reject) => {
-        const arr = [];
-        req.on('data', (chunk) => {
-            arr.push(chunk);
-        });
-        req.on('end', () => {
-            try {
-                const body = Buffer.concat(arr).toString();
-                resolve(resolveBody(body));
-            }
-            catch (e) {
-                resolve({});
+    return new TokenData(consumeUntil("end"), str);
+  }
+  function compile(path, options = {}) {
+    const { encode = encodeURIComponent, delimiter = DEFAULT_DELIMITER } = options;
+    const data = typeof path === "object" ? path : parse(path, options);
+    const fn = tokensToFunction(data.tokens, delimiter, encode);
+    return function path2(params = {}) {
+      const [path3, ...missing] = fn(params);
+      if (missing.length) {
+        throw new TypeError(`Missing parameters: ${missing.join(", ")}`);
+      }
+      return path3;
+    };
+  }
+  function tokensToFunction(tokens, delimiter, encode) {
+    const encoders = tokens.map((token) => tokenToFunction(token, delimiter, encode));
+    return (data) => {
+      const result = [""];
+      for (const encoder of encoders) {
+        const [value, ...extras] = encoder(data);
+        result[0] += value;
+        result.push(...extras);
+      }
+      return result;
+    };
+  }
+  function tokenToFunction(token, delimiter, encode) {
+    if (token.type === "text")
+      return () => [token.value];
+    if (token.type === "group") {
+      const fn = tokensToFunction(token.tokens, delimiter, encode);
+      return (data) => {
+        const [value, ...missing] = fn(data);
+        if (!missing.length)
+          return [value];
+        return [""];
+      };
+    }
+    const encodeValue = encode || NOOP_VALUE;
+    if (token.type === "wildcard" && encode !== false) {
+      return (data) => {
+        const value = data[token.name];
+        if (value == null)
+          return ["", token.name];
+        if (!Array.isArray(value) || value.length === 0) {
+          throw new TypeError(`Expected "${token.name}" to be a non-empty array`);
+        }
+        return [
+          value.map((value2, index) => {
+            if (typeof value2 !== "string") {
+              throw new TypeError(`Expected "${token.name}/${index}" to be a string`);
             }
-        });
+            return encodeValue(value2);
+          }).join(delimiter)
+        ];
+      };
+    }
+    return (data) => {
+      const value = data[token.name];
+      if (value == null)
+        return ["", token.name];
+      if (typeof value !== "string") {
+        throw new TypeError(`Expected "${token.name}" to be a string`);
+      }
+      return [encodeValue(value)];
+    };
+  }
+  function match(path, options = {}) {
+    const { decode = decodeURIComponent, delimiter = DEFAULT_DELIMITER } = options;
+    const { regexp, keys } = pathToRegexp(path, options);
+    const decoders = keys.map((key) => {
+      if (decode === false)
+        return NOOP_VALUE;
+      if (key.type === "param")
+        return decode;
+      return (value) => value.split(delimiter).map(decode);
     });
-};
-const parseSearch = (req) => {
-    const parsedUrl = url.parse(req.url, true);
-    return parsedUrl.query;
-};
-/**
- * 把url当个key 的 value 的字符串转成json
- * @param value
- */
-const parseSearchValue = (value, opts) => {
-    if (!value)
-        return {};
-    const decode = opts?.decode ?? false;
-    if (decode) {
-        value = decodeURIComponent(value);
+    return function match2(input) {
+      const m = regexp.exec(input);
+      if (!m)
+        return false;
+      const path2 = m[0];
+      const params = Object.create(null);
+      for (let i = 1;i < m.length; i++) {
+        if (m[i] === undefined)
+          continue;
+        const key = keys[i - 1];
+        const decoder = decoders[i - 1];
+        params[key.name] = decoder(m[i]);
+      }
+      return { path: path2, params };
+    };
+  }
+  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));
+      }
+    }
+    let pattern = `^(?:${sources.join("|")})`;
+    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;
+  }
+  function* flatten(tokens, index, init) {
+    if (index === tokens.length) {
+      return yield init;
+    }
+    const token = tokens[index];
+    if (token.type === "group") {
+      for (const seq of flatten(token.tokens, 0, init.slice())) {
+        yield* flatten(tokens, index + 1, seq);
+      }
+    } else {
+      init.push(token);
+    }
+    yield* flatten(tokens, index + 1, init);
+  }
+  function toRegExpSource(tokens, delimiter, keys, originalPath) {
+    let result = "";
+    let backtrack = "";
+    let isSafeSegmentParam = true;
+    for (const token of tokens) {
+      if (token.type === "text") {
+        result += escape(token.value);
+        backtrack += token.value;
+        isSafeSegmentParam || (isSafeSegmentParam = token.value.includes(delimiter));
+        continue;
+      }
+      if (token.type === "param" || token.type === "wildcard") {
+        if (!isSafeSegmentParam && !backtrack) {
+          throw new PathError(`Missing text before "${token.name}" ${token.type}`, originalPath);
+        }
+        if (token.type === "param") {
+          result += `(${negate(delimiter, isSafeSegmentParam ? "" : backtrack)}+)`;
+        } else {
+          result += `([\\s\\S]+)`;
+        }
+        keys.push(token);
+        backtrack = "";
+        isSafeSegmentParam = false;
+        continue;
+      }
+    }
+    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) {
+    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++];
+      if (token.type === "text") {
+        value += escapeText(token.value);
+        continue;
+      }
+      if (token.type === "group") {
+        value += `{${stringifyTokens(token.tokens)}}`;
+        continue;
+      }
+      if (token.type === "param") {
+        value += `:${name(token.name)}`;
+        continue;
+      }
+      if (token.type === "wildcard") {
+        value += `*${name(token.name)}`;
+        continue;
+      }
+      throw new TypeError(`Unknown token type: ${token.type}`);
+    }
+    return value;
+  }
+  function stringify(data) {
+    return stringifyTokens(data.tokens);
+  }
+  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;
+  }
+});
+
+// src/router-simple.ts
+var import_path_to_regexp = __toESM(require_dist(), 1);
+
+// src/server/parse-body.ts
+import url from "node:url";
+
+// src/utils/is-engine.ts
+var isNode = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+var isBrowser = typeof window !== "undefined" && typeof document !== "undefined" && typeof document.createElement === "function";
+var isDeno = typeof Deno !== "undefined" && typeof Deno.version === "object" && typeof Deno.version.deno === "string";
+var isBun = typeof Bun !== "undefined" && typeof Bun.version === "string";
+
+// src/server/parse-body.ts
+var parseBody = async (req) => {
+  const resolveBody = (body) => {
+    const contentType = req.headers["content-type"] || "";
+    const resolve = (data) => {
+      return data;
+    };
+    if (contentType.includes("application/json")) {
+      return resolve(JSON.parse(body));
+    }
+    if (contentType.includes("application/x-www-form-urlencoded")) {
+      const formData = new URLSearchParams(body);
+      const result = {};
+      formData.forEach((value, key) => {
+        try {
+          result[key] = JSON.parse(value);
+        } catch {
+          result[key] = value;
+        }
+      });
+      return resolve(result);
     }
     try {
-        return JSON.parse(value);
+      return resolve(JSON.parse(body));
+    } catch {
+      return resolve({});
     }
-    catch (e) {
-        return {};
+  };
+  if (isBun) {
+    const body = req.body;
+    if (body) {
+      return resolveBody(body);
     }
+    return {};
+  }
+  return new Promise((resolve, reject) => {
+    const arr = [];
+    req.on("data", (chunk) => {
+      arr.push(chunk);
+    });
+    req.on("end", () => {
+      try {
+        const body = Buffer.concat(arr).toString();
+        resolve(resolveBody(body));
+      } catch (e) {
+        resolve({});
+      }
+    });
+  });
+};
+var parseSearch = (req) => {
+  const parsedUrl = url.parse(req.url, true);
+  return parsedUrl.query;
+};
+var parseSearchValue = (value, opts) => {
+  if (!value)
+    return {};
+  const decode = opts?.decode ?? false;
+  if (decode) {
+    value = decodeURIComponent(value);
+  }
+  try {
+    return JSON.parse(value);
+  } catch (e) {
+    return {};
+  }
 };
 
-/**
- * SimpleRouter
- */
+// src/router-simple.ts
 class SimpleRouter {
-    routes = [];
-    exclude = []; // 排除的请求
-    constructor(opts) {
-        this.exclude = opts?.exclude || ['/api/router'];
-    }
-    getBody(req) {
-        return parseBody(req);
-    }
-    getSearch(req) {
-        return parseSearch(req);
-    }
-    parseSearchValue = parseSearchValue;
-    use(method, route, ...fns) {
-        const handlers = Array.isArray(fns) ? fns.flat() : [];
-        const pattern = distExports.pathToRegexp(route);
-        this.routes.push({ method: method.toLowerCase(), regexp: pattern.regexp, keys: pattern.keys, handlers });
-        return this;
-    }
-    get(route, ...fns) {
-        return this.use('get', route, ...fns);
-    }
-    post(route, ...fns) {
-        return this.use('post', route, ...fns);
-    }
-    sse(route, ...fns) {
-        return this.use('sse', route, ...fns);
-    }
-    all(route, ...fns) {
-        this.use('post', route, ...fns);
-        this.use('get', route, ...fns);
-        this.use('sse', route, ...fns);
-        return this;
-    }
-    getJson(v) {
-        if (typeof v === 'object') {
-            return v;
-        }
-        try {
-            return JSON.parse(v);
-        }
-        catch (e) {
-            return {};
-        }
+  routes = [];
+  exclude = [];
+  constructor(opts) {
+    this.exclude = opts?.exclude || ["/api/router"];
+  }
+  getBody(req) {
+    return parseBody(req);
+  }
+  getSearch(req) {
+    return parseSearch(req);
+  }
+  parseSearchValue = parseSearchValue;
+  use(method, route, ...fns) {
+    const handlers = Array.isArray(fns) ? fns.flat() : [];
+    const pattern = import_path_to_regexp.pathToRegexp(route);
+    this.routes.push({ method: method.toLowerCase(), regexp: pattern.regexp, keys: pattern.keys, handlers });
+    return this;
+  }
+  get(route, ...fns) {
+    return this.use("get", route, ...fns);
+  }
+  post(route, ...fns) {
+    return this.use("post", route, ...fns);
+  }
+  sse(route, ...fns) {
+    return this.use("sse", route, ...fns);
+  }
+  all(route, ...fns) {
+    this.use("post", route, ...fns);
+    this.use("get", route, ...fns);
+    this.use("sse", route, ...fns);
+    return this;
+  }
+  getJson(v) {
+    if (typeof v === "object") {
+      return v;
     }
-    isSse(req) {
-        const { headers } = req;
-        if (!headers)
-            return false;
-        if (headers['accept'] && headers['accept'].includes('text/event-stream')) {
-            return true;
-        }
-        if (headers['content-type'] && headers['content-type'].includes('text/event-stream')) {
-            return true;
-        }
-        return false;
+    try {
+      return JSON.parse(v);
+    } catch (e) {
+      return {};
     }
-    /**
-     * 解析 req 和 res 请求
-     * @param req
-     * @param res
-     * @returns
-     */
-    parse(req, res) {
-        const { pathname } = new URL(req.url, 'http://localhost');
-        let method = req.method.toLowerCase();
-        if (this.exclude.includes(pathname)) {
-            return 'is_exclude';
-        }
-        const isSse = this.isSse(req);
-        if (isSse)
-            method = 'sse';
-        const route = this.routes.find((route) => {
-            const matchResult = route.regexp.exec(pathname);
-            if (matchResult && route.method === method) {
-                const params = {};
-                route.keys.forEach((key, i) => {
-                    params[key.name] = matchResult[i + 1];
-                });
-                req.params = params;
-                return true;
-            }
-        });
-        if (route) {
-            const { handlers } = route;
-            return handlers.reduce((promiseChain, handler) => promiseChain.then(() => Promise.resolve(handler(req, res))), Promise.resolve());
-        }
-        return 'not_found';
+  }
+  isSse(req) {
+    const { headers } = req;
+    if (!headers)
+      return false;
+    if (headers["accept"] && headers["accept"].includes("text/event-stream")) {
+      return true;
+    }
+    if (headers["content-type"] && headers["content-type"].includes("text/event-stream")) {
+      return true;
     }
-    /**
-     * 创建一个新的 HttpChain 实例
-     * @param req
-     * @param res
-     * @returns
-     */
-    chain(req, res) {
-        const chain = new HttpChain({ req, res, simpleRouter: this });
-        return chain;
+    return false;
+  }
+  parse(req, res) {
+    const { pathname } = new URL(req.url, "http://localhost");
+    let method = req.method.toLowerCase();
+    if (this.exclude.includes(pathname)) {
+      return "is_exclude";
     }
-    static Chain(opts) {
-        return new HttpChain(opts);
+    const isSse = this.isSse(req);
+    if (isSse)
+      method = "sse";
+    const route = this.routes.find((route2) => {
+      const matchResult = route2.regexp.exec(pathname);
+      if (matchResult && route2.method === method) {
+        const params = {};
+        route2.keys.forEach((key, i) => {
+          params[key.name] = matchResult[i + 1];
+        });
+        req.params = params;
+        return true;
+      }
+    });
+    if (route) {
+      const { handlers } = route;
+      return handlers.reduce((promiseChain, handler) => promiseChain.then(() => Promise.resolve(handler(req, res))), Promise.resolve());
     }
+    return "not_found";
+  }
+  chain(req, res) {
+    const chain = new HttpChain({ req, res, simpleRouter: this });
+    return chain;
+  }
+  static Chain(opts) {
+    return new HttpChain(opts);
+  }
 }
-/**
- * HttpChain 类, 用于链式调用,router.get内部使用
- */
+
 class HttpChain {
-    /**
-     * 请求对象, 每一次请求都是不一样的
-     */
-    req;
-    /**
-     * 响应对象, 每一次请求响应都是不一样的
-     */
-    res;
-    simpleRouter;
-    server;
-    hasSetHeader = false;
-    isSseSet = false;
-    constructor(opts) {
-        if (opts?.res) {
-            this.res = opts.res;
-        }
-        if (opts?.req) {
-            this.req = opts.req;
-        }
-        this.simpleRouter = opts?.simpleRouter;
-    }
-    setReq(req) {
-        this.req = req;
-        return this;
-    }
-    setRes(res) {
-        this.res = res;
-        return this;
-    }
-    setRouter(router) {
-        this.simpleRouter = router;
-        return this;
-    }
-    setServer(server) {
-        this.server = server;
-        return this;
-    }
-    /**
-     * 兼容 express 的一点功能
-     * @param status
-     * @returns
-     */
-    status(status) {
-        if (!this.res)
-            return this;
-        if (this.hasSetHeader) {
-            return this;
-        }
-        this.hasSetHeader = true;
-        this.res.writeHead(status);
-        return this;
-    }
-    writeHead(status) {
-        if (!this.res)
-            return this;
-        if (this.hasSetHeader) {
-            return this;
-        }
-        this.hasSetHeader = true;
-        this.res.writeHead(status);
-        return this;
-    }
-    json(data) {
-        if (!this.res)
-            return this;
-        this.res.end(JSON.stringify(data));
-        return this;
-    }
-    /**
-     * 兼容 express 的一点功能
-     * @param data
-     * @returns
-     */
-    end(data) {
-        if (!this.res)
-            return this;
-        if (typeof data === 'object') {
-            this.res.end(JSON.stringify(data));
-        }
-        else if (typeof data === 'string') {
-            this.res.end(data);
-        }
-        else {
-            this.res.end('nothing');
-        }
-        return this;
-    }
-    listen(opts, callback) {
-        this.server.listen(opts, callback);
-        return this;
-    }
-    /**
-     * 外部 parse 方法
-     * @returns
-     */
-    parse(opts) {
-        const { listenOptions, listenCallBack } = opts || {};
-        if (!this.server || !this.simpleRouter) {
-            throw new Error('Server and SimpleRouter must be set before calling parse');
-        }
-        const that = this;
-        const listener = (req, res) => {
-            try {
-                that.simpleRouter.parse(req, res);
-            }
-            catch (error) {
-                console.error('Error parsing request:', error);
-                if (!res.headersSent) {
-                    res.writeHead(500);
-                    res.end(JSON.stringify({ code: 500, message: 'Internal Server Error' }));
-                }
-            }
-        };
-        if (listenOptions) {
-            this.server.listen(listenOptions, listenCallBack);
-        }
-        this.server.on('request', listener);
-        return () => {
-            that.server.removeListener('request', listener);
-        };
-    }
-    getString(value) {
-        if (typeof value === 'string') {
-            return value;
-        }
-        return JSON.stringify(value);
-    }
-    sse(value) {
-        const res = this.res;
-        const req = this.req;
-        if (!res || !req)
-            return;
-        const data = this.getString(value);
-        if (this.isSseSet) {
-            res.write(`data: ${data}\n\n`);
-            return this;
-        }
-        const headersMap = new Map([
-            ['Content-Type', 'text/event-stream'],
-            ['Cache-Control', 'no-cache'],
-            ['Connection', 'keep-alive'],
-        ]);
-        this.isSseSet = true;
-        let intervalId;
-        if (!this.hasSetHeader) {
-            this.hasSetHeader = true;
-            res.setHeaders(headersMap);
-            // 每隔 2 秒发送一个空行，保持连接
-            setInterval(() => {
-                res.write('\n'); // 发送一个空行，保持连接
-            }, 3000);
-            // 客户端断开连接时清理
-            req.on('close', () => {
-                clearInterval(intervalId);
-                res.end();
-            });
-        }
-        this.res.write(`data: ${data}\n\n`);
-        return this;
+  req;
+  res;
+  simpleRouter;
+  server;
+  hasSetHeader = false;
+  isSseSet = false;
+  constructor(opts) {
+    if (opts?.res) {
+      this.res = opts.res;
+    }
+    if (opts?.req) {
+      this.req = opts.req;
+    }
+    this.simpleRouter = opts?.simpleRouter;
+  }
+  setReq(req) {
+    this.req = req;
+    return this;
+  }
+  setRes(res) {
+    this.res = res;
+    return this;
+  }
+  setRouter(router) {
+    this.simpleRouter = router;
+    return this;
+  }
+  setServer(server) {
+    this.server = server;
+    return this;
+  }
+  status(status) {
+    if (!this.res)
+      return this;
+    if (this.hasSetHeader) {
+      return this;
+    }
+    this.hasSetHeader = true;
+    this.res.writeHead(status);
+    return this;
+  }
+  writeHead(status) {
+    if (!this.res)
+      return this;
+    if (this.hasSetHeader) {
+      return this;
+    }
+    this.hasSetHeader = true;
+    this.res.writeHead(status);
+    return this;
+  }
+  json(data) {
+    if (!this.res)
+      return this;
+    this.res.end(JSON.stringify(data));
+    return this;
+  }
+  end(data) {
+    if (!this.res)
+      return this;
+    if (typeof data === "object") {
+      this.res.end(JSON.stringify(data));
+    } else if (typeof data === "string") {
+      this.res.end(data);
+    } else {
+      this.res.end("nothing");
     }
-    close() {
-        if (this.req?.destroy) {
-            this.req.destroy();
+    return this;
+  }
+  listen(opts, callback) {
+    this.server.listen(opts, callback);
+    return this;
+  }
+  parse(opts) {
+    const { listenOptions, listenCallBack } = opts || {};
+    if (!this.server || !this.simpleRouter) {
+      throw new Error("Server and SimpleRouter must be set before calling parse");
+    }
+    const that = this;
+    const listener = (req, res) => {
+      try {
+        that.simpleRouter.parse(req, res);
+      } catch (error) {
+        console.error("Error parsing request:", error);
+        if (!res.headersSent) {
+          res.writeHead(500);
+          res.end(JSON.stringify({ code: 500, message: "Internal Server Error" }));
         }
-        return this;
+      }
+    };
+    if (listenOptions) {
+      this.server.listen(listenOptions, listenCallBack);
     }
-}
+    this.server.on("request", listener);
+    return () => {
+      that.server.removeListener("request", listener);
+    };
+  }
+  getString(value) {
+    if (typeof value === "string") {
+      return value;
+    }
+    return JSON.stringify(value);
+  }
+  sse(value) {
+    const res = this.res;
+    const req = this.req;
+    if (!res || !req)
+      return;
+    const data = this.getString(value);
+    if (this.isSseSet) {
+      res.write(`data: ${data}
 
-export { HttpChain, SimpleRouter };
+`);
+      return this;
+    }
+    const headersMap = new Map([
+      ["Content-Type", "text/event-stream"],
+      ["Cache-Control", "no-cache"],
+      ["Connection", "keep-alive"]
+    ]);
+    this.isSseSet = true;
+    let intervalId;
+    if (!this.hasSetHeader) {
+      this.hasSetHeader = true;
+      res.setHeaders(headersMap);
+      setInterval(() => {
+        res.write(`
+`);
+      }, 3000);
+      req.on("close", () => {
+        clearInterval(intervalId);
+        res.end();
+      });
+    }
+    this.res.write(`data: ${data}
+
+`);
+    return this;
+  }
+  close() {
+    if (this.req?.destroy) {
+      this.req.destroy();
+    }
+    return this;
+  }
+}
+export {
+  SimpleRouter,
+  HttpChain
+};