path-to-regexp 7.0.0 → 8.0.0

package/dist/index.js

@@ -1,101 +1,129 @@
 "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.pathToRegexp = exports.match = exports.compile = exports.parse = exports.TokenData = void 0;
+exports.TokenData = void 0;
+exports.parse = parse;
+exports.compile = compile;
+exports.match = match;
 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 a regular expression string.
+ */
+function escape(str) {
+    return str.replace(/[.+*?^${}()[\]|/\\]/g, "\\$&");
+}
+/**
+ * Get the flags for a regexp from the options.
+ */
+function toFlags(options) {
+    return options.sensitive ? "s" : "is";
+}
 /**
  * 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];
-            }
-            if (!name) {
-                throw new TypeError(`Missing parameter name at ${i}`);
+    function name() {
+        let value = "";
+        if (ID_START.test(chars[++i])) {
+            value += chars[i];
+            while (ID_CONTINUE.test(chars[++i])) {
+                value += chars[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}`);
+            }
+        }
+        if (!value) {
+            throw new TypeError(`Missing parameter name at ${i}: ${DEBUG_URL}`);
+        }
+        return value;
+    }
+    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++] };
         }
-        tokens.push({ type: "CHAR", index: i, value: chars[i++] });
     }
-    tokens.push({ type: "END", index: i, value: "" });
-    return new Iter(tokens);
+    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) {
@@ -103,7 +131,7 @@ class Iter {
         if (value !== undefined)
             return value;
         const { type: nextType, index } = this.peek();
-        throw new TypeError(`Unexpected ${nextType} at ${index}, expected ${type}: https://git.new/pathToRegexpError`);
+        throw new TypeError(`Unexpected ${nextType} at ${index}, expected ${type}: ${DEBUG_URL}`);
     }
     text() {
         let result = "";
@@ -113,17 +141,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;
@@ -131,179 +156,154 @@ exports.TokenData = TokenData;
  * Parse a string for the raw tokens.
  */
 function parse(str, options = {}) {
-    const { delimiter = DEFAULT_DELIMITER, encodePath = NOOP_VALUE } = 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}*\`: https://git.new/pathToRegexpError`);
+    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 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;
         }
-        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() : prefix + suffix;
-            it.consume("}");
-            const modifier = it.modifier();
-            tokens.push({
-                name: name || (pattern ? String(key++) : ""),
-                prefix: encodePath(prefix),
-                suffix: encodePath(suffix),
-                pattern,
-                modifier,
-                separator,
-            });
-            continue;
+    }
+    const tokens = consume("END");
+    return new TokenData(tokens);
+}
+/**
+ * Transform tokens into a path building function.
+ */
+function $compile(data, options) {
+    const { encode = encodeURIComponent, delimiter = DEFAULT_DELIMITER } = 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(", ")}`);
         }
-        it.consume("END");
-        break;
-    } while (true);
-    return new TokenData(tokens, delimiter);
+        return path;
+    };
 }
-exports.parse = parse;
 /**
  * Compile a string to a template function for the path.
  */
 function compile(path, options = {}) {
-    const data = path instanceof TokenData ? path : parse(path, options);
-    return compileTokens(data, options);
+    return $compile(path instanceof TokenData ? path : parse(path, options), options);
+}
+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;
+    };
 }
-exports.compile = compile;
 /**
  * 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 = "" } = 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, } = options;
-    const reFlags = flags(options);
-    const stringify = toStringify(loose, data.delimiter);
-    const keyToRegexp = toKeyRegexp(stringify, data.delimiter);
-    // Compile all the tokens into regexps.
-    const encoders = data.tokens.map((token) => {
-        const fn = tokenToFunction(token, encode);
-        if (!validate || typeof token === "string")
-            return fn;
-        const pattern = keyToRegexp(token);
-        const validRe = new RegExp(`^${pattern}$`, reFlags);
-        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.
  */
-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);
+function $match(data, options = {}) {
+    const { decode = decodeURIComponent, delimiter = DEFAULT_DELIMITER, end = true, trailing = true, } = options;
+    const flags = toFlags(options);
+    const sources = [];
     const keys = [];
-    const re = tokensToRegexp(data, keys, options);
-    const decoders = keys.map((key) => {
-        if (decode && (key.modifier === "+" || key.modifier === "*")) {
-            const re = new RegExp(stringify(key.separator || ""), "g");
-            return (value) => value.split(re).map(decode);
+    for (const { tokens } of data) {
+        for (const seq of flatten(tokens, 0, [])) {
+            const regexp = sequenceToRegExp(seq, delimiter, keys);
+            sources.push(regexp);
         }
-        return decode || NOOP_VALUE;
+    }
+    let pattern = `^(?:${sources.join("|")})`;
+    if (trailing)
+        pattern += `(?:${escape(delimiter)}$)?`;
+    pattern += end ? "$" : `(?=${escape(delimiter)}|$)`;
+    const re = new RegExp(pattern, flags);
+    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(pathname) {
-        const m = re.exec(pathname);
+    return Object.assign(function match(input) {
+        const m = re.exec(input);
         if (!m)
             return false;
-        const { 0: path, index } = m;
+        const { 0: path } = m;
         const params = Object.create(null);
         for (let i = 1; i < m.length; i++) {
             if (m[i] === undefined)
@@ -312,93 +312,71 @@ function match(path, options = {}) {
             const decoder = decoders[i - 1];
             params[key.name] = decoder(m[i]);
         }
-        return { path, index, params };
-    };
-}
-exports.match = match;
-/**
- * Escape a regular expression string.
- */
-function escape(str) {
-    return str.replace(/([.+*?=^!:${}()[\]|/\\])/g, "\\$1");
+        return { path, params };
+    }, { re });
 }
-/**
- * Escape and repeat loose characters for regular expressions.
- */
-function looseReplacer(value, loose) {
-    return loose ? `${escape(value)}+` : escape(value);
-}
-/**
- * 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 flags(options) {
-    return options.sensitive ? "" : "i";
+function match(path, options = {}) {
+    const paths = Array.isArray(path) ? path : [path];
+    const items = paths.map((path) => path instanceof TokenData ? path : parse(path, options));
+    return $match(items, options);
 }
 /**
- * Expose a function for taking tokens and returning a RegExp.
+ * Generate a flat list of sequence tokens from the given tokens.
  */
-function tokensToRegexp(data, keys, options) {
-    const { trailing = true, start = true, end = true, loose = true } = options;
-    const stringify = toStringify(loose, data.delimiter);
-    const keyToRegexp = toKeyRegexp(stringify, data.delimiter);
-    let pattern = start ? "^" : "";
-    for (const token of data.tokens) {
-        if (typeof token === "string") {
-            pattern += stringify(token);
-        }
-        else {
-            if (token.name)
-                keys.push(token);
-            pattern += keyToRegexp(token);
+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);
         }
     }
-    if (trailing)
-        pattern += `(?:${stringify(data.delimiter)})?`;
-    pattern += end ? "$" : `(?=${escape(data.delimiter)}|$)`;
-    return new RegExp(pattern, flags(options));
+    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 toKeyRegexp(stringify, delimiter) {
-    const segmentPattern = `[^${escape(delimiter)}]+?`;
-    return (key) => {
-        const prefix = key.prefix ? stringify(key.prefix) : "";
-        const suffix = key.suffix ? stringify(key.suffix) : "";
-        const modifier = key.modifier || "";
-        if (key.name) {
-            const pattern = key.pattern || segmentPattern;
-            if (key.modifier === "+" || key.modifier === "*") {
-                const mod = key.modifier === "*" ? "?" : "";
-                const split = key.separator ? stringify(key.separator) : "";
-                return `(?:${prefix}((?:${pattern})(?:${split}(?:${pattern}))*)${suffix})${mod}`;
+function sequenceToRegExp(tokens, delimiter, keys) {
+    let result = "";
+    let backtrack = "";
+    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;
+        }
+        if (token.type === "param" || token.type === "wildcard") {
+            if (!isSafeSegmentParam && !backtrack) {
+                throw new TypeError(`Missing text after "${token.name}": ${DEBUG_URL}`);
             }
-            return `(?:${prefix}(${pattern})${suffix})${modifier}`;
+            if (token.type === "param") {
+                result += `(${negate(delimiter, isSafeSegmentParam ? "" : backtrack)}+)`;
+            }
+            else {
+                result += `(.+)`;
+            }
+            keys.push(token);
+            backtrack = "";
+            isSafeSegmentParam = false;
+            continue;
         }
-        return `(?:${prefix}${suffix})${modifier}`;
-    };
+    }
+    return result;
 }
-/**
- * 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 }]`.
- */
-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 });
+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("|")}).)`;
 }
-exports.pathToRegexp = pathToRegexp;
 //# sourceMappingURL=index.js.map