first commit

5 files changed, 887 insertions, 0 deletions

diff --git a/node_modules/path-to-regexp/LICENSE b/node_modules/path-to-regexp/LICENSE
new file mode 100644
index 0000000..983fbe8
--- /dev/null
+++ b/node_modules/path-to-regexp/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Blake Embrey (hello@blakeembrey.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/node_modules/path-to-regexp/Readme.md b/node_modules/path-to-regexp/Readme.md
new file mode 100644
index 0000000..f33e392
--- /dev/null
+++ b/node_modules/path-to-regexp/Readme.md
@@ -0,0 +1,224 @@
+# Path-to-RegExp
+
+> Turn a path string such as `/user/:name` into a regular expression.
+
+[![NPM version][npm-image]][npm-url]
+[![NPM downloads][downloads-image]][downloads-url]
+[![Build status][build-image]][build-url]
+[![Build coverage][coverage-image]][coverage-url]
+[![License][license-image]][license-url]
+
+## Installation
+
+```
+npm install path-to-regexp --save
+```
+
+## Usage
+
+```js
+const {
+  match,
+  pathToRegexp,
+  compile,
+  parse,
+  stringify,
+} = require("path-to-regexp");
+```
+
+### Parameters
+
+Parameters match arbitrary strings in a path by matching up to the end of the segment, or up to any proceeding tokens. They are defined by prefixing a colon to the parameter name (`:foo`). Parameter names can use any valid JavaScript identifier, or be double quoted to use other characters (`:"param-name"`).
+
+```js
+const fn = match("/:foo/:bar");
+
+fn("/test/route");
+//=> { path: '/test/route', params: { foo: 'test', bar: 'route' } }
+```
+
+### Wildcard
+
+Wildcard parameters match one or more characters across multiple segments. They are defined the same way as regular parameters, but are prefixed with an asterisk (`*foo`).
+
+```js
+const fn = match("/*splat");
+
+fn("/bar/baz");
+//=> { path: '/bar/baz', params: { splat: [ 'bar', 'baz' ] } }
+```
+
+### Optional
+
+Braces can be used to define parts of the path that are optional.
+
+```js
+const fn = match("/users{/:id}/delete");
+
+fn("/users/delete");
+//=> { path: '/users/delete', params: {} }
+
+fn("/users/123/delete");
+//=> { path: '/users/123/delete', params: { id: '123' } }
+```
+
+## Match
+
+The `match` function returns a function for matching strings against a path:
+
+- **path** String, `TokenData` object, or array of strings and `TokenData` objects.
+- **options** _(optional)_ (Extends [pathToRegexp](#pathToRegexp) options)
+  - **decode** Function for decoding strings to params, or `false` to disable all processing. (default: `decodeURIComponent`)
+
+```js
+const fn = match("/foo/:bar");
+```
+
+**Please note:** `path-to-regexp` is intended for ordered data (e.g. paths, hosts). It can not handle arbitrarily ordered data (e.g. query strings, URL fragments, JSON, etc).
+
+## PathToRegexp
+
+The `pathToRegexp` function returns the `regexp` for matching strings against paths, and an array of `keys` for understanding the `RegExp#exec` matches.
+
+- **path** String, `TokenData` object, or array of strings and `TokenData` objects.
+- **options** _(optional)_ (See [parse](#parse) for more options)
+  - **sensitive** Regexp will be case sensitive. (default: `false`)
+  - **end** Validate the match reaches the end of the string. (default: `true`)
+  - **delimiter** The default delimiter for segments, e.g. `[^/]` for `:named` parameters. (default: `'/'`)
+  - **trailing** Allows optional trailing delimiter to match. (default: `true`)
+
+```js
+const { regexp, keys } = pathToRegexp("/foo/:bar");
+
+regexp.exec("/foo/123"); //=> ["/foo/123", "123"]
+```
+
+## Compile ("Reverse" Path-To-RegExp)
+
+The `compile` function will return a function for transforming parameters into a valid path:
+
+- **path** A string or `TokenData` object.
+- **options** (See [parse](#parse) for more options)
+  - **delimiter** The default delimiter for segments, e.g. `[^/]` for `:named` parameters. (default: `'/'`)
+  - **encode** Function for encoding input strings for output into the path, or `false` to disable entirely. (default: `encodeURIComponent`)
+
+```js
+const toPath = compile("/user/:id");
+
+toPath({ id: "name" }); //=> "/user/name"
+toPath({ id: "café" }); //=> "/user/caf%C3%A9"
+
+const toPathRepeated = compile("/*segment");
+
+toPathRepeated({ segment: ["foo"] }); //=> "/foo"
+toPathRepeated({ segment: ["a", "b", "c"] }); //=> "/a/b/c"
+
+// When disabling `encode`, you need to make sure inputs are encoded correctly. No arrays are accepted.
+const toPathRaw = compile("/user/:id", { encode: false });
+
+toPathRaw({ id: "%3A%2F" }); //=> "/user/%3A%2F"
+```
+
+## Stringify
+
+Transform a `TokenData` object to a Path-to-RegExp string.
+
+- **data** A `TokenData` object.
+
+```js
+const data = {
+  tokens: [
+    { type: "text", value: "/" },
+    { type: "param", name: "foo" },
+  ],
+};
+
+const path = stringify(data); //=> "/:foo"
+```
+
+## Developers
+
+- If you are rewriting paths with match and compile, consider using `encode: false` and `decode: false` to keep raw paths passed around.
+- To ensure matches work on paths containing characters usually encoded, such as emoji, consider using [encodeurl](https://github.com/pillarjs/encodeurl) for `encodePath`.
+
+### Parse
+
+The `parse` function accepts a string and returns `TokenData`, which can be used with `match` and `compile`.
+
+- **path** A string.
+- **options** _(optional)_
+  - **encodePath** A function for encoding input strings. (default: `x => x`, recommended: [`encodeurl`](https://github.com/pillarjs/encodeurl))
+
+### Tokens
+
+`TokenData` has two properties:
+
+- **tokens** A sequence of tokens, currently of types `text`, `param`, `wildcard`, or `group`.
+- **originalPath** The original path used with `parse`, shown in error messages to assist debugging.
+
+### Custom path
+
+In some applications you may not be able to use the `path-to-regexp` syntax, but you still want to use this library for `match` and `compile`. For example:
+
+```js
+import { match } from "path-to-regexp";
+
+const tokens = [
+  { type: "text", value: "/" },
+  { type: "param", name: "foo" },
+];
+const originalPath = "/[foo]"; // To help debug error messages.
+const path = { tokens, originalPath };
+const fn = match(path);
+
+fn("/test"); //=> { path: '/test', params: { foo: 'test' } }
+```
+
+## Errors
+
+An effort has been made to ensure ambiguous paths from previous releases throw an error. This means you might be seeing an error when things worked before.
+
+### Missing parameter name
+
+Parameter names must be provided after `:` or `*`, for example `/*path`. They can be valid JavaScript identifiers (e.g. `:myName`) or JSON strings (`:"my-name"`).
+
+### Unexpected `?` or `+`
+
+In past releases, `?`, `*`, and `+` were used to denote optional or repeating parameters. As an alternative, try these:
+
+- For optional (`?`), use braces: `/file{.:ext}`.
+- For one or more (`+`), use a wildcard: `/*path`.
+- For zero or more (`*`), use both: `/files{/*path}`.
+
+### Unexpected `(`, `)`, `[`, `]`, etc.
+
+Previous versions of Path-to-RegExp used these for RegExp features. This version no longer supports them so they've been reserved to avoid ambiguity. To match these characters literally, escape them with a backslash, e.g. `"\\("`.
+
+### Unterminated quote
+
+Parameter names can be wrapped in double quote characters, and this error means you forgot to close the quote character. For example, `:"foo`.
+
+### Express <= 4.x
+
+Path-To-RegExp breaks compatibility with Express <= `4.x` in the following ways:
+
+- The wildcard `*` must have a name and matches the behavior of parameters `:`.
+- The optional character `?` is no longer supported, use braces instead: `/:file{.:ext}`.
+- Regexp characters are not supported.
+- Some characters have been reserved to avoid confusion during upgrade (`()[]?+!`).
+- Parameter names now support valid JavaScript identifiers, or quoted like `:"this"`.
+
+## License
+
+MIT
+
+[npm-image]: https://img.shields.io/npm/v/path-to-regexp
+[npm-url]: https://npmjs.org/package/path-to-regexp
+[downloads-image]: https://img.shields.io/npm/dm/path-to-regexp
+[downloads-url]: https://npmjs.org/package/path-to-regexp
+[build-image]: https://img.shields.io/github/actions/workflow/status/pillarjs/path-to-regexp/ci.yml?branch=master
+[build-url]: https://github.com/pillarjs/path-to-regexp/actions/workflows/ci.yml?query=branch%3Amaster
+[coverage-image]: https://img.shields.io/codecov/c/gh/pillarjs/path-to-regexp
+[coverage-url]: https://codecov.io/gh/pillarjs/path-to-regexp
+[license-image]: http://img.shields.io/npm/l/path-to-regexp.svg?style=flat
+[license-url]: LICENSE.md
diff --git a/node_modules/path-to-regexp/dist/index.d.ts b/node_modules/path-to-regexp/dist/index.d.ts
new file mode 100644
index 0000000..c173a44
--- /dev/null
+++ b/node_modules/path-to-regexp/dist/index.d.ts
@@ -0,0 +1,147 @@
+/**
+ * Encode a string into another string.
+ */
+export type Encode = (value: string) => string;
+/**
+ * Decode a string into another string.
+ */
+export type Decode = (value: string) => string;
+export interface ParseOptions {
+    /**
+     * A function for encoding input strings.
+     */
+    encodePath?: Encode;
+}
+export interface PathToRegexpOptions {
+    /**
+     * Matches the path completely without trailing characters. (default: `true`)
+     */
+    end?: boolean;
+    /**
+     * Allows optional trailing delimiter to match. (default: `true`)
+     */
+    trailing?: boolean;
+    /**
+     * Match will be case sensitive. (default: `false`)
+     */
+    sensitive?: boolean;
+    /**
+     * The default delimiter for segments. (default: `'/'`)
+     */
+    delimiter?: string;
+}
+export interface MatchOptions extends PathToRegexpOptions {
+    /**
+     * Function for decoding strings for params, or `false` to disable entirely. (default: `decodeURIComponent`)
+     */
+    decode?: Decode | false;
+}
+export interface CompileOptions {
+    /**
+     * Function for encoding input strings for output into the path, or `false` to disable entirely. (default: `encodeURIComponent`)
+     */
+    encode?: Encode | false;
+    /**
+     * The default delimiter for segments. (default: `'/'`)
+     */
+    delimiter?: string;
+}
+/**
+ * Plain text.
+ */
+export interface Text {
+    type: "text";
+    value: string;
+}
+/**
+ * A parameter designed to match arbitrary text within a segment.
+ */
+export interface Parameter {
+    type: "param";
+    name: string;
+}
+/**
+ * A wildcard parameter designed to match multiple segments.
+ */
+export interface Wildcard {
+    type: "wildcard";
+    name: string;
+}
+/**
+ * A set of possible tokens to expand when matching.
+ */
+export interface Group {
+    type: "group";
+    tokens: Token[];
+}
+/**
+ * A token that corresponds with a regexp capture.
+ */
+export type Key = Parameter | Wildcard;
+/**
+ * A sequence of `path-to-regexp` keys that match capturing groups.
+ */
+export type Keys = Array<Key>;
+/**
+ * A sequence of path match characters.
+ */
+export type Token = Text | Parameter | Wildcard | Group;
+/**
+ * Tokenized path instance.
+ */
+export declare class TokenData {
+    readonly tokens: Token[];
+    readonly originalPath?: string | undefined;
+    constructor(tokens: Token[], originalPath?: string | undefined);
+}
+/**
+ * ParseError is thrown when there is an error processing the path.
+ */
+export declare class PathError extends TypeError {
+    readonly originalPath: string | undefined;
+    constructor(message: string, originalPath: string | undefined);
+}
+/**
+ * Parse a string for the raw tokens.
+ */
+export declare function parse(str: string, options?: ParseOptions): TokenData;
+/**
+ * Compile a string to a template function for the path.
+ */
+export declare function compile<P extends ParamData = ParamData>(path: Path, options?: CompileOptions & ParseOptions): (params?: P) => string;
+export type ParamData = Partial<Record<string, string | string[]>>;
+export type PathFunction<P extends ParamData> = (data?: P) => string;
+/**
+ * A match result contains data about the path match.
+ */
+export interface MatchResult<P extends ParamData> {
+    path: string;
+    params: P;
+}
+/**
+ * A match is either `false` (no match) or a match result.
+ */
+export type Match<P extends ParamData> = false | MatchResult<P>;
+/**
+ * The match function takes a string and returns whether it matched the path.
+ */
+export type MatchFunction<P extends ParamData> = (path: string) => Match<P>;
+/**
+ * Supported path types.
+ */
+export type Path = string | TokenData;
+/**
+ * Transform a path into a match function.
+ */
+export declare function match<P extends ParamData>(path: Path | Path[], options?: MatchOptions & ParseOptions): MatchFunction<P>;
+/**
+ * Transform a path into a regular expression and capture keys.
+ */
+export declare function pathToRegexp(path: Path | Path[], options?: PathToRegexpOptions & ParseOptions): {
+    regexp: RegExp;
+    keys: Keys;
+};
+/**
+ * Stringify token data into a path string.
+ */
+export declare function stringify(data: TokenData): string;
diff --git a/node_modules/path-to-regexp/dist/index.js b/node_modules/path-to-regexp/dist/index.js
new file mode 100644
index 0000000..97f36e8
--- /dev/null
+++ b/node_modules/path-to-regexp/dist/index.js
@@ -0,0 +1,431 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathError = exports.TokenData = void 0;
+exports.parse = parse;
+exports.compile = compile;
+exports.match = match;
+exports.pathToRegexp = pathToRegexp;
+exports.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 ID = /^[$_\p{ID_Start}][$\u200c\u200d\p{ID_Continue}]*$/u;
+/**
+ * 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;
+    }
+}
+exports.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;
+    }
+}
+exports.PathError = PathError;
+/**
+ * Parse a string for the raw tokens.
+ */
+function parse(str, options = {}) {
+    const { encodePath = NOOP_VALUE } = options;
+    const chars = [...str];
+    let index = 0;
+    function consumeUntil(end) {
+        const output = [];
+        let path = "";
+        function writePath() {
+            if (!path)
+                return;
+            output.push({
+                type: "text",
+                value: encodePath(path),
+            });
+            path = "";
+        }
+        while (index < chars.length) {
+            const value = chars[index++];
+            if (value === end) {
+                writePath();
+                return output;
+            }
+            if (value === "\\") {
+                if (index === chars.length) {
+                    throw new PathError(`Unexpected end after \\ at index ${index}`, str);
+                }
+                path += chars[index++];
+                continue;
+            }
+            if (value === ":" || value === "*") {
+                const type = value === ":" ? "param" : "wildcard";
+                let name = "";
+                if (ID_START.test(chars[index])) {
+                    do {
+                        name += 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++;
+                        name += chars[index];
+                    }
+                    if (quoteStart) {
+                        throw new PathError(`Unterminated quote at index ${quoteStart}`, str);
+                    }
+                }
+                if (!name) {
+                    throw new PathError(`Missing parameter name at index ${index}`, str);
+                }
+                writePath();
+                output.push({ type, name });
+                continue;
+            }
+            if (value === "{") {
+                writePath();
+                output.push({
+                    type: "group",
+                    tokens: consumeUntil("}"),
+                });
+                continue;
+            }
+            if (value === "}" ||
+                value === "(" ||
+                value === ")" ||
+                value === "[" ||
+                value === "]" ||
+                value === "+" ||
+                value === "?" ||
+                value === "!") {
+                throw new PathError(`Unexpected ${value} at index ${index - 1}`, str);
+            }
+            path += value;
+        }
+        if (end) {
+            throw new PathError(`Unexpected end at index ${index}, expected ${end}`, str);
+        }
+        writePath();
+        return output;
+    }
+    return new TokenData(consumeUntil(""), 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 missing = [];
+        const path = fn(params, missing);
+        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, missing) => {
+        let result = "";
+        for (const encoder of encoders) {
+            result += encoder(data, missing);
+        }
+        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, missing) => {
+            const len = missing.length;
+            const value = fn(data, missing);
+            if (missing.length === len)
+                return value;
+            missing.length = len; // Reset optional group.
+            return "";
+        };
+    }
+    const encodeValue = encode || NOOP_VALUE;
+    if (token.type === "wildcard" && encode !== false) {
+        return (data, missing) => {
+            const value = data[token.name];
+            if (value == null) {
+                missing.push(token.name);
+                return "";
+            }
+            if (!Array.isArray(value) || value.length === 0) {
+                throw new TypeError(`Expected "${token.name}" to be a non-empty array`);
+            }
+            let result = "";
+            for (let i = 0; i < value.length; i++) {
+                if (typeof value[i] !== "string") {
+                    throw new TypeError(`Expected "${token.name}/${i}" to be a string`);
+                }
+                if (i > 0)
+                    result += delimiter;
+                result += encodeValue(value[i]);
+            }
+            return result;
+        };
+    }
+    return (data, missing) => {
+        const value = data[token.name];
+        if (value == null) {
+            missing.push(token.name);
+            return "";
+        }
+        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 };
+    };
+}
+/**
+ * Transform a path into a regular expression and capture keys.
+ */
+function pathToRegexp(path, options = {}) {
+    const { delimiter = DEFAULT_DELIMITER, end = true, sensitive = false, trailing = true, } = options;
+    const keys = [];
+    let source = "";
+    let combinations = 0;
+    function process(path) {
+        if (Array.isArray(path)) {
+            for (const p of path)
+                process(p);
+            return;
+        }
+        const data = typeof path === "object" ? path : parse(path, options);
+        flatten(data.tokens, 0, [], (tokens) => {
+            if (combinations >= 256) {
+                throw new PathError("Too many path combinations", data.originalPath);
+            }
+            if (combinations > 0)
+                source += "|";
+            source += toRegExpSource(tokens, delimiter, keys, data.originalPath);
+            combinations++;
+        });
+    }
+    process(path);
+    let pattern = `^(?:${source})`;
+    if (trailing)
+        pattern += "(?:" + escape(delimiter) + "$)?";
+    pattern += end ? "$" : "(?=" + escape(delimiter) + "|$)";
+    return { regexp: new RegExp(pattern, sensitive ? "" : "i"), keys };
+}
+/**
+ * Generate a flat list of sequence tokens from the given tokens.
+ */
+function flatten(tokens, index, result, callback) {
+    while (index < tokens.length) {
+        const token = tokens[index++];
+        if (token.type === "group") {
+            const len = result.length;
+            flatten(token.tokens, 0, result, (seq) => flatten(tokens, index, seq, callback));
+            result.length = len;
+            continue;
+        }
+        result.push(token);
+    }
+    callback(result);
+}
+/**
+ * Transform a flat sequence of tokens into a regular expression.
+ */
+function toRegExpSource(tokens, delimiter, keys, originalPath) {
+    let result = "";
+    let backtrack = "";
+    let wildcardBacktrack = "";
+    let prevCaptureType = 0;
+    let hasSegmentCapture = 0;
+    let index = 0;
+    function hasInSegment(index, type) {
+        while (index < tokens.length) {
+            const token = tokens[index++];
+            if (token.type === type)
+                return true;
+            if (token.type === "text") {
+                if (token.value.includes(delimiter))
+                    break;
+            }
+        }
+        return false;
+    }
+    function peekText(index) {
+        let result = "";
+        while (index < tokens.length) {
+            const token = tokens[index++];
+            if (token.type !== "text")
+                break;
+            result += token.value;
+        }
+        return result;
+    }
+    while (index < tokens.length) {
+        const token = tokens[index++];
+        if (token.type === "text") {
+            result += escape(token.value);
+            backtrack += token.value;
+            if (prevCaptureType === 2)
+                wildcardBacktrack += token.value;
+            if (token.value.includes(delimiter))
+                hasSegmentCapture = 0;
+            continue;
+        }
+        if (token.type === "param" || token.type === "wildcard") {
+            if (prevCaptureType && !backtrack) {
+                throw new PathError(`Missing text before "${token.name}" ${token.type}`, originalPath);
+            }
+            if (token.type === "param") {
+                result +=
+                    hasSegmentCapture & 2 // Seen wildcard in segment.
+                        ? `(${negate(delimiter, backtrack)}+)`
+                        : hasInSegment(index, "wildcard") // See wildcard later in segment.
+                            ? `(${negate(delimiter, peekText(index))}+)`
+                            : hasSegmentCapture & 1 // Seen parameter in segment.
+                                ? `(${negate(delimiter, backtrack)}+|${escape(backtrack)})`
+                                : `(${negate(delimiter, "")}+)`;
+                hasSegmentCapture |= prevCaptureType = 1;
+            }
+            else {
+                result +=
+                    hasSegmentCapture & 2 // Seen wildcard in segment.
+                        ? `(${negate(backtrack, "")}+)`
+                        : wildcardBacktrack // No capture in segment, seen wildcard in path.
+                            ? `(${negate(wildcardBacktrack, "")}+|${negate(delimiter, "")}+)`
+                            : `([^]+)`;
+                wildcardBacktrack = "";
+                hasSegmentCapture |= prevCaptureType = 2;
+            }
+            keys.push(token);
+            backtrack = "";
+            continue;
+        }
+        throw new TypeError(`Unknown token type: ${token.type}`);
+    }
+    return result;
+}
+/**
+ * Block backtracking on previous text/delimiter.
+ */
+function negate(a, b) {
+    if (b.length > a.length)
+        return negate(b, a); // Longest string first.
+    if (a === b)
+        b = ""; // Cleaner regex strings, no duplication.
+    if (b.length > 1)
+        return `(?:(?!${escape(a)}|${escape(b)})[^])`;
+    if (a.length > 1)
+        return `(?:(?!${escape(a)})[^${escape(b)}])`;
+    return `[^${escape(a + b)}]`;
+}
+/**
+ * Stringify an array of tokens into a path string.
+ */
+function stringifyTokens(tokens, index) {
+    let value = "";
+    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, 0) + "}";
+            continue;
+        }
+        if (token.type === "param") {
+            value += ":" + stringifyName(token.name, tokens[index]);
+            continue;
+        }
+        if (token.type === "wildcard") {
+            value += "*" + stringifyName(token.name, tokens[index]);
+            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, 0);
+}
+/**
+ * Stringify a parameter name, escaping when it cannot be emitted directly.
+ */
+function stringifyName(name, next) {
+    if (!ID.test(name))
+        return JSON.stringify(name);
+    if ((next === null || next === void 0 ? void 0 : next.type) === "text" && ID_CONTINUE.test(next.value[0])) {
+        return JSON.stringify(name);
+    }
+    return name;
+}
+//# sourceMappingURL=index.js.map
\ No newline at end of file
diff --git a/node_modules/path-to-regexp/package.json b/node_modules/path-to-regexp/package.json
new file mode 100644
index 0000000..44ca91d
--- /dev/null
+++ b/node_modules/path-to-regexp/package.json
@@ -0,0 +1,64 @@
+{
+  "name": "path-to-regexp",
+  "version": "8.4.2",
+  "description": "Express style path to RegExp utility",
+  "keywords": [
+    "express",
+    "regexp",
+    "route",
+    "routing"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pillarjs/path-to-regexp.git"
+  },
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/express"
+  },
+  "license": "MIT",
+  "exports": "./dist/index.js",
+  "main": "dist/index.js",
+  "typings": "dist/index.d.ts",
+  "files": [
+    "dist/"
+  ],
+  "scripts": {
+    "bench": "vitest bench",
+    "build": "ts-scripts build",
+    "format": "ts-scripts format",
+    "lint": "ts-scripts lint",
+    "prepare": "ts-scripts install && npm run build",
+    "size": "size-limit",
+    "specs": "ts-scripts specs",
+    "test": "ts-scripts test && npm run size"
+  },
+  "devDependencies": {
+    "@borderless/ts-scripts": "^0.15.0",
+    "@size-limit/preset-small-lib": "^11.1.2",
+    "@types/node": "^22.7.2",
+    "@types/semver": "^7.3.1",
+    "@vitest/coverage-v8": "^3.0.5",
+    "recheck": "^4.5.0",
+    "size-limit": "^11.1.2",
+    "typescript": "^5.7.3",
+    "vitest": "^3.0.5"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "size-limit": [
+    {
+      "path": "dist/index.js",
+      "limit": "2 kB"
+    }
+  ],
+  "ts-scripts": {
+    "dist": [
+      "dist"
+    ],
+    "project": [
+      "tsconfig.build.json"
+    ]
+  }
+}