Very Popular
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622/** * Tokenizer results. */interface LexToken { type: | "OPEN" | "CLOSE" | "PATTERN" | "NAME" | "CHAR" | "ESCAPED_CHAR" | "MODIFIER" | "END"; index: number; value: string;}
/** * Tokenize input string. */function lexer(str: string): LexToken[] { const tokens: LexToken[] = []; let i = 0;
while (i < str.length) { const char = str[i];
if (char === "*" || char === "+" || char === "?") { tokens.push({ type: "MODIFIER", index: i, value: str[i++] }); continue; }
if (char === "\\") { tokens.push({ type: "ESCAPED_CHAR", index: i++, value: str[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 === ":") { let name = ""; let j = i + 1;
while (j < str.length) { const 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 (!name) throw new TypeError(`Missing parameter name at ${i}`);
tokens.push({ type: "NAME", index: i, value: name }); i = j; continue; }
if (char === "(") { let count = 1; let pattern = ""; let j = i + 1;
if (str[j] === "?") { throw new TypeError(`Pattern cannot start with "?" at ${j}`); }
while (j < str.length) { if (str[j] === "\\") { pattern += str[j++] + str[j++]; continue; }
if (str[j] === ")") { count--; if (count === 0) { j++; break; } } else if (str[j] === "(") { count++; if (str[j + 1] !== "?") { throw new TypeError(`Capturing groups are not allowed at ${j}`); } }
pattern += str[j++]; }
if (count) throw new TypeError(`Unbalanced pattern at ${i}`); if (!pattern) throw new TypeError(`Missing pattern at ${i}`);
tokens.push({ type: "PATTERN", index: i, value: pattern }); i = j; continue; }
tokens.push({ type: "CHAR", index: i, value: str[i++] }); }
tokens.push({ type: "END", index: i, value: "" });
return tokens;}
export interface ParseOptions { /** * Set the default delimiter for repeat parameters. (default: `'/'`) */ delimiter?: string; /** * List of characters to automatically consider prefixes when parsing. */ prefixes?: string;}
/** * Parse a string for the raw tokens. */export function parse(str: string, options: ParseOptions = {}): Token[] { const tokens = lexer(str); const { prefixes = "./" } = options; const defaultPattern = `[^${escapeString(options.delimiter || "/#?")}]+?`; const result: Token[] = []; let key = 0; let i = 0; let path = "";
const tryConsume = (type: LexToken["type"]): string | undefined => { if (i < tokens.length && tokens[i].type === type) return tokens[i++].value; };
const mustConsume = (type: LexToken["type"]): string => { const value = tryConsume(type); if (value !== undefined) return value; const { type: nextType, index } = tokens[i]; throw new TypeError(`Unexpected ${nextType} at ${index}, expected ${type}`); };
const consumeText = (): string => { let result = ""; let value: string | undefined; while ((value = tryConsume("CHAR") || tryConsume("ESCAPED_CHAR"))) { result += value; } return result; };
while (i < tokens.length) { const char = tryConsume("CHAR"); const name = tryConsume("NAME"); const pattern = tryConsume("PATTERN");
if (name || pattern) { let prefix = char || "";
if (prefixes.indexOf(prefix) === -1) { path += prefix; prefix = ""; }
if (path) { result.push(path); path = ""; }
result.push({ name: name || key++, prefix, suffix: "", pattern: pattern || defaultPattern, modifier: tryConsume("MODIFIER") || "", }); continue; }
const value = char || tryConsume("ESCAPED_CHAR"); if (value) { path += value; continue; }
if (path) { result.push(path); path = ""; }
const open = tryConsume("OPEN"); if (open) { const prefix = consumeText(); const name = tryConsume("NAME") || ""; const pattern = tryConsume("PATTERN") || ""; const suffix = consumeText();
mustConsume("CLOSE");
result.push({ name: name || (pattern ? key++ : ""), pattern: name && !pattern ? defaultPattern : pattern, prefix, suffix, modifier: tryConsume("MODIFIER") || "", }); continue; }
mustConsume("END"); }
return result;}
export interface TokensToFunctionOptions { /** * When `true` the regexp will be case sensitive. (default: `false`) */ sensitive?: boolean; /** * Function for encoding input strings for output. */ encode?: (value: string, token: Key) => string; /** * When `false` the function can produce an invalid (unmatched) path. (default: `true`) */ validate?: boolean;}
/** * Compile a string to a template function for the path. */export function compile<P extends object = object>( str: string, options?: ParseOptions & TokensToFunctionOptions) { return tokensToFunction<P>(parse(str, options), options);}
export type PathFunction<P extends object = object> = (data?: P) => string;
/** * Expose a method for transforming tokens into the path function. */export function tokensToFunction<P extends object = object>( tokens: Token[], options: TokensToFunctionOptions = {}): PathFunction<P> { const reFlags = flags(options); const { encode = (x: string) => x, validate = true } = options;
// Compile all the tokens into regexps. const matches = tokens.map((token) => { if (typeof token === "object") { return new RegExp(`^(?:${token.pattern})$`, reFlags); } });
return (data: Record<string, any> | null | undefined) => { let path = "";
for (let i = 0; i < tokens.length; i++) { const token = tokens[i];
if (typeof token === "string") { path += token; continue; }
const value = data ? data[token.name] : undefined; const optional = token.modifier === "?" || token.modifier === "*"; const repeat = token.modifier === "*" || token.modifier === "+";
if (Array.isArray(value)) { if (!repeat) { throw new TypeError( `Expected "${token.name}" to not repeat, but got an array` ); }
if (value.length === 0) { if (optional) continue;
throw new TypeError(`Expected "${token.name}" to not be empty`); }
for (let j = 0; j < value.length; j++) { const segment = encode(value[j], token);
if (validate && !(matches[i] as RegExp).test(segment)) { throw new TypeError( `Expected all "${token.name}" to match "${token.pattern}", but got "${segment}"` ); }
path += token.prefix + segment + token.suffix; }
continue; }
if (typeof value === "string" || typeof value === "number") { const segment = encode(String(value), token);
if (validate && !(matches[i] as RegExp).test(segment)) { throw new TypeError( `Expected "${token.name}" to match "${token.pattern}", but got "${segment}"` ); }
path += token.prefix + segment + token.suffix; continue; }
if (optional) continue;
const typeOfMessage = repeat ? "an array" : "a string"; throw new TypeError(`Expected "${token.name}" to be ${typeOfMessage}`); }
return path; };}
export interface RegexpToFunctionOptions { /** * Function for decoding strings for params. */ decode?: (value: string, token: Key) => string;}
/** * A match result contains data about the path match. */export interface MatchResult<P extends object = object> { path: string; index: number; params: P;}
/** * A match is either `false` (no match) or a match result. */export type Match<P extends object = object> = false | MatchResult<P>;
/** * The match function takes a string and returns whether it matched the path. */export type MatchFunction<P extends object = object> = ( path: string) => Match<P>;
/** * Create path match function from `path-to-regexp` spec. */export function match<P extends object = object>( str: Path, options?: ParseOptions & TokensToRegexpOptions & RegexpToFunctionOptions) { const keys: Key[] = []; const re = pathToRegexp(str, keys, options); return regexpToFunction<P>(re, keys, options);}
/** * Create a path match function from `path-to-regexp` output. */export function regexpToFunction<P extends object = object>( re: RegExp, keys: Key[], options: RegexpToFunctionOptions = {}): MatchFunction<P> { const { decode = (x: string) => x } = options;
return function (pathname: string) { const m = re.exec(pathname); if (!m) return false;
const { 0: path, index } = m; const params = Object.create(null);
for (let i = 1; i < m.length; i++) { if (m[i] === undefined) continue;
const key = keys[i - 1];
if (key.modifier === "*" || key.modifier === "+") { params[key.name] = m[i].split(key.prefix + key.suffix).map((value) => { return decode(value, key); }); } else { params[key.name] = decode(m[i], key); } }
return { path, index, params }; };}
/** * Escape a regular expression string. */function escapeString(str: string) { return str.replace(/([.+*?=^!:${}()[\]|/\\])/g, "\\$1");}
/** * Get the flags for a regexp from the options. */function flags(options?: { sensitive?: boolean }) { return options && options.sensitive ? "" : "i";}
/** * Metadata about a key. */export interface Key { name: string | number; prefix: string; suffix: string; pattern: string; modifier: string;}
/** * A token is a string (nothing special) or key metadata (capture group). */export type Token = string | Key;
/** * Pull out keys from a regexp. */function regexpToRegexp(path: RegExp, keys?: Key[]): RegExp { if (!keys) return path;
const groupsRegex = /\((?:\?<(.*?)>)?(?!\?)/g;
let index = 0; let 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;}
/** * Transform an array into a regexp. */function arrayToRegexp( paths: Array<string | RegExp>, keys?: Key[], options?: TokensToRegexpOptions & ParseOptions): RegExp { const parts = paths.map((path) => pathToRegexp(path, keys, options).source); return new RegExp(`(?:${parts.join("|")})`, flags(options));}
/** * Create a path regexp from string input. */function stringToRegexp( path: string, keys?: Key[], options?: TokensToRegexpOptions & ParseOptions) { return tokensToRegexp(parse(path, options), keys, options);}
export interface TokensToRegexpOptions { /** * When `true` the regexp will be case sensitive. (default: `false`) */ sensitive?: boolean; /** * When `true` the regexp won't allow an optional trailing delimiter to match. (default: `false`) */ strict?: boolean; /** * When `true` the regexp will match to the end of the string. (default: `true`) */ end?: boolean; /** * When `true` the regexp will match from the beginning of the string. (default: `true`) */ start?: boolean; /** * Sets the final character for non-ending optimistic matches. (default: `/`) */ delimiter?: string; /** * List of characters that can also be "end" characters. */ endsWith?: string; /** * Encode path tokens for use in the `RegExp`. */ encode?: (value: string) => string;}
/** * Expose a function for taking tokens and returning a RegExp. */export function tokensToRegexp( tokens: Token[], keys?: Key[], options: TokensToRegexpOptions = {}) { const { strict = false, start = true, end = true, encode = (x: string) => x, delimiter = "/#?", endsWith = "", } = options; const endsWithRe = `[${escapeString(endsWith)}]|$`; const delimiterRe = `[${escapeString(delimiter)}]`; let route = start ? "^" : "";
// Iterate over the tokens and create our regexp string. for (const token of tokens) { if (typeof token === "string") { route += escapeString(encode(token)); } else { const prefix = escapeString(encode(token.prefix)); const suffix = escapeString(encode(token.suffix));
if (token.pattern) { if (keys) keys.push(token);
if (prefix || suffix) { if (token.modifier === "+" || token.modifier === "*") { const mod = token.modifier === "*" ? "?" : ""; route += `(?:${prefix}((?:${token.pattern})(?:${suffix}${prefix}(?:${token.pattern}))*)${suffix})${mod}`; } else { route += `(?:${prefix}(${token.pattern})${suffix})${token.modifier}`; } } else { if (token.modifier === "+" || token.modifier === "*") { route += `((?:${token.pattern})${token.modifier})`; } else { route += `(${token.pattern})${token.modifier}`; } } } else { route += `(?:${prefix}${suffix})${token.modifier}`; } } }
if (end) { if (!strict) route += `${delimiterRe}?`;
route += !options.endsWith ? "$" : `(?=${endsWithRe})`; } else { const endToken = tokens[tokens.length - 1]; const isEndDelimited = typeof endToken === "string" ? delimiterRe.indexOf(endToken[endToken.length - 1]) > -1 : endToken === undefined;
if (!strict) { route += `(?:${delimiterRe}(?=${endsWithRe}))?`; }
if (!isEndDelimited) { route += `(?=${delimiterRe}|${endsWithRe})`; } }
return new RegExp(route, flags(options));}
/** * Supported `path-to-regexp` input types. */export type Path = string | RegExp | Array<string | RegExp>;
/** * 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 }]`. */export function pathToRegexp( path: Path, keys?: Key[], options?: TokensToRegexpOptions & ParseOptions) { if (path instanceof RegExp) return regexpToRegexp(path, keys); if (Array.isArray(path)) return arrayToRegexp(path, keys, options); return stringToRegexp(path, keys, options);}