path-to-regexp 7.2.0 → 8.1.0

package/dist/index.js

@@ -1,106 +1,131 @@
 "use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _Iter_peek;
 Object.defineProperty(exports, "__esModule", { value: true });
 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_CHAR = /^\p{XID_Continue}$/u;
+const ID_START = /^[$_\p{ID_Start}]$/u;
+const ID_CONTINUE = /^[$\u200c\u200d\p{ID_Continue}]$/u;
 const DEBUG_URL = "https://git.new/pathToRegexpError";
 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, "\\$&");
+}
 /**
  * Tokenize input string.
  */
-function lexer(str) {
+function* lexer(str) {
     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 (value === "\\") {
-            tokens.push({ type: "ESCAPED", index: i++, value: chars[i++] });
-            continue;
-        }
-        if (value === ":") {
-            let name = "";
-            while (ID_CHAR.test(chars[++i])) {
-                name += chars[i];
+    function name() {
+        let value = "";
+        if (ID_START.test(chars[++i])) {
+            value += chars[i];
+            while (ID_CONTINUE.test(chars[++i])) {
+                value += chars[i];
             }
-            if (!name) {
-                throw new TypeError(`Missing parameter name at ${i}`);
-            }
-            tokens.push({ type: "NAME", index: i, value: name });
-            continue;
         }
-        if (value === "(") {
-            const pos = i++;
-            let count = 1;
-            let pattern = "";
-            if (chars[i] === "?") {
-                throw new TypeError(`Pattern cannot start with "?" at ${i}`);
-            }
+        else if (chars[i] === '"') {
+            let pos = i;
             while (i < chars.length) {
-                if (chars[i] === "\\") {
-                    pattern += chars[i++] + chars[i++];
-                    continue;
+                if (chars[++i] === '"') {
+                    i++;
+                    pos = 0;
+                    break;
                 }
-                if (chars[i] === ")") {
-                    count--;
-                    if (count === 0) {
-                        i++;
-                        break;
-                    }
+                if (chars[i] === "\\") {
+                    value += chars[++i];
                 }
-                else if (chars[i] === "(") {
-                    count++;
-                    if (chars[i + 1] !== "?") {
-                        throw new TypeError(`Capturing groups are not allowed at ${i}`);
-                    }
+                else {
+                    value += chars[i];
                 }
-                pattern += chars[i++];
             }
-            if (count)
-                throw new TypeError(`Unbalanced pattern at ${pos}`);
-            if (!pattern)
-                throw new TypeError(`Missing pattern at ${pos}`);
-            tokens.push({ type: "PATTERN", index: i, value: pattern });
-            continue;
+            if (pos) {
+                throw new TypeError(`Unterminated quote at ${pos}: ${DEBUG_URL}`);
+            }
         }
-        tokens.push({ type: "CHAR", index: i, value: chars[i++] });
+        if (!value) {
+            throw new TypeError(`Missing parameter name at ${i}: ${DEBUG_URL}`);
+        }
+        return value;
     }
-    tokens.push({ type: "END", index: i, value: "" });
-    return new Iter(tokens);
+    while (i < chars.length) {
+        const value = chars[i];
+        const type = SIMPLE_TOKENS[value];
+        if (type) {
+            yield { type, index: i++, value };
+        }
+        else if (value === "\\") {
+            yield { type: "ESCAPED", index: i++, value: chars[i++] };
+        }
+        else if (value === ":") {
+            const value = name();
+            yield { type: "PARAM", index: i, value };
+        }
+        else if (value === "*") {
+            const value = name();
+            yield { type: "WILDCARD", index: i, value };
+        }
+        else {
+            yield { type: "CHAR", index: i, value: chars[i++] };
+        }
+    }
+    return { type: "END", index: i, value: "" };
 }
 class Iter {
     constructor(tokens) {
         this.tokens = tokens;
-        this.index = 0;
+        _Iter_peek.set(this, void 0);
     }
     peek() {
-        return this.tokens[this.index];
+        if (!__classPrivateFieldGet(this, _Iter_peek, "f")) {
+            const next = this.tokens.next();
+            __classPrivateFieldSet(this, _Iter_peek, next.value, "f");
+        }
+        return __classPrivateFieldGet(this, _Iter_peek, "f");
     }
     tryConsume(type) {
         const token = this.peek();
         if (token.type !== type)
             return;
-        this.index++;
+        __classPrivateFieldSet(this, _Iter_peek, undefined, "f"); // Reset after consumed.
         return token.value;
     }
     consume(type) {
@@ -118,17 +143,14 @@ class Iter {
         }
         return result;
     }
-    modifier() {
-        return this.tryConsume("?") || this.tryConsume("*") || this.tryConsume("+");
-    }
 }
+_Iter_peek = new WeakMap();
 /**
- * Tokenized path instance. Can we passed around instead of string.
+ * Tokenized path instance.
  */
 class TokenData {
-    constructor(tokens, delimiter) {
+    constructor(tokens) {
         this.tokens = tokens;
-        this.delimiter = delimiter;
     }
 }
 exports.TokenData = TokenData;
@@ -136,298 +158,256 @@ 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) {
-            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}`);
+    const { encodePath = NOOP_VALUE } = options;
+    const it = new Iter(lexer(str));
+    function consume(endType) {
+        const tokens = [];
+        while (true) {
+            const path = it.text();
+            if (path)
+                tokens.push({ type: "text", value: encodePath(path) });
+            const param = it.tryConsume("PARAM");
+            if (param) {
+                tokens.push({
+                    type: "param",
+                    name: param,
+                });
+                continue;
             }
-            continue;
-        }
-        const asterisk = it.tryConsume("*");
-        if (asterisk) {
-            tokens.push({
-                name: String(key++),
-                pattern: `(?:(?!${escape(delimiter)}).)*`,
-                modifier: "*",
-                separator: delimiter,
-            });
-            continue;
-        }
-        const open = it.tryConsume("{");
-        if (open) {
-            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;
+            const wildcard = it.tryConsume("WILDCARD");
+            if (wildcard) {
+                tokens.push({
+                    type: "wildcard",
+                    name: wildcard,
+                });
+                continue;
+            }
+            const open = it.tryConsume("{");
+            if (open) {
+                tokens.push({
+                    type: "group",
+                    tokens: consume("}"),
+                });
+                continue;
+            }
+            it.consume(endType);
+            return tokens;
         }
-        it.consume("END");
-        break;
-    } while (true);
-    return new TokenData(tokens, delimiter);
+    }
+    const tokens = consume("END");
+    return new TokenData(tokens);
 }
 /**
  * Compile a string to a template function for the path.
  */
 function compile(path, options = {}) {
+    const { encode = encodeURIComponent, delimiter = DEFAULT_DELIMITER } = options;
     const data = path instanceof TokenData ? path : parse(path, options);
-    return compileTokens(data, options);
+    const fn = tokensToFunction(data.tokens, delimiter, encode);
+    return function path(data = {}) {
+        const [path, ...missing] = fn(data);
+        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, 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`);
-            }
-            return encodeValue(value);
-        };
-        const compile = (value) => {
-            if (!Array.isArray(value)) {
-                throw new TypeError(`Expected "${token.name}" to be an array`);
-            }
-            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) : "";
-            };
-        }
+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 = data[token.name];
-            return compile(value);
+            const [value, ...missing] = fn(data);
+            if (!missing.length)
+                return [value];
+            return [""];
         };
     }
-    const stringify = (value) => {
-        if (typeof value !== "string") {
-            throw new TypeError(`Expected "${token.name}" to be a string`);
-        }
-        return prefix + encodeValue(value) + suffix;
-    };
-    if (optional) {
+    const encodeValue = encode || NOOP_VALUE;
+    if (token.type === "wildcard" && encode !== false) {
         return (data) => {
             const value = data[token.name];
             if (value == null)
-                return "";
-            return stringify(value);
+                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];
-        return stringify(value);
-    };
-}
-/**
- * Transform tokens into a path building function.
- */
-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;
+        if (value == null)
+            return ["", token.name];
+        if (typeof value !== "string") {
+            throw new TypeError(`Expected "${token.name}" to be a string`);
+        }
+        return [encodeValue(value)];
     };
 }
 /**
- * Create path match function from `path-to-regexp` spec.
+ * Transform a path into a match function.
  */
 function match(path, options = {}) {
-    const { decode = decodeURIComponent, loose = true, delimiter = DEFAULT_DELIMITER, } = options;
-    const re = pathToRegexp(path, options);
-    const stringify = toStringify(loose, delimiter);
-    const decoders = re.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;
+    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 = re.exec(input);
+        const m = regexp.exec(input);
         if (!m)
             return false;
-        const { 0: path, index } = m;
+        const path = m[0];
         const params = Object.create(null);
         for (let i = 1; i < m.length; i++) {
             if (m[i] === undefined)
                 continue;
-            const key = re.keys[i - 1];
+            const key = keys[i - 1];
             const decoder = decoders[i - 1];
             params[key.name] = decoder(m[i]);
         }
-        return { path, index, params };
+        return { path, params };
     };
 }
-/**
- * Escape a regular expression string.
- */
-function escape(str) {
-    return str.replace(/[.+*?^${}()[\]|/\\]/g, "\\$&");
-}
-/**
- * Escape and repeat loose characters for regular expressions.
- */
-function looseReplacer(value, loose) {
-    const escaped = escape(value);
-    return loose ? `(?:${escaped})+(?!${escaped})` : escaped;
-}
-/**
- * Encode all non-delimiter characters using the encode function.
- */
-function toStringify(loose, delimiter) {
-    if (!loose)
-        return escape;
-    const re = new RegExp(`(?:(?!${escape(delimiter)}).)+|(.)`, "g");
-    return (value) => value.replace(re, looseReplacer);
-}
-/**
- * Get the flags for a regexp from the options.
- */
-function toFlags(options) {
-    return options.sensitive ? "" : "i";
+function pathToRegexp(path, options = {}) {
+    const { delimiter = DEFAULT_DELIMITER, end = true, sensitive = false, trailing = true, } = options;
+    const keys = [];
+    const sources = [];
+    const flags = sensitive ? "s" : "is";
+    const paths = Array.isArray(path) ? path : [path];
+    const items = paths.map((path) => path instanceof TokenData ? path : parse(path, options));
+    for (const { tokens } of items) {
+        for (const seq of flatten(tokens, 0, [])) {
+            const regexp = sequenceToRegExp(seq, delimiter, keys);
+            sources.push(regexp);
+        }
+    }
+    let pattern = `^(?:${sources.join("|")})`;
+    if (trailing)
+        pattern += `(?:${escape(delimiter)}$)?`;
+    pattern += end ? "$" : `(?=${escape(delimiter)}|$)`;
+    const regexp = new RegExp(pattern, flags);
+    return { regexp, keys };
 }
 /**
- * Expose a function for taking tokens and returning a RegExp.
+ * Generate a flat list of sequence tokens from the given tokens.
  */
-function pathToSource(path, keys, flags, options) {
-    const data = path instanceof TokenData ? path : parse(path, options);
-    const { trailing = true, loose = true, start = true, end = true, strict = false, } = 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 pattern;
+function* flatten(tokens, index, init) {
+    if (index === tokens.length) {
+        return yield init;
+    }
+    const token = tokens[index];
+    if (token.type === "group") {
+        const fork = init.slice();
+        for (const seq of flatten(token.tokens, 0, fork)) {
+            yield* flatten(tokens, index + 1, seq);
+        }
+    }
+    else {
+        init.push(token);
+    }
+    yield* flatten(tokens, index + 1, init);
 }
 /**
- * Convert a token into a regexp string (re-used for path validation).
+ * Transform a flat sequence of tokens into a regular expression.
  */
-function toRegExpSource(data, stringify, keys, flags, strict) {
-    const defaultPattern = `(?:(?!${escape(data.delimiter)}).)+?`;
+function sequenceToRegExp(tokens, delimiter, keys) {
+    let result = "";
     let backtrack = "";
-    let safe = true;
-    return data.tokens.map((token) => {
-        if (typeof token === "string") {
-            backtrack = token;
-            return stringify(token);
+    let isSafeSegmentParam = true;
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        if (token.type === "text") {
+            result += escape(token.value);
+            backtrack = token.value;
+            isSafeSegmentParam || (isSafeSegmentParam = token.value.includes(delimiter));
+            continue;
         }
-        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}`);
+        if (token.type === "param" || token.type === "wildcard") {
+            if (!isSafeSegmentParam && !backtrack) {
+                throw new TypeError(`Missing text after "${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}`);
-                }
-                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}`;
+            if (token.type === "param") {
+                result += `(${negate(delimiter, isSafeSegmentParam ? "" : backtrack)}+)`;
+            }
+            else {
+                result += `(.+)`;
             }
-            return `(?:${pre}(${pattern})${post})${modifier}`;
+            keys.push(token);
+            backtrack = "";
+            isSafeSegmentParam = false;
+            continue;
         }
-        return `(?:${pre}${post})${modifier}`;
-    });
-}
-function checkPattern(pattern, name, flags) {
-    try {
-        return new RegExp(`^${pattern}$`, flags);
-    }
-    catch (err) {
-        throw new TypeError(`Invalid pattern for "${name}": ${err.message}`);
     }
+    return result;
 }
-function safePattern(re, value) {
-    return value ? !re.test(value) : false;
+function negate(delimiter, backtrack) {
+    const values = [delimiter, backtrack].filter(Boolean);
+    const isSimple = values.every((value) => value.length === 1);
+    if (isSimple)
+        return `[^${escape(values.join(""))}]`;
+    return `(?:(?!${values.map(escape).join("|")}).)`;
 }
 /**
- * Normalize the given path string, returning a regular expression.
- *
- * An empty array can be passed in for the keys, which will hold the
- * placeholder key descriptions. For example, using `/user/:id`, `keys` will
- * contain `[{ name: 'id', delimiter: '/', optional: false, repeat: false }]`.
+ * Stringify token data into a path string.
  */
-function pathToRegexp(path, options = {}) {
-    const keys = [];
-    const flags = toFlags(options);
-    if (Array.isArray(path)) {
-        const regexps = path.map((p) => pathToSource(p, keys, flags, options));
-        return Object.assign(new RegExp(regexps.join("|")), { keys });
-    }
-    const regexp = pathToSource(path, keys, flags, options);
-    return Object.assign(new RegExp(regexp), { keys });
+function stringify(data) {
+    return data.tokens
+        .map(function stringifyToken(token, index, tokens) {
+        if (token.type === "text")
+            return escapeText(token.value);
+        if (token.type === "group") {
+            return `{${token.tokens.map(stringifyToken).join("")}}`;
+        }
+        const isSafe = isNameSafe(token.name) && isNextNameSafe(tokens[index + 1]);
+        const key = isSafe ? token.name : JSON.stringify(token.name);
+        if (token.type === "param")
+            return `:${key}`;
+        if (token.type === "wildcard")
+            return `*${key}`;
+        throw new TypeError(`Unexpected token: ${token}`);
+    })
+        .join("");
+}
+function isNameSafe(name) {
+    const [first, ...rest] = name;
+    if (!ID_START.test(first))
+        return false;
+    return rest.every((char) => ID_CONTINUE.test(char));
+}
+function isNextNameSafe(token) {
+    if (token?.type !== "text")
+        return true;
+    return !ID_CONTINUE.test(token.value[0]);
 }
 //# sourceMappingURL=index.js.map