path-to-regexp 6.2.2 → 7.1.0

package/dist/index.js

@@ -1,397 +1,420 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.pathToRegexp = exports.tokensToRegexp = exports.regexpToFunction = exports.match = exports.tokensToFunction = exports.compile = exports.parse = void 0;
+exports.TokenData = void 0;
+exports.parse = parse;
+exports.compile = compile;
+exports.match = match;
+exports.pathToRegexp = pathToRegexp;
+const DEFAULT_DELIMITER = "/";
+const NOOP_VALUE = (value) => value;
+const ID_CHAR = /^\p{XID_Continue}$/u;
+const DEBUG_URL = "https://git.new/pathToRegexpError";
+const SIMPLE_TOKENS = {
+    "!": "!",
+    "@": "@",
+    ";": ";",
+    ",": ",",
+    "*": "*",
+    "+": "+",
+    "?": "?",
+    "{": "{",
+    "}": "}",
+};
 /**
  * Tokenize input string.
  */
 function lexer(str) {
-    var tokens = [];
-    var i = 0;
-    while (i < str.length) {
-        var char = str[i];
-        if (char === "*" || char === "+" || char === "?") {
-            tokens.push({ type: "MODIFIER", index: i, value: str[i++] });
+    const chars = [...str];
+    const tokens = [];
+    let i = 0;
+    while (i < chars.length) {
+        const value = chars[i];
+        const type = SIMPLE_TOKENS[value];
+        if (type) {
+            tokens.push({ type, index: i++, value });
             continue;
         }
-        if (char === "\\") {
-            tokens.push({ type: "ESCAPED_CHAR", index: i++, value: str[i++] });
+        if (value === "\\") {
+            tokens.push({ type: "ESCAPED", index: i++, value: chars[i++] });
             continue;
         }
-        if (char === "{") {
-            tokens.push({ type: "OPEN", index: i, value: str[i++] });
-            continue;
-        }
-        if (char === "}") {
-            tokens.push({ type: "CLOSE", index: i, value: str[i++] });
-            continue;
-        }
-        if (char === ":") {
-            var name = "";
-            var j = i + 1;
-            while (j < str.length) {
-                var code = str.charCodeAt(j);
-                if (
-                // `0-9`
-                (code >= 48 && code <= 57) ||
-                    // `A-Z`
-                    (code >= 65 && code <= 90) ||
-                    // `a-z`
-                    (code >= 97 && code <= 122) ||
-                    // `_`
-                    code === 95) {
-                    name += str[j++];
-                    continue;
-                }
-                break;
+        if (value === ":") {
+            let name = "";
+            while (ID_CHAR.test(chars[++i])) {
+                name += chars[i];
+            }
+            if (!name) {
+                throw new TypeError(`Missing parameter name at ${i}`);
             }
-            if (!name)
-                throw new TypeError("Missing parameter name at ".concat(i));
             tokens.push({ type: "NAME", index: i, value: name });
-            i = j;
             continue;
         }
-        if (char === "(") {
-            var count = 1;
-            var pattern = "";
-            var j = i + 1;
-            if (str[j] === "?") {
-                throw new TypeError("Pattern cannot start with \"?\" at ".concat(j));
+        if (value === "(") {
+            const pos = i++;
+            let count = 1;
+            let pattern = "";
+            if (chars[i] === "?") {
+                throw new TypeError(`Pattern cannot start with "?" at ${i}`);
             }
-            while (j < str.length) {
-                if (str[j] === "\\") {
-                    pattern += str[j++] + str[j++];
+            while (i < chars.length) {
+                if (chars[i] === "\\") {
+                    pattern += chars[i++] + chars[i++];
                     continue;
                 }
-                if (str[j] === ")") {
+                if (chars[i] === ")") {
                     count--;
                     if (count === 0) {
-                        j++;
+                        i++;
                         break;
                     }
                 }
-                else if (str[j] === "(") {
+                else if (chars[i] === "(") {
                     count++;
-                    if (str[j + 1] !== "?") {
-                        throw new TypeError("Capturing groups are not allowed at ".concat(j));
+                    if (chars[i + 1] !== "?") {
+                        throw new TypeError(`Capturing groups are not allowed at ${i}`);
                     }
                 }
-                pattern += str[j++];
+                pattern += chars[i++];
             }
             if (count)
-                throw new TypeError("Unbalanced pattern at ".concat(i));
+                throw new TypeError(`Unbalanced pattern at ${pos}`);
             if (!pattern)
-                throw new TypeError("Missing pattern at ".concat(i));
+                throw new TypeError(`Missing pattern at ${pos}`);
             tokens.push({ type: "PATTERN", index: i, value: pattern });
-            i = j;
             continue;
         }
-        tokens.push({ type: "CHAR", index: i, value: str[i++] });
+        tokens.push({ type: "CHAR", index: i, value: chars[i++] });
     }
     tokens.push({ type: "END", index: i, value: "" });
-    return tokens;
+    return new Iter(tokens);
 }
-/**
- * Parse a string for the raw tokens.
- */
-function parse(str, options) {
-    if (options === void 0) { options = {}; }
-    var tokens = lexer(str);
-    var _a = options.prefixes, prefixes = _a === void 0 ? "./" : _a;
-    var defaultPattern = "[^".concat(escapeString(options.delimiter || "/#?"), "]+?");
-    var result = [];
-    var key = 0;
-    var i = 0;
-    var path = "";
-    var tryConsume = function (type) {
-        if (i < tokens.length && tokens[i].type === type)
-            return tokens[i++].value;
-    };
-    var mustConsume = function (type) {
-        var value = tryConsume(type);
+class Iter {
+    constructor(tokens) {
+        this.tokens = tokens;
+        this.index = 0;
+    }
+    peek() {
+        return this.tokens[this.index];
+    }
+    tryConsume(type) {
+        const token = this.peek();
+        if (token.type !== type)
+            return;
+        this.index++;
+        return token.value;
+    }
+    consume(type) {
+        const value = this.tryConsume(type);
         if (value !== undefined)
             return value;
-        var _a = tokens[i], nextType = _a.type, index = _a.index;
-        throw new TypeError("Unexpected ".concat(nextType, " at ").concat(index, ", expected ").concat(type));
-    };
-    var consumeText = function () {
-        var result = "";
-        var value;
-        while ((value = tryConsume("CHAR") || tryConsume("ESCAPED_CHAR"))) {
+        const { type: nextType, index } = this.peek();
+        throw new TypeError(`Unexpected ${nextType} at ${index}, expected ${type}: ${DEBUG_URL}`);
+    }
+    text() {
+        let result = "";
+        let value;
+        while ((value = this.tryConsume("CHAR") || this.tryConsume("ESCAPED"))) {
             result += value;
         }
         return result;
-    };
-    while (i < tokens.length) {
-        var char = tryConsume("CHAR");
-        var name = tryConsume("NAME");
-        var pattern = tryConsume("PATTERN");
+    }
+    modifier() {
+        return this.tryConsume("?") || this.tryConsume("*") || this.tryConsume("+");
+    }
+}
+/**
+ * Tokenized path instance. Can we passed around instead of string.
+ */
+class TokenData {
+    constructor(tokens, delimiter) {
+        this.tokens = tokens;
+        this.delimiter = delimiter;
+    }
+}
+exports.TokenData = TokenData;
+/**
+ * Parse a string for the raw tokens.
+ */
+function parse(str, options = {}) {
+    const { encodePath = NOOP_VALUE, delimiter = encodePath(DEFAULT_DELIMITER) } = options;
+    const tokens = [];
+    const it = lexer(str);
+    let key = 0;
+    do {
+        const path = it.text();
+        if (path)
+            tokens.push(encodePath(path));
+        const name = it.tryConsume("NAME");
+        const pattern = it.tryConsume("PATTERN");
         if (name || pattern) {
-            var prefix = char || "";
-            if (prefixes.indexOf(prefix) === -1) {
-                path += prefix;
-                prefix = "";
-            }
-            if (path) {
-                result.push(path);
-                path = "";
-            }
-            result.push({
-                name: name || key++,
-                prefix: prefix,
-                suffix: "",
-                pattern: pattern || defaultPattern,
-                modifier: tryConsume("MODIFIER") || "",
+            tokens.push({
+                name: name || String(key++),
+                pattern,
             });
+            const next = it.peek();
+            if (next.type === "*") {
+                throw new TypeError(`Unexpected * at ${next.index}, you probably want \`/*\` or \`{/:foo}*\`: ${DEBUG_URL}`);
+            }
             continue;
         }
-        var value = char || tryConsume("ESCAPED_CHAR");
-        if (value) {
-            path += value;
+        const asterisk = it.tryConsume("*");
+        if (asterisk) {
+            tokens.push({
+                name: String(key++),
+                pattern: `(?:(?!${escape(delimiter)}).)*`,
+                modifier: "*",
+                separator: delimiter,
+            });
             continue;
         }
-        if (path) {
-            result.push(path);
-            path = "";
-        }
-        var open = tryConsume("OPEN");
+        const open = it.tryConsume("{");
         if (open) {
-            var prefix = consumeText();
-            var name_1 = tryConsume("NAME") || "";
-            var pattern_1 = tryConsume("PATTERN") || "";
-            var suffix = consumeText();
-            mustConsume("CLOSE");
-            result.push({
-                name: name_1 || (pattern_1 ? key++ : ""),
-                pattern: name_1 && !pattern_1 ? defaultPattern : pattern_1,
-                prefix: prefix,
-                suffix: suffix,
-                modifier: tryConsume("MODIFIER") || "",
+            const prefix = it.text();
+            const name = it.tryConsume("NAME");
+            const pattern = it.tryConsume("PATTERN");
+            const suffix = it.text();
+            const separator = it.tryConsume(";") && it.text();
+            it.consume("}");
+            const modifier = it.modifier();
+            tokens.push({
+                name: name || (pattern ? String(key++) : ""),
+                prefix: encodePath(prefix),
+                suffix: encodePath(suffix),
+                pattern,
+                modifier,
+                separator,
             });
             continue;
         }
-        mustConsume("END");
-    }
-    return result;
+        it.consume("END");
+        break;
+    } while (true);
+    return new TokenData(tokens, delimiter);
 }
-exports.parse = parse;
 /**
  * Compile a string to a template function for the path.
  */
-function compile(str, options) {
-    return tokensToFunction(parse(str, options), options);
+function compile(path, options = {}) {
+    const data = path instanceof TokenData ? path : parse(path, options);
+    return compileTokens(data, options);
 }
-exports.compile = compile;
 /**
- * Expose a method for transforming tokens into the path function.
+ * Convert a single token into a path building function.
  */
-function tokensToFunction(tokens, options) {
-    if (options === void 0) { options = {}; }
-    var reFlags = flags(options);
-    var _a = options.encode, encode = _a === void 0 ? function (x) { return x; } : _a, _b = options.validate, validate = _b === void 0 ? true : _b;
-    // Compile all the tokens into regexps.
-    var matches = tokens.map(function (token) {
-        if (typeof token === "object") {
-            return new RegExp("^(?:".concat(token.pattern, ")$"), reFlags);
-        }
-    });
-    return function (data) {
-        var path = "";
-        for (var i = 0; i < tokens.length; i++) {
-            var token = tokens[i];
-            if (typeof token === "string") {
-                path += token;
-                continue;
-            }
-            var value = data ? data[token.name] : undefined;
-            var optional = token.modifier === "?" || token.modifier === "*";
-            var repeat = token.modifier === "*" || token.modifier === "+";
-            if (Array.isArray(value)) {
-                if (!repeat) {
-                    throw new TypeError("Expected \"".concat(token.name, "\" to not repeat, but got an array"));
-                }
-                if (value.length === 0) {
-                    if (optional)
-                        continue;
-                    throw new TypeError("Expected \"".concat(token.name, "\" to not be empty"));
-                }
-                for (var j = 0; j < value.length; j++) {
-                    var segment = encode(value[j], token);
-                    if (validate && !matches[i].test(segment)) {
-                        throw new TypeError("Expected all \"".concat(token.name, "\" to match \"").concat(token.pattern, "\", but got \"").concat(segment, "\""));
-                    }
-                    path += token.prefix + segment + token.suffix;
-                }
-                continue;
+function tokenToFunction(token, encode) {
+    if (typeof token === "string") {
+        return () => token;
+    }
+    const encodeValue = encode || NOOP_VALUE;
+    const repeated = token.modifier === "+" || token.modifier === "*";
+    const optional = token.modifier === "?" || token.modifier === "*";
+    const { prefix = "", suffix = "", separator = suffix + prefix } = token;
+    if (encode && repeated) {
+        const stringify = (value, index) => {
+            if (typeof value !== "string") {
+                throw new TypeError(`Expected "${token.name}/${index}" to be a string`);
             }
-            if (typeof value === "string" || typeof value === "number") {
-                var segment = encode(String(value), token);
-                if (validate && !matches[i].test(segment)) {
-                    throw new TypeError("Expected \"".concat(token.name, "\" to match \"").concat(token.pattern, "\", but got \"").concat(segment, "\""));
-                }
-                path += token.prefix + segment + token.suffix;
-                continue;
+            return encodeValue(value);
+        };
+        const compile = (value) => {
+            if (!Array.isArray(value)) {
+                throw new TypeError(`Expected "${token.name}" to be an array`);
             }
-            if (optional)
-                continue;
-            var typeOfMessage = repeat ? "an array" : "a string";
-            throw new TypeError("Expected \"".concat(token.name, "\" to be ").concat(typeOfMessage));
+            if (value.length === 0)
+                return "";
+            return prefix + value.map(stringify).join(separator) + suffix;
+        };
+        if (optional) {
+            return (data) => {
+                const value = data[token.name];
+                if (value == null)
+                    return "";
+                return value.length ? compile(value) : "";
+            };
         }
-        return path;
+        return (data) => {
+            const value = data[token.name];
+            return compile(value);
+        };
+    }
+    const stringify = (value) => {
+        if (typeof value !== "string") {
+            throw new TypeError(`Expected "${token.name}" to be a string`);
+        }
+        return prefix + encodeValue(value) + suffix;
+    };
+    if (optional) {
+        return (data) => {
+            const value = data[token.name];
+            if (value == null)
+                return "";
+            return stringify(value);
+        };
+    }
+    return (data) => {
+        const value = data[token.name];
+        return stringify(value);
     };
 }
-exports.tokensToFunction = tokensToFunction;
 /**
- * Create path match function from `path-to-regexp` spec.
+ * Transform tokens into a path building function.
  */
-function match(str, options) {
-    var keys = [];
-    var re = pathToRegexp(str, keys, options);
-    return regexpToFunction(re, keys, options);
+function compileTokens(data, options) {
+    const { encode = encodeURIComponent, loose = true, validate = true, strict = false, } = options;
+    const flags = toFlags(options);
+    const stringify = toStringify(loose, data.delimiter);
+    const sources = toRegExpSource(data, stringify, [], flags, strict);
+    // Compile all the tokens into regexps.
+    const encoders = data.tokens.map((token, index) => {
+        const fn = tokenToFunction(token, encode);
+        if (!validate || typeof token === "string")
+            return fn;
+        const validRe = new RegExp(`^${sources[index]}$`, flags);
+        return (data) => {
+            const value = fn(data);
+            if (!validRe.test(value)) {
+                throw new TypeError(`Invalid value for "${token.name}": ${JSON.stringify(value)}`);
+            }
+            return value;
+        };
+    });
+    return function path(data = {}) {
+        let path = "";
+        for (const encoder of encoders)
+            path += encoder(data);
+        return path;
+    };
 }
-exports.match = match;
 /**
- * Create a path match function from `path-to-regexp` output.
+ * Create path match function from `path-to-regexp` spec.
  */
-function regexpToFunction(re, keys, options) {
-    if (options === void 0) { options = {}; }
-    var _a = options.decode, decode = _a === void 0 ? function (x) { return x; } : _a;
-    return function (pathname) {
-        var m = re.exec(pathname);
+function match(path, options = {}) {
+    const { decode = decodeURIComponent, loose = true } = options;
+    const data = path instanceof TokenData ? path : parse(path, options);
+    const stringify = toStringify(loose, data.delimiter);
+    const keys = [];
+    const re = tokensToRegexp(data, keys, options);
+    const decoders = keys.map((key) => {
+        if (decode && (key.modifier === "+" || key.modifier === "*")) {
+            const { prefix = "", suffix = "", separator = suffix + prefix } = key;
+            const re = new RegExp(stringify(separator), "g");
+            return (value) => value.split(re).map(decode);
+        }
+        return decode || NOOP_VALUE;
+    });
+    return function match(input) {
+        const m = re.exec(input);
         if (!m)
             return false;
-        var path = m[0], index = m.index;
-        var params = Object.create(null);
-        var _loop_1 = function (i) {
+        const { 0: path, index } = m;
+        const params = Object.create(null);
+        for (let i = 1; i < m.length; i++) {
             if (m[i] === undefined)
-                return "continue";
-            var key = keys[i - 1];
-            if (key.modifier === "*" || key.modifier === "+") {
-                params[key.name] = m[i].split(key.prefix + key.suffix).map(function (value) {
-                    return decode(value, key);
-                });
-            }
-            else {
-                params[key.name] = decode(m[i], key);
-            }
-        };
-        for (var i = 1; i < m.length; i++) {
-            _loop_1(i);
+                continue;
+            const key = keys[i - 1];
+            const decoder = decoders[i - 1];
+            params[key.name] = decoder(m[i]);
         }
-        return { path: path, index: index, params: params };
+        return { path, index, params };
     };
 }
-exports.regexpToFunction = regexpToFunction;
 /**
  * Escape a regular expression string.
  */
-function escapeString(str) {
-    return str.replace(/([.+*?=^!:${}()[\]|/\\])/g, "\\$1");
+function escape(str) {
+    return str.replace(/([.+*?^${}()[\]|/\\])/g, "\\$1");
 }
 /**
- * Get the flags for a regexp from the options.
+ * Escape and repeat loose characters for regular expressions.
  */
-function flags(options) {
-    return options && options.sensitive ? "" : "i";
+function looseReplacer(value, loose) {
+    const escaped = escape(value);
+    return loose ? `(?:${escaped})+(?!${escaped})` : escaped;
 }
 /**
- * Pull out keys from a regexp.
+ * Encode all non-delimiter characters using the encode function.
  */
-function regexpToRegexp(path, keys) {
-    if (!keys)
-        return path;
-    var groupsRegex = /\((?:\?<(.*?)>)?(?!\?)/g;
-    var index = 0;
-    var execResult = groupsRegex.exec(path.source);
-    while (execResult) {
-        keys.push({
-            // Use parenthesized substring match if available, index otherwise
-            name: execResult[1] || index++,
-            prefix: "",
-            suffix: "",
-            modifier: "",
-            pattern: "",
-        });
-        execResult = groupsRegex.exec(path.source);
-    }
-    return path;
+function toStringify(loose, delimiter) {
+    if (!loose)
+        return escape;
+    const re = new RegExp(`(?:(?!${escape(delimiter)}).)+|(.)`, "g");
+    return (value) => value.replace(re, looseReplacer);
 }
 /**
- * Transform an array into a regexp.
+ * Get the flags for a regexp from the options.
  */
-function arrayToRegexp(paths, keys, options) {
-    var parts = paths.map(function (path) { return pathToRegexp(path, keys, options).source; });
-    return new RegExp("(?:".concat(parts.join("|"), ")"), flags(options));
+function toFlags(options) {
+    return options.sensitive ? "" : "i";
 }
 /**
- * Create a path regexp from string input.
+ * Expose a function for taking tokens and returning a RegExp.
  */
-function stringToRegexp(path, keys, options) {
-    return tokensToRegexp(parse(path, options), keys, options);
+function tokensToRegexp(data, keys, options) {
+    const { trailing = true, loose = true, start = true, end = true, strict = false, } = options;
+    const flags = toFlags(options);
+    const stringify = toStringify(loose, data.delimiter);
+    const sources = toRegExpSource(data, stringify, keys, flags, strict);
+    let pattern = start ? "^" : "";
+    pattern += sources.join("");
+    if (trailing)
+        pattern += `(?:${stringify(data.delimiter)})?`;
+    pattern += end ? "$" : `(?=${escape(data.delimiter)}|$)`;
+    return new RegExp(pattern, flags);
 }
 /**
- * Expose a function for taking tokens and returning a RegExp.
+ * Convert a token into a regexp string (re-used for path validation).
  */
-function tokensToRegexp(tokens, keys, options) {
-    if (options === void 0) { options = {}; }
-    var _a = options.strict, strict = _a === void 0 ? false : _a, _b = options.start, start = _b === void 0 ? true : _b, _c = options.end, end = _c === void 0 ? true : _c, _d = options.encode, encode = _d === void 0 ? function (x) { return x; } : _d, _e = options.delimiter, delimiter = _e === void 0 ? "/#?" : _e, _f = options.endsWith, endsWith = _f === void 0 ? "" : _f;
-    var endsWithRe = "[".concat(escapeString(endsWith), "]|$");
-    var delimiterRe = "[".concat(escapeString(delimiter), "]");
-    var route = start ? "^" : "";
-    // Iterate over the tokens and create our regexp string.
-    for (var _i = 0, tokens_1 = tokens; _i < tokens_1.length; _i++) {
-        var token = tokens_1[_i];
+function toRegExpSource(data, stringify, keys, flags, strict) {
+    const defaultPattern = `(?:(?!${escape(data.delimiter)}).)+?`;
+    let backtrack = "";
+    let safe = true;
+    return data.tokens.map((token, index) => {
         if (typeof token === "string") {
-            route += escapeString(encode(token));
+            backtrack = token;
+            return stringify(token);
         }
-        else {
-            var prefix = escapeString(encode(token.prefix));
-            var suffix = escapeString(encode(token.suffix));
-            if (token.pattern) {
-                if (keys)
-                    keys.push(token);
-                if (prefix || suffix) {
-                    if (token.modifier === "+" || token.modifier === "*") {
-                        var mod = token.modifier === "*" ? "?" : "";
-                        route += "(?:".concat(prefix, "((?:").concat(token.pattern, ")(?:").concat(suffix).concat(prefix, "(?:").concat(token.pattern, "))*)").concat(suffix, ")").concat(mod);
-                    }
-                    else {
-                        route += "(?:".concat(prefix, "(").concat(token.pattern, ")").concat(suffix, ")").concat(token.modifier);
-                    }
+        const { prefix = "", suffix = "", separator = suffix + prefix, modifier = "", } = token;
+        const pre = stringify(prefix);
+        const post = stringify(suffix);
+        if (token.name) {
+            const pattern = token.pattern ? `(?:${token.pattern})` : defaultPattern;
+            const re = checkPattern(pattern, token.name, flags);
+            safe || (safe = safePattern(re, prefix || backtrack));
+            if (!safe) {
+                throw new TypeError(`Ambiguous pattern for "${token.name}": ${DEBUG_URL}`);
+            }
+            safe = !strict || safePattern(re, suffix);
+            backtrack = "";
+            keys.push(token);
+            if (modifier === "+" || modifier === "*") {
+                const mod = modifier === "*" ? "?" : "";
+                const sep = stringify(separator);
+                if (!sep) {
+                    throw new TypeError(`Missing separator for "${token.name}": ${DEBUG_URL}`);
                 }
-                else {
-                    if (token.modifier === "+" || token.modifier === "*") {
-                        route += "((?:".concat(token.pattern, ")").concat(token.modifier, ")");
-                    }
-                    else {
-                        route += "(".concat(token.pattern, ")").concat(token.modifier);
-                    }
+                safe || (safe = !strict || safePattern(re, separator));
+                if (!safe) {
+                    throw new TypeError(`Ambiguous pattern for "${token.name}" separator: ${DEBUG_URL}`);
                 }
+                safe = !strict;
+                return `(?:${pre}(${pattern}(?:${sep}${pattern})*)${post})${mod}`;
             }
-            else {
-                route += "(?:".concat(prefix).concat(suffix, ")").concat(token.modifier);
-            }
+            return `(?:${pre}(${pattern})${post})${modifier}`;
         }
+        return `(?:${pre}${post})${modifier}`;
+    });
+}
+function checkPattern(pattern, name, flags) {
+    try {
+        return new RegExp(`^${pattern}$`, flags);
     }
-    if (end) {
-        if (!strict)
-            route += "".concat(delimiterRe, "?");
-        route += !options.endsWith ? "$" : "(?=".concat(endsWithRe, ")");
-    }
-    else {
-        var endToken = tokens[tokens.length - 1];
-        var isEndDelimited = typeof endToken === "string"
-            ? delimiterRe.indexOf(endToken[endToken.length - 1]) > -1
-            : endToken === undefined;
-        if (!strict) {
-            route += "(?:".concat(delimiterRe, "(?=").concat(endsWithRe, "))?");
-        }
-        if (!isEndDelimited) {
-            route += "(?=".concat(delimiterRe, "|").concat(endsWithRe, ")");
-        }
+    catch (err) {
+        throw new TypeError(`Invalid pattern for "${name}": ${err.message}`);
     }
-    return new RegExp(route, flags(options));
 }
-exports.tokensToRegexp = tokensToRegexp;
+function safePattern(re, value) {
+    return value ? !re.test(value) : false;
+}
 /**
  * Normalize the given path string, returning a regular expression.
  *
@@ -399,12 +422,10 @@ exports.tokensToRegexp = tokensToRegexp;
  * placeholder key descriptions. For example, using `/user/:id`, `keys` will
  * contain `[{ name: 'id', delimiter: '/', optional: false, repeat: false }]`.
  */
-function pathToRegexp(path, keys, options) {
-    if (path instanceof RegExp)
-        return regexpToRegexp(path, keys);
-    if (Array.isArray(path))
-        return arrayToRegexp(path, keys, options);
-    return stringToRegexp(path, keys, options);
+function pathToRegexp(path, options = {}) {
+    const data = path instanceof TokenData ? path : parse(path, options);
+    const keys = [];
+    const regexp = tokensToRegexp(data, keys, options);
+    return Object.assign(regexp, { keys });
 }
-exports.pathToRegexp = pathToRegexp;
 //# sourceMappingURL=index.js.map