Shaving some bytes

Author: blakeembrey

src/index.ts

@@ -333,8 +333,8 @@ export function compile<P extends ParamData = ParamData>(
  const data = path instanceof TokenData ? path : parse(path, options);
  const fn = tokensToFunction(data.tokens, delimiter, encode);
 
- return function path(data: P = {} as P) {
- const [path, ...missing] = fn(data);
+ return function path(params: P = {} as P) {
+ const [path, ...missing] = fn(params);
  if (missing.length) {
  throw new TypeError(`Missing parameters: ${missing.join(", ")}`);
  }
@@ -498,16 +498,9 @@ export function pathToRegexp(
  const keys: Keys = [];
  const sources: string[] = [];
  const flags = sensitive ? "" : "i";
- 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);
- }
+ for (const seq of flat(path, options)) {
+ sources.push(toRegExp(seq, delimiter, keys));
  }
 
  let pattern = `^(?:${sources.join("|")})`;
@@ -523,6 +516,22 @@ export function pathToRegexp(
  */
 type Flattened = Text | Parameter | Wildcard;
 
+/**
+ * Path or array of paths to normalize.
+ */
+function* flat(
+ path: Path | Path[],
+ options: ParseOptions,
+): Generator<Flattened[]> {
+ if (Array.isArray(path)) {
+ for (const p of path) yield* flat(p, options);
+ return;
+ }
+
+ const data = path instanceof TokenData ? path : parse(path, options);
+ yield* flatten(data.tokens, 0, []);
+}
+
 /**
  * Generate a flat list of sequence tokens from the given tokens.
  */
@@ -538,8 +547,7 @@ function* flatten(
  const token = tokens[index];
 
  if (token.type === "group") {
- const fork = init.slice();
- for (const seq of flatten(token.tokens, 0, fork)) {
+ for (const seq of flatten(token.tokens, 0, init.slice())) {
  yield* flatten(tokens, index + 1, seq);
  }
  } else {
@@ -552,14 +560,12 @@ function* flatten(
 /**
  * Transform a flat sequence of tokens into a regular expression.
  */
-function sequenceToRegExp(tokens: Flattened[], delimiter: string, keys: Keys) {
+function toRegExp(tokens: Flattened[], delimiter: string, keys: Keys) {
  let result = "";
  let backtrack = "";
  let isSafeSegmentParam = true;
 
- for (let i = 0; i < tokens.length; i++) {
- const token = tokens[i];
-
+ for (const token of tokens) {
  if (token.type === "text") {
  result += escape(token.value);
  backtrack += token.value;
@@ -588,6 +594,9 @@ function sequenceToRegExp(tokens: Flattened[], delimiter: string, keys: Keys) {
  return result;
 }
 
+/**
+ * Block backtracking on previous text and ignore delimiter string.
+ */
 function negate(delimiter: string, backtrack: string) {
  if (backtrack.length < 2) {
  if (delimiter.length < 2) return `[^${escape(delimiter + backtrack)}]`;
@@ -621,12 +630,18 @@ export function stringify(data: TokenData) {
  .join("");
 }
 
+/**
+ * Validate the parameter name contains valid ID characters.
+ */
 function isNameSafe(name: string) {
  const [first, ...rest] = name;
  if (!ID_START.test(first)) return false;
  return rest.every((char) => ID_CONTINUE.test(char));
 }
 
+/**
+ * Validate the next token does not interfere with the current param name.
+ */
 function isNextNameSafe(token: Token | undefined) {
  if (!token || token.type !== "text") return true;
  return !ID_CONTINUE.test(token.value[0]);