@tanstack/router-generator 1.166.8 → 1.166.10

package/dist/esm/utils.js

@@ -1,644 +1,609 @@
-import * as fsp from "node:fs/promises";
+import "./filesystem/physical/rootPathId.js";
 import path from "node:path";
+import * as fsp from "node:fs/promises";
 import * as prettier from "prettier";
-import { rootPathId } from "./filesystem/physical/rootPathId.js";
-class RoutePrefixMap {
-  constructor(routes) {
-    this.prefixToRoute = /* @__PURE__ */ new Map();
-    this.layoutRoutes = [];
-    for (const route of routes) {
-      if (!route.routePath || route.routePath === `/${rootPathId}`) continue;
-      if (route._fsRouteType === "lazy" || route._fsRouteType === "loader" || route._fsRouteType === "component" || route._fsRouteType === "pendingComponent" || route._fsRouteType === "errorComponent" || route._fsRouteType === "notFoundComponent") {
-        continue;
-      }
-      this.prefixToRoute.set(route.routePath, route);
-      if (route._fsRouteType === "pathless_layout" || route._fsRouteType === "layout" || route._fsRouteType === "__root") {
-        this.layoutRoutes.push(route);
-      }
-    }
-    this.layoutRoutes.sort(
-      (a, b) => (b.routePath?.length ?? 0) - (a.routePath?.length ?? 0)
-    );
-  }
-  /**
-   * Find the longest matching parent route for a given path.
-   * O(k) where k is the number of path segments, not O(n) routes.
-   */
-  findParent(routePath) {
-    if (!routePath || routePath === "/") return null;
-    let searchPath = routePath;
-    while (searchPath.length > 0) {
-      const lastSlash = searchPath.lastIndexOf("/");
-      if (lastSlash <= 0) break;
-      searchPath = searchPath.substring(0, lastSlash);
-      const parent = this.prefixToRoute.get(searchPath);
-      if (parent && parent.routePath !== routePath) {
-        return parent;
-      }
-    }
-    return null;
-  }
-  /**
-   * Check if a route exists at the given path.
-   */
-  has(routePath) {
-    return this.prefixToRoute.has(routePath);
-  }
-  /**
-   * Get a route by exact path.
-   */
-  get(routePath) {
-    return this.prefixToRoute.get(routePath);
-  }
-}
+//#region src/utils.ts
+/**
+* Prefix map for O(1) parent route lookups.
+* Maps each route path prefix to the route node that owns that prefix.
+* Enables finding longest matching parent without linear search.
+*/
+var RoutePrefixMap = class {
+	constructor(routes) {
+		this.prefixToRoute = /* @__PURE__ */ new Map();
+		this.layoutRoutes = [];
+		for (const route of routes) {
+			if (!route.routePath || route.routePath === `/__root`) continue;
+			if (route._fsRouteType === "lazy" || route._fsRouteType === "loader" || route._fsRouteType === "component" || route._fsRouteType === "pendingComponent" || route._fsRouteType === "errorComponent" || route._fsRouteType === "notFoundComponent") continue;
+			this.prefixToRoute.set(route.routePath, route);
+			if (route._fsRouteType === "pathless_layout" || route._fsRouteType === "layout" || route._fsRouteType === "__root") this.layoutRoutes.push(route);
+		}
+		this.layoutRoutes.sort((a, b) => (b.routePath?.length ?? 0) - (a.routePath?.length ?? 0));
+	}
+	/**
+	* Find the longest matching parent route for a given path.
+	* O(k) where k is the number of path segments, not O(n) routes.
+	*/
+	findParent(routePath) {
+		if (!routePath || routePath === "/") return null;
+		let searchPath = routePath;
+		while (searchPath.length > 0) {
+			const lastSlash = searchPath.lastIndexOf("/");
+			if (lastSlash <= 0) break;
+			searchPath = searchPath.substring(0, lastSlash);
+			const parent = this.prefixToRoute.get(searchPath);
+			if (parent && parent.routePath !== routePath) return parent;
+		}
+		return null;
+	}
+	/**
+	* Check if a route exists at the given path.
+	*/
+	has(routePath) {
+		return this.prefixToRoute.has(routePath);
+	}
+	/**
+	* Get a route by exact path.
+	*/
+	get(routePath) {
+		return this.prefixToRoute.get(routePath);
+	}
+};
 function multiSortBy(arr, accessors = [(d) => d]) {
-  const len = arr.length;
-  const indexed = new Array(len);
-  for (let i = 0; i < len; i++) {
-    const item = arr[i];
-    const keys = new Array(accessors.length);
-    for (let j = 0; j < accessors.length; j++) {
-      keys[j] = accessors[j](item);
-    }
-    indexed[i] = { item, index: i, keys };
-  }
-  indexed.sort((a, b) => {
-    for (let j = 0; j < accessors.length; j++) {
-      const ao = a.keys[j];
-      const bo = b.keys[j];
-      if (typeof ao === "undefined") {
-        if (typeof bo === "undefined") {
-          continue;
-        }
-        return 1;
-      }
-      if (ao === bo) {
-        continue;
-      }
-      return ao > bo ? 1 : -1;
-    }
-    return a.index - b.index;
-  });
-  const result = new Array(len);
-  for (let i = 0; i < len; i++) {
-    result[i] = indexed[i].item;
-  }
-  return result;
-}
-function cleanPath(path2) {
-  return path2.replace(/\/{2,}/g, "/");
-}
-function trimPathLeft(path2) {
-  return path2 === "/" ? path2 : path2.replace(/^\/{1,}/, "");
-}
-function removeLeadingSlash(path2) {
-  return path2.replace(/^\//, "");
+	const len = arr.length;
+	const indexed = new Array(len);
+	for (let i = 0; i < len; i++) {
+		const item = arr[i];
+		const keys = new Array(accessors.length);
+		for (let j = 0; j < accessors.length; j++) keys[j] = accessors[j](item);
+		indexed[i] = {
+			item,
+			index: i,
+			keys
+		};
+	}
+	indexed.sort((a, b) => {
+		for (let j = 0; j < accessors.length; j++) {
+			const ao = a.keys[j];
+			const bo = b.keys[j];
+			if (typeof ao === "undefined") {
+				if (typeof bo === "undefined") continue;
+				return 1;
+			}
+			if (ao === bo) continue;
+			return ao > bo ? 1 : -1;
+		}
+		return a.index - b.index;
+	});
+	const result = new Array(len);
+	for (let i = 0; i < len; i++) result[i] = indexed[i].item;
+	return result;
+}
+function cleanPath(path) {
+	return path.replace(/\/{2,}/g, "/");
+}
+function trimPathLeft(path) {
+	return path === "/" ? path : path.replace(/^\/{1,}/, "");
+}
+function removeLeadingSlash(path) {
+	return path.replace(/^\//, "");
 }
 function removeTrailingSlash(s) {
-  return s.replace(/\/$/, "");
-}
-const BRACKET_CONTENT_RE = /\[(.*?)\]/g;
-const SPLIT_REGEX = new RegExp("(?<!\\[)\\.(?!\\])", "g");
-const DISALLOWED_ESCAPE_CHARS = /* @__PURE__ */ new Set([
-  "/",
-  "\\",
-  "?",
-  "#",
-  ":",
-  "*",
-  "<",
-  ">",
-  "|",
-  "!",
-  "$",
-  "%"
+	return s.replace(/\/$/, "");
+}
+var BRACKET_CONTENT_RE = /\[(.*?)\]/g;
+var SPLIT_REGEX = /(?<!\[)\.(?!\])/g;
+/**
+* Characters that cannot be escaped in square brackets.
+* These are characters that would cause issues in URLs or file systems.
+*/
+var DISALLOWED_ESCAPE_CHARS = new Set([
+	"/",
+	"\\",
+	"?",
+	"#",
+	":",
+	"*",
+	"<",
+	">",
+	"|",
+	"!",
+	"$",
+	"%"
 ]);
 function determineInitialRoutePath(routePath) {
-  const originalRoutePath = cleanPath(
-    `/${(cleanPath(routePath) || "").split(SPLIT_REGEX).join("/")}`
-  ) || "";
-  const parts = routePath.split(SPLIT_REGEX);
-  const escapedParts = parts.map((part) => {
-    let match;
-    while ((match = BRACKET_CONTENT_RE.exec(part)) !== null) {
-      const character = match[1];
-      if (character === void 0) continue;
-      if (DISALLOWED_ESCAPE_CHARS.has(character)) {
-        console.error(
-          `Error: Disallowed character "${character}" found in square brackets in route path "${routePath}".
-You cannot use any of the following characters in square brackets: ${Array.from(
-            DISALLOWED_ESCAPE_CHARS
-          ).join(", ")}
-Please remove and/or replace them.`
-        );
-        process.exit(1);
-      }
-    }
-    return part.replace(BRACKET_CONTENT_RE, "$1");
-  });
-  const final = cleanPath(`/${escapedParts.join("/")}`) || "";
-  return {
-    routePath: final,
-    originalRoutePath
-  };
-}
+	const originalRoutePath = cleanPath(`/${(cleanPath(routePath) || "").split(SPLIT_REGEX).join("/")}`) || "";
+	return {
+		routePath: cleanPath(`/${routePath.split(SPLIT_REGEX).map((part) => {
+			let match;
+			while ((match = BRACKET_CONTENT_RE.exec(part)) !== null) {
+				const character = match[1];
+				if (character === void 0) continue;
+				if (DISALLOWED_ESCAPE_CHARS.has(character)) {
+					console.error(`Error: Disallowed character "${character}" found in square brackets in route path "${routePath}".\nYou cannot use any of the following characters in square brackets: ${Array.from(DISALLOWED_ESCAPE_CHARS).join(", ")}\nPlease remove and/or replace them.`);
+					process.exit(1);
+				}
+			}
+			return part.replace(BRACKET_CONTENT_RE, "$1");
+		}).join("/")}`) || "",
+		originalRoutePath
+	};
+}
+/**
+* Checks if a segment is fully escaped (entirely wrapped in brackets with no nested brackets).
+* E.g., "[index]" -> true, "[_layout]" -> true, "foo[.]bar" -> false, "index" -> false
+*/
 function isFullyEscapedSegment(originalSegment) {
-  return originalSegment.startsWith("[") && originalSegment.endsWith("]") && !originalSegment.slice(1, -1).includes("[") && !originalSegment.slice(1, -1).includes("]");
-}
+	return originalSegment.startsWith("[") && originalSegment.endsWith("]") && !originalSegment.slice(1, -1).includes("[") && !originalSegment.slice(1, -1).includes("]");
+}
+/**
+* Checks if the leading underscore in a segment is escaped.
+* Returns true if:
+* - Segment starts with [_] pattern: "[_]layout" -> "_layout"
+* - Segment is fully escaped and content starts with _: "[_1nd3x]" -> "_1nd3x"
+*/
 function hasEscapedLeadingUnderscore(originalSegment) {
-  return originalSegment.startsWith("[_]") || originalSegment.startsWith("[_") && isFullyEscapedSegment(originalSegment);
-}
+	return originalSegment.startsWith("[_]") || originalSegment.startsWith("[_") && isFullyEscapedSegment(originalSegment);
+}
+/**
+* Checks if the trailing underscore in a segment is escaped.
+* Returns true if:
+* - Segment ends with [_] pattern: "blog[_]" -> "blog_"
+* - Segment is fully escaped and content ends with _: "[_r0ut3_]" -> "_r0ut3_"
+*/
 function hasEscapedTrailingUnderscore(originalSegment) {
-  return originalSegment.endsWith("[_]") || originalSegment.endsWith("_]") && isFullyEscapedSegment(originalSegment);
+	return originalSegment.endsWith("[_]") || originalSegment.endsWith("_]") && isFullyEscapedSegment(originalSegment);
 }
-const backslashRegex = /\\/g;
+var backslashRegex = /\\/g;
 function replaceBackslash(s) {
-  return s.replace(backslashRegex, "/");
-}
-const alphanumericRegex = /[a-zA-Z0-9_]/;
-const splatSlashRegex = /\/\$\//g;
-const trailingSplatRegex = /\$$/g;
-const bracketSplatRegex = /\$\{\$\}/g;
-const dollarSignRegex = /\$/g;
-const splitPathRegex = /[/-]/g;
-const leadingDigitRegex = /^(\d)/g;
-const toVariableSafeChar = (char) => {
-  if (alphanumericRegex.test(char)) {
-    return char;
-  }
-  switch (char) {
-    case ".":
-      return "Dot";
-    case "-":
-      return "Dash";
-    case "@":
-      return "At";
-    case "(":
-      return "";
-    // Removed since route groups use parentheses
-    case ")":
-      return "";
-    // Removed since route groups use parentheses
-    case " ":
-      return "";
-    // Remove spaces
-    default:
-      return `Char${char.charCodeAt(0)}`;
-  }
+	return s.replace(backslashRegex, "/");
+}
+var alphanumericRegex = /[a-zA-Z0-9_]/;
+var splatSlashRegex = /\/\$\//g;
+var trailingSplatRegex = /\$$/g;
+var bracketSplatRegex = /\$\{\$\}/g;
+var dollarSignRegex = /\$/g;
+var splitPathRegex = /[/-]/g;
+var leadingDigitRegex = /^(\d)/g;
+var toVariableSafeChar = (char) => {
+	if (alphanumericRegex.test(char)) return char;
+	switch (char) {
+		case ".": return "Dot";
+		case "-": return "Dash";
+		case "@": return "At";
+		case "(": return "";
+		case ")": return "";
+		case " ": return "";
+		default: return `Char${char.charCodeAt(0)}`;
+	}
 };
 function routePathToVariable(routePath) {
-  const cleaned = removeUnderscores(routePath);
-  if (!cleaned) return "";
-  const parts = cleaned.replace(splatSlashRegex, "/splat/").replace(trailingSplatRegex, "splat").replace(bracketSplatRegex, "splat").replace(dollarSignRegex, "").split(splitPathRegex);
-  let result = "";
-  for (let i = 0; i < parts.length; i++) {
-    const part = parts[i];
-    const segment = i > 0 ? capitalize(part) : part;
-    for (let j = 0; j < segment.length; j++) {
-      result += toVariableSafeChar(segment[j]);
-    }
-  }
-  return result.replace(leadingDigitRegex, "R$1");
-}
-const underscoreStartEndRegex = /(^_|_$)/gi;
-const underscoreSlashRegex = /(\/_|_\/)/gi;
+	const cleaned = removeUnderscores(routePath);
+	if (!cleaned) return "";
+	const parts = cleaned.replace(splatSlashRegex, "/splat/").replace(trailingSplatRegex, "splat").replace(bracketSplatRegex, "splat").replace(dollarSignRegex, "").split(splitPathRegex);
+	let result = "";
+	for (let i = 0; i < parts.length; i++) {
+		const part = parts[i];
+		const segment = i > 0 ? capitalize(part) : part;
+		for (let j = 0; j < segment.length; j++) result += toVariableSafeChar(segment[j]);
+	}
+	return result.replace(leadingDigitRegex, "R$1");
+}
+var underscoreStartEndRegex = /(^_|_$)/gi;
+var underscoreSlashRegex = /(\/_|_\/)/gi;
 function removeUnderscores(s) {
-  return s?.replace(underscoreStartEndRegex, "").replace(underscoreSlashRegex, "/");
-}
+	return s?.replace(underscoreStartEndRegex, "").replace(underscoreSlashRegex, "/");
+}
+/**
+* Removes underscores from a path, but preserves underscores that were escaped
+* in the original path (indicated by [_] syntax).
+*
+* @param routePath - The path with brackets removed
+* @param originalPath - The original path that may contain [_] escape sequences
+* @returns The path with non-escaped underscores removed
+*/
 function removeUnderscoresWithEscape(routePath, originalPath) {
-  if (!routePath) return "";
-  if (!originalPath) return removeUnderscores(routePath) ?? "";
-  const routeSegments = routePath.split("/");
-  const originalSegments = originalPath.split("/");
-  const newSegments = routeSegments.map((segment, i) => {
-    const originalSegment = originalSegments[i] || "";
-    const leadingEscaped = hasEscapedLeadingUnderscore(originalSegment);
-    const trailingEscaped = hasEscapedTrailingUnderscore(originalSegment);
-    let result = segment;
-    if (result.startsWith("_") && !leadingEscaped) {
-      result = result.slice(1);
-    }
-    if (result.endsWith("_") && !trailingEscaped) {
-      result = result.slice(0, -1);
-    }
-    return result;
-  });
-  return newSegments.join("/");
-}
+	if (!routePath) return "";
+	if (!originalPath) return removeUnderscores(routePath) ?? "";
+	const routeSegments = routePath.split("/");
+	const originalSegments = originalPath.split("/");
+	return routeSegments.map((segment, i) => {
+		const originalSegment = originalSegments[i] || "";
+		const leadingEscaped = hasEscapedLeadingUnderscore(originalSegment);
+		const trailingEscaped = hasEscapedTrailingUnderscore(originalSegment);
+		let result = segment;
+		if (result.startsWith("_") && !leadingEscaped) result = result.slice(1);
+		if (result.endsWith("_") && !trailingEscaped) result = result.slice(0, -1);
+		return result;
+	}).join("/");
+}
+/**
+* Removes layout segments (segments starting with underscore) from a path,
+* but preserves segments where the underscore was escaped.
+*
+* @param routePath - The path with brackets removed
+* @param originalPath - The original path that may contain [_] escape sequences
+* @returns The path with non-escaped layout segments removed
+*/
 function removeLayoutSegmentsWithEscape(routePath = "/", originalPath) {
-  if (!originalPath) return removeLayoutSegments(routePath);
-  const routeSegments = routePath.split("/");
-  const originalSegments = originalPath.split("/");
-  const newSegments = routeSegments.filter((segment, i) => {
-    const originalSegment = originalSegments[i] || "";
-    return !isSegmentPathless(segment, originalSegment);
-  });
-  return newSegments.join("/");
-}
+	if (!originalPath) return removeLayoutSegments(routePath);
+	const routeSegments = routePath.split("/");
+	const originalSegments = originalPath.split("/");
+	return routeSegments.filter((segment, i) => {
+		return !isSegmentPathless(segment, originalSegments[i] || "");
+	}).join("/");
+}
+/**
+* Checks if a segment should be treated as a pathless/layout segment.
+* A segment is pathless if it starts with underscore and the underscore is not escaped.
+*
+* @param segment - The segment from routePath (brackets removed)
+* @param originalSegment - The segment from originalRoutePath (may contain brackets)
+* @returns true if the segment is pathless (has non-escaped leading underscore)
+*/
 function isSegmentPathless(segment, originalSegment) {
-  if (!segment.startsWith("_")) return false;
-  return !hasEscapedLeadingUnderscore(originalSegment);
+	if (!segment.startsWith("_")) return false;
+	return !hasEscapedLeadingUnderscore(originalSegment);
 }
 function escapeRegExp(s) {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function sanitizeTokenFlags(flags) {
-  if (!flags) return flags;
-  return flags.replace(/[gy]/g, "");
+	if (!flags) return flags;
+	return flags.replace(/[gy]/g, "");
 }
 function createTokenRegex(token, opts) {
-  if (token === void 0 || token === null) {
-    throw new Error(
-      `createTokenRegex: token is ${token}. This usually means the config was not properly parsed with defaults.`
-    );
-  }
-  try {
-    if (typeof token === "string") {
-      return opts.type === "segment" ? new RegExp(`^${escapeRegExp(token)}$`) : new RegExp(`[./]${escapeRegExp(token)}[.]`);
-    }
-    if (token instanceof RegExp) {
-      const flags = sanitizeTokenFlags(token.flags);
-      return opts.type === "segment" ? new RegExp(`^(?:${token.source})$`, flags) : new RegExp(`[./](?:${token.source})[.]`, flags);
-    }
-    if (typeof token === "object" && "regex" in token) {
-      const flags = sanitizeTokenFlags(token.flags);
-      return opts.type === "segment" ? new RegExp(`^(?:${token.regex})$`, flags) : new RegExp(`[./](?:${token.regex})[.]`, flags);
-    }
-    throw new Error(
-      `createTokenRegex: invalid token type. Expected string, RegExp, or { regex, flags } object, got: ${typeof token}`
-    );
-  } catch (e) {
-    if (e instanceof SyntaxError) {
-      const pattern = typeof token === "string" ? token : token instanceof RegExp ? token.source : token.regex;
-      throw new Error(
-        `Invalid regex pattern in token config: "${pattern}". ${e.message}`
-      );
-    }
-    throw e;
-  }
+	if (token === void 0 || token === null) throw new Error(`createTokenRegex: token is ${token}. This usually means the config was not properly parsed with defaults.`);
+	try {
+		if (typeof token === "string") return opts.type === "segment" ? new RegExp(`^${escapeRegExp(token)}$`) : new RegExp(`[./]${escapeRegExp(token)}[.]`);
+		if (token instanceof RegExp) {
+			const flags = sanitizeTokenFlags(token.flags);
+			return opts.type === "segment" ? new RegExp(`^(?:${token.source})$`, flags) : new RegExp(`[./](?:${token.source})[.]`, flags);
+		}
+		if (typeof token === "object" && "regex" in token) {
+			const flags = sanitizeTokenFlags(token.flags);
+			return opts.type === "segment" ? new RegExp(`^(?:${token.regex})$`, flags) : new RegExp(`[./](?:${token.regex})[.]`, flags);
+		}
+		throw new Error(`createTokenRegex: invalid token type. Expected string, RegExp, or { regex, flags } object, got: ${typeof token}`);
+	} catch (e) {
+		if (e instanceof SyntaxError) {
+			const pattern = typeof token === "string" ? token : token instanceof RegExp ? token.source : token.regex;
+			throw new Error(`Invalid regex pattern in token config: "${pattern}". ${e.message}`);
+		}
+		throw e;
+	}
 }
 function isBracketWrappedSegment(segment) {
-  return segment.startsWith("[") && segment.endsWith("]");
+	return segment.startsWith("[") && segment.endsWith("]");
 }
 function unwrapBracketWrappedSegment(segment) {
-  return isBracketWrappedSegment(segment) ? segment.slice(1, -1) : segment;
+	return isBracketWrappedSegment(segment) ? segment.slice(1, -1) : segment;
 }
 function capitalize(s) {
-  if (typeof s !== "string") return "";
-  return s.charAt(0).toUpperCase() + s.slice(1);
+	if (typeof s !== "string") return "";
+	return s.charAt(0).toUpperCase() + s.slice(1);
 }
 function removeExt(d, addExtensions = false) {
-  if (typeof addExtensions === "string") {
-    const dotIndex = d.lastIndexOf(".");
-    if (dotIndex === -1) return d;
-    return d.substring(0, dotIndex) + addExtensions;
-  }
-  return addExtensions ? d : d.substring(0, d.lastIndexOf(".")) || d;
-}
+	if (typeof addExtensions === "string") {
+		const dotIndex = d.lastIndexOf(".");
+		if (dotIndex === -1) return d;
+		return d.substring(0, dotIndex) + addExtensions;
+	}
+	return addExtensions ? d : d.substring(0, d.lastIndexOf(".")) || d;
+}
+/**
+* This function writes to a file if the content is different.
+*
+* @param filepath The path to the file
+* @param content Original content
+* @param incomingContent New content
+* @param callbacks Callbacks to run before and after writing
+* @returns Whether the file was written
+*/
 async function writeIfDifferent(filepath, content, incomingContent, callbacks) {
-  if (content !== incomingContent) {
-    callbacks?.beforeWrite?.();
-    await fsp.writeFile(filepath, incomingContent);
-    callbacks?.afterWrite?.();
-    return true;
-  }
-  return false;
-}
+	if (content !== incomingContent) {
+		callbacks?.beforeWrite?.();
+		await fsp.writeFile(filepath, incomingContent);
+		callbacks?.afterWrite?.();
+		return true;
+	}
+	return false;
+}
+/**
+* This function formats the source code using the default formatter (Prettier).
+*
+* @param source The content to format
+* @param config The configuration object
+* @returns The formatted content
+*/
 async function format(source, config) {
-  const prettierOptions = {
-    semi: config.semicolons,
-    singleQuote: config.quoteStyle === "single",
-    parser: "typescript"
-  };
-  return prettier.format(source, prettierOptions);
-}
+	const prettierOptions = {
+		semi: config.semicolons,
+		singleQuote: config.quoteStyle === "single",
+		parser: "typescript"
+	};
+	return prettier.format(source, prettierOptions);
+}
+/**
+* This function resets the regex index to 0 so that it can be reused
+* without having to create a new regex object or worry about the last
+* state when using the global flag.
+*
+* @param regex The regex object to reset
+* @returns
+*/
 function resetRegex(regex) {
-  regex.lastIndex = 0;
-  return;
-}
+	regex.lastIndex = 0;
+}
+/**
+* This function checks if a file exists.
+*
+* @param file The path to the file
+* @returns Whether the file exists
+*/
 async function checkFileExists(file) {
-  try {
-    await fsp.access(file, fsp.constants.F_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-const possiblyNestedRouteGroupPatternRegex = /\([^/]+\)\/?/g;
+	try {
+		await fsp.access(file, fsp.constants.F_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+var possiblyNestedRouteGroupPatternRegex = /\([^/]+\)\/?/g;
 function removeGroups(s) {
-  return s.replace(possiblyNestedRouteGroupPatternRegex, "");
-}
+	return s.replace(possiblyNestedRouteGroupPatternRegex, "");
+}
+/**
+* Removes all segments from a given path that start with an underscore ('_').
+*
+* @param {string} routePath - The path from which to remove segments. Defaults to '/'.
+* @returns {string} The path with all underscore-prefixed segments removed.
+* @example
+* removeLayoutSegments('/workspace/_auth/foo') // '/workspace/foo'
+*/
 function removeLayoutSegments(routePath = "/") {
-  const segments = routePath.split("/");
-  const newSegments = segments.filter((segment) => !segment.startsWith("_"));
-  return newSegments.join("/");
-}
+	return routePath.split("/").filter((segment) => !segment.startsWith("_")).join("/");
+}
+/**
+* The `node.path` is used as the `id` in the route definition.
+* This function checks if the given node has a parent and if so, it determines the correct path for the given node.
+* @param node - The node to determine the path for.
+* @returns The correct path for the given node.
+*/
 function determineNodePath(node) {
-  return node.path = node.parent ? node.routePath?.replace(node.parent.routePath ?? "", "") || "/" : node.routePath;
-}
+	return node.path = node.parent ? node.routePath?.replace(node.parent.routePath ?? "", "") || "/" : node.routePath;
+}
+/**
+* Removes the last segment from a given path. Segments are considered to be separated by a '/'.
+*
+* @param {string} routePath - The path from which to remove the last segment. Defaults to '/'.
+* @returns {string} The path with the last segment removed.
+* @example
+* removeLastSegmentFromPath('/workspace/_auth/foo') // '/workspace/_auth'
+*/
 function removeLastSegmentFromPath(routePath = "/") {
-  const segments = routePath.split("/");
-  segments.pop();
-  return segments.join("/");
+	const segments = routePath.split("/");
+	segments.pop();
+	return segments.join("/");
 }
+/**
+* Find parent route using RoutePrefixMap for O(k) lookups instead of O(n).
+*/
 function hasParentRoute(prefixMap, node, routePathToCheck) {
-  if (!routePathToCheck || routePathToCheck === "/") {
-    return null;
-  }
-  return prefixMap.findParent(routePathToCheck);
-}
-const getResolvedRouteNodeVariableName = (routeNode) => {
-  return routeNode.children?.length ? `${routeNode.variableName}RouteWithChildren` : `${routeNode.variableName}Route`;
+	if (!routePathToCheck || routePathToCheck === "/") return null;
+	return prefixMap.findParent(routePathToCheck);
+}
+/**
+* Gets the final variable name for a route
+*/
+var getResolvedRouteNodeVariableName = (routeNode) => {
+	return routeNode.children?.length ? `${routeNode.variableName}RouteWithChildren` : `${routeNode.variableName}Route`;
 };
+/**
+* Checks if a given RouteNode is valid for augmenting it with typing based on conditions.
+* Also asserts that the RouteNode is defined.
+*
+* @param routeNode - The RouteNode to check.
+* @returns A boolean indicating whether the RouteNode is defined.
+*/
 function isRouteNodeValidForAugmentation(routeNode) {
-  if (!routeNode || routeNode.isVirtual) {
-    return false;
-  }
-  return true;
-}
-const inferPath = (routeNode) => {
-  if (routeNode.cleanedPath === "/") {
-    return routeNode.cleanedPath ?? "";
-  }
-  return routeNode.cleanedPath?.replace(/\/$/, "") ?? "";
+	if (!routeNode || routeNode.isVirtual) return false;
+	return true;
+}
+/**
+* Infers the path for use by TS
+*/
+var inferPath = (routeNode) => {
+	if (routeNode.cleanedPath === "/") return routeNode.cleanedPath ?? "";
+	return routeNode.cleanedPath?.replace(/\/$/, "") ?? "";
 };
-const inferFullPath = (routeNode) => {
-  const fullPath = removeGroups(
-    removeUnderscoresWithEscape(
-      removeLayoutSegmentsWithEscape(
-        routeNode.routePath,
-        routeNode.originalRoutePath
-      ),
-      routeNode.originalRoutePath
-    )
-  );
-  if (fullPath === "") {
-    return "/";
-  }
-  const isIndexRoute = routeNode.routePath?.endsWith("/");
-  if (isIndexRoute) {
-    return fullPath;
-  }
-  return fullPath.replace(/\/$/, "");
+/**
+* Infers the full path for use by TS
+*/
+var inferFullPath = (routeNode) => {
+	const fullPath = removeGroups(removeUnderscoresWithEscape(removeLayoutSegmentsWithEscape(routeNode.routePath, routeNode.originalRoutePath), routeNode.originalRoutePath));
+	if (fullPath === "") return "/";
+	if (routeNode.routePath?.endsWith("/")) return fullPath;
+	return fullPath.replace(/\/$/, "");
 };
-const shouldPreferIndexRoute = (current, existing) => {
-  return existing.cleanedPath === "/" && current.cleanedPath !== "/";
+var shouldPreferIndexRoute = (current, existing) => {
+	return existing.cleanedPath === "/" && current.cleanedPath !== "/";
 };
-const createRouteNodesByFullPath = (routeNodes) => {
-  const map = /* @__PURE__ */ new Map();
-  for (const routeNode of routeNodes) {
-    const fullPath = inferFullPath(routeNode);
-    if (fullPath === "/" && map.has("/")) {
-      const existing = map.get("/");
-      if (shouldPreferIndexRoute(routeNode, existing)) {
-        continue;
-      }
-    }
-    map.set(fullPath, routeNode);
-  }
-  return map;
+/**
+* Creates a map from fullPath to routeNode
+*/
+var createRouteNodesByFullPath = (routeNodes) => {
+	const map = /* @__PURE__ */ new Map();
+	for (const routeNode of routeNodes) {
+		const fullPath = inferFullPath(routeNode);
+		if (fullPath === "/" && map.has("/")) {
+			if (shouldPreferIndexRoute(routeNode, map.get("/"))) continue;
+		}
+		map.set(fullPath, routeNode);
+	}
+	return map;
 };
-const createRouteNodesByTo = (routeNodes) => {
-  const map = /* @__PURE__ */ new Map();
-  for (const routeNode of dedupeBranchesAndIndexRoutes(routeNodes)) {
-    const to = inferTo(routeNode);
-    if (to === "/" && map.has("/")) {
-      const existing = map.get("/");
-      if (shouldPreferIndexRoute(routeNode, existing)) {
-        continue;
-      }
-    }
-    map.set(to, routeNode);
-  }
-  return map;
+/**
+* Create a map from 'to' to a routeNode
+*/
+var createRouteNodesByTo = (routeNodes) => {
+	const map = /* @__PURE__ */ new Map();
+	for (const routeNode of dedupeBranchesAndIndexRoutes(routeNodes)) {
+		const to = inferTo(routeNode);
+		if (to === "/" && map.has("/")) {
+			if (shouldPreferIndexRoute(routeNode, map.get("/"))) continue;
+		}
+		map.set(to, routeNode);
+	}
+	return map;
 };
-const createRouteNodesById = (routeNodes) => {
-  return new Map(
-    routeNodes.map((routeNode) => {
-      const id = routeNode.routePath ?? "";
-      return [id, routeNode];
-    })
-  );
+/**
+* Create a map from 'id' to a routeNode
+*/
+var createRouteNodesById = (routeNodes) => {
+	return new Map(routeNodes.map((routeNode) => {
+		return [routeNode.routePath ?? "", routeNode];
+	}));
 };
-const inferTo = (routeNode) => {
-  const fullPath = inferFullPath(routeNode);
-  if (fullPath === "/") return fullPath;
-  return fullPath.replace(/\/$/, "");
+/**
+* Infers to path
+*/
+var inferTo = (routeNode) => {
+	const fullPath = inferFullPath(routeNode);
+	if (fullPath === "/") return fullPath;
+	return fullPath.replace(/\/$/, "");
 };
-const dedupeBranchesAndIndexRoutes = (routes) => {
-  return routes.filter((route) => {
-    if (route.children?.find((child) => child.cleanedPath === "/")) return false;
-    return true;
-  });
+/**
+* Dedupes branches and index routes
+*/
+var dedupeBranchesAndIndexRoutes = (routes) => {
+	return routes.filter((route) => {
+		if (route.children?.find((child) => child.cleanedPath === "/")) return false;
+		return true;
+	});
 };
 function checkUnique(routes, key) {
-  const keys = routes.map((d) => d[key]);
-  const uniqueKeys = new Set(keys);
-  if (keys.length !== uniqueKeys.size) {
-    const duplicateKeys = keys.filter((d, i) => keys.indexOf(d) !== i);
-    const conflictingFiles = routes.filter(
-      (d) => duplicateKeys.includes(d[key])
-    );
-    return conflictingFiles;
-  }
-  return void 0;
+	const keys = routes.map((d) => d[key]);
+	const uniqueKeys = new Set(keys);
+	if (keys.length !== uniqueKeys.size) {
+		const duplicateKeys = keys.filter((d, i) => keys.indexOf(d) !== i);
+		return routes.filter((d) => duplicateKeys.includes(d[key]));
+	}
 }
 function checkRouteFullPathUniqueness(_routes, config) {
-  const emptyPathRoutes = _routes.filter((d) => d.routePath === "");
-  if (emptyPathRoutes.length) {
-    const errorMessage = `Invalid route path "" was found. Root routes must be defined via __root.tsx (createRootRoute), not createFileRoute('') or a route file that resolves to an empty path.
-Conflicting files: 
- ${emptyPathRoutes.map((d) => path.resolve(config.routesDirectory, d.filePath)).join("\n ")}
-`;
-    throw new Error(errorMessage);
-  }
-  const routes = _routes.map((d) => {
-    const inferredFullPath = inferFullPath(d);
-    return { ...d, inferredFullPath };
-  });
-  const conflictingFiles = checkUnique(routes, "inferredFullPath");
-  if (conflictingFiles !== void 0) {
-    const errorMessage = `Conflicting configuration paths were found for the following route${conflictingFiles.length > 1 ? "s" : ""}: ${conflictingFiles.map((p) => `"${p.inferredFullPath}"`).join(", ")}.
+	const emptyPathRoutes = _routes.filter((d) => d.routePath === "");
+	if (emptyPathRoutes.length) {
+		const errorMessage = `Invalid route path "" was found. Root routes must be defined via __root.tsx (createRootRoute), not createFileRoute('') or a route file that resolves to an empty path.
+Conflicting files: \n ${emptyPathRoutes.map((d) => path.resolve(config.routesDirectory, d.filePath)).join("\n ")}\n`;
+		throw new Error(errorMessage);
+	}
+	const conflictingFiles = checkUnique(_routes.map((d) => {
+		const inferredFullPath = inferFullPath(d);
+		return {
+			...d,
+			inferredFullPath
+		};
+	}), "inferredFullPath");
+	if (conflictingFiles !== void 0) {
+		const errorMessage = `Conflicting configuration paths were found for the following route${conflictingFiles.length > 1 ? "s" : ""}: ${conflictingFiles.map((p) => `"${p.inferredFullPath}"`).join(", ")}.
 Please ensure each Route has a unique full path.
-Conflicting files: 
- ${conflictingFiles.map((d) => path.resolve(config.routesDirectory, d.filePath)).join("\n ")}
-`;
-    throw new Error(errorMessage);
-  }
+Conflicting files: \n ${conflictingFiles.map((d) => path.resolve(config.routesDirectory, d.filePath)).join("\n ")}\n`;
+		throw new Error(errorMessage);
+	}
 }
 function buildRouteTreeConfig(nodes, disableTypes, depth = 1) {
-  const children = nodes.map((node) => {
-    if (node._fsRouteType === "__root") {
-      return;
-    }
-    if (node._fsRouteType === "pathless_layout" && !node.children?.length) {
-      return;
-    }
-    const route = `${node.variableName}`;
-    if (node.children?.length) {
-      const childConfigs = buildRouteTreeConfig(
-        node.children,
-        disableTypes,
-        depth + 1
-      );
-      const childrenDeclaration = disableTypes ? "" : `interface ${route}RouteChildren {
-  ${node.children.map(
-        (child) => `${child.variableName}Route: typeof ${getResolvedRouteNodeVariableName(child)}`
-      ).join(",")}
+	return nodes.map((node) => {
+		if (node._fsRouteType === "__root") return;
+		if (node._fsRouteType === "pathless_layout" && !node.children?.length) return;
+		const route = `${node.variableName}`;
+		if (node.children?.length) {
+			const childConfigs = buildRouteTreeConfig(node.children, disableTypes, depth + 1);
+			const childrenDeclaration = disableTypes ? "" : `interface ${route}RouteChildren {
+  ${node.children.map((child) => `${child.variableName}Route: typeof ${getResolvedRouteNodeVariableName(child)}`).join(",")}
 }`;
-      const children2 = `const ${route}RouteChildren${disableTypes ? "" : `: ${route}RouteChildren`} = {
-  ${node.children.map(
-        (child) => `${child.variableName}Route: ${getResolvedRouteNodeVariableName(child)}`
-      ).join(",")}
+			const children = `const ${route}RouteChildren${disableTypes ? "" : `: ${route}RouteChildren`} = {
+  ${node.children.map((child) => `${child.variableName}Route: ${getResolvedRouteNodeVariableName(child)}`).join(",")}
 }`;
-      const routeWithChildren = `const ${route}RouteWithChildren = ${route}Route._addFileChildren(${route}RouteChildren)`;
-      return [
-        childConfigs.join("\n"),
-        childrenDeclaration,
-        children2,
-        routeWithChildren
-      ].join("\n\n");
-    }
-    return void 0;
-  });
-  return children.filter((x) => x !== void 0);
+			const routeWithChildren = `const ${route}RouteWithChildren = ${route}Route._addFileChildren(${route}RouteChildren)`;
+			return [
+				childConfigs.join("\n"),
+				childrenDeclaration,
+				children,
+				routeWithChildren
+			].join("\n\n");
+		}
+	}).filter((x) => x !== void 0);
 }
 function buildImportString(importDeclaration) {
-  const { source, specifiers, importKind } = importDeclaration;
-  return specifiers.length ? `import ${importKind === "type" ? "type " : ""}{ ${specifiers.map((s) => s.local ? `${s.imported} as ${s.local}` : s.imported).join(", ")} } from '${source}'` : "";
+	const { source, specifiers, importKind } = importDeclaration;
+	return specifiers.length ? `import ${importKind === "type" ? "type " : ""}{ ${specifiers.map((s) => s.local ? `${s.imported} as ${s.local}` : s.imported).join(", ")} } from '${source}'` : "";
 }
 function mergeImportDeclarations(imports) {
-  const merged = /* @__PURE__ */ new Map();
-  for (const imp of imports) {
-    const key = `${imp.source}-${imp.importKind ?? ""}`;
-    let existing = merged.get(key);
-    if (!existing) {
-      existing = { ...imp, specifiers: [] };
-      merged.set(key, existing);
-    }
-    const existingSpecs = existing.specifiers;
-    for (const specifier of imp.specifiers) {
-      let found = false;
-      for (let i = 0; i < existingSpecs.length; i++) {
-        const e = existingSpecs[i];
-        if (e.imported === specifier.imported && e.local === specifier.local) {
-          found = true;
-          break;
-        }
-      }
-      if (!found) {
-        existingSpecs.push(specifier);
-      }
-    }
-  }
-  return [...merged.values()];
-}
-const findParent = (node) => {
-  if (!node) {
-    return `rootRouteImport`;
-  }
-  if (node.parent) {
-    return `${node.parent.variableName}Route`;
-  }
-  return findParent(node.parent);
+	const merged = /* @__PURE__ */ new Map();
+	for (const imp of imports) {
+		const key = `${imp.source}-${imp.importKind ?? ""}`;
+		let existing = merged.get(key);
+		if (!existing) {
+			existing = {
+				...imp,
+				specifiers: []
+			};
+			merged.set(key, existing);
+		}
+		const existingSpecs = existing.specifiers;
+		for (const specifier of imp.specifiers) {
+			let found = false;
+			for (let i = 0; i < existingSpecs.length; i++) {
+				const e = existingSpecs[i];
+				if (e.imported === specifier.imported && e.local === specifier.local) {
+					found = true;
+					break;
+				}
+			}
+			if (!found) existingSpecs.push(specifier);
+		}
+	}
+	return [...merged.values()];
+}
+var findParent = (node) => {
+	if (!node) return `rootRouteImport`;
+	if (node.parent) return `${node.parent.variableName}Route`;
+	return findParent(node.parent);
 };
 function buildFileRoutesByPathInterface(opts) {
-  return `declare module '${opts.module}' {
+	return `declare module '${opts.module}' {
   interface ${opts.interfaceName} {
     ${opts.routeNodes.map((routeNode) => {
-    const filePathId = routeNode.routePath;
-    const preloaderRoute = `typeof ${routeNode.variableName}RouteImport`;
-    const parent = findParent(routeNode);
-    return `'${filePathId}': {
+		const filePathId = routeNode.routePath;
+		const preloaderRoute = `typeof ${routeNode.variableName}RouteImport`;
+		const parent = findParent(routeNode);
+		return `'${filePathId}': {
           id: '${filePathId}'
           path: '${inferPath(routeNode)}'
           fullPath: '${inferFullPath(routeNode)}'
           preLoaderRoute: ${preloaderRoute}
           parentRoute: typeof ${parent}
         }`;
-  }).join("\n")}
+	}).join("\n")}
   }
 }`;
 }
 function getImportPath(node, config, generatedRouteTreePath) {
-  return replaceBackslash(
-    removeExt(
-      path.relative(
-        path.dirname(generatedRouteTreePath),
-        path.resolve(config.routesDirectory, node.filePath)
-      ),
-      config.addExtensions
-    )
-  );
+	return replaceBackslash(removeExt(path.relative(path.dirname(generatedRouteTreePath), path.resolve(config.routesDirectory, node.filePath)), config.addExtensions));
 }
 function getImportForRouteNode(node, config, generatedRouteTreePath, root) {
-  let source = "";
-  if (config.importRoutesUsingAbsolutePaths) {
-    source = replaceBackslash(
-      removeExt(
-        path.resolve(root, config.routesDirectory, node.filePath),
-        config.addExtensions
-      )
-    );
-  } else {
-    source = `./${getImportPath(node, config, generatedRouteTreePath)}`;
-  }
-  return {
-    source,
-    specifiers: [
-      {
-        imported: "Route",
-        local: `${node.variableName}RouteImport`
-      }
-    ]
-  };
-}
-export {
-  RoutePrefixMap,
-  buildFileRoutesByPathInterface,
-  buildImportString,
-  buildRouteTreeConfig,
-  capitalize,
-  checkFileExists,
-  checkRouteFullPathUniqueness,
-  cleanPath,
-  createRouteNodesByFullPath,
-  createRouteNodesById,
-  createRouteNodesByTo,
-  createTokenRegex,
-  dedupeBranchesAndIndexRoutes,
-  determineInitialRoutePath,
-  determineNodePath,
-  findParent,
-  format,
-  getImportForRouteNode,
-  getImportPath,
-  getResolvedRouteNodeVariableName,
-  hasEscapedLeadingUnderscore,
-  hasEscapedTrailingUnderscore,
-  hasParentRoute,
-  inferFullPath,
-  inferPath,
-  inferTo,
-  isBracketWrappedSegment,
-  isRouteNodeValidForAugmentation,
-  isSegmentPathless,
-  mergeImportDeclarations,
-  multiSortBy,
-  removeExt,
-  removeGroups,
-  removeLastSegmentFromPath,
-  removeLayoutSegments,
-  removeLayoutSegmentsWithEscape,
-  removeLeadingSlash,
-  removeTrailingSlash,
-  removeUnderscores,
-  removeUnderscoresWithEscape,
-  replaceBackslash,
-  resetRegex,
-  routePathToVariable,
-  trimPathLeft,
-  unwrapBracketWrappedSegment,
-  writeIfDifferent
-};
-//# sourceMappingURL=utils.js.map
+	let source = "";
+	if (config.importRoutesUsingAbsolutePaths) source = replaceBackslash(removeExt(path.resolve(root, config.routesDirectory, node.filePath), config.addExtensions));
+	else source = `./${getImportPath(node, config, generatedRouteTreePath)}`;
+	return {
+		source,
+		specifiers: [{
+			imported: "Route",
+			local: `${node.variableName}RouteImport`
+		}]
+	};
+}
+//#endregion
+export { RoutePrefixMap, buildFileRoutesByPathInterface, buildImportString, buildRouteTreeConfig, capitalize, checkFileExists, checkRouteFullPathUniqueness, cleanPath, createRouteNodesByFullPath, createRouteNodesById, createRouteNodesByTo, createTokenRegex, determineInitialRoutePath, determineNodePath, findParent, format, getImportForRouteNode, getImportPath, getResolvedRouteNodeVariableName, hasEscapedLeadingUnderscore, hasParentRoute, inferFullPath, isRouteNodeValidForAugmentation, isSegmentPathless, mergeImportDeclarations, multiSortBy, removeExt, removeGroups, removeLastSegmentFromPath, removeLayoutSegmentsWithEscape, removeLeadingSlash, removeTrailingSlash, removeUnderscores, removeUnderscoresWithEscape, replaceBackslash, resetRegex, routePathToVariable, trimPathLeft, unwrapBracketWrappedSegment, writeIfDifferent };
+
+//# sourceMappingURL=utils.js.map