@tanstack/router-core 1.171.17 → 1.171.18

package/dist/cjs/new-process-route-tree.cjs

@@ -115,14 +115,15 @@ function parseSegment(path, start, output = new Uint16Array(6)) {
 * @param node The current segment node in the trie to populate.
 * @param onRoute Callback invoked for each route processed.
 */
-function parseSegments(defaultCaseSensitive, data, route, start, node, depth, onRoute) {
+function parseSegments(defaultCaseSensitive, data, route, start, node, depth, dynamicListsToSort, onRoute) {
 	onRoute?.(route);
 	let cursor = start;
 	{
 		const path = route.fullPath ?? route.from;
+		const options = route.options;
 		const length = path.length;
-		const caseSensitive = route.options?.caseSensitive ?? defaultCaseSensitive;
-		const parseParams = route.options?.params?.parse ?? route.options?.parseParams;
+		const caseSensitive = options?.caseSensitive ?? defaultCaseSensitive;
+		const parseParams = options?.params?.parse ?? options?.parseParams;
 		while (cursor < length) {
 			const segment = parseSegment(path, cursor, data);
 			let nextNode;
@@ -130,89 +131,58 @@ function parseSegments(defaultCaseSensitive, data, route, start, node, depth, on
 			const end = segment[5];
 			cursor = end + 1;
 			depth++;
-			switch (segment[0]) {
+			const kind = segment[0];
+			switch (kind) {
 				case 0: {
 					const value = path.substring(segment[2], segment[3]);
-					if (caseSensitive) {
-						const existingNode = node.static?.get(value);
-						if (existingNode) nextNode = existingNode;
-						else {
-							node.static ??= /* @__PURE__ */ new Map();
-							const next = createStaticNode(route.fullPath ?? route.from);
-							next.parent = node;
-							next.depth = depth;
-							nextNode = next;
-							node.static.set(value, next);
-						}
-					} else {
-						const name = value.toLowerCase();
-						const existingNode = node.staticInsensitive?.get(name);
-						if (existingNode) nextNode = existingNode;
-						else {
-							node.staticInsensitive ??= /* @__PURE__ */ new Map();
-							const next = createStaticNode(route.fullPath ?? route.from);
-							next.parent = node;
-							next.depth = depth;
-							nextNode = next;
-							node.staticInsensitive.set(name, next);
-						}
+					let name = value;
+					let staticChildren;
+					if (caseSensitive) staticChildren = node.static ??= /* @__PURE__ */ new Map();
+					else {
+						name = value.toLowerCase();
+						staticChildren = node.staticInsensitive ??= /* @__PURE__ */ new Map();
 					}
-					break;
-				}
-				case 1: {
-					const prefix_raw = path.substring(start, segment[1]);
-					const suffix_raw = path.substring(segment[4], end);
-					const actuallyCaseSensitive = caseSensitive && !!(prefix_raw || suffix_raw);
-					const prefix = !prefix_raw ? void 0 : actuallyCaseSensitive ? prefix_raw : prefix_raw.toLowerCase();
-					const suffix = !suffix_raw ? void 0 : actuallyCaseSensitive ? suffix_raw : suffix_raw.toLowerCase();
-					const existingNode = !parseParams && node.dynamic?.find((s) => !s.parse && s.caseSensitive === actuallyCaseSensitive && s.prefix === prefix && s.suffix === suffix);
+					const existingNode = staticChildren.get(name);
 					if (existingNode) nextNode = existingNode;
 					else {
-						const next = createDynamicNode(1, route.fullPath ?? route.from, actuallyCaseSensitive, prefix, suffix);
-						nextNode = next;
-						next.depth = depth;
+						const next = createStaticNode(path);
 						next.parent = node;
-						node.dynamic ??= [];
-						node.dynamic.push(next);
+						next.depth = depth;
+						nextNode = next;
+						staticChildren.set(name, next);
 					}
 					break;
 				}
-				case 3: {
+				case 1:
+				case 3:
+				case 2: {
 					const prefix_raw = path.substring(start, segment[1]);
 					const suffix_raw = path.substring(segment[4], end);
 					const actuallyCaseSensitive = caseSensitive && !!(prefix_raw || suffix_raw);
 					const prefix = !prefix_raw ? void 0 : actuallyCaseSensitive ? prefix_raw : prefix_raw.toLowerCase();
 					const suffix = !suffix_raw ? void 0 : actuallyCaseSensitive ? suffix_raw : suffix_raw.toLowerCase();
-					const existingNode = !parseParams && node.optional?.find((s) => !s.parse && s.caseSensitive === actuallyCaseSensitive && s.prefix === prefix && s.suffix === suffix);
+					const siblings = kind === 1 ? node.dynamic : kind === 3 ? node.optional : node.wildcard;
+					const existingNode = kind !== 2 && !parseParams && siblings?.find((s) => !s.parse && s.caseSensitive === actuallyCaseSensitive && s.prefix === prefix && s.suffix === suffix);
 					if (existingNode) nextNode = existingNode;
 					else {
-						const next = createDynamicNode(3, route.fullPath ?? route.from, actuallyCaseSensitive, prefix, suffix);
+						const next = createDynamicNode(kind, path, actuallyCaseSensitive, prefix, suffix);
 						nextNode = next;
 						next.parent = node;
 						next.depth = depth;
-						node.optional ??= [];
-						node.optional.push(next);
+						let nodes;
+						if (kind === 1) nodes = node.dynamic ??= [];
+						else if (kind === 3) nodes = node.optional ??= [];
+						else nodes = node.wildcard ??= [];
+						nodes.push(next);
+						if (nodes.length === 2) dynamicListsToSort?.push(nodes);
 					}
 					break;
 				}
-				case 2: {
-					const prefix_raw = path.substring(start, segment[1]);
-					const suffix_raw = path.substring(segment[4], end);
-					const actuallyCaseSensitive = caseSensitive && !!(prefix_raw || suffix_raw);
-					const prefix = !prefix_raw ? void 0 : actuallyCaseSensitive ? prefix_raw : prefix_raw.toLowerCase();
-					const suffix = !suffix_raw ? void 0 : actuallyCaseSensitive ? suffix_raw : suffix_raw.toLowerCase();
-					const next = createDynamicNode(2, route.fullPath ?? route.from, actuallyCaseSensitive, prefix, suffix);
-					nextNode = next;
-					next.parent = node;
-					next.depth = depth;
-					node.wildcard ??= [];
-					node.wildcard.push(next);
-				}
 			}
 			node = nextNode;
 		}
 		if (parseParams && route.children && !route.isRoot && route.id && route.id.charCodeAt(route.id.lastIndexOf("/") + 1) === 95) {
-			const pathlessNode = createStaticNode(route.fullPath ?? route.from);
+			const pathlessNode = createStaticNode(path);
 			pathlessNode.kind = SEGMENT_TYPE_PATHLESS;
 			pathlessNode.parent = node;
 			depth++;
@@ -223,7 +193,7 @@ function parseSegments(defaultCaseSensitive, data, route, start, node, depth, on
 		}
 		const isLeaf = (route.path || !route.children) && !route.isRoot;
 		if (isLeaf && path.endsWith("/")) {
-			const indexNode = createStaticNode(route.fullPath ?? route.from);
+			const indexNode = createStaticNode(path);
 			indexNode.kind = SEGMENT_TYPE_INDEX;
 			indexNode.parent = node;
 			depth++;
@@ -232,13 +202,13 @@ function parseSegments(defaultCaseSensitive, data, route, start, node, depth, on
 			node = indexNode;
 		}
 		node.parse = parseParams ?? null;
-		node.priority = route.options?.params?.priority ?? 0;
+		node.priority = options?.params?.priority ?? 0;
 		if (isLeaf && !node.route) {
 			node.route = route;
-			node.fullPath = route.fullPath ?? route.from;
+			node.fullPath = path;
 		}
 	}
-	if (route.children) for (const child of route.children) parseSegments(defaultCaseSensitive, data, child, cursor, node, depth, onRoute);
+	if (route.children) for (const child of route.children) parseSegments(defaultCaseSensitive, data, child, cursor, node, depth, dynamicListsToSort, onRoute);
 }
 function sortDynamic(a, b) {
 	if (a.parse && !b.parse) return -1;
@@ -260,23 +230,6 @@ function sortDynamic(a, b) {
 	if (!a.caseSensitive && b.caseSensitive) return 1;
 	return 0;
 }
-function sortTreeNodes(node) {
-	if (node.pathless) for (const child of node.pathless) sortTreeNodes(child);
-	if (node.static) for (const child of node.static.values()) sortTreeNodes(child);
-	if (node.staticInsensitive) for (const child of node.staticInsensitive.values()) sortTreeNodes(child);
-	if (node.dynamic?.length) {
-		node.dynamic.sort(sortDynamic);
-		for (const child of node.dynamic) sortTreeNodes(child);
-	}
-	if (node.optional?.length) {
-		node.optional.sort(sortDynamic);
-		for (const child of node.optional) sortTreeNodes(child);
-	}
-	if (node.wildcard?.length) {
-		node.wildcard.sort(sortDynamic);
-		for (const child of node.wildcard) sortTreeNodes(child);
-	}
-}
 function createStaticNode(fullPath) {
 	return {
 		kind: 0,
@@ -323,8 +276,9 @@ function createDynamicNode(kind, fullPath, caseSensitive, prefix, suffix) {
 function processRouteMasks(routeList, processedTree) {
 	const segmentTree = createStaticNode("/");
 	const data = new Uint16Array(6);
-	for (const route of routeList) parseSegments(false, data, route, 1, segmentTree, 0);
-	sortTreeNodes(segmentTree);
+	const dynamicListsToSort = [];
+	for (const route of routeList) parseSegments(false, data, route, 1, segmentTree, 0, dynamicListsToSort);
+	for (const nodes of dynamicListsToSort) nodes.sort(sortDynamic);
 	processedTree.masksTree = segmentTree;
 	processedTree.flatCache = require_lru_cache.createLRUCache(1e3);
 }
@@ -381,10 +335,11 @@ function trimPathRight(path) {
 function processRouteTree(routeTree, caseSensitive = false, initRoute) {
 	const segmentTree = createStaticNode(routeTree.fullPath);
 	const data = new Uint16Array(6);
+	const dynamicListsToSort = [];
 	const routesById = {};
 	const routesByPath = {};
 	let index = 0;
-	parseSegments(caseSensitive, data, routeTree, 1, segmentTree, 0, (route) => {
+	parseSegments(caseSensitive, data, routeTree, 1, segmentTree, 0, dynamicListsToSort, (route) => {
 		initRoute?.(route, index);
 		if (route.id in routesById) {
 			if (process.env.NODE_ENV !== "production") throw new Error(`Invariant failed: Duplicate routes found with id: ${String(route.id)}`);
@@ -397,7 +352,7 @@ function processRouteTree(routeTree, caseSensitive = false, initRoute) {
 		}
 		index++;
 	});
-	sortTreeNodes(segmentTree);
+	for (const nodes of dynamicListsToSort) nodes.sort(sortDynamic);
 	return {
 		processedTree: {
 			segmentTree,
@@ -523,7 +478,6 @@ function getNodeMatch(path, parts, segmentTree, fuzzy) {
 		node: segmentTree,
 		index: 1,
 		skipped: 0,
-		depth: 1,
 		statics: 0,
 		dynamics: 0,
 		optionals: 0
@@ -532,7 +486,7 @@ function getNodeMatch(path, parts, segmentTree, fuzzy) {
 	let bestMatch = null;
 	while (stack.length) {
 		const frame = stack.pop();
-		const { node, index, skipped, depth, statics, dynamics, optionals } = frame;
+		const { node, index, skipped, statics, dynamics, optionals } = frame;
 		let { extract, rawParams } = frame;
 		if (node.kind === 2 && node.route && !isFrameMoreSpecific(bestMatch, frame)) continue;
 		if (node.parse) {
@@ -553,7 +507,6 @@ function getNodeMatch(path, parts, segmentTree, fuzzy) {
 				node: node.index,
 				index,
 				skipped,
-				depth: depth + 1,
 				statics,
 				dynamics,
 				optionals,
@@ -585,7 +538,6 @@ function getNodeMatch(path, parts, segmentTree, fuzzy) {
 				node: segment,
 				index: partsLength,
 				skipped,
-				depth: depth + 1,
 				statics,
 				dynamics,
 				optionals,
@@ -594,15 +546,13 @@ function getNodeMatch(path, parts, segmentTree, fuzzy) {
 			});
 		}
 		if (node.optional) {
-			const nextSkipped = skipped | 1 << depth;
-			const nextDepth = depth + 1;
+			const nextSkipped = skipped | 1 << node.depth + 1;
 			for (let i = node.optional.length - 1; i >= 0; i--) {
 				const segment = node.optional[i];
 				stack.push({
 					node: segment,
 					index,
 					skipped: nextSkipped,
-					depth: nextDepth,
 					statics,
 					dynamics,
 					optionals,
@@ -622,7 +572,6 @@ function getNodeMatch(path, parts, segmentTree, fuzzy) {
 					node: segment,
 					index: index + 1,
 					skipped,
-					depth: nextDepth,
 					statics,
 					dynamics,
 					optionals: optionals + segmentScore(partsLength, index),
@@ -643,7 +592,6 @@ function getNodeMatch(path, parts, segmentTree, fuzzy) {
 				node: segment,
 				index: index + 1,
 				skipped,
-				depth: depth + 1,
 				statics,
 				dynamics: dynamics + segmentScore(partsLength, index),
 				optionals,
@@ -657,7 +605,6 @@ function getNodeMatch(path, parts, segmentTree, fuzzy) {
 				node: match,
 				index: index + 1,
 				skipped,
-				depth: depth + 1,
 				statics: statics + segmentScore(partsLength, index),
 				dynamics,
 				optionals,
@@ -671,7 +618,6 @@ function getNodeMatch(path, parts, segmentTree, fuzzy) {
 				node: match,
 				index: index + 1,
 				skipped,
-				depth: depth + 1,
 				statics: statics + segmentScore(partsLength, index),
 				dynamics,
 				optionals,
@@ -679,22 +625,18 @@ function getNodeMatch(path, parts, segmentTree, fuzzy) {
 				rawParams
 			});
 		}
-		if (node.pathless) {
-			const nextDepth = depth + 1;
-			for (let i = node.pathless.length - 1; i >= 0; i--) {
-				const segment = node.pathless[i];
-				stack.push({
-					node: segment,
-					index,
-					skipped,
-					depth: nextDepth,
-					statics,
-					dynamics,
-					optionals,
-					extract,
-					rawParams
-				});
-			}
+		if (node.pathless) for (let i = node.pathless.length - 1; i >= 0; i--) {
+			const segment = node.pathless[i];
+			stack.push({
+				node: segment,
+				index,
+				skipped,
+				statics,
+				dynamics,
+				optionals,
+				extract,
+				rawParams
+			});
 		}
 	}
 	if (bestMatch) return bestMatch;
@@ -732,7 +674,7 @@ function validateParseParams(path, parts, frame) {
 }
 function isFrameMoreSpecific(prev, next) {
 	if (!prev) return true;
-	return next.statics > prev.statics || next.statics === prev.statics && (next.dynamics > prev.dynamics || next.dynamics === prev.dynamics && (next.optionals > prev.optionals || next.optionals === prev.optionals && ((next.node.kind === SEGMENT_TYPE_INDEX) > (prev.node.kind === SEGMENT_TYPE_INDEX) || next.node.kind === SEGMENT_TYPE_INDEX === (prev.node.kind === SEGMENT_TYPE_INDEX) && next.depth > prev.depth)));
+	return next.statics > prev.statics || next.statics === prev.statics && (next.dynamics > prev.dynamics || next.dynamics === prev.dynamics && (next.optionals > prev.optionals || next.optionals === prev.optionals && ((next.node.kind === SEGMENT_TYPE_INDEX) > (prev.node.kind === SEGMENT_TYPE_INDEX) || next.node.kind === SEGMENT_TYPE_INDEX === (prev.node.kind === SEGMENT_TYPE_INDEX) && next.node.depth > prev.node.depth)));
 }
 //#endregion
 exports.buildRouteBranch = buildRouteBranch;

package/dist/cjs/new-process-route-tree.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"new-process-route-tree.cjs","names":[],"sources":["../../src/new-process-route-tree.ts"],"sourcesContent":["import { invariant } from './invariant'\nimport { createLRUCache } from './lru-cache'\nimport { last } from './utils'\nimport type { LRUCache } from './lru-cache'\n\nexport const SEGMENT_TYPE_PATHNAME = 0\nexport const SEGMENT_TYPE_PARAM = 1\nexport const SEGMENT_TYPE_WILDCARD = 2\nexport const SEGMENT_TYPE_OPTIONAL_PARAM = 3\nconst SEGMENT_TYPE_INDEX = 4\nconst SEGMENT_TYPE_PATHLESS = 5 // only used in matching to represent pathless routes that need to carry more information\n\n/**\n * All the kinds of segments that can be present in a route path.\n */\nexport type SegmentKind =\n  | typeof SEGMENT_TYPE_PATHNAME\n  | typeof SEGMENT_TYPE_PARAM\n  | typeof SEGMENT_TYPE_WILDCARD\n  | typeof SEGMENT_TYPE_OPTIONAL_PARAM\n\n/**\n * All the kinds of segments that can be present in the segment tree.\n */\ntype ExtendedSegmentKind =\n  | SegmentKind\n  | typeof SEGMENT_TYPE_INDEX\n  | typeof SEGMENT_TYPE_PATHLESS\n\nfunction getOpenAndCloseBraces(\n  part: string,\n): [openBrace: number, closeBrace: number] | null {\n  const openBrace = part.indexOf('{')\n  if (openBrace === -1) return null\n  const closeBrace = part.indexOf('}', openBrace)\n  if (closeBrace === -1) return null\n  const afterOpen = openBrace + 1\n  if (afterOpen >= part.length) return null\n  return [openBrace, closeBrace]\n}\n\ntype ParsedSegment = Uint16Array & {\n  /** segment type (0 = pathname, 1 = param, 2 = wildcard, 3 = optional param) */\n  0: SegmentKind\n  /** index of the end of the prefix */\n  1: number\n  /** index of the start of the value */\n  2: number\n  /** index of the end of the value */\n  3: number\n  /** index of the start of the suffix */\n  4: number\n  /** index of the end of the segment */\n  5: number\n}\n\n/**\n * Populates the `output` array with the parsed representation of the given `segment` string.\n *\n * Usage:\n * ```ts\n * let output\n * let cursor = 0\n * while (cursor < path.length) {\n *   output = parseSegment(path, cursor, output)\n *   const end = output[5]\n *   cursor = end + 1\n * ```\n *\n * `output` is stored outside to avoid allocations during repeated calls. It doesn't need to be typed\n * or initialized, it will be done automatically.\n */\nexport function parseSegment(\n  /** The full path string containing the segment. */\n  path: string,\n  /** The starting index of the segment within the path. */\n  start: number,\n  /** A Uint16Array (length: 6) to populate with the parsed segment data. */\n  output: Uint16Array = new Uint16Array(6),\n): ParsedSegment {\n  const next = path.indexOf('/', start)\n  const end = next === -1 ? path.length : next\n  const part = path.substring(start, end)\n\n  if (!part || !part.includes('$')) {\n    // early escape for static pathname\n    output[0] = SEGMENT_TYPE_PATHNAME\n    output[1] = start\n    output[2] = start\n    output[3] = end\n    output[4] = end\n    output[5] = end\n    return output as ParsedSegment\n  }\n\n  // $ (wildcard)\n  if (part === '$') {\n    const total = path.length\n    output[0] = SEGMENT_TYPE_WILDCARD\n    output[1] = start\n    output[2] = start\n    output[3] = total\n    output[4] = total\n    output[5] = total\n    return output as ParsedSegment\n  }\n\n  // $paramName\n  if (part.charCodeAt(0) === 36) {\n    output[0] = SEGMENT_TYPE_PARAM\n    output[1] = start\n    output[2] = start + 1 // skip '$'\n    output[3] = end\n    output[4] = end\n    output[5] = end\n    return output as ParsedSegment\n  }\n\n  const braces = getOpenAndCloseBraces(part)\n  if (braces) {\n    const [openBrace, closeBrace] = braces\n    const firstChar = part.charCodeAt(openBrace + 1)\n\n    // Check for {-$...} (optional param)\n    // prefix{-$paramName}suffix\n    // /^([^{]*)\\{-\\$([a-zA-Z_$][a-zA-Z0-9_$]*)\\}([^}]*)$/\n    if (firstChar === 45) {\n      // '-'\n      if (\n        openBrace + 2 < part.length &&\n        part.charCodeAt(openBrace + 2) === 36 // '$'\n      ) {\n        const paramStart = openBrace + 3\n        const paramEnd = closeBrace\n        // Validate param name exists\n        if (paramStart < paramEnd) {\n          output[0] = SEGMENT_TYPE_OPTIONAL_PARAM\n          output[1] = start + openBrace\n          output[2] = start + paramStart\n          output[3] = start + paramEnd\n          output[4] = start + closeBrace + 1\n          output[5] = end\n          return output as ParsedSegment\n        }\n      }\n    } else if (firstChar === 36) {\n      // '$'\n      const dollarPos = openBrace + 1\n      const afterDollar = openBrace + 2\n      // Check for {$} (wildcard)\n      if (afterDollar === closeBrace) {\n        // For wildcard, value should be '$' (from dollarPos to afterDollar)\n        // prefix{$}suffix\n        // /^([^{]*)\\{\\$\\}([^}]*)$/\n        output[0] = SEGMENT_TYPE_WILDCARD\n        output[1] = start + openBrace\n        output[2] = start + dollarPos\n        output[3] = start + afterDollar\n        output[4] = start + closeBrace + 1\n        output[5] = path.length\n        return output as ParsedSegment\n      }\n      // Regular param {$paramName} - value is the param name (after $)\n      // prefix{$paramName}suffix\n      // /^([^{]*)\\{\\$([a-zA-Z_$][a-zA-Z0-9_$]*)\\}([^}]*)$/\n      output[0] = SEGMENT_TYPE_PARAM\n      output[1] = start + openBrace\n      output[2] = start + afterDollar\n      output[3] = start + closeBrace\n      output[4] = start + closeBrace + 1\n      output[5] = end\n      return output as ParsedSegment\n    }\n  }\n\n  // fallback to static pathname (should never happen)\n  output[0] = SEGMENT_TYPE_PATHNAME\n  output[1] = start\n  output[2] = start\n  output[3] = end\n  output[4] = end\n  output[5] = end\n  return output as ParsedSegment\n}\n\n/**\n * Recursively parses the segments of the given route tree and populates a segment trie.\n *\n * @param data A reusable Uint16Array for parsing segments. (non important, we're just avoiding allocations)\n * @param route The current route to parse.\n * @param start The starting index for parsing within the route's full path.\n * @param node The current segment node in the trie to populate.\n * @param onRoute Callback invoked for each route processed.\n */\nfunction parseSegments<TRouteLike extends RouteLike>(\n  defaultCaseSensitive: boolean,\n  data: Uint16Array,\n  route: TRouteLike,\n  start: number,\n  node: AnySegmentNode<TRouteLike>,\n  depth: number,\n  onRoute?: (route: TRouteLike) => void,\n) {\n  onRoute?.(route)\n  let cursor = start\n  {\n    const path = route.fullPath ?? route.from\n    const length = path.length\n    const caseSensitive = route.options?.caseSensitive ?? defaultCaseSensitive\n    const parseParams =\n      route.options?.params?.parse ?? route.options?.parseParams\n    while (cursor < length) {\n      const segment = parseSegment(path, cursor, data)\n      let nextNode: AnySegmentNode<TRouteLike>\n      const start = cursor\n      const end = segment[5]\n      cursor = end + 1\n      depth++\n      const kind = segment[0]\n      switch (kind) {\n        case SEGMENT_TYPE_PATHNAME: {\n          const value = path.substring(segment[2], segment[3])\n          if (caseSensitive) {\n            const existingNode = node.static?.get(value)\n            if (existingNode) {\n              nextNode = existingNode\n            } else {\n              node.static ??= new Map()\n              const next = createStaticNode<TRouteLike>(\n                route.fullPath ?? route.from,\n              )\n              next.parent = node\n              next.depth = depth\n              nextNode = next\n              node.static.set(value, next)\n            }\n          } else {\n            const name = value.toLowerCase()\n            const existingNode = node.staticInsensitive?.get(name)\n            if (existingNode) {\n              nextNode = existingNode\n            } else {\n              node.staticInsensitive ??= new Map()\n              const next = createStaticNode<TRouteLike>(\n                route.fullPath ?? route.from,\n              )\n              next.parent = node\n              next.depth = depth\n              nextNode = next\n              node.staticInsensitive.set(name, next)\n            }\n          }\n          break\n        }\n        case SEGMENT_TYPE_PARAM: {\n          const prefix_raw = path.substring(start, segment[1])\n          const suffix_raw = path.substring(segment[4], end)\n          const actuallyCaseSensitive =\n            caseSensitive && !!(prefix_raw || suffix_raw)\n          const prefix = !prefix_raw\n            ? undefined\n            : actuallyCaseSensitive\n              ? prefix_raw\n              : prefix_raw.toLowerCase()\n          const suffix = !suffix_raw\n            ? undefined\n            : actuallyCaseSensitive\n              ? suffix_raw\n              : suffix_raw.toLowerCase()\n          const existingNode =\n            !parseParams &&\n            node.dynamic?.find(\n              (s) =>\n                !s.parse &&\n                s.caseSensitive === actuallyCaseSensitive &&\n                s.prefix === prefix &&\n                s.suffix === suffix,\n            )\n          if (existingNode) {\n            nextNode = existingNode\n          } else {\n            const next = createDynamicNode<TRouteLike>(\n              SEGMENT_TYPE_PARAM,\n              route.fullPath ?? route.from,\n              actuallyCaseSensitive,\n              prefix,\n              suffix,\n            )\n            nextNode = next\n            next.depth = depth\n            next.parent = node\n            node.dynamic ??= []\n            node.dynamic.push(next)\n          }\n          break\n        }\n        case SEGMENT_TYPE_OPTIONAL_PARAM: {\n          const prefix_raw = path.substring(start, segment[1])\n          const suffix_raw = path.substring(segment[4], end)\n          const actuallyCaseSensitive =\n            caseSensitive && !!(prefix_raw || suffix_raw)\n          const prefix = !prefix_raw\n            ? undefined\n            : actuallyCaseSensitive\n              ? prefix_raw\n              : prefix_raw.toLowerCase()\n          const suffix = !suffix_raw\n            ? undefined\n            : actuallyCaseSensitive\n              ? suffix_raw\n              : suffix_raw.toLowerCase()\n          const existingNode =\n            !parseParams &&\n            node.optional?.find(\n              (s) =>\n                !s.parse &&\n                s.caseSensitive === actuallyCaseSensitive &&\n                s.prefix === prefix &&\n                s.suffix === suffix,\n            )\n          if (existingNode) {\n            nextNode = existingNode\n          } else {\n            const next = createDynamicNode<TRouteLike>(\n              SEGMENT_TYPE_OPTIONAL_PARAM,\n              route.fullPath ?? route.from,\n              actuallyCaseSensitive,\n              prefix,\n              suffix,\n            )\n            nextNode = next\n            next.parent = node\n            next.depth = depth\n            node.optional ??= []\n            node.optional.push(next)\n          }\n          break\n        }\n        case SEGMENT_TYPE_WILDCARD: {\n          const prefix_raw = path.substring(start, segment[1])\n          const suffix_raw = path.substring(segment[4], end)\n          const actuallyCaseSensitive =\n            caseSensitive && !!(prefix_raw || suffix_raw)\n          const prefix = !prefix_raw\n            ? undefined\n            : actuallyCaseSensitive\n              ? prefix_raw\n              : prefix_raw.toLowerCase()\n          const suffix = !suffix_raw\n            ? undefined\n            : actuallyCaseSensitive\n              ? suffix_raw\n              : suffix_raw.toLowerCase()\n          const next = createDynamicNode<TRouteLike>(\n            SEGMENT_TYPE_WILDCARD,\n            route.fullPath ?? route.from,\n            actuallyCaseSensitive,\n            prefix,\n            suffix,\n          )\n          nextNode = next\n          next.parent = node\n          next.depth = depth\n          node.wildcard ??= []\n          node.wildcard.push(next)\n        }\n      }\n      node = nextNode\n    }\n\n    // create pathless node\n    if (\n      parseParams &&\n      route.children &&\n      !route.isRoot &&\n      route.id &&\n      route.id.charCodeAt(route.id.lastIndexOf('/') + 1) === 95 /* '_' */\n    ) {\n      const pathlessNode = createStaticNode<TRouteLike>(\n        route.fullPath ?? route.from,\n      )\n      pathlessNode.kind = SEGMENT_TYPE_PATHLESS\n      pathlessNode.parent = node\n      depth++\n      pathlessNode.depth = depth\n      node.pathless ??= []\n      node.pathless.push(pathlessNode)\n      node = pathlessNode\n    }\n\n    const isLeaf = (route.path || !route.children) && !route.isRoot\n    // create index node\n    if (isLeaf && path.endsWith('/')) {\n      const indexNode = createStaticNode<TRouteLike>(\n        route.fullPath ?? route.from,\n      )\n      indexNode.kind = SEGMENT_TYPE_INDEX\n      indexNode.parent = node\n      depth++\n      indexNode.depth = depth\n      node.index = indexNode\n      node = indexNode\n    }\n\n    node.parse = parseParams ?? null\n    node.priority = route.options?.params?.priority ?? 0\n\n    // make node \"matchable\"\n    if (isLeaf && !node.route) {\n      node.route = route\n      node.fullPath = route.fullPath ?? route.from\n    }\n  }\n  if (route.children)\n    for (const child of route.children) {\n      parseSegments(\n        defaultCaseSensitive,\n        data,\n        child as TRouteLike,\n        cursor,\n        node,\n        depth,\n        onRoute,\n      )\n    }\n}\n\nfunction sortDynamic(\n  a: {\n    prefix?: string\n    suffix?: string\n    caseSensitive: boolean\n    parse: null | ((params: Record<string, string>) => unknown)\n    priority: number\n  },\n  b: {\n    prefix?: string\n    suffix?: string\n    caseSensitive: boolean\n    parse: null | ((params: Record<string, string>) => unknown)\n    priority: number\n  },\n) {\n  if (a.parse && !b.parse) return -1\n  if (!a.parse && b.parse) return 1\n  if (a.parse && b.parse && (a.priority || b.priority))\n    return b.priority - a.priority\n  if (a.prefix && b.prefix && a.prefix !== b.prefix) {\n    if (a.prefix.startsWith(b.prefix)) return -1\n    if (b.prefix.startsWith(a.prefix)) return 1\n  }\n  if (a.suffix && b.suffix && a.suffix !== b.suffix) {\n    if (a.suffix.endsWith(b.suffix)) return -1\n    if (b.suffix.endsWith(a.suffix)) return 1\n  }\n  if (a.prefix && !b.prefix) return -1\n  if (!a.prefix && b.prefix) return 1\n  if (a.suffix && !b.suffix) return -1\n  if (!a.suffix && b.suffix) return 1\n  if (a.caseSensitive && !b.caseSensitive) return -1\n  if (!a.caseSensitive && b.caseSensitive) return 1\n\n  // Equal specificity preserves route declaration order through stable sort.\n  return 0\n}\n\nfunction sortTreeNodes(node: SegmentNode<RouteLike>) {\n  if (node.pathless) {\n    for (const child of node.pathless) {\n      sortTreeNodes(child)\n    }\n  }\n  if (node.static) {\n    for (const child of node.static.values()) {\n      sortTreeNodes(child)\n    }\n  }\n  if (node.staticInsensitive) {\n    for (const child of node.staticInsensitive.values()) {\n      sortTreeNodes(child)\n    }\n  }\n  if (node.dynamic?.length) {\n    node.dynamic.sort(sortDynamic)\n    for (const child of node.dynamic) {\n      sortTreeNodes(child)\n    }\n  }\n  if (node.optional?.length) {\n    node.optional.sort(sortDynamic)\n    for (const child of node.optional) {\n      sortTreeNodes(child)\n    }\n  }\n  if (node.wildcard?.length) {\n    node.wildcard.sort(sortDynamic)\n    for (const child of node.wildcard) {\n      sortTreeNodes(child)\n    }\n  }\n}\n\nfunction createStaticNode<T extends RouteLike>(\n  fullPath: string,\n): StaticSegmentNode<T> {\n  return {\n    kind: SEGMENT_TYPE_PATHNAME,\n    depth: 0,\n    pathless: null,\n    index: null,\n    static: null,\n    staticInsensitive: null,\n    dynamic: null,\n    optional: null,\n    wildcard: null,\n    route: null,\n    fullPath,\n    parent: null,\n    parse: null,\n    priority: 0,\n  }\n}\n\n/**\n * Keys must be declared in the same order as in `SegmentNode` type,\n * to ensure they are represented as the same object class in the engine.\n */\nfunction createDynamicNode<T extends RouteLike>(\n  kind:\n    | typeof SEGMENT_TYPE_PARAM\n    | typeof SEGMENT_TYPE_WILDCARD\n    | typeof SEGMENT_TYPE_OPTIONAL_PARAM,\n  fullPath: string,\n  caseSensitive: boolean,\n  prefix?: string,\n  suffix?: string,\n): DynamicSegmentNode<T> {\n  return {\n    kind,\n    depth: 0,\n    pathless: null,\n    index: null,\n    static: null,\n    staticInsensitive: null,\n    dynamic: null,\n    optional: null,\n    wildcard: null,\n    route: null,\n    fullPath,\n    parent: null,\n    parse: null,\n    priority: 0,\n    caseSensitive,\n    prefix,\n    suffix,\n  }\n}\n\ntype StaticSegmentNode<T extends RouteLike> = SegmentNode<T> & {\n  kind:\n    | typeof SEGMENT_TYPE_PATHNAME\n    | typeof SEGMENT_TYPE_PATHLESS\n    | typeof SEGMENT_TYPE_INDEX\n}\n\ntype DynamicSegmentNode<T extends RouteLike> = SegmentNode<T> & {\n  kind:\n    | typeof SEGMENT_TYPE_PARAM\n    | typeof SEGMENT_TYPE_WILDCARD\n    | typeof SEGMENT_TYPE_OPTIONAL_PARAM\n  prefix?: string\n  suffix?: string\n  caseSensitive: boolean\n}\n\ntype AnySegmentNode<T extends RouteLike> =\n  | StaticSegmentNode<T>\n  | DynamicSegmentNode<T>\n\ntype SegmentNode<T extends RouteLike> = {\n  kind: ExtendedSegmentKind\n\n  pathless: Array<StaticSegmentNode<T>> | null\n\n  /** Exact index segment (highest priority) */\n  index: StaticSegmentNode<T> | null\n\n  /** Static segments (2nd priority) */\n  static: Map<string, StaticSegmentNode<T>> | null\n\n  /** Case insensitive static segments (3rd highest priority) */\n  staticInsensitive: Map<string, StaticSegmentNode<T>> | null\n\n  /** Dynamic segments ($param) */\n  dynamic: Array<DynamicSegmentNode<T>> | null\n\n  /** Optional dynamic segments ({-$param}) */\n  optional: Array<DynamicSegmentNode<T>> | null\n\n  /** Wildcard segments ($ - lowest priority) */\n  wildcard: Array<DynamicSegmentNode<T>> | null\n\n  /** Terminal route (if this path can end here) */\n  route: T | null\n\n  /** The full path for this segment node (will only be valid on leaf nodes) */\n  fullPath: string\n\n  parent: AnySegmentNode<T> | null\n\n  depth: number\n\n  /** route.options.params.parse function, set on the last node of the route */\n  parse: null | ((params: Record<string, string>) => unknown)\n\n  /** route.options.params.priority ?? 0 */\n  priority: number\n}\n\ntype RouteLike = {\n  id?: string\n  path?: string // relative path from the parent,\n  children?: Array<RouteLike> // child routes,\n  parentRoute?: RouteLike // parent route,\n  isRoot?: boolean\n  options?: {\n    caseSensitive?: boolean\n    parseParams?: (params: Record<string, string>) => unknown\n    params?: {\n      parse?: (params: Record<string, string>) => unknown\n      priority?: number\n    }\n  }\n} &\n  // router tree\n  (| { fullPath: string; from?: never } // full path from the root\n    // flat route masks list\n    | { fullPath?: never; from: string } // full path from the root\n  )\n\nexport type ProcessedTree<\n  TTree extends Extract<RouteLike, { fullPath: string }>,\n  TFlat extends Extract<RouteLike, { from: string }>,\n  TSingle extends Extract<RouteLike, { from: string }>,\n> = {\n  /** a representation of the `routeTree` as a segment tree */\n  segmentTree: AnySegmentNode<TTree>\n  /** a mini route tree generated from the flat `routeMasks` list */\n  masksTree: AnySegmentNode<TFlat> | null\n  /** @deprecated keep until v2 so that `router.matchRoute` can keep not caring about the actual route tree */\n  singleCache: LRUCache<string, AnySegmentNode<TSingle>>\n  /** a cache of route matches from the `segmentTree` */\n  matchCache: LRUCache<string, RouteMatch<TTree> | null>\n  /** a cache of route matches from the `masksTree` */\n  flatCache: LRUCache<string, ReturnType<typeof findMatch<TFlat>>> | null\n}\n\nexport function processRouteMasks<\n  TRouteLike extends Extract<RouteLike, { from: string }>,\n>(\n  routeList: Array<TRouteLike>,\n  processedTree: ProcessedTree<any, TRouteLike, any>,\n) {\n  const segmentTree = createStaticNode<TRouteLike>('/')\n  const data = new Uint16Array(6)\n  for (const route of routeList) {\n    parseSegments(false, data, route, 1, segmentTree, 0)\n  }\n  sortTreeNodes(segmentTree)\n  processedTree.masksTree = segmentTree\n  processedTree.flatCache = createLRUCache<\n    string,\n    ReturnType<typeof findMatch<TRouteLike>>\n  >(1000)\n}\n\n/**\n * Take an arbitrary list of routes, create a tree from them (if it hasn't been created already), and match a path against it.\n */\nexport function findFlatMatch<T extends Extract<RouteLike, { from: string }>>(\n  /** The path to match. */\n  path: string,\n  /** The `processedTree` returned by the initial `processRouteTree` call. */\n  processedTree: ProcessedTree<any, T, any>,\n) {\n  path ||= '/'\n  const cached = processedTree.flatCache!.get(path)\n  if (cached) return cached\n  const result = findMatch(path, processedTree.masksTree!)\n  processedTree.flatCache!.set(path, result)\n  return result\n}\n\n/**\n * @deprecated keep until v2 so that `router.matchRoute` can keep not caring about the actual route tree\n */\nexport function findSingleMatch(\n  from: string,\n  caseSensitive: boolean,\n  fuzzy: boolean,\n  path: string,\n  processedTree: ProcessedTree<any, any, { from: string }>,\n) {\n  from ||= '/'\n  path ||= '/'\n  const key = caseSensitive ? `case\\0${from}` : from\n  let tree = processedTree.singleCache.get(key)\n  if (!tree) {\n    // single flat routes (router.matchRoute) are not eagerly processed,\n    // if we haven't seen this route before, process it now\n    tree = createStaticNode<{ from: string }>('/')\n    const data = new Uint16Array(6)\n    parseSegments(caseSensitive, data, { from }, 1, tree, 0)\n    processedTree.singleCache.set(key, tree)\n  }\n  return findMatch(path, tree, fuzzy)\n}\n\ntype RouteMatch<T extends Extract<RouteLike, { fullPath: string }>> = {\n  route: T\n  rawParams: Record<string, string>\n  branch: ReadonlyArray<T>\n}\n\nexport function findRouteMatch<\n  T extends Extract<RouteLike, { fullPath: string }>,\n>(\n  /** The path to match against the route tree. */\n  path: string,\n  /** The `processedTree` returned by the initial `processRouteTree` call. */\n  processedTree: ProcessedTree<T, any, any>,\n  /** If `true`, allows fuzzy matching (partial matches), i.e. which node in the tree would have been an exact match if the `path` had been shorter? */\n  fuzzy = false,\n): RouteMatch<T> | null {\n  const key = fuzzy ? path : `nofuzz\\0${path}` // the main use for `findRouteMatch` is fuzzy:true, so we optimize for that case\n  const cached = processedTree.matchCache.get(key)\n  if (cached !== undefined) return cached\n  path ||= '/'\n  let result: RouteMatch<T> | null\n\n  try {\n    result = findMatch(\n      path,\n      processedTree.segmentTree,\n      fuzzy,\n    ) as RouteMatch<T> | null\n  } catch (err) {\n    if (err instanceof URIError) {\n      result = null\n    } else {\n      throw err\n    }\n  }\n\n  if (result) result.branch = buildRouteBranch(result.route)\n  processedTree.matchCache.set(key, result)\n  return result\n}\n\n/** Trim trailing slashes (except preserving root '/'). */\nexport function trimPathRight(path: string) {\n  return path === '/' ? path : path.replace(/\\/{1,}$/, '')\n}\n\nexport interface ProcessRouteTreeResult<\n  TRouteLike extends Extract<RouteLike, { fullPath: string }> & { id: string },\n> {\n  /** Should be considered a black box, needs to be provided to all matching functions in this module. */\n  processedTree: ProcessedTree<TRouteLike, any, any>\n  /** A lookup map of routes by their unique IDs. */\n  routesById: Record<string, TRouteLike>\n  /** A lookup map of routes by their trimmed full paths. */\n  routesByPath: Record<string, TRouteLike>\n}\n\n/**\n * Processes a route tree into a segment trie for efficient path matching.\n * Also builds lookup maps for routes by ID and by trimmed full path.\n */\nexport function processRouteTree<\n  TRouteLike extends Extract<RouteLike, { fullPath: string }> & { id: string },\n>(\n  /** The root of the route tree to process. */\n  routeTree: TRouteLike,\n  /** Whether matching should be case sensitive by default (overridden by individual route options). */\n  caseSensitive: boolean = false,\n  /** Optional callback invoked for each route during processing. */\n  initRoute?: (route: TRouteLike, index: number) => void,\n): ProcessRouteTreeResult<TRouteLike> {\n  const segmentTree = createStaticNode<TRouteLike>(routeTree.fullPath)\n  const data = new Uint16Array(6)\n  const routesById = {} as Record<string, TRouteLike>\n  const routesByPath = {} as Record<string, TRouteLike>\n  let index = 0\n  parseSegments(caseSensitive, data, routeTree, 1, segmentTree, 0, (route) => {\n    initRoute?.(route, index)\n\n    if (route.id in routesById) {\n      if (process.env.NODE_ENV !== 'production') {\n        throw new Error(\n          `Invariant failed: Duplicate routes found with id: ${String(route.id)}`,\n        )\n      }\n\n      invariant()\n    }\n\n    routesById[route.id] = route\n\n    if (index !== 0 && route.path) {\n      const trimmedFullPath = trimPathRight(route.fullPath)\n      if (!routesByPath[trimmedFullPath] || route.fullPath.endsWith('/')) {\n        routesByPath[trimmedFullPath] = route\n      }\n    }\n\n    index++\n  })\n  sortTreeNodes(segmentTree)\n  const processedTree: ProcessedTree<TRouteLike, any, any> = {\n    segmentTree,\n    singleCache: createLRUCache<string, AnySegmentNode<any>>(1000),\n    matchCache: createLRUCache<string, RouteMatch<TRouteLike> | null>(1000),\n    flatCache: null,\n    masksTree: null,\n  }\n  return {\n    processedTree,\n    routesById,\n    routesByPath,\n  }\n}\n\nfunction findMatch<T extends RouteLike>(\n  path: string,\n  segmentTree: AnySegmentNode<T>,\n  fuzzy = false,\n): {\n  route: T\n  /**\n   * The raw (unparsed) params extracted from the path.\n   * This will be the exhaustive list of all params defined in the route's path.\n   */\n  rawParams: Record<string, string>\n} | null {\n  const parts = path.split('/')\n  const leaf = getNodeMatch(path, parts, segmentTree, fuzzy)\n  if (!leaf) return null\n  const [rawParams] = extractParams(path, parts, leaf)\n  return {\n    route: leaf.node.route!,\n    rawParams,\n  }\n}\n\ntype ParamExtractionState = {\n  part: number\n  node: number\n  path: number\n  segment: number\n}\n\n/**\n * This function is \"resumable\":\n * - the `leaf` input can contain `extract` and `rawParams` properties from a previous `extractParams` call\n * - the returned `state` can be passed back as `extract` in a future call to continue extracting params from where we left off\n *\n * Inputs are *not* mutated.\n */\nfunction extractParams<T extends RouteLike>(\n  path: string,\n  parts: Array<string>,\n  leaf: {\n    node: AnySegmentNode<T>\n    skipped: number\n    extract?: ParamExtractionState\n    rawParams?: Record<string, string>\n  },\n): [rawParams: Record<string, string>, state: ParamExtractionState] {\n  const list = buildBranch(leaf.node)\n  let nodeParts: Array<string> | null = null\n  const rawParams: Record<string, string> = Object.create(null)\n  /** which segment of the path we're currently processing */\n  let partIndex = leaf.extract?.part ?? 0\n  /** which node of the route tree branch we're currently processing */\n  let nodeIndex = leaf.extract?.node ?? 0\n  /** index of the 1st character of the segment we're processing in the path string */\n  let pathIndex = leaf.extract?.path ?? 0\n  /** which fullPath segment we're currently processing */\n  let segmentCount = leaf.extract?.segment ?? 0\n  for (\n    ;\n    nodeIndex < list.length;\n    partIndex++, nodeIndex++, pathIndex++, segmentCount++\n  ) {\n    const node = list[nodeIndex]!\n    // index nodes are terminating nodes, nothing to extract, just leave\n    if (node.kind === SEGMENT_TYPE_INDEX) break\n    // pathless nodes do not consume a path segment\n    if (node.kind === SEGMENT_TYPE_PATHLESS) {\n      segmentCount--\n      partIndex--\n      pathIndex--\n      continue\n    }\n    const part = parts[partIndex]\n    const currentPathIndex = pathIndex\n    if (part) pathIndex += part.length\n    if (node.kind === SEGMENT_TYPE_PARAM) {\n      nodeParts ??= leaf.node.fullPath.split('/')\n      const nodePart = nodeParts[segmentCount]!\n      const preLength = node.prefix?.length ?? 0\n      // we can't rely on the presence of prefix/suffix to know whether it's curly-braced or not, because `/{$param}/` is valid, but has no prefix/suffix\n      const isCurlyBraced = nodePart.charCodeAt(preLength) === 123 // '{'\n      // param name is extracted at match-time so that tree nodes that are identical except for param name can share the same node\n      if (isCurlyBraced) {\n        const sufLength = node.suffix?.length ?? 0\n        const name = nodePart.substring(\n          preLength + 2,\n          nodePart.length - sufLength - 1,\n        )\n        const value = part!.substring(preLength, part!.length - sufLength)\n        rawParams[name] = decodeURIComponent(value)\n      } else {\n        const name = nodePart.substring(1)\n        rawParams[name] = decodeURIComponent(part!)\n      }\n    } else if (node.kind === SEGMENT_TYPE_OPTIONAL_PARAM) {\n      if (leaf.skipped & (1 << nodeIndex)) {\n        partIndex-- // stay on the same part\n        pathIndex = currentPathIndex - 1 // undo pathIndex advancement; -1 to account for loop increment\n        continue\n      }\n      nodeParts ??= leaf.node.fullPath.split('/')\n      const nodePart = nodeParts[segmentCount]!\n      const preLength = node.prefix?.length ?? 0\n      const sufLength = node.suffix?.length ?? 0\n      const name = nodePart.substring(\n        preLength + 3,\n        nodePart.length - sufLength - 1,\n      )\n      const value =\n        node.suffix || node.prefix\n          ? part!.substring(preLength, part!.length - sufLength)\n          : part\n      if (value) rawParams[name] = decodeURIComponent(value)\n    } else if (node.kind === SEGMENT_TYPE_WILDCARD) {\n      const n = node\n      const value = path.substring(\n        currentPathIndex + (n.prefix?.length ?? 0),\n        path.length - (n.suffix?.length ?? 0),\n      )\n      const splat = decodeURIComponent(value)\n      // TODO: Deprecate *\n      rawParams['*'] = splat\n      rawParams._splat = splat\n      break\n    }\n  }\n  if (leaf.rawParams) Object.assign(rawParams, leaf.rawParams)\n  return [\n    rawParams,\n    {\n      part: partIndex,\n      node: nodeIndex,\n      path: pathIndex,\n      segment: segmentCount,\n    },\n  ]\n}\n\nexport function buildRouteBranch<T extends RouteLike>(route: T) {\n  const list = [route]\n  while (route.parentRoute) {\n    route = route.parentRoute as T\n    list.push(route)\n  }\n  list.reverse()\n  return list\n}\n\nfunction buildBranch<T extends RouteLike>(node: AnySegmentNode<T>) {\n  const list: Array<AnySegmentNode<T>> = Array(node.depth + 1)\n  do {\n    list[node.depth] = node\n    node = node.parent!\n  } while (node)\n  return list\n}\n\ntype MatchStackFrame<T extends RouteLike> = {\n  node: AnySegmentNode<T>\n  /** index of the segment of path */\n  index: number\n  /** how many nodes between `node` and the root of the segment tree */\n  depth: number\n  /**\n   * Bitmask of skipped optional segments.\n   *\n   * This is a very performant way of storing an \"array of booleans\", but it means beyond 32 segments we can't track skipped optionals.\n   * If we really really need to support more than 32 segments we can switch to using a `BigInt` here. It's about 2x slower in worst case scenarios.\n   */\n  skipped: number\n  /** Positional bitmasks tracking which consumed URL segments matched each segment kind. */\n  statics: number\n  dynamics: number\n  optionals: number\n  /** intermediary state for param extraction */\n  extract?: ParamExtractionState\n  /** intermediary params from param extraction */\n  rawParams?: Record<string, string>\n}\n\nfunction getNodeMatch<T extends RouteLike>(\n  path: string,\n  parts: Array<string>,\n  segmentTree: AnySegmentNode<T>,\n  fuzzy: boolean,\n) {\n  // quick check for root index\n  // this is an optimization, algorithm should work correctly without this block\n  if (path === '/' && segmentTree.index)\n    return { node: segmentTree.index, skipped: 0 } as Pick<\n      Frame,\n      'node' | 'skipped'\n    >\n\n  const trailingSlash = !last(parts)\n  const pathIsIndex = trailingSlash && path !== '/'\n  const partsLength = parts.length - (trailingSlash ? 1 : 0)\n\n  type Frame = MatchStackFrame<T>\n\n  // use a stack to explore all possible paths (params cause branching)\n  // iterate \"backwards\" (low priority first) so that we can push() each candidate, and pop() the highest priority candidate first\n  // - pros: it is depth-first, so we find full matches faster\n  // - cons: we cannot short-circuit, because highest priority matches are at the end of the loop (for loop with i--) (but we have no good short-circuiting anyway)\n  // other possible approaches:\n  // - shift instead of pop (measure performance difference), this allows iterating \"forwards\" (effectively breadth-first)\n  // - never remove from the stack, keep a cursor instead. Then we can push \"forwards\" and avoid reversing the order of candidates (effectively breadth-first)\n  const stack: Array<Frame> = [\n    {\n      node: segmentTree,\n      index: 1,\n      skipped: 0,\n      depth: 1,\n      statics: 0,\n      dynamics: 0,\n      optionals: 0,\n    },\n  ]\n\n  let bestFuzzy: Frame | null = null\n  let bestMatch: Frame | null = null\n\n  while (stack.length) {\n    const frame = stack.pop()!\n    const { node, index, skipped, depth, statics, dynamics, optionals } = frame\n    let { extract, rawParams } = frame\n\n    // Wildcard candidates are pushed speculatively as fallbacks in case a\n    // higher-priority wildcard later fails params.parse. If a better wildcard\n    // has already validated and become bestMatch, lower-priority wildcard\n    // fallbacks cannot win anymore and should not run params.parse.\n    if (\n      node.kind === SEGMENT_TYPE_WILDCARD &&\n      node.route &&\n      !isFrameMoreSpecific(bestMatch, frame)\n    ) {\n      continue\n    }\n\n    if (node.parse) {\n      const result = validateParseParams(path, parts, frame)\n      if (!result) continue\n      rawParams = frame.rawParams\n      extract = frame.extract\n    }\n\n    // In fuzzy mode, track the best partial match we've found so far\n    if (\n      fuzzy &&\n      node.route &&\n      node.kind !== SEGMENT_TYPE_INDEX &&\n      isFrameMoreSpecific(bestFuzzy, frame)\n    ) {\n      bestFuzzy = frame\n    }\n\n    const isBeyondPath = index === partsLength\n    if (isBeyondPath) {\n      if (\n        node.route &&\n        (!pathIsIndex ||\n          node.kind === SEGMENT_TYPE_INDEX ||\n          node.kind === SEGMENT_TYPE_WILDCARD) &&\n        isFrameMoreSpecific(bestMatch, frame)\n      ) {\n        bestMatch = frame\n      }\n      // beyond the length of the path parts, only some segment types can match\n      if (!node.optional && !node.wildcard && !node.index && !node.pathless)\n        continue\n    }\n\n    const part = isBeyondPath ? undefined : parts[index]!\n    let lowerPart: string\n\n    // 0. Try index match\n    if (isBeyondPath && node.index) {\n      const indexFrame = {\n        node: node.index,\n        index,\n        skipped,\n        depth: depth + 1,\n        statics,\n        dynamics,\n        optionals,\n        extract,\n        rawParams,\n      }\n      let indexValid = true\n      if (node.index.parse) {\n        const result = validateParseParams(path, parts, indexFrame)\n        if (!result) indexValid = false\n      }\n      if (indexValid) {\n        // perfect match, no need to continue\n        // this is an optimization, algorithm should work correctly without this block\n        if (\n          !dynamics &&\n          !optionals &&\n          !skipped &&\n          isPerfectStaticMatch(statics, partsLength)\n        ) {\n          return indexFrame\n        }\n        if (isFrameMoreSpecific(bestMatch, indexFrame)) {\n          // index matches skip the stack because they cannot have children\n          bestMatch = indexFrame\n        }\n      }\n    }\n\n    // 5. Try wildcard match\n    if (node.wildcard) {\n      for (let i = node.wildcard.length - 1; i >= 0; i--) {\n        const segment = node.wildcard[i]!\n        const { prefix, suffix } = segment\n        if (prefix) {\n          if (isBeyondPath) continue\n          const casePart = segment.caseSensitive\n            ? part\n            : (lowerPart ??= part!.toLowerCase())\n          if (!casePart!.startsWith(prefix)) continue\n        }\n        if (suffix) {\n          if (isBeyondPath) continue\n          const end = parts.slice(index).join('/').slice(-suffix.length)\n          const casePart = segment.caseSensitive ? end : end.toLowerCase()\n          if (casePart !== suffix) continue\n        }\n        // wildcard matches consume the rest of the URL and cannot have children\n        stack.push({\n          node: segment,\n          index: partsLength,\n          skipped,\n          depth: depth + 1,\n          statics,\n          dynamics,\n          optionals,\n          extract,\n          rawParams,\n        })\n      }\n    }\n\n    // 4. Try optional match\n    if (node.optional) {\n      const nextSkipped = skipped | (1 << depth)\n      const nextDepth = depth + 1\n      for (let i = node.optional.length - 1; i >= 0; i--) {\n        const segment = node.optional[i]!\n        // when skipping, node and depth advance by 1, but index doesn't\n        stack.push({\n          node: segment,\n          index,\n          skipped: nextSkipped,\n          depth: nextDepth,\n          statics,\n          dynamics,\n          optionals,\n          extract,\n          rawParams,\n        }) // enqueue skipping the optional\n      }\n      if (!isBeyondPath) {\n        for (let i = node.optional.length - 1; i >= 0; i--) {\n          const segment = node.optional[i]!\n          const { prefix, suffix } = segment\n          if (prefix || suffix) {\n            const casePart = segment.caseSensitive\n              ? part!\n              : (lowerPart ??= part!.toLowerCase())\n            if (prefix && !casePart.startsWith(prefix)) continue\n            if (suffix && !casePart.endsWith(suffix)) continue\n          }\n          stack.push({\n            node: segment,\n            index: index + 1,\n            skipped,\n            depth: nextDepth,\n            statics,\n            dynamics,\n            optionals: optionals + segmentScore(partsLength, index),\n            extract,\n            rawParams,\n          })\n        }\n      }\n    }\n\n    // 3. Try dynamic match\n    if (!isBeyondPath && node.dynamic && part) {\n      for (let i = node.dynamic.length - 1; i >= 0; i--) {\n        const segment = node.dynamic[i]!\n        const { prefix, suffix } = segment\n        if (prefix || suffix) {\n          const casePart = segment.caseSensitive\n            ? part\n            : (lowerPart ??= part.toLowerCase())\n          if (prefix && !casePart.startsWith(prefix)) continue\n          if (suffix && !casePart.endsWith(suffix)) continue\n        }\n        stack.push({\n          node: segment,\n          index: index + 1,\n          skipped,\n          depth: depth + 1,\n          statics,\n          dynamics: dynamics + segmentScore(partsLength, index),\n          optionals,\n          extract,\n          rawParams,\n        })\n      }\n    }\n\n    // 2. Try case insensitive static match\n    if (!isBeyondPath && node.staticInsensitive) {\n      const match = node.staticInsensitive.get(\n        (lowerPart ??= part!.toLowerCase()),\n      )\n      if (match) {\n        stack.push({\n          node: match,\n          index: index + 1,\n          skipped,\n          depth: depth + 1,\n          statics: statics + segmentScore(partsLength, index),\n          dynamics,\n          optionals,\n          extract,\n          rawParams,\n        })\n      }\n    }\n\n    // 1. Try static match\n    if (!isBeyondPath && node.static) {\n      const match = node.static.get(part!)\n      if (match) {\n        stack.push({\n          node: match,\n          index: index + 1,\n          skipped,\n          depth: depth + 1,\n          statics: statics + segmentScore(partsLength, index),\n          dynamics,\n          optionals,\n          extract,\n          rawParams,\n        })\n      }\n    }\n\n    // 0. Try pathless match\n    if (node.pathless) {\n      const nextDepth = depth + 1\n      for (let i = node.pathless.length - 1; i >= 0; i--) {\n        const segment = node.pathless[i]!\n        stack.push({\n          node: segment,\n          index,\n          skipped,\n          depth: nextDepth,\n          statics,\n          dynamics,\n          optionals,\n          extract,\n          rawParams,\n        })\n      }\n    }\n  }\n\n  if (bestMatch) return bestMatch\n\n  if (fuzzy && bestFuzzy) {\n    let sliceIndex = bestFuzzy.index\n    for (let i = 0; i < bestFuzzy.index; i++) {\n      sliceIndex += parts[i]!.length\n    }\n    const splat = sliceIndex === path.length ? '/' : path.slice(sliceIndex)\n    bestFuzzy.rawParams ??= Object.create(null)\n    bestFuzzy.rawParams!['**'] = decodeURIComponent(splat)\n    return bestFuzzy\n  }\n\n  return null\n}\n\nfunction segmentScore(partsLength: number, index: number): number {\n  // The specificity scores are bitmasks over consumed URL segments. Earlier\n  // URL segments should dominate later ones when comparing scores, so the\n  // first real segment gets the highest bit and the last gets bit 0. Since\n  // `parts[0]` is the empty string before the leading slash, real URL segments\n  // are [1, partsLength), making this segment's bit `partsLength - index - 1`.\n  return 2 ** (partsLength - index - 1)\n}\n\nfunction isPerfectStaticMatch(statics: number, partsLength: number): boolean {\n  return statics === 2 ** (partsLength - 1) - 1\n}\n\nfunction validateParseParams<T extends RouteLike>(\n  path: string,\n  parts: Array<string>,\n  frame: MatchStackFrame<T>,\n) {\n  let rawParams: Record<string, string>\n  let state: ParamExtractionState\n\n  try {\n    ;[rawParams, state] = extractParams(path, parts, frame)\n  } catch {\n    return null\n  }\n\n  frame.rawParams = rawParams\n  frame.extract = state\n\n  if (!frame.node.parse) return true\n\n  try {\n    if (frame.node.parse(rawParams) === false) return null\n  } catch {\n    // Thrown parse errors should be surfaced on the selected match by\n    // extractStrictParams, not used as fallback route selection.\n  }\n\n  return true\n}\n\nfunction isFrameMoreSpecific(\n  // the stack frame previously saved as \"best match\"\n  prev: MatchStackFrame<any> | null,\n  // the candidate stack frame\n  next: MatchStackFrame<any>,\n): boolean {\n  if (!prev) return true\n  return (\n    next.statics > prev.statics ||\n    (next.statics === prev.statics &&\n      (next.dynamics > prev.dynamics ||\n        (next.dynamics === prev.dynamics &&\n          (next.optionals > prev.optionals ||\n            (next.optionals === prev.optionals &&\n              ((next.node.kind === SEGMENT_TYPE_INDEX) >\n                (prev.node.kind === SEGMENT_TYPE_INDEX) ||\n                ((next.node.kind === SEGMENT_TYPE_INDEX) ===\n                  (prev.node.kind === SEGMENT_TYPE_INDEX) &&\n                  next.depth > prev.depth)))))))\n  )\n}\n"],"mappings":";;;AASA,MAAM,qBAAqB;AAC3B,MAAM,wBAAwB;AAmB9B,SAAS,sBACP,MACgD;CAChD,MAAM,YAAY,KAAK,QAAQ,GAAG;CAClC,IAAI,cAAc,IAAI,OAAO;CAC7B,MAAM,aAAa,KAAK,QAAQ,KAAK,SAAS;CAC9C,IAAI,eAAe,IAAI,OAAO;CAE9B,IADkB,YAAY,KACb,KAAK,QAAQ,OAAO;CACrC,OAAO,CAAC,WAAW,UAAU;AAC/B;;;;;;;;;;;;;;;;;AAiCA,SAAgB,aAEd,MAEA,OAEA,SAAsB,IAAI,YAAY,CAAC,GACxB;CACf,MAAM,OAAO,KAAK,QAAQ,KAAK,KAAK;CACpC,MAAM,MAAM,SAAS,KAAK,KAAK,SAAS;CACxC,MAAM,OAAO,KAAK,UAAU,OAAO,GAAG;CAEtC,IAAI,CAAC,QAAQ,CAAC,KAAK,SAAS,GAAG,GAAG;EAEhC,OAAO,KAAA;EACP,OAAO,KAAK;EACZ,OAAO,KAAK;EACZ,OAAO,KAAK;EACZ,OAAO,KAAK;EACZ,OAAO,KAAK;EACZ,OAAO;CACT;CAGA,IAAI,SAAS,KAAK;EAChB,MAAM,QAAQ,KAAK;EACnB,OAAO,KAAA;EACP,OAAO,KAAK;EACZ,OAAO,KAAK;EACZ,OAAO,KAAK;EACZ,OAAO,KAAK;EACZ,OAAO,KAAK;EACZ,OAAO;CACT;CAGA,IAAI,KAAK,WAAW,CAAC,MAAM,IAAI;EAC7B,OAAO,KAAA;EACP,OAAO,KAAK;EACZ,OAAO,KAAK,QAAQ;EACpB,OAAO,KAAK;EACZ,OAAO,KAAK;EACZ,OAAO,KAAK;EACZ,OAAO;CACT;CAEA,MAAM,SAAS,sBAAsB,IAAI;CACzC,IAAI,QAAQ;EACV,MAAM,CAAC,WAAW,cAAc;EAChC,MAAM,YAAY,KAAK,WAAW,YAAY,CAAC;EAK/C,IAAI,cAAc;OAGd,YAAY,IAAI,KAAK,UACrB,KAAK,WAAW,YAAY,CAAC,MAAM,IACnC;IACA,MAAM,aAAa,YAAY;IAC/B,MAAM,WAAW;IAEjB,IAAI,aAAa,UAAU;KACzB,OAAO,KAAA;KACP,OAAO,KAAK,QAAQ;KACpB,OAAO,KAAK,QAAQ;KACpB,OAAO,KAAK,QAAQ;KACpB,OAAO,KAAK,QAAQ,aAAa;KACjC,OAAO,KAAK;KACZ,OAAO;IACT;GACF;SACK,IAAI,cAAc,IAAI;GAE3B,MAAM,YAAY,YAAY;GAC9B,MAAM,cAAc,YAAY;GAEhC,IAAI,gBAAgB,YAAY;IAI9B,OAAO,KAAA;IACP,OAAO,KAAK,QAAQ;IACpB,OAAO,KAAK,QAAQ;IACpB,OAAO,KAAK,QAAQ;IACpB,OAAO,KAAK,QAAQ,aAAa;IACjC,OAAO,KAAK,KAAK;IACjB,OAAO;GACT;GAIA,OAAO,KAAA;GACP,OAAO,KAAK,QAAQ;GACpB,OAAO,KAAK,QAAQ;GACpB,OAAO,KAAK,QAAQ;GACpB,OAAO,KAAK,QAAQ,aAAa;GACjC,OAAO,KAAK;GACZ,OAAO;EACT;CACF;CAGA,OAAO,KAAA;CACP,OAAO,KAAK;CACZ,OAAO,KAAK;CACZ,OAAO,KAAK;CACZ,OAAO,KAAK;CACZ,OAAO,KAAK;CACZ,OAAO;AACT;;;;;;;;;;AAWA,SAAS,cACP,sBACA,MACA,OACA,OACA,MACA,OACA,SACA;CACA,UAAU,KAAK;CACf,IAAI,SAAS;CACb;EACE,MAAM,OAAO,MAAM,YAAY,MAAM;EACrC,MAAM,SAAS,KAAK;EACpB,MAAM,gBAAgB,MAAM,SAAS,iBAAiB;EACtD,MAAM,cACJ,MAAM,SAAS,QAAQ,SAAS,MAAM,SAAS;EACjD,OAAO,SAAS,QAAQ;GACtB,MAAM,UAAU,aAAa,MAAM,QAAQ,IAAI;GAC/C,IAAI;GACJ,MAAM,QAAQ;GACd,MAAM,MAAM,QAAQ;GACpB,SAAS,MAAM;GACf;GAEA,QADa,QAAQ,IACrB;IACE,KAAA,GAA4B;KAC1B,MAAM,QAAQ,KAAK,UAAU,QAAQ,IAAI,QAAQ,EAAE;KACnD,IAAI,eAAe;MACjB,MAAM,eAAe,KAAK,QAAQ,IAAI,KAAK;MAC3C,IAAI,cACF,WAAW;WACN;OACL,KAAK,2BAAW,IAAI,IAAI;OACxB,MAAM,OAAO,iBACX,MAAM,YAAY,MAAM,IAC1B;OACA,KAAK,SAAS;OACd,KAAK,QAAQ;OACb,WAAW;OACX,KAAK,OAAO,IAAI,OAAO,IAAI;MAC7B;KACF,OAAO;MACL,MAAM,OAAO,MAAM,YAAY;MAC/B,MAAM,eAAe,KAAK,mBAAmB,IAAI,IAAI;MACrD,IAAI,cACF,WAAW;WACN;OACL,KAAK,sCAAsB,IAAI,IAAI;OACnC,MAAM,OAAO,iBACX,MAAM,YAAY,MAAM,IAC1B;OACA,KAAK,SAAS;OACd,KAAK,QAAQ;OACb,WAAW;OACX,KAAK,kBAAkB,IAAI,MAAM,IAAI;MACvC;KACF;KACA;IACF;IACA,KAAA,GAAyB;KACvB,MAAM,aAAa,KAAK,UAAU,OAAO,QAAQ,EAAE;KACnD,MAAM,aAAa,KAAK,UAAU,QAAQ,IAAI,GAAG;KACjD,MAAM,wBACJ,iBAAiB,CAAC,EAAE,cAAc;KACpC,MAAM,SAAS,CAAC,aACZ,KAAA,IACA,wBACE,aACA,WAAW,YAAY;KAC7B,MAAM,SAAS,CAAC,aACZ,KAAA,IACA,wBACE,aACA,WAAW,YAAY;KAC7B,MAAM,eACJ,CAAC,eACD,KAAK,SAAS,MACX,MACC,CAAC,EAAE,SACH,EAAE,kBAAkB,yBACpB,EAAE,WAAW,UACb,EAAE,WAAW,MACjB;KACF,IAAI,cACF,WAAW;UACN;MACL,MAAM,OAAO,kBAAA,GAEX,MAAM,YAAY,MAAM,MACxB,uBACA,QACA,MACF;MACA,WAAW;MACX,KAAK,QAAQ;MACb,KAAK,SAAS;MACd,KAAK,YAAY,CAAC;MAClB,KAAK,QAAQ,KAAK,IAAI;KACxB;KACA;IACF;IACA,KAAA,GAAkC;KAChC,MAAM,aAAa,KAAK,UAAU,OAAO,QAAQ,EAAE;KACnD,MAAM,aAAa,KAAK,UAAU,QAAQ,IAAI,GAAG;KACjD,MAAM,wBACJ,iBAAiB,CAAC,EAAE,cAAc;KACpC,MAAM,SAAS,CAAC,aACZ,KAAA,IACA,wBACE,aACA,WAAW,YAAY;KAC7B,MAAM,SAAS,CAAC,aACZ,KAAA,IACA,wBACE,aACA,WAAW,YAAY;KAC7B,MAAM,eACJ,CAAC,eACD,KAAK,UAAU,MACZ,MACC,CAAC,EAAE,SACH,EAAE,kBAAkB,yBACpB,EAAE,WAAW,UACb,EAAE,WAAW,MACjB;KACF,IAAI,cACF,WAAW;UACN;MACL,MAAM,OAAO,kBAAA,GAEX,MAAM,YAAY,MAAM,MACxB,uBACA,QACA,MACF;MACA,WAAW;MACX,KAAK,SAAS;MACd,KAAK,QAAQ;MACb,KAAK,aAAa,CAAC;MACnB,KAAK,SAAS,KAAK,IAAI;KACzB;KACA;IACF;IACA,KAAA,GAA4B;KAC1B,MAAM,aAAa,KAAK,UAAU,OAAO,QAAQ,EAAE;KACnD,MAAM,aAAa,KAAK,UAAU,QAAQ,IAAI,GAAG;KACjD,MAAM,wBACJ,iBAAiB,CAAC,EAAE,cAAc;KACpC,MAAM,SAAS,CAAC,aACZ,KAAA,IACA,wBACE,aACA,WAAW,YAAY;KAC7B,MAAM,SAAS,CAAC,aACZ,KAAA,IACA,wBACE,aACA,WAAW,YAAY;KAC7B,MAAM,OAAO,kBAAA,GAEX,MAAM,YAAY,MAAM,MACxB,uBACA,QACA,MACF;KACA,WAAW;KACX,KAAK,SAAS;KACd,KAAK,QAAQ;KACb,KAAK,aAAa,CAAC;KACnB,KAAK,SAAS,KAAK,IAAI;IACzB;GACF;GACA,OAAO;EACT;EAGA,IACE,eACA,MAAM,YACN,CAAC,MAAM,UACP,MAAM,MACN,MAAM,GAAG,WAAW,MAAM,GAAG,YAAY,GAAG,IAAI,CAAC,MAAM,IACvD;GACA,MAAM,eAAe,iBACnB,MAAM,YAAY,MAAM,IAC1B;GACA,aAAa,OAAO;GACpB,aAAa,SAAS;GACtB;GACA,aAAa,QAAQ;GACrB,KAAK,aAAa,CAAC;GACnB,KAAK,SAAS,KAAK,YAAY;GAC/B,OAAO;EACT;EAEA,MAAM,UAAU,MAAM,QAAQ,CAAC,MAAM,aAAa,CAAC,MAAM;EAEzD,IAAI,UAAU,KAAK,SAAS,GAAG,GAAG;GAChC,MAAM,YAAY,iBAChB,MAAM,YAAY,MAAM,IAC1B;GACA,UAAU,OAAO;GACjB,UAAU,SAAS;GACnB;GACA,UAAU,QAAQ;GAClB,KAAK,QAAQ;GACb,OAAO;EACT;EAEA,KAAK,QAAQ,eAAe;EAC5B,KAAK,WAAW,MAAM,SAAS,QAAQ,YAAY;EAGnD,IAAI,UAAU,CAAC,KAAK,OAAO;GACzB,KAAK,QAAQ;GACb,KAAK,WAAW,MAAM,YAAY,MAAM;EAC1C;CACF;CACA,IAAI,MAAM,UACR,KAAK,MAAM,SAAS,MAAM,UACxB,cACE,sBACA,MACA,OACA,QACA,MACA,OACA,OACF;AAEN;AAEA,SAAS,YACP,GAOA,GAOA;CACA,IAAI,EAAE,SAAS,CAAC,EAAE,OAAO,OAAO;CAChC,IAAI,CAAC,EAAE,SAAS,EAAE,OAAO,OAAO;CAChC,IAAI,EAAE,SAAS,EAAE,UAAU,EAAE,YAAY,EAAE,WACzC,OAAO,EAAE,WAAW,EAAE;CACxB,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,QAAQ;EACjD,IAAI,EAAE,OAAO,WAAW,EAAE,MAAM,GAAG,OAAO;EAC1C,IAAI,EAAE,OAAO,WAAW,EAAE,MAAM,GAAG,OAAO;CAC5C;CACA,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,QAAQ;EACjD,IAAI,EAAE,OAAO,SAAS,EAAE,MAAM,GAAG,OAAO;EACxC,IAAI,EAAE,OAAO,SAAS,EAAE,MAAM,GAAG,OAAO;CAC1C;CACA,IAAI,EAAE,UAAU,CAAC,EAAE,QAAQ,OAAO;CAClC,IAAI,CAAC,EAAE,UAAU,EAAE,QAAQ,OAAO;CAClC,IAAI,EAAE,UAAU,CAAC,EAAE,QAAQ,OAAO;CAClC,IAAI,CAAC,EAAE,UAAU,EAAE,QAAQ,OAAO;CAClC,IAAI,EAAE,iBAAiB,CAAC,EAAE,eAAe,OAAO;CAChD,IAAI,CAAC,EAAE,iBAAiB,EAAE,eAAe,OAAO;CAGhD,OAAO;AACT;AAEA,SAAS,cAAc,MAA8B;CACnD,IAAI,KAAK,UACP,KAAK,MAAM,SAAS,KAAK,UACvB,cAAc,KAAK;CAGvB,IAAI,KAAK,QACP,KAAK,MAAM,SAAS,KAAK,OAAO,OAAO,GACrC,cAAc,KAAK;CAGvB,IAAI,KAAK,mBACP,KAAK,MAAM,SAAS,KAAK,kBAAkB,OAAO,GAChD,cAAc,KAAK;CAGvB,IAAI,KAAK,SAAS,QAAQ;EACxB,KAAK,QAAQ,KAAK,WAAW;EAC7B,KAAK,MAAM,SAAS,KAAK,SACvB,cAAc,KAAK;CAEvB;CACA,IAAI,KAAK,UAAU,QAAQ;EACzB,KAAK,SAAS,KAAK,WAAW;EAC9B,KAAK,MAAM,SAAS,KAAK,UACvB,cAAc,KAAK;CAEvB;CACA,IAAI,KAAK,UAAU,QAAQ;EACzB,KAAK,SAAS,KAAK,WAAW;EAC9B,KAAK,MAAM,SAAS,KAAK,UACvB,cAAc,KAAK;CAEvB;AACF;AAEA,SAAS,iBACP,UACsB;CACtB,OAAO;EACL,MAAA;EACA,OAAO;EACP,UAAU;EACV,OAAO;EACP,QAAQ;EACR,mBAAmB;EACnB,SAAS;EACT,UAAU;EACV,UAAU;EACV,OAAO;EACP;EACA,QAAQ;EACR,OAAO;EACP,UAAU;CACZ;AACF;;;;;AAMA,SAAS,kBACP,MAIA,UACA,eACA,QACA,QACuB;CACvB,OAAO;EACL;EACA,OAAO;EACP,UAAU;EACV,OAAO;EACP,QAAQ;EACR,mBAAmB;EACnB,SAAS;EACT,UAAU;EACV,UAAU;EACV,OAAO;EACP;EACA,QAAQ;EACR,OAAO;EACP,UAAU;EACV;EACA;EACA;CACF;AACF;AAqGA,SAAgB,kBAGd,WACA,eACA;CACA,MAAM,cAAc,iBAA6B,GAAG;CACpD,MAAM,OAAO,IAAI,YAAY,CAAC;CAC9B,KAAK,MAAM,SAAS,WAClB,cAAc,OAAO,MAAM,OAAO,GAAG,aAAa,CAAC;CAErD,cAAc,WAAW;CACzB,cAAc,YAAY;CAC1B,cAAc,YAAY,kBAAA,eAGxB,GAAI;AACR;;;;AAKA,SAAgB,cAEd,MAEA,eACA;CACA,SAAS;CACT,MAAM,SAAS,cAAc,UAAW,IAAI,IAAI;CAChD,IAAI,QAAQ,OAAO;CACnB,MAAM,SAAS,UAAU,MAAM,cAAc,SAAU;CACvD,cAAc,UAAW,IAAI,MAAM,MAAM;CACzC,OAAO;AACT;;;;AAKA,SAAgB,gBACd,MACA,eACA,OACA,MACA,eACA;CACA,SAAS;CACT,SAAS;CACT,MAAM,MAAM,gBAAgB,SAAS,SAAS;CAC9C,IAAI,OAAO,cAAc,YAAY,IAAI,GAAG;CAC5C,IAAI,CAAC,MAAM;EAGT,OAAO,iBAAmC,GAAG;EAE7C,cAAc,eAAe,IADZ,YAAY,CACA,GAAM,EAAE,KAAK,GAAG,GAAG,MAAM,CAAC;EACvD,cAAc,YAAY,IAAI,KAAK,IAAI;CACzC;CACA,OAAO,UAAU,MAAM,MAAM,KAAK;AACpC;AAQA,SAAgB,eAId,MAEA,eAEA,QAAQ,OACc;CACtB,MAAM,MAAM,QAAQ,OAAO,WAAW;CACtC,MAAM,SAAS,cAAc,WAAW,IAAI,GAAG;CAC/C,IAAI,WAAW,KAAA,GAAW,OAAO;CACjC,SAAS;CACT,IAAI;CAEJ,IAAI;EACF,SAAS,UACP,MACA,cAAc,aACd,KACF;CACF,SAAS,KAAK;EACZ,IAAI,eAAe,UACjB,SAAS;OAET,MAAM;CAEV;CAEA,IAAI,QAAQ,OAAO,SAAS,iBAAiB,OAAO,KAAK;CACzD,cAAc,WAAW,IAAI,KAAK,MAAM;CACxC,OAAO;AACT;;AAGA,SAAgB,cAAc,MAAc;CAC1C,OAAO,SAAS,MAAM,OAAO,KAAK,QAAQ,WAAW,EAAE;AACzD;;;;;AAiBA,SAAgB,iBAId,WAEA,gBAAyB,OAEzB,WACoC;CACpC,MAAM,cAAc,iBAA6B,UAAU,QAAQ;CACnE,MAAM,OAAO,IAAI,YAAY,CAAC;CAC9B,MAAM,aAAa,CAAC;CACpB,MAAM,eAAe,CAAC;CACtB,IAAI,QAAQ;CACZ,cAAc,eAAe,MAAM,WAAW,GAAG,aAAa,IAAI,UAAU;EAC1E,YAAY,OAAO,KAAK;EAExB,IAAI,MAAM,MAAM,YAAY;GAC1B,IAAA,QAAA,IAAA,aAA6B,cAC3B,MAAM,IAAI,MACR,qDAAqD,OAAO,MAAM,EAAE,GACtE;GAGF,kBAAA,UAAU;EACZ;EAEA,WAAW,MAAM,MAAM;EAEvB,IAAI,UAAU,KAAK,MAAM,MAAM;GAC7B,MAAM,kBAAkB,cAAc,MAAM,QAAQ;GACpD,IAAI,CAAC,aAAa,oBAAoB,MAAM,SAAS,SAAS,GAAG,GAC/D,aAAa,mBAAmB;EAEpC;EAEA;CACF,CAAC;CACD,cAAc,WAAW;CAQzB,OAAO;EACL,eAAA;GAPA;GACA,aAAa,kBAAA,eAA4C,GAAI;GAC7D,YAAY,kBAAA,eAAsD,GAAI;GACtE,WAAW;GACX,WAAW;EAGX;EACA;EACA;CACF;AACF;AAEA,SAAS,UACP,MACA,aACA,QAAQ,OAQD;CACP,MAAM,QAAQ,KAAK,MAAM,GAAG;CAC5B,MAAM,OAAO,aAAa,MAAM,OAAO,aAAa,KAAK;CACzD,IAAI,CAAC,MAAM,OAAO;CAClB,MAAM,CAAC,aAAa,cAAc,MAAM,OAAO,IAAI;CACnD,OAAO;EACL,OAAO,KAAK,KAAK;EACjB;CACF;AACF;;;;;;;;AAgBA,SAAS,cACP,MACA,OACA,MAMkE;CAClE,MAAM,OAAO,YAAY,KAAK,IAAI;CAClC,IAAI,YAAkC;CACtC,MAAM,YAAoC,OAAO,OAAO,IAAI;;CAE5D,IAAI,YAAY,KAAK,SAAS,QAAQ;;CAEtC,IAAI,YAAY,KAAK,SAAS,QAAQ;;CAEtC,IAAI,YAAY,KAAK,SAAS,QAAQ;;CAEtC,IAAI,eAAe,KAAK,SAAS,WAAW;CAC5C,OAEE,YAAY,KAAK,QACjB,aAAa,aAAa,aAAa,gBACvC;EACA,MAAM,OAAO,KAAK;EAElB,IAAI,KAAK,SAAS,oBAAoB;EAEtC,IAAI,KAAK,SAAS,uBAAuB;GACvC;GACA;GACA;GACA;EACF;EACA,MAAM,OAAO,MAAM;EACnB,MAAM,mBAAmB;EACzB,IAAI,MAAM,aAAa,KAAK;EAC5B,IAAI,KAAK,SAAA,GAA6B;GACpC,cAAc,KAAK,KAAK,SAAS,MAAM,GAAG;GAC1C,MAAM,WAAW,UAAU;GAC3B,MAAM,YAAY,KAAK,QAAQ,UAAU;GAIzC,IAFsB,SAAS,WAAW,SAAS,MAAM,KAEtC;IACjB,MAAM,YAAY,KAAK,QAAQ,UAAU;IACzC,MAAM,OAAO,SAAS,UACpB,YAAY,GACZ,SAAS,SAAS,YAAY,CAChC;IACA,MAAM,QAAQ,KAAM,UAAU,WAAW,KAAM,SAAS,SAAS;IACjE,UAAU,QAAQ,mBAAmB,KAAK;GAC5C,OAAO;IACL,MAAM,OAAO,SAAS,UAAU,CAAC;IACjC,UAAU,QAAQ,mBAAmB,IAAK;GAC5C;EACF,OAAO,IAAI,KAAK,SAAA,GAAsC;GACpD,IAAI,KAAK,UAAW,KAAK,WAAY;IACnC;IACA,YAAY,mBAAmB;IAC/B;GACF;GACA,cAAc,KAAK,KAAK,SAAS,MAAM,GAAG;GAC1C,MAAM,WAAW,UAAU;GAC3B,MAAM,YAAY,KAAK,QAAQ,UAAU;GACzC,MAAM,YAAY,KAAK,QAAQ,UAAU;GACzC,MAAM,OAAO,SAAS,UACpB,YAAY,GACZ,SAAS,SAAS,YAAY,CAChC;GACA,MAAM,QACJ,KAAK,UAAU,KAAK,SAChB,KAAM,UAAU,WAAW,KAAM,SAAS,SAAS,IACnD;GACN,IAAI,OAAO,UAAU,QAAQ,mBAAmB,KAAK;EACvD,OAAO,IAAI,KAAK,SAAA,GAAgC;GAC9C,MAAM,IAAI;GACV,MAAM,QAAQ,KAAK,UACjB,oBAAoB,EAAE,QAAQ,UAAU,IACxC,KAAK,UAAU,EAAE,QAAQ,UAAU,EACrC;GACA,MAAM,QAAQ,mBAAmB,KAAK;GAEtC,UAAU,OAAO;GACjB,UAAU,SAAS;GACnB;EACF;CACF;CACA,IAAI,KAAK,WAAW,OAAO,OAAO,WAAW,KAAK,SAAS;CAC3D,OAAO,CACL,WACA;EACE,MAAM;EACN,MAAM;EACN,MAAM;EACN,SAAS;CACX,CACF;AACF;AAEA,SAAgB,iBAAsC,OAAU;CAC9D,MAAM,OAAO,CAAC,KAAK;CACnB,OAAO,MAAM,aAAa;EACxB,QAAQ,MAAM;EACd,KAAK,KAAK,KAAK;CACjB;CACA,KAAK,QAAQ;CACb,OAAO;AACT;AAEA,SAAS,YAAiC,MAAyB;CACjE,MAAM,OAAiC,MAAM,KAAK,QAAQ,CAAC;CAC3D,GAAG;EACD,KAAK,KAAK,SAAS;EACnB,OAAO,KAAK;CACd,SAAS;CACT,OAAO;AACT;AAyBA,SAAS,aACP,MACA,OACA,aACA,OACA;CAGA,IAAI,SAAS,OAAO,YAAY,OAC9B,OAAO;EAAE,MAAM,YAAY;EAAO,SAAS;CAAE;CAK/C,MAAM,gBAAgB,CAAC,cAAA,KAAK,KAAK;CACjC,MAAM,cAAc,iBAAiB,SAAS;CAC9C,MAAM,cAAc,MAAM,UAAU,gBAAgB,IAAI;CAWxD,MAAM,QAAsB,CAC1B;EACE,MAAM;EACN,OAAO;EACP,SAAS;EACT,OAAO;EACP,SAAS;EACT,UAAU;EACV,WAAW;CACb,CACF;CAEA,IAAI,YAA0B;CAC9B,IAAI,YAA0B;CAE9B,OAAO,MAAM,QAAQ;EACnB,MAAM,QAAQ,MAAM,IAAI;EACxB,MAAM,EAAE,MAAM,OAAO,SAAS,OAAO,SAAS,UAAU,cAAc;EACtE,IAAI,EAAE,SAAS,cAAc;EAM7B,IACE,KAAK,SAAA,KACL,KAAK,SACL,CAAC,oBAAoB,WAAW,KAAK,GAErC;EAGF,IAAI,KAAK,OAAO;GAEd,IAAI,CADW,oBAAoB,MAAM,OAAO,KAC3C,GAAQ;GACb,YAAY,MAAM;GAClB,UAAU,MAAM;EAClB;EAGA,IACE,SACA,KAAK,SACL,KAAK,SAAS,sBACd,oBAAoB,WAAW,KAAK,GAEpC,YAAY;EAGd,MAAM,eAAe,UAAU;EAC/B,IAAI,cAAc;GAChB,IACE,KAAK,UACJ,CAAC,eACA,KAAK,SAAS,sBACd,KAAK,SAAA,MACP,oBAAoB,WAAW,KAAK,GAEpC,YAAY;GAGd,IAAI,CAAC,KAAK,YAAY,CAAC,KAAK,YAAY,CAAC,KAAK,SAAS,CAAC,KAAK,UAC3D;EACJ;EAEA,MAAM,OAAO,eAAe,KAAA,IAAY,MAAM;EAC9C,IAAI;EAGJ,IAAI,gBAAgB,KAAK,OAAO;GAC9B,MAAM,aAAa;IACjB,MAAM,KAAK;IACX;IACA;IACA,OAAO,QAAQ;IACf;IACA;IACA;IACA;IACA;GACF;GACA,IAAI,aAAa;GACjB,IAAI,KAAK,MAAM;QAET,CADW,oBAAoB,MAAM,OAAO,UAC3C,GAAQ,aAAa;GAAA;GAE5B,IAAI,YAAY;IAGd,IACE,CAAC,YACD,CAAC,aACD,CAAC,WACD,qBAAqB,SAAS,WAAW,GAEzC,OAAO;IAET,IAAI,oBAAoB,WAAW,UAAU,GAE3C,YAAY;GAEhB;EACF;EAGA,IAAI,KAAK,UACP,KAAK,IAAI,IAAI,KAAK,SAAS,SAAS,GAAG,KAAK,GAAG,KAAK;GAClD,MAAM,UAAU,KAAK,SAAS;GAC9B,MAAM,EAAE,QAAQ,WAAW;GAC3B,IAAI,QAAQ;IACV,IAAI,cAAc;IAIlB,IAAI,EAHa,QAAQ,gBACrB,OACC,cAAc,KAAM,YAAY,GACtB,WAAW,MAAM,GAAG;GACrC;GACA,IAAI,QAAQ;IACV,IAAI,cAAc;IAClB,MAAM,MAAM,MAAM,MAAM,KAAK,EAAE,KAAK,GAAG,EAAE,MAAM,CAAC,OAAO,MAAM;IAE7D,KADiB,QAAQ,gBAAgB,MAAM,IAAI,YAAY,OAC9C,QAAQ;GAC3B;GAEA,MAAM,KAAK;IACT,MAAM;IACN,OAAO;IACP;IACA,OAAO,QAAQ;IACf;IACA;IACA;IACA;IACA;GACF,CAAC;EACH;EAIF,IAAI,KAAK,UAAU;GACjB,MAAM,cAAc,UAAW,KAAK;GACpC,MAAM,YAAY,QAAQ;GAC1B,KAAK,IAAI,IAAI,KAAK,SAAS,SAAS,GAAG,KAAK,GAAG,KAAK;IAClD,MAAM,UAAU,KAAK,SAAS;IAE9B,MAAM,KAAK;KACT,MAAM;KACN;KACA,SAAS;KACT,OAAO;KACP;KACA;KACA;KACA;KACA;IACF,CAAC;GACH;GACA,IAAI,CAAC,cACH,KAAK,IAAI,IAAI,KAAK,SAAS,SAAS,GAAG,KAAK,GAAG,KAAK;IAClD,MAAM,UAAU,KAAK,SAAS;IAC9B,MAAM,EAAE,QAAQ,WAAW;IAC3B,IAAI,UAAU,QAAQ;KACpB,MAAM,WAAW,QAAQ,gBACrB,OACC,cAAc,KAAM,YAAY;KACrC,IAAI,UAAU,CAAC,SAAS,WAAW,MAAM,GAAG;KAC5C,IAAI,UAAU,CAAC,SAAS,SAAS,MAAM,GAAG;IAC5C;IACA,MAAM,KAAK;KACT,MAAM;KACN,OAAO,QAAQ;KACf;KACA,OAAO;KACP;KACA;KACA,WAAW,YAAY,aAAa,aAAa,KAAK;KACtD;KACA;IACF,CAAC;GACH;EAEJ;EAGA,IAAI,CAAC,gBAAgB,KAAK,WAAW,MACnC,KAAK,IAAI,IAAI,KAAK,QAAQ,SAAS,GAAG,KAAK,GAAG,KAAK;GACjD,MAAM,UAAU,KAAK,QAAQ;GAC7B,MAAM,EAAE,QAAQ,WAAW;GAC3B,IAAI,UAAU,QAAQ;IACpB,MAAM,WAAW,QAAQ,gBACrB,OACC,cAAc,KAAK,YAAY;IACpC,IAAI,UAAU,CAAC,SAAS,WAAW,MAAM,GAAG;IAC5C,IAAI,UAAU,CAAC,SAAS,SAAS,MAAM,GAAG;GAC5C;GACA,MAAM,KAAK;IACT,MAAM;IACN,OAAO,QAAQ;IACf;IACA,OAAO,QAAQ;IACf;IACA,UAAU,WAAW,aAAa,aAAa,KAAK;IACpD;IACA;IACA;GACF,CAAC;EACH;EAIF,IAAI,CAAC,gBAAgB,KAAK,mBAAmB;GAC3C,MAAM,QAAQ,KAAK,kBAAkB,IAClC,cAAc,KAAM,YAAY,CACnC;GACA,IAAI,OACF,MAAM,KAAK;IACT,MAAM;IACN,OAAO,QAAQ;IACf;IACA,OAAO,QAAQ;IACf,SAAS,UAAU,aAAa,aAAa,KAAK;IAClD;IACA;IACA;IACA;GACF,CAAC;EAEL;EAGA,IAAI,CAAC,gBAAgB,KAAK,QAAQ;GAChC,MAAM,QAAQ,KAAK,OAAO,IAAI,IAAK;GACnC,IAAI,OACF,MAAM,KAAK;IACT,MAAM;IACN,OAAO,QAAQ;IACf;IACA,OAAO,QAAQ;IACf,SAAS,UAAU,aAAa,aAAa,KAAK;IAClD;IACA;IACA;IACA;GACF,CAAC;EAEL;EAGA,IAAI,KAAK,UAAU;GACjB,MAAM,YAAY,QAAQ;GAC1B,KAAK,IAAI,IAAI,KAAK,SAAS,SAAS,GAAG,KAAK,GAAG,KAAK;IAClD,MAAM,UAAU,KAAK,SAAS;IAC9B,MAAM,KAAK;KACT,MAAM;KACN;KACA;KACA,OAAO;KACP;KACA;KACA;KACA;KACA;IACF,CAAC;GACH;EACF;CACF;CAEA,IAAI,WAAW,OAAO;CAEtB,IAAI,SAAS,WAAW;EACtB,IAAI,aAAa,UAAU;EAC3B,KAAK,IAAI,IAAI,GAAG,IAAI,UAAU,OAAO,KACnC,cAAc,MAAM,GAAI;EAE1B,MAAM,QAAQ,eAAe,KAAK,SAAS,MAAM,KAAK,MAAM,UAAU;EACtE,UAAU,cAAc,OAAO,OAAO,IAAI;EAC1C,UAAU,UAAW,QAAQ,mBAAmB,KAAK;EACrD,OAAO;CACT;CAEA,OAAO;AACT;AAEA,SAAS,aAAa,aAAqB,OAAuB;CAMhE,OAAO,MAAM,cAAc,QAAQ;AACrC;AAEA,SAAS,qBAAqB,SAAiB,aAA8B;CAC3E,OAAO,YAAY,MAAM,cAAc,KAAK;AAC9C;AAEA,SAAS,oBACP,MACA,OACA,OACA;CACA,IAAI;CACJ,IAAI;CAEJ,IAAI;EACD,CAAC,WAAW,SAAS,cAAc,MAAM,OAAO,KAAK;CACxD,QAAQ;EACN,OAAO;CACT;CAEA,MAAM,YAAY;CAClB,MAAM,UAAU;CAEhB,IAAI,CAAC,MAAM,KAAK,OAAO,OAAO;CAE9B,IAAI;EACF,IAAI,MAAM,KAAK,MAAM,SAAS,MAAM,OAAO,OAAO;CACpD,QAAQ,CAGR;CAEA,OAAO;AACT;AAEA,SAAS,oBAEP,MAEA,MACS;CACT,IAAI,CAAC,MAAM,OAAO;CAClB,OACE,KAAK,UAAU,KAAK,WACnB,KAAK,YAAY,KAAK,YACpB,KAAK,WAAW,KAAK,YACnB,KAAK,aAAa,KAAK,aACrB,KAAK,YAAY,KAAK,aACpB,KAAK,cAAc,KAAK,eACrB,KAAK,KAAK,SAAS,uBAClB,KAAK,KAAK,SAAS,uBAClB,KAAK,KAAK,SAAS,wBAClB,KAAK,KAAK,SAAS,uBACpB,KAAK,QAAQ,KAAK;AAEpC"}
+{"version":3,"file":"new-process-route-tree.cjs","names":[],"sources":["../../src/new-process-route-tree.ts"],"sourcesContent":["import { invariant } from './invariant'\nimport { createLRUCache } from './lru-cache'\nimport { last } from './utils'\nimport type { LRUCache } from './lru-cache'\n\nexport const SEGMENT_TYPE_PATHNAME = 0\nexport const SEGMENT_TYPE_PARAM = 1\nexport const SEGMENT_TYPE_WILDCARD = 2\nexport const SEGMENT_TYPE_OPTIONAL_PARAM = 3\nconst SEGMENT_TYPE_INDEX = 4\nconst SEGMENT_TYPE_PATHLESS = 5 // only used in matching to represent pathless routes that need to carry more information\n\n/**\n * All the kinds of segments that can be present in a route path.\n */\nexport type SegmentKind =\n  | typeof SEGMENT_TYPE_PATHNAME\n  | typeof SEGMENT_TYPE_PARAM\n  | typeof SEGMENT_TYPE_WILDCARD\n  | typeof SEGMENT_TYPE_OPTIONAL_PARAM\n\n/**\n * All the kinds of segments that can be present in the segment tree.\n */\ntype ExtendedSegmentKind =\n  | SegmentKind\n  | typeof SEGMENT_TYPE_INDEX\n  | typeof SEGMENT_TYPE_PATHLESS\n\nfunction getOpenAndCloseBraces(\n  part: string,\n): [openBrace: number, closeBrace: number] | null {\n  const openBrace = part.indexOf('{')\n  if (openBrace === -1) return null\n  const closeBrace = part.indexOf('}', openBrace)\n  if (closeBrace === -1) return null\n  const afterOpen = openBrace + 1\n  if (afterOpen >= part.length) return null\n  return [openBrace, closeBrace]\n}\n\ntype ParsedSegment = Uint16Array & {\n  /** segment type (0 = pathname, 1 = param, 2 = wildcard, 3 = optional param) */\n  0: SegmentKind\n  /** index of the end of the prefix */\n  1: number\n  /** index of the start of the value */\n  2: number\n  /** index of the end of the value */\n  3: number\n  /** index of the start of the suffix */\n  4: number\n  /** index of the end of the segment */\n  5: number\n}\n\n/**\n * Populates the `output` array with the parsed representation of the given `segment` string.\n *\n * Usage:\n * ```ts\n * let output\n * let cursor = 0\n * while (cursor < path.length) {\n *   output = parseSegment(path, cursor, output)\n *   const end = output[5]\n *   cursor = end + 1\n * ```\n *\n * `output` is stored outside to avoid allocations during repeated calls. It doesn't need to be typed\n * or initialized, it will be done automatically.\n */\nexport function parseSegment(\n  /** The full path string containing the segment. */\n  path: string,\n  /** The starting index of the segment within the path. */\n  start: number,\n  /** A Uint16Array (length: 6) to populate with the parsed segment data. */\n  output: Uint16Array = new Uint16Array(6),\n): ParsedSegment {\n  const next = path.indexOf('/', start)\n  const end = next === -1 ? path.length : next\n  const part = path.substring(start, end)\n\n  if (!part || !part.includes('$')) {\n    // early escape for static pathname\n    output[0] = SEGMENT_TYPE_PATHNAME\n    output[1] = start\n    output[2] = start\n    output[3] = end\n    output[4] = end\n    output[5] = end\n    return output as ParsedSegment\n  }\n\n  // $ (wildcard)\n  if (part === '$') {\n    const total = path.length\n    output[0] = SEGMENT_TYPE_WILDCARD\n    output[1] = start\n    output[2] = start\n    output[3] = total\n    output[4] = total\n    output[5] = total\n    return output as ParsedSegment\n  }\n\n  // $paramName\n  if (part.charCodeAt(0) === 36) {\n    output[0] = SEGMENT_TYPE_PARAM\n    output[1] = start\n    output[2] = start + 1 // skip '$'\n    output[3] = end\n    output[4] = end\n    output[5] = end\n    return output as ParsedSegment\n  }\n\n  const braces = getOpenAndCloseBraces(part)\n  if (braces) {\n    const [openBrace, closeBrace] = braces\n    const firstChar = part.charCodeAt(openBrace + 1)\n\n    // Check for {-$...} (optional param)\n    // prefix{-$paramName}suffix\n    // /^([^{]*)\\{-\\$([a-zA-Z_$][a-zA-Z0-9_$]*)\\}([^}]*)$/\n    if (firstChar === 45) {\n      // '-'\n      if (\n        openBrace + 2 < part.length &&\n        part.charCodeAt(openBrace + 2) === 36 // '$'\n      ) {\n        const paramStart = openBrace + 3\n        const paramEnd = closeBrace\n        // Validate param name exists\n        if (paramStart < paramEnd) {\n          output[0] = SEGMENT_TYPE_OPTIONAL_PARAM\n          output[1] = start + openBrace\n          output[2] = start + paramStart\n          output[3] = start + paramEnd\n          output[4] = start + closeBrace + 1\n          output[5] = end\n          return output as ParsedSegment\n        }\n      }\n    } else if (firstChar === 36) {\n      // '$'\n      const dollarPos = openBrace + 1\n      const afterDollar = openBrace + 2\n      // Check for {$} (wildcard)\n      if (afterDollar === closeBrace) {\n        // For wildcard, value should be '$' (from dollarPos to afterDollar)\n        // prefix{$}suffix\n        // /^([^{]*)\\{\\$\\}([^}]*)$/\n        output[0] = SEGMENT_TYPE_WILDCARD\n        output[1] = start + openBrace\n        output[2] = start + dollarPos\n        output[3] = start + afterDollar\n        output[4] = start + closeBrace + 1\n        output[5] = path.length\n        return output as ParsedSegment\n      }\n      // Regular param {$paramName} - value is the param name (after $)\n      // prefix{$paramName}suffix\n      // /^([^{]*)\\{\\$([a-zA-Z_$][a-zA-Z0-9_$]*)\\}([^}]*)$/\n      output[0] = SEGMENT_TYPE_PARAM\n      output[1] = start + openBrace\n      output[2] = start + afterDollar\n      output[3] = start + closeBrace\n      output[4] = start + closeBrace + 1\n      output[5] = end\n      return output as ParsedSegment\n    }\n  }\n\n  // fallback to static pathname (should never happen)\n  output[0] = SEGMENT_TYPE_PATHNAME\n  output[1] = start\n  output[2] = start\n  output[3] = end\n  output[4] = end\n  output[5] = end\n  return output as ParsedSegment\n}\n\n/**\n * Recursively parses the segments of the given route tree and populates a segment trie.\n *\n * @param data A reusable Uint16Array for parsing segments. (non important, we're just avoiding allocations)\n * @param route The current route to parse.\n * @param start The starting index for parsing within the route's full path.\n * @param node The current segment node in the trie to populate.\n * @param onRoute Callback invoked for each route processed.\n */\nfunction parseSegments<TRouteLike extends RouteLike>(\n  defaultCaseSensitive: boolean,\n  data: Uint16Array,\n  route: TRouteLike,\n  start: number,\n  node: AnySegmentNode<TRouteLike>,\n  depth: number,\n  /** Each dynamic sibling list is recorded once, when it first needs sorting. */\n  dynamicListsToSort?: Array<Array<DynamicSegmentNode<TRouteLike>>>,\n  onRoute?: (route: TRouteLike) => void,\n) {\n  onRoute?.(route)\n  let cursor = start\n  {\n    const path = route.fullPath ?? route.from\n    const options = route.options\n    const length = path.length\n    const caseSensitive = options?.caseSensitive ?? defaultCaseSensitive\n    const parseParams = options?.params?.parse ?? options?.parseParams\n    while (cursor < length) {\n      const segment = parseSegment(path, cursor, data)\n      let nextNode: AnySegmentNode<TRouteLike>\n      const start = cursor\n      const end = segment[5]\n      cursor = end + 1\n      depth++\n      const kind = segment[0]\n      switch (kind) {\n        case SEGMENT_TYPE_PATHNAME: {\n          const value = path.substring(segment[2], segment[3])\n          let name = value\n          let staticChildren: Map<string, StaticSegmentNode<TRouteLike>>\n          if (caseSensitive) {\n            staticChildren = node.static ??= new Map()\n          } else {\n            name = value.toLowerCase()\n            staticChildren = node.staticInsensitive ??= new Map()\n          }\n          const existingNode = staticChildren.get(name)\n          if (existingNode) {\n            nextNode = existingNode\n          } else {\n            const next = createStaticNode<TRouteLike>(path)\n            next.parent = node\n            next.depth = depth\n            nextNode = next\n            staticChildren.set(name, next)\n          }\n          break\n        }\n        case SEGMENT_TYPE_PARAM:\n        case SEGMENT_TYPE_OPTIONAL_PARAM:\n        case SEGMENT_TYPE_WILDCARD: {\n          const prefix_raw = path.substring(start, segment[1])\n          const suffix_raw = path.substring(segment[4], end)\n          const actuallyCaseSensitive =\n            caseSensitive && !!(prefix_raw || suffix_raw)\n          const prefix = !prefix_raw\n            ? undefined\n            : actuallyCaseSensitive\n              ? prefix_raw\n              : prefix_raw.toLowerCase()\n          const suffix = !suffix_raw\n            ? undefined\n            : actuallyCaseSensitive\n              ? suffix_raw\n              : suffix_raw.toLowerCase()\n          const siblings =\n            kind === SEGMENT_TYPE_PARAM\n              ? node.dynamic\n              : kind === SEGMENT_TYPE_OPTIONAL_PARAM\n                ? node.optional\n                : node.wildcard\n          const existingNode =\n            // Keep wildcard aliases as separate match candidates, even when\n            // they have the same shape and no parser.\n            kind !== SEGMENT_TYPE_WILDCARD &&\n            !parseParams &&\n            siblings?.find(\n              (s) =>\n                !s.parse &&\n                s.caseSensitive === actuallyCaseSensitive &&\n                s.prefix === prefix &&\n                s.suffix === suffix,\n            )\n          if (existingNode) {\n            nextNode = existingNode\n          } else {\n            const next = createDynamicNode<TRouteLike>(\n              kind,\n              path,\n              actuallyCaseSensitive,\n              prefix,\n              suffix,\n            )\n            nextNode = next\n            next.parent = node\n            next.depth = depth\n            let nodes: Array<DynamicSegmentNode<TRouteLike>>\n            if (kind === SEGMENT_TYPE_PARAM) {\n              nodes = node.dynamic ??= []\n            } else if (kind === SEGMENT_TYPE_OPTIONAL_PARAM) {\n              nodes = node.optional ??= []\n            } else {\n              nodes = node.wildcard ??= []\n            }\n            nodes.push(next)\n            if (nodes.length === 2) {\n              dynamicListsToSort?.push(nodes)\n            }\n          }\n          break\n        }\n      }\n      node = nextNode\n    }\n\n    // create pathless node\n    if (\n      parseParams &&\n      route.children &&\n      !route.isRoot &&\n      route.id &&\n      route.id.charCodeAt(route.id.lastIndexOf('/') + 1) === 95 /* '_' */\n    ) {\n      const pathlessNode = createStaticNode<TRouteLike>(path)\n      pathlessNode.kind = SEGMENT_TYPE_PATHLESS\n      pathlessNode.parent = node\n      depth++\n      pathlessNode.depth = depth\n      node.pathless ??= []\n      node.pathless.push(pathlessNode)\n      node = pathlessNode\n    }\n\n    const isLeaf = (route.path || !route.children) && !route.isRoot\n    // create index node\n    if (isLeaf && path.endsWith('/')) {\n      const indexNode = createStaticNode<TRouteLike>(path)\n      indexNode.kind = SEGMENT_TYPE_INDEX\n      indexNode.parent = node\n      depth++\n      indexNode.depth = depth\n      node.index = indexNode\n      node = indexNode\n    }\n\n    node.parse = parseParams ?? null\n    node.priority = options?.params?.priority ?? 0\n\n    // make node \"matchable\"\n    if (isLeaf && !node.route) {\n      node.route = route\n      node.fullPath = path\n    }\n  }\n  if (route.children)\n    for (const child of route.children) {\n      parseSegments(\n        defaultCaseSensitive,\n        data,\n        child as TRouteLike,\n        cursor,\n        node,\n        depth,\n        dynamicListsToSort,\n        onRoute,\n      )\n    }\n}\n\nfunction sortDynamic(\n  a: {\n    prefix?: string\n    suffix?: string\n    caseSensitive: boolean\n    parse: null | ((params: Record<string, string>) => unknown)\n    priority: number\n  },\n  b: {\n    prefix?: string\n    suffix?: string\n    caseSensitive: boolean\n    parse: null | ((params: Record<string, string>) => unknown)\n    priority: number\n  },\n) {\n  if (a.parse && !b.parse) return -1\n  if (!a.parse && b.parse) return 1\n  if (a.parse && b.parse && (a.priority || b.priority))\n    return b.priority - a.priority\n  if (a.prefix && b.prefix && a.prefix !== b.prefix) {\n    if (a.prefix.startsWith(b.prefix)) return -1\n    if (b.prefix.startsWith(a.prefix)) return 1\n  }\n  if (a.suffix && b.suffix && a.suffix !== b.suffix) {\n    if (a.suffix.endsWith(b.suffix)) return -1\n    if (b.suffix.endsWith(a.suffix)) return 1\n  }\n  if (a.prefix && !b.prefix) return -1\n  if (!a.prefix && b.prefix) return 1\n  if (a.suffix && !b.suffix) return -1\n  if (!a.suffix && b.suffix) return 1\n  if (a.caseSensitive && !b.caseSensitive) return -1\n  if (!a.caseSensitive && b.caseSensitive) return 1\n\n  // Equal specificity preserves route declaration order through stable sort.\n  return 0\n}\n\nfunction createStaticNode<T extends RouteLike>(\n  fullPath: string,\n): StaticSegmentNode<T> {\n  return {\n    kind: SEGMENT_TYPE_PATHNAME,\n    depth: 0,\n    pathless: null,\n    index: null,\n    static: null,\n    staticInsensitive: null,\n    dynamic: null,\n    optional: null,\n    wildcard: null,\n    route: null,\n    fullPath,\n    parent: null,\n    parse: null,\n    priority: 0,\n  }\n}\n\n/**\n * Keys must be declared in the same order as in `SegmentNode` type,\n * to ensure they are represented as the same object class in the engine.\n */\nfunction createDynamicNode<T extends RouteLike>(\n  kind:\n    | typeof SEGMENT_TYPE_PARAM\n    | typeof SEGMENT_TYPE_WILDCARD\n    | typeof SEGMENT_TYPE_OPTIONAL_PARAM,\n  fullPath: string,\n  caseSensitive: boolean,\n  prefix?: string,\n  suffix?: string,\n): DynamicSegmentNode<T> {\n  return {\n    kind,\n    depth: 0,\n    pathless: null,\n    index: null,\n    static: null,\n    staticInsensitive: null,\n    dynamic: null,\n    optional: null,\n    wildcard: null,\n    route: null,\n    fullPath,\n    parent: null,\n    parse: null,\n    priority: 0,\n    caseSensitive,\n    prefix,\n    suffix,\n  }\n}\n\ntype StaticSegmentNode<T extends RouteLike> = SegmentNode<T> & {\n  kind:\n    | typeof SEGMENT_TYPE_PATHNAME\n    | typeof SEGMENT_TYPE_PATHLESS\n    | typeof SEGMENT_TYPE_INDEX\n}\n\ntype DynamicSegmentNode<T extends RouteLike> = SegmentNode<T> & {\n  kind:\n    | typeof SEGMENT_TYPE_PARAM\n    | typeof SEGMENT_TYPE_WILDCARD\n    | typeof SEGMENT_TYPE_OPTIONAL_PARAM\n  prefix?: string\n  suffix?: string\n  caseSensitive: boolean\n}\n\ntype AnySegmentNode<T extends RouteLike> =\n  | StaticSegmentNode<T>\n  | DynamicSegmentNode<T>\n\ntype SegmentNode<T extends RouteLike> = {\n  kind: ExtendedSegmentKind\n\n  pathless: Array<StaticSegmentNode<T>> | null\n\n  /** Exact index segment (highest priority) */\n  index: StaticSegmentNode<T> | null\n\n  /** Static segments (2nd priority) */\n  static: Map<string, StaticSegmentNode<T>> | null\n\n  /** Case insensitive static segments (3rd highest priority) */\n  staticInsensitive: Map<string, StaticSegmentNode<T>> | null\n\n  /** Dynamic segments ($param) */\n  dynamic: Array<DynamicSegmentNode<T>> | null\n\n  /** Optional dynamic segments ({-$param}) */\n  optional: Array<DynamicSegmentNode<T>> | null\n\n  /** Wildcard segments ($ - lowest priority) */\n  wildcard: Array<DynamicSegmentNode<T>> | null\n\n  /** Terminal route (if this path can end here) */\n  route: T | null\n\n  /** The full path for this segment node (will only be valid on leaf nodes) */\n  fullPath: string\n\n  parent: AnySegmentNode<T> | null\n\n  depth: number\n\n  /** route.options.params.parse function, set on the last node of the route */\n  parse: null | ((params: Record<string, string>) => unknown)\n\n  /** route.options.params.priority ?? 0 */\n  priority: number\n}\n\ntype RouteLike = {\n  id?: string\n  path?: string // relative path from the parent,\n  children?: Array<RouteLike> // child routes,\n  parentRoute?: RouteLike // parent route,\n  isRoot?: boolean\n  options?: {\n    caseSensitive?: boolean\n    parseParams?: (params: Record<string, string>) => unknown\n    params?: {\n      parse?: (params: Record<string, string>) => unknown\n      priority?: number\n    }\n  }\n} &\n  // router tree\n  (| { fullPath: string; from?: never } // full path from the root\n    // flat route masks list\n    | { fullPath?: never; from: string } // full path from the root\n  )\n\nexport type ProcessedTree<\n  TTree extends Extract<RouteLike, { fullPath: string }>,\n  TFlat extends Extract<RouteLike, { from: string }>,\n  TSingle extends Extract<RouteLike, { from: string }>,\n> = {\n  /** a representation of the `routeTree` as a segment tree */\n  segmentTree: AnySegmentNode<TTree>\n  /** a mini route tree generated from the flat `routeMasks` list */\n  masksTree: AnySegmentNode<TFlat> | null\n  /** @deprecated keep until v2 so that `router.matchRoute` can keep not caring about the actual route tree */\n  singleCache: LRUCache<string, AnySegmentNode<TSingle>>\n  /** a cache of route matches from the `segmentTree` */\n  matchCache: LRUCache<string, RouteMatch<TTree> | null>\n  /** a cache of route matches from the `masksTree` */\n  flatCache: LRUCache<string, ReturnType<typeof findMatch<TFlat>>> | null\n}\n\nexport function processRouteMasks<\n  TRouteLike extends Extract<RouteLike, { from: string }>,\n>(\n  routeList: Array<TRouteLike>,\n  processedTree: ProcessedTree<any, TRouteLike, any>,\n) {\n  const segmentTree = createStaticNode<TRouteLike>('/')\n  const data = new Uint16Array(6)\n  const dynamicListsToSort: Array<Array<DynamicSegmentNode<TRouteLike>>> = []\n  for (const route of routeList) {\n    parseSegments(false, data, route, 1, segmentTree, 0, dynamicListsToSort)\n  }\n  for (const nodes of dynamicListsToSort) {\n    nodes.sort(sortDynamic)\n  }\n  processedTree.masksTree = segmentTree\n  processedTree.flatCache = createLRUCache<\n    string,\n    ReturnType<typeof findMatch<TRouteLike>>\n  >(1000)\n}\n\n/**\n * Take an arbitrary list of routes, create a tree from them (if it hasn't been created already), and match a path against it.\n */\nexport function findFlatMatch<T extends Extract<RouteLike, { from: string }>>(\n  /** The path to match. */\n  path: string,\n  /** The `processedTree` returned by the initial `processRouteTree` call. */\n  processedTree: ProcessedTree<any, T, any>,\n) {\n  path ||= '/'\n  const cached = processedTree.flatCache!.get(path)\n  if (cached) return cached\n  const result = findMatch(path, processedTree.masksTree!)\n  processedTree.flatCache!.set(path, result)\n  return result\n}\n\n/**\n * @deprecated keep until v2 so that `router.matchRoute` can keep not caring about the actual route tree\n */\nexport function findSingleMatch(\n  from: string,\n  caseSensitive: boolean,\n  fuzzy: boolean,\n  path: string,\n  processedTree: ProcessedTree<any, any, { from: string }>,\n) {\n  from ||= '/'\n  path ||= '/'\n  const key = caseSensitive ? `case\\0${from}` : from\n  let tree = processedTree.singleCache.get(key)\n  if (!tree) {\n    // single flat routes (router.matchRoute) are not eagerly processed,\n    // if we haven't seen this route before, process it now\n    tree = createStaticNode<{ from: string }>('/')\n    const data = new Uint16Array(6)\n    parseSegments(caseSensitive, data, { from }, 1, tree, 0)\n    processedTree.singleCache.set(key, tree)\n  }\n  return findMatch(path, tree, fuzzy)\n}\n\ntype RouteMatch<T extends Extract<RouteLike, { fullPath: string }>> = {\n  route: T\n  rawParams: Record<string, string>\n  branch: ReadonlyArray<T>\n}\n\nexport function findRouteMatch<\n  T extends Extract<RouteLike, { fullPath: string }>,\n>(\n  /** The path to match against the route tree. */\n  path: string,\n  /** The `processedTree` returned by the initial `processRouteTree` call. */\n  processedTree: ProcessedTree<T, any, any>,\n  /** If `true`, allows fuzzy matching (partial matches), i.e. which node in the tree would have been an exact match if the `path` had been shorter? */\n  fuzzy = false,\n): RouteMatch<T> | null {\n  const key = fuzzy ? path : `nofuzz\\0${path}` // the main use for `findRouteMatch` is fuzzy:true, so we optimize for that case\n  const cached = processedTree.matchCache.get(key)\n  if (cached !== undefined) return cached\n  path ||= '/'\n  let result: RouteMatch<T> | null\n\n  try {\n    result = findMatch(\n      path,\n      processedTree.segmentTree,\n      fuzzy,\n    ) as RouteMatch<T> | null\n  } catch (err) {\n    if (err instanceof URIError) {\n      result = null\n    } else {\n      throw err\n    }\n  }\n\n  if (result) result.branch = buildRouteBranch(result.route)\n  processedTree.matchCache.set(key, result)\n  return result\n}\n\n/** Trim trailing slashes (except preserving root '/'). */\nexport function trimPathRight(path: string) {\n  return path === '/' ? path : path.replace(/\\/{1,}$/, '')\n}\n\nexport interface ProcessRouteTreeResult<\n  TRouteLike extends Extract<RouteLike, { fullPath: string }> & { id: string },\n> {\n  /** Should be considered a black box, needs to be provided to all matching functions in this module. */\n  processedTree: ProcessedTree<TRouteLike, any, any>\n  /** A lookup map of routes by their unique IDs. */\n  routesById: Record<string, TRouteLike>\n  /** A lookup map of routes by their trimmed full paths. */\n  routesByPath: Record<string, TRouteLike>\n}\n\n/**\n * Processes a route tree into a segment trie for efficient path matching.\n * Also builds lookup maps for routes by ID and by trimmed full path.\n */\nexport function processRouteTree<\n  TRouteLike extends Extract<RouteLike, { fullPath: string }> & { id: string },\n>(\n  /** The root of the route tree to process. */\n  routeTree: TRouteLike,\n  /** Whether matching should be case sensitive by default (overridden by individual route options). */\n  caseSensitive: boolean = false,\n  /** Optional callback invoked for each route during processing. */\n  initRoute?: (route: TRouteLike, index: number) => void,\n): ProcessRouteTreeResult<TRouteLike> {\n  const segmentTree = createStaticNode<TRouteLike>(routeTree.fullPath)\n  const data = new Uint16Array(6)\n  const dynamicListsToSort: Array<Array<DynamicSegmentNode<TRouteLike>>> = []\n  const routesById = {} as Record<string, TRouteLike>\n  const routesByPath = {} as Record<string, TRouteLike>\n  let index = 0\n  parseSegments(\n    caseSensitive,\n    data,\n    routeTree,\n    1,\n    segmentTree,\n    0,\n    dynamicListsToSort,\n    (route) => {\n      initRoute?.(route, index)\n\n      if (route.id in routesById) {\n        if (process.env.NODE_ENV !== 'production') {\n          throw new Error(\n            `Invariant failed: Duplicate routes found with id: ${String(route.id)}`,\n          )\n        }\n\n        invariant()\n      }\n\n      routesById[route.id] = route\n\n      if (index !== 0 && route.path) {\n        const trimmedFullPath = trimPathRight(route.fullPath)\n        if (!routesByPath[trimmedFullPath] || route.fullPath.endsWith('/')) {\n          routesByPath[trimmedFullPath] = route\n        }\n      }\n\n      index++\n    },\n  )\n  for (const nodes of dynamicListsToSort) {\n    nodes.sort(sortDynamic)\n  }\n  const processedTree: ProcessedTree<TRouteLike, any, any> = {\n    segmentTree,\n    singleCache: createLRUCache<string, AnySegmentNode<any>>(1000),\n    matchCache: createLRUCache<string, RouteMatch<TRouteLike> | null>(1000),\n    flatCache: null,\n    masksTree: null,\n  }\n  return {\n    processedTree,\n    routesById,\n    routesByPath,\n  }\n}\n\nfunction findMatch<T extends RouteLike>(\n  path: string,\n  segmentTree: AnySegmentNode<T>,\n  fuzzy = false,\n): {\n  route: T\n  /**\n   * The raw (unparsed) params extracted from the path.\n   * This will be the exhaustive list of all params defined in the route's path.\n   */\n  rawParams: Record<string, string>\n} | null {\n  const parts = path.split('/')\n  const leaf = getNodeMatch(path, parts, segmentTree, fuzzy)\n  if (!leaf) return null\n  const [rawParams] = extractParams(path, parts, leaf)\n  return {\n    route: leaf.node.route!,\n    rawParams,\n  }\n}\n\ntype ParamExtractionState = {\n  part: number\n  node: number\n  path: number\n  segment: number\n}\n\n/**\n * This function is \"resumable\":\n * - the `leaf` input can contain `extract` and `rawParams` properties from a previous `extractParams` call\n * - the returned `state` can be passed back as `extract` in a future call to continue extracting params from where we left off\n *\n * Inputs are *not* mutated.\n */\nfunction extractParams<T extends RouteLike>(\n  path: string,\n  parts: Array<string>,\n  leaf: {\n    node: AnySegmentNode<T>\n    skipped: number\n    extract?: ParamExtractionState\n    rawParams?: Record<string, string>\n  },\n): [rawParams: Record<string, string>, state: ParamExtractionState] {\n  const list = buildBranch(leaf.node)\n  let nodeParts: Array<string> | null = null\n  const rawParams: Record<string, string> = Object.create(null)\n  /** which segment of the path we're currently processing */\n  let partIndex = leaf.extract?.part ?? 0\n  /** which node of the route tree branch we're currently processing */\n  let nodeIndex = leaf.extract?.node ?? 0\n  /** index of the 1st character of the segment we're processing in the path string */\n  let pathIndex = leaf.extract?.path ?? 0\n  /** which fullPath segment we're currently processing */\n  let segmentCount = leaf.extract?.segment ?? 0\n  for (\n    ;\n    nodeIndex < list.length;\n    partIndex++, nodeIndex++, pathIndex++, segmentCount++\n  ) {\n    const node = list[nodeIndex]!\n    // index nodes are terminating nodes, nothing to extract, just leave\n    if (node.kind === SEGMENT_TYPE_INDEX) break\n    // pathless nodes do not consume a path segment\n    if (node.kind === SEGMENT_TYPE_PATHLESS) {\n      segmentCount--\n      partIndex--\n      pathIndex--\n      continue\n    }\n    const part = parts[partIndex]\n    const currentPathIndex = pathIndex\n    if (part) pathIndex += part.length\n    if (node.kind === SEGMENT_TYPE_PARAM) {\n      nodeParts ??= leaf.node.fullPath.split('/')\n      const nodePart = nodeParts[segmentCount]!\n      const preLength = node.prefix?.length ?? 0\n      // we can't rely on the presence of prefix/suffix to know whether it's curly-braced or not, because `/{$param}/` is valid, but has no prefix/suffix\n      const isCurlyBraced = nodePart.charCodeAt(preLength) === 123 // '{'\n      // param name is extracted at match-time so that tree nodes that are identical except for param name can share the same node\n      if (isCurlyBraced) {\n        const sufLength = node.suffix?.length ?? 0\n        const name = nodePart.substring(\n          preLength + 2,\n          nodePart.length - sufLength - 1,\n        )\n        const value = part!.substring(preLength, part!.length - sufLength)\n        rawParams[name] = decodeURIComponent(value)\n      } else {\n        const name = nodePart.substring(1)\n        rawParams[name] = decodeURIComponent(part!)\n      }\n    } else if (node.kind === SEGMENT_TYPE_OPTIONAL_PARAM) {\n      if (leaf.skipped & (1 << nodeIndex)) {\n        partIndex-- // stay on the same part\n        pathIndex = currentPathIndex - 1 // undo pathIndex advancement; -1 to account for loop increment\n        continue\n      }\n      nodeParts ??= leaf.node.fullPath.split('/')\n      const nodePart = nodeParts[segmentCount]!\n      const preLength = node.prefix?.length ?? 0\n      const sufLength = node.suffix?.length ?? 0\n      const name = nodePart.substring(\n        preLength + 3,\n        nodePart.length - sufLength - 1,\n      )\n      const value =\n        node.suffix || node.prefix\n          ? part!.substring(preLength, part!.length - sufLength)\n          : part\n      if (value) rawParams[name] = decodeURIComponent(value)\n    } else if (node.kind === SEGMENT_TYPE_WILDCARD) {\n      const n = node\n      const value = path.substring(\n        currentPathIndex + (n.prefix?.length ?? 0),\n        path.length - (n.suffix?.length ?? 0),\n      )\n      const splat = decodeURIComponent(value)\n      // TODO: Deprecate *\n      rawParams['*'] = splat\n      rawParams._splat = splat\n      break\n    }\n  }\n  if (leaf.rawParams) Object.assign(rawParams, leaf.rawParams)\n  return [\n    rawParams,\n    {\n      part: partIndex,\n      node: nodeIndex,\n      path: pathIndex,\n      segment: segmentCount,\n    },\n  ]\n}\n\nexport function buildRouteBranch<T extends RouteLike>(route: T) {\n  const list = [route]\n  while (route.parentRoute) {\n    route = route.parentRoute as T\n    list.push(route)\n  }\n  list.reverse()\n  return list\n}\n\nfunction buildBranch<T extends RouteLike>(node: AnySegmentNode<T>) {\n  const list: Array<AnySegmentNode<T>> = Array(node.depth + 1)\n  do {\n    list[node.depth] = node\n    node = node.parent!\n  } while (node)\n  return list\n}\n\ntype MatchStackFrame<T extends RouteLike> = {\n  node: AnySegmentNode<T>\n  /** index of the segment of path */\n  index: number\n  /**\n   * Bitmask of skipped optional segments.\n   *\n   * This is a very performant way of storing an \"array of booleans\", but it means beyond 32 segments we can't track skipped optionals.\n   * If we really really need to support more than 32 segments we can switch to using a `BigInt` here. It's about 2x slower in worst case scenarios.\n   */\n  skipped: number\n  /** Positional bitmasks tracking which consumed URL segments matched each segment kind. */\n  statics: number\n  dynamics: number\n  optionals: number\n  /** intermediary state for param extraction */\n  extract?: ParamExtractionState\n  /** intermediary params from param extraction */\n  rawParams?: Record<string, string>\n}\n\nfunction getNodeMatch<T extends RouteLike>(\n  path: string,\n  parts: Array<string>,\n  segmentTree: AnySegmentNode<T>,\n  fuzzy: boolean,\n) {\n  // quick check for root index\n  // this is an optimization, algorithm should work correctly without this block\n  if (path === '/' && segmentTree.index)\n    return { node: segmentTree.index, skipped: 0 } as Pick<\n      Frame,\n      'node' | 'skipped'\n    >\n\n  const trailingSlash = !last(parts)\n  const pathIsIndex = trailingSlash && path !== '/'\n  const partsLength = parts.length - (trailingSlash ? 1 : 0)\n\n  type Frame = MatchStackFrame<T>\n\n  // use a stack to explore all possible paths (params cause branching)\n  // iterate \"backwards\" (low priority first) so that we can push() each candidate, and pop() the highest priority candidate first\n  // - pros: it is depth-first, so we find full matches faster\n  // - cons: we cannot short-circuit, because highest priority matches are at the end of the loop (for loop with i--) (but we have no good short-circuiting anyway)\n  // other possible approaches:\n  // - shift instead of pop (measure performance difference), this allows iterating \"forwards\" (effectively breadth-first)\n  // - never remove from the stack, keep a cursor instead. Then we can push \"forwards\" and avoid reversing the order of candidates (effectively breadth-first)\n  const stack: Array<Frame> = [\n    {\n      node: segmentTree,\n      index: 1,\n      skipped: 0,\n      statics: 0,\n      dynamics: 0,\n      optionals: 0,\n    },\n  ]\n\n  let bestFuzzy: Frame | null = null\n  let bestMatch: Frame | null = null\n\n  while (stack.length) {\n    const frame = stack.pop()!\n    const { node, index, skipped, statics, dynamics, optionals } = frame\n    let { extract, rawParams } = frame\n\n    // Wildcard candidates are pushed speculatively as fallbacks in case a\n    // higher-priority wildcard later fails params.parse. If a better wildcard\n    // has already validated and become bestMatch, lower-priority wildcard\n    // fallbacks cannot win anymore and should not run params.parse.\n    if (\n      node.kind === SEGMENT_TYPE_WILDCARD &&\n      node.route &&\n      !isFrameMoreSpecific(bestMatch, frame)\n    ) {\n      continue\n    }\n\n    if (node.parse) {\n      const result = validateParseParams(path, parts, frame)\n      if (!result) continue\n      rawParams = frame.rawParams\n      extract = frame.extract\n    }\n\n    // In fuzzy mode, track the best partial match we've found so far\n    if (\n      fuzzy &&\n      node.route &&\n      node.kind !== SEGMENT_TYPE_INDEX &&\n      isFrameMoreSpecific(bestFuzzy, frame)\n    ) {\n      bestFuzzy = frame\n    }\n\n    const isBeyondPath = index === partsLength\n    if (isBeyondPath) {\n      if (\n        node.route &&\n        (!pathIsIndex ||\n          node.kind === SEGMENT_TYPE_INDEX ||\n          node.kind === SEGMENT_TYPE_WILDCARD) &&\n        isFrameMoreSpecific(bestMatch, frame)\n      ) {\n        bestMatch = frame\n      }\n      // beyond the length of the path parts, only some segment types can match\n      if (!node.optional && !node.wildcard && !node.index && !node.pathless)\n        continue\n    }\n\n    const part = isBeyondPath ? undefined : parts[index]!\n    let lowerPart: string\n\n    // 0. Try index match\n    if (isBeyondPath && node.index) {\n      const indexFrame = {\n        node: node.index,\n        index,\n        skipped,\n        statics,\n        dynamics,\n        optionals,\n        extract,\n        rawParams,\n      }\n      let indexValid = true\n      if (node.index.parse) {\n        const result = validateParseParams(path, parts, indexFrame)\n        if (!result) indexValid = false\n      }\n      if (indexValid) {\n        // perfect match, no need to continue\n        // this is an optimization, algorithm should work correctly without this block\n        if (\n          !dynamics &&\n          !optionals &&\n          !skipped &&\n          isPerfectStaticMatch(statics, partsLength)\n        ) {\n          return indexFrame\n        }\n        if (isFrameMoreSpecific(bestMatch, indexFrame)) {\n          // index matches skip the stack because they cannot have children\n          bestMatch = indexFrame\n        }\n      }\n    }\n\n    // 5. Try wildcard match\n    if (node.wildcard) {\n      for (let i = node.wildcard.length - 1; i >= 0; i--) {\n        const segment = node.wildcard[i]!\n        const { prefix, suffix } = segment\n        if (prefix) {\n          if (isBeyondPath) continue\n          const casePart = segment.caseSensitive\n            ? part\n            : (lowerPart ??= part!.toLowerCase())\n          if (!casePart!.startsWith(prefix)) continue\n        }\n        if (suffix) {\n          if (isBeyondPath) continue\n          const end = parts.slice(index).join('/').slice(-suffix.length)\n          const casePart = segment.caseSensitive ? end : end.toLowerCase()\n          if (casePart !== suffix) continue\n        }\n        // wildcard matches consume the rest of the URL and cannot have children\n        stack.push({\n          node: segment,\n          index: partsLength,\n          skipped,\n          statics,\n          dynamics,\n          optionals,\n          extract,\n          rawParams,\n        })\n      }\n    }\n\n    // 4. Try optional match\n    if (node.optional) {\n      // A skipped optional is keyed by the child node's trie depth.\n      const nextSkipped = skipped | (1 << (node.depth + 1))\n      for (let i = node.optional.length - 1; i >= 0; i--) {\n        const segment = node.optional[i]!\n        // when skipping, the node advances by 1, but the index doesn't\n        stack.push({\n          node: segment,\n          index,\n          skipped: nextSkipped,\n          statics,\n          dynamics,\n          optionals,\n          extract,\n          rawParams,\n        }) // enqueue skipping the optional\n      }\n      if (!isBeyondPath) {\n        for (let i = node.optional.length - 1; i >= 0; i--) {\n          const segment = node.optional[i]!\n          const { prefix, suffix } = segment\n          if (prefix || suffix) {\n            const casePart = segment.caseSensitive\n              ? part!\n              : (lowerPart ??= part!.toLowerCase())\n            if (prefix && !casePart.startsWith(prefix)) continue\n            if (suffix && !casePart.endsWith(suffix)) continue\n          }\n          stack.push({\n            node: segment,\n            index: index + 1,\n            skipped,\n            statics,\n            dynamics,\n            optionals: optionals + segmentScore(partsLength, index),\n            extract,\n            rawParams,\n          })\n        }\n      }\n    }\n\n    // 3. Try dynamic match\n    if (!isBeyondPath && node.dynamic && part) {\n      for (let i = node.dynamic.length - 1; i >= 0; i--) {\n        const segment = node.dynamic[i]!\n        const { prefix, suffix } = segment\n        if (prefix || suffix) {\n          const casePart = segment.caseSensitive\n            ? part\n            : (lowerPart ??= part.toLowerCase())\n          if (prefix && !casePart.startsWith(prefix)) continue\n          if (suffix && !casePart.endsWith(suffix)) continue\n        }\n        stack.push({\n          node: segment,\n          index: index + 1,\n          skipped,\n          statics,\n          dynamics: dynamics + segmentScore(partsLength, index),\n          optionals,\n          extract,\n          rawParams,\n        })\n      }\n    }\n\n    // 2. Try case insensitive static match\n    if (!isBeyondPath && node.staticInsensitive) {\n      const match = node.staticInsensitive.get(\n        (lowerPart ??= part!.toLowerCase()),\n      )\n      if (match) {\n        stack.push({\n          node: match,\n          index: index + 1,\n          skipped,\n          statics: statics + segmentScore(partsLength, index),\n          dynamics,\n          optionals,\n          extract,\n          rawParams,\n        })\n      }\n    }\n\n    // 1. Try static match\n    if (!isBeyondPath && node.static) {\n      const match = node.static.get(part!)\n      if (match) {\n        stack.push({\n          node: match,\n          index: index + 1,\n          skipped,\n          statics: statics + segmentScore(partsLength, index),\n          dynamics,\n          optionals,\n          extract,\n          rawParams,\n        })\n      }\n    }\n\n    // 0. Try pathless match\n    if (node.pathless) {\n      for (let i = node.pathless.length - 1; i >= 0; i--) {\n        const segment = node.pathless[i]!\n        stack.push({\n          node: segment,\n          index,\n          skipped,\n          statics,\n          dynamics,\n          optionals,\n          extract,\n          rawParams,\n        })\n      }\n    }\n  }\n\n  if (bestMatch) return bestMatch\n\n  if (fuzzy && bestFuzzy) {\n    let sliceIndex = bestFuzzy.index\n    for (let i = 0; i < bestFuzzy.index; i++) {\n      sliceIndex += parts[i]!.length\n    }\n    const splat = sliceIndex === path.length ? '/' : path.slice(sliceIndex)\n    bestFuzzy.rawParams ??= Object.create(null)\n    bestFuzzy.rawParams!['**'] = decodeURIComponent(splat)\n    return bestFuzzy\n  }\n\n  return null\n}\n\nfunction segmentScore(partsLength: number, index: number): number {\n  // The specificity scores are bitmasks over consumed URL segments. Earlier\n  // URL segments should dominate later ones when comparing scores, so the\n  // first real segment gets the highest bit and the last gets bit 0. Since\n  // `parts[0]` is the empty string before the leading slash, real URL segments\n  // are [1, partsLength), making this segment's bit `partsLength - index - 1`.\n  return 2 ** (partsLength - index - 1)\n}\n\nfunction isPerfectStaticMatch(statics: number, partsLength: number): boolean {\n  return statics === 2 ** (partsLength - 1) - 1\n}\n\nfunction validateParseParams<T extends RouteLike>(\n  path: string,\n  parts: Array<string>,\n  frame: MatchStackFrame<T>,\n) {\n  let rawParams: Record<string, string>\n  let state: ParamExtractionState\n\n  try {\n    ;[rawParams, state] = extractParams(path, parts, frame)\n  } catch {\n    return null\n  }\n\n  frame.rawParams = rawParams\n  frame.extract = state\n\n  if (!frame.node.parse) return true\n\n  try {\n    if (frame.node.parse(rawParams) === false) return null\n  } catch {\n    // Thrown parse errors should be surfaced on the selected match by\n    // extractStrictParams, not used as fallback route selection.\n  }\n\n  return true\n}\n\nfunction isFrameMoreSpecific(\n  // the stack frame previously saved as \"best match\"\n  prev: MatchStackFrame<any> | null,\n  // the candidate stack frame\n  next: MatchStackFrame<any>,\n): boolean {\n  if (!prev) return true\n  return (\n    next.statics > prev.statics ||\n    (next.statics === prev.statics &&\n      (next.dynamics > prev.dynamics ||\n        (next.dynamics === prev.dynamics &&\n          (next.optionals > prev.optionals ||\n            (next.optionals === prev.optionals &&\n              ((next.node.kind === SEGMENT_TYPE_INDEX) >\n                (prev.node.kind === SEGMENT_TYPE_INDEX) ||\n                ((next.node.kind === SEGMENT_TYPE_INDEX) ===\n                  (prev.node.kind === SEGMENT_TYPE_INDEX) &&\n                  next.node.depth > prev.node.depth)))))))\n  )\n}\n"],"mappings":"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"}