@baseplate-dev/plugin-auth 4.0.1 → 4.0.2

package/dist/web/assets/__federation_shared_@tanstack/{react-router-CNzDweD5.js → react-router-BPEAtEJI.js}

@@ -1,4 +1,4 @@
-import { importShared } from '../__federation_fn_import-DsXcpNlB.js';
+import { importShared } from '../__federation_fn_import-pxYUpmb_.js';
 import { j as jsxRuntimeExports } from '../jsx-runtime-XI9uIe3W.js';
 import { r as requireReact } from '../index-DUwCgkeV.js';
 
@@ -171,7 +171,7 @@ function __flush(store) {
     __initialBatchValues.clear();
   }
 }
-function batch(fn) {
+function batch$1(fn) {
   __batchDepth++;
   try {
     fn();
@@ -578,6 +578,9 @@ function createMemoryHistory(opts = {
     (_entry, index2) => assignKeyAndIndex(index2, void 0)
   );
   const getLocation = () => parseHref(entries[index], states[index]);
+  let blockers = [];
+  const _getBlockers = () => blockers;
+  const _setBlockers = (newBlockers) => blockers = newBlockers;
   return createHistory({
     getLocation,
     getLength: () => entries.length,
@@ -603,21 +606,34 @@ function createMemoryHistory(opts = {
     go: (n) => {
       index = Math.min(Math.max(index + n, 0), entries.length - 1);
     },
-    createHref: (path) => path
+    createHref: (path) => path,
+    getBlockers: _getBlockers,
+    setBlockers: _setBlockers
   });
 }
+function sanitizePath(path) {
+  let sanitized = path.replace(/[\x00-\x1f\x7f]/g, "");
+  if (sanitized.startsWith("//")) {
+    sanitized = "/" + sanitized.replace(/^\/+/, "");
+  }
+  return sanitized;
+}
 function parseHref(href, state) {
-  const hashIndex = href.indexOf("#");
-  const searchIndex = href.indexOf("?");
+  const sanitizedHref = sanitizePath(href);
+  const hashIndex = sanitizedHref.indexOf("#");
+  const searchIndex = sanitizedHref.indexOf("?");
   const addedKey = createRandomKey();
   return {
-    href,
-    pathname: href.substring(
+    href: sanitizedHref,
+    pathname: sanitizedHref.substring(
       0,
-      hashIndex > 0 ? searchIndex > 0 ? Math.min(hashIndex, searchIndex) : hashIndex : searchIndex > 0 ? searchIndex : href.length
+      hashIndex > 0 ? searchIndex > 0 ? Math.min(hashIndex, searchIndex) : hashIndex : searchIndex > 0 ? searchIndex : sanitizedHref.length
     ),
-    hash: hashIndex > -1 ? href.substring(hashIndex) : "",
-    search: searchIndex > -1 ? href.slice(searchIndex, hashIndex === -1 ? void 0 : hashIndex) : "",
+    hash: hashIndex > -1 ? sanitizedHref.substring(hashIndex) : "",
+    search: searchIndex > -1 ? sanitizedHref.slice(
+      searchIndex,
+      hashIndex === -1 ? void 0 : hashIndex
+    ) : "",
     state: state || { [stateIndexKey]: 0, key: addedKey, __TSR_key: addedKey }
   };
 }
@@ -625,6 +641,16 @@ function createRandomKey() {
   return (Math.random() + 1).toString(36).substring(7);
 }
 
+const isServer = false;
+
+function batch(fn) {
+  let result;
+  batch$1(() => {
+    result = fn();
+  });
+  return result;
+}
+
 function last(arr) {
   return arr[arr.length - 1];
 }
@@ -638,10 +664,12 @@ function functionalUpdate(updater, previous) {
   return updater;
 }
 const hasOwn = Object.prototype.hasOwnProperty;
-function replaceEqualDeep(prev, _next) {
+const isEnumerable = Object.prototype.propertyIsEnumerable;
+function replaceEqualDeep(prev, _next, _depth = 0) {
   if (prev === _next) {
     return prev;
   }
+  if (_depth > 500) return _next;
   const next = _next;
   const array = isPlainArray(prev) && isPlainArray(next);
   if (!array && !(isPlainObject(prev) && isPlainObject(next))) return next;
@@ -666,22 +694,22 @@ function replaceEqualDeep(prev, _next) {
       copy[key] = n;
       continue;
     }
-    const v = replaceEqualDeep(p, n);
+    const v = replaceEqualDeep(p, n, _depth + 1);
     copy[key] = v;
     if (v === p) equalItems++;
   }
   return prevSize === nextSize && equalItems === prevSize ? prev : copy;
 }
 function getEnumerableOwnKeys(o) {
-  const keys = [];
   const names = Object.getOwnPropertyNames(o);
   for (const name of names) {
-    if (!Object.prototype.propertyIsEnumerable.call(o, name)) return false;
-    keys.push(name);
+    if (!isEnumerable.call(o, name)) return false;
   }
   const symbols = Object.getOwnPropertySymbols(o);
+  if (symbols.length === 0) return names;
+  const keys = names;
   for (const symbol of symbols) {
-    if (!Object.prototype.propertyIsEnumerable.call(o, symbol)) return false;
+    if (!isEnumerable.call(o, symbol)) return false;
     keys.push(symbol);
   }
   return keys;
@@ -781,11 +809,15 @@ function isPromise(value) {
     value && typeof value === "object" && typeof value.then === "function"
   );
 }
+function sanitizePathSegment(segment) {
+  return segment.replace(/[\x00-\x1f\x7f]/g, "");
+}
 function decodeSegment(segment) {
+  let decoded;
   try {
-    return decodeURI(segment);
+    decoded = decodeURI(segment);
   } catch {
-    return segment.replaceAll(/%[0-9A-F]{2}/gi, (match) => {
+    decoded = segment.replaceAll(/%[0-9A-F]{2}/gi, (match) => {
       try {
         return decodeURI(match);
       } catch {
@@ -793,9 +825,34 @@ function decodeSegment(segment) {
       }
     });
   }
+  return sanitizePathSegment(decoded);
+}
+const SAFE_URL_PROTOCOLS = ["http:", "https:", "mailto:", "tel:"];
+function isDangerousProtocol(url) {
+  if (!url) return false;
+  try {
+    const parsed = new URL(url);
+    return !SAFE_URL_PROTOCOLS.includes(parsed.protocol);
+  } catch {
+    return false;
+  }
+}
+const HTML_ESCAPE_LOOKUP = {
+  "&": "\\u0026",
+  ">": "\\u003e",
+  "<": "\\u003c",
+  "\u2028": "\\u2028",
+  "\u2029": "\\u2029"
+};
+const HTML_ESCAPE_REGEX = /[&><\u2028\u2029]/g;
+function escapeHtml(str) {
+  return str.replace(HTML_ESCAPE_REGEX, (match) => HTML_ESCAPE_LOOKUP[match]);
 }
-function decodePath(path, decodeIgnore) {
-  if (!path) return path;
+function decodePath(path) {
+  if (!path) return { path, handledProtocolRelativeURL: false };
+  if (!/[%\\\x00-\x1f\x7f]/.test(path) && !path.startsWith("//")) {
+    return { path, handledProtocolRelativeURL: false };
+  }
   const re = /%25|%5C/gi;
   let cursor = 0;
   let result = "";
@@ -804,7 +861,17 @@ function decodePath(path, decodeIgnore) {
     result += decodeSegment(path.slice(cursor, match.index)) + match[0];
     cursor = re.lastIndex;
   }
-  return result + decodeSegment(cursor ? path.slice(cursor) : path);
+  result = result + decodeSegment(cursor ? path.slice(cursor) : path);
+  let handledProtocolRelativeURL = false;
+  if (result.startsWith("//")) {
+    handledProtocolRelativeURL = true;
+    result = "/" + result.replace(/^\/+/, "");
+  }
+  return { path: result, handledProtocolRelativeURL };
+}
+function encodePathLikeUrl(path) {
+  if (!/\s|[^\u0000-\u007F]/.test(path)) return path;
+  return path.replace(/\s|[^\u0000-\u007F]/gu, encodeURIComponent);
 }
 
 var prefix = "Invariant failed";
@@ -885,9 +952,17 @@ const SEGMENT_TYPE_PATHNAME = 0;
 const SEGMENT_TYPE_PARAM = 1;
 const SEGMENT_TYPE_WILDCARD = 2;
 const SEGMENT_TYPE_OPTIONAL_PARAM = 3;
-const PARAM_W_CURLY_BRACES_RE = /^([^{]*)\{\$([a-zA-Z_$][a-zA-Z0-9_$]*)\}([^}]*)$/;
-const OPTIONAL_PARAM_W_CURLY_BRACES_RE = /^([^{]*)\{-\$([a-zA-Z_$][a-zA-Z0-9_$]*)\}([^}]*)$/;
-const WILDCARD_W_CURLY_BRACES_RE = /^([^{]*)\{\$\}([^}]*)$/;
+const SEGMENT_TYPE_INDEX = 4;
+const SEGMENT_TYPE_PATHLESS = 5;
+function getOpenAndCloseBraces(part) {
+  const openBrace = part.indexOf("{");
+  if (openBrace === -1) return null;
+  const closeBrace = part.indexOf("}", openBrace);
+  if (closeBrace === -1) return null;
+  const afterOpen = openBrace + 1;
+  if (afterOpen >= part.length) return null;
+  return [openBrace, closeBrace];
+}
 function parseSegment(path, start, output = new Uint16Array(6)) {
   const next = path.indexOf("/", start);
   const end = next === -1 ? path.length : next;
@@ -920,45 +995,44 @@ function parseSegment(path, start, output = new Uint16Array(6)) {
     output[5] = end;
     return output;
   }
-  const wildcardBracesMatch = part.match(WILDCARD_W_CURLY_BRACES_RE);
-  if (wildcardBracesMatch) {
-    const prefix = wildcardBracesMatch[1];
-    const pLength = prefix.length;
-    output[0] = SEGMENT_TYPE_WILDCARD;
-    output[1] = start + pLength;
-    output[2] = start + pLength + 1;
-    output[3] = start + pLength + 2;
-    output[4] = start + pLength + 3;
-    output[5] = path.length;
-    return output;
-  }
-  const optionalParamBracesMatch = part.match(OPTIONAL_PARAM_W_CURLY_BRACES_RE);
-  if (optionalParamBracesMatch) {
-    const prefix = optionalParamBracesMatch[1];
-    const paramName = optionalParamBracesMatch[2];
-    const suffix = optionalParamBracesMatch[3];
-    const pLength = prefix.length;
-    output[0] = SEGMENT_TYPE_OPTIONAL_PARAM;
-    output[1] = start + pLength;
-    output[2] = start + pLength + 3;
-    output[3] = start + pLength + 3 + paramName.length;
-    output[4] = end - suffix.length;
-    output[5] = end;
-    return output;
-  }
-  const paramBracesMatch = part.match(PARAM_W_CURLY_BRACES_RE);
-  if (paramBracesMatch) {
-    const prefix = paramBracesMatch[1];
-    const paramName = paramBracesMatch[2];
-    const suffix = paramBracesMatch[3];
-    const pLength = prefix.length;
-    output[0] = SEGMENT_TYPE_PARAM;
-    output[1] = start + pLength;
-    output[2] = start + pLength + 2;
-    output[3] = start + pLength + 2 + paramName.length;
-    output[4] = end - suffix.length;
-    output[5] = end;
-    return output;
+  const braces = getOpenAndCloseBraces(part);
+  if (braces) {
+    const [openBrace, closeBrace] = braces;
+    const firstChar = part.charCodeAt(openBrace + 1);
+    if (firstChar === 45) {
+      if (openBrace + 2 < part.length && part.charCodeAt(openBrace + 2) === 36) {
+        const paramStart = openBrace + 3;
+        const paramEnd = closeBrace;
+        if (paramStart < paramEnd) {
+          output[0] = SEGMENT_TYPE_OPTIONAL_PARAM;
+          output[1] = start + openBrace;
+          output[2] = start + paramStart;
+          output[3] = start + paramEnd;
+          output[4] = start + closeBrace + 1;
+          output[5] = end;
+          return output;
+        }
+      }
+    } else if (firstChar === 36) {
+      const dollarPos = openBrace + 1;
+      const afterDollar = openBrace + 2;
+      if (afterDollar === closeBrace) {
+        output[0] = SEGMENT_TYPE_WILDCARD;
+        output[1] = start + openBrace;
+        output[2] = start + dollarPos;
+        output[3] = start + afterDollar;
+        output[4] = start + closeBrace + 1;
+        output[5] = path.length;
+        return output;
+      }
+      output[0] = SEGMENT_TYPE_PARAM;
+      output[1] = start + openBrace;
+      output[2] = start + afterDollar;
+      output[3] = start + closeBrace;
+      output[4] = start + closeBrace + 1;
+      output[5] = end;
+      return output;
+    }
   }
   output[0] = SEGMENT_TYPE_PATHNAME;
   output[1] = start;
@@ -975,6 +1049,7 @@ function parseSegments(defaultCaseSensitive, data, route, start, node, depth, on
     const path = route.fullPath ?? route.from;
     const length = path.length;
     const caseSensitive = route.options?.caseSensitive ?? defaultCaseSensitive;
+    const skipOnParamError = !!(route.options?.params?.parse && route.options?.skipRouteOnParseError?.params);
     while (cursor < length) {
       const segment = parseSegment(path, cursor, data);
       let nextNode;
@@ -1024,8 +1099,8 @@ function parseSegments(defaultCaseSensitive, data, route, start, node, depth, on
           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 = node.dynamic?.find(
-            (s) => s.caseSensitive === actuallyCaseSensitive && s.prefix === prefix && s.suffix === suffix
+          const existingNode = !skipOnParamError && node.dynamic?.find(
+            (s) => !s.skipOnParamError && s.caseSensitive === actuallyCaseSensitive && s.prefix === prefix && s.suffix === suffix
           );
           if (existingNode) {
             nextNode = existingNode;
@@ -1051,8 +1126,8 @@ function parseSegments(defaultCaseSensitive, data, route, start, node, depth, on
           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 = node.optional?.find(
-            (s) => s.caseSensitive === actuallyCaseSensitive && s.prefix === prefix && s.suffix === suffix
+          const existingNode = !skipOnParamError && node.optional?.find(
+            (s) => !s.skipOnParamError && s.caseSensitive === actuallyCaseSensitive && s.prefix === prefix && s.suffix === suffix
           );
           if (existingNode) {
             nextNode = existingNode;
@@ -1094,11 +1169,36 @@ function parseSegments(defaultCaseSensitive, data, route, start, node, depth, on
       }
       node = nextNode;
     }
-    if ((route.path || !route.children) && !route.isRoot) {
-      const isIndex = path.endsWith("/");
-      if (!isIndex) node.notFound = route;
-      if (!node.route || !node.isIndex && isIndex) node.route = route;
-      node.isIndex ||= isIndex;
+    if (skipOnParamError && route.children && !route.isRoot && route.id && route.id.charCodeAt(route.id.lastIndexOf("/") + 1) === 95) {
+      const pathlessNode = createStaticNode(
+        route.fullPath ?? route.from
+      );
+      pathlessNode.kind = SEGMENT_TYPE_PATHLESS;
+      pathlessNode.parent = node;
+      depth++;
+      pathlessNode.depth = depth;
+      node.pathless ??= [];
+      node.pathless.push(pathlessNode);
+      node = pathlessNode;
+    }
+    const isLeaf = (route.path || !route.children) && !route.isRoot;
+    if (isLeaf && path.endsWith("/")) {
+      const indexNode = createStaticNode(
+        route.fullPath ?? route.from
+      );
+      indexNode.kind = SEGMENT_TYPE_INDEX;
+      indexNode.parent = node;
+      depth++;
+      indexNode.depth = depth;
+      node.index = indexNode;
+      node = indexNode;
+    }
+    node.parse = route.options?.params?.parse ?? null;
+    node.skipOnParamError = skipOnParamError;
+    node.parsingPriority = route.options?.skipRouteOnParseError?.priority ?? 0;
+    if (isLeaf && !node.route) {
+      node.route = route;
+      node.fullPath = route.fullPath ?? route.from;
     }
   }
   if (route.children)
@@ -1115,6 +1215,10 @@ function parseSegments(defaultCaseSensitive, data, route, start, node, depth, on
     }
 }
 function sortDynamic(a, b) {
+  if (a.skipOnParamError && !b.skipOnParamError) return -1;
+  if (!a.skipOnParamError && b.skipOnParamError) return 1;
+  if (a.skipOnParamError && b.skipOnParamError && (a.parsingPriority || b.parsingPriority))
+    return b.parsingPriority - a.parsingPriority;
   if (a.prefix && b.prefix && a.prefix !== b.prefix) {
     if (a.prefix.startsWith(b.prefix)) return -1;
     if (b.prefix.startsWith(a.prefix)) return 1;
@@ -1132,6 +1236,11 @@ function sortDynamic(a, b) {
   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);
@@ -1165,6 +1274,8 @@ function createStaticNode(fullPath) {
   return {
     kind: SEGMENT_TYPE_PATHNAME,
     depth: 0,
+    pathless: null,
+    index: null,
     static: null,
     staticInsensitive: null,
     dynamic: null,
@@ -1173,14 +1284,17 @@ function createStaticNode(fullPath) {
     route: null,
     fullPath,
     parent: null,
-    isIndex: false,
-    notFound: null
+    parse: null,
+    skipOnParamError: false,
+    parsingPriority: 0
   };
 }
 function createDynamicNode(kind, fullPath, caseSensitive, prefix, suffix) {
   return {
     kind,
     depth: 0,
+    pathless: null,
+    index: null,
     static: null,
     staticInsensitive: null,
     dynamic: null,
@@ -1189,8 +1303,9 @@ function createDynamicNode(kind, fullPath, caseSensitive, prefix, suffix) {
     route: null,
     fullPath,
     parent: null,
-    isIndex: false,
-    notFound: null,
+    parse: null,
+    skipOnParamError: false,
+    parsingPriority: 0,
     caseSensitive,
     prefix,
     suffix
@@ -1232,11 +1347,20 @@ function findRouteMatch(path, processedTree, fuzzy = false) {
   const cached = processedTree.matchCache.get(key);
   if (cached !== void 0) return cached;
   path ||= "/";
-  const result = findMatch(
-    path,
-    processedTree.segmentTree,
-    fuzzy
-  );
+  let result;
+  try {
+    result = findMatch(
+      path,
+      processedTree.segmentTree,
+      fuzzy
+    );
+  } catch (err) {
+    if (err instanceof URIError) {
+      result = null;
+    } else {
+      throw err;
+    }
+  }
   if (result) result.branch = buildRouteBranch(result.route);
   processedTree.matchCache.set(key, result);
   return result;
@@ -1283,27 +1407,36 @@ function findMatch(path, segmentTree, fuzzy = false) {
   const parts = path.split("/");
   const leaf = getNodeMatch(path, parts, segmentTree, fuzzy);
   if (!leaf) return null;
-  const params = extractParams(path, parts, leaf);
-  const isFuzzyMatch = "**" in leaf;
-  if (isFuzzyMatch) params["**"] = leaf["**"];
-  const route = isFuzzyMatch ? leaf.node.notFound ?? leaf.node.route : leaf.node.route;
+  const [rawParams] = extractParams(path, parts, leaf);
   return {
-    route,
-    params
+    route: leaf.node.route,
+    rawParams,
+    parsedParams: leaf.parsedParams
   };
 }
 function extractParams(path, parts, leaf) {
   const list = buildBranch(leaf.node);
   let nodeParts = null;
-  const params = {};
-  for (let partIndex = 0, nodeIndex = 0, pathIndex = 0; nodeIndex < list.length; partIndex++, nodeIndex++, pathIndex++) {
+  const rawParams = {};
+  let partIndex = leaf.extract?.part ?? 0;
+  let nodeIndex = leaf.extract?.node ?? 0;
+  let pathIndex = leaf.extract?.path ?? 0;
+  let segmentCount = leaf.extract?.segment ?? 0;
+  for (; nodeIndex < list.length; partIndex++, nodeIndex++, pathIndex++, segmentCount++) {
     const node = list[nodeIndex];
+    if (node.kind === SEGMENT_TYPE_INDEX) break;
+    if (node.kind === SEGMENT_TYPE_PATHLESS) {
+      segmentCount--;
+      partIndex--;
+      pathIndex--;
+      continue;
+    }
     const part = parts[partIndex];
     const currentPathIndex = pathIndex;
     if (part) pathIndex += part.length;
     if (node.kind === SEGMENT_TYPE_PARAM) {
       nodeParts ??= leaf.node.fullPath.split("/");
-      const nodePart = nodeParts[nodeIndex];
+      const nodePart = nodeParts[segmentCount];
       const preLength = node.prefix?.length ?? 0;
       const isCurlyBraced = nodePart.charCodeAt(preLength) === 123;
       if (isCurlyBraced) {
@@ -1313,18 +1446,19 @@ function extractParams(path, parts, leaf) {
           nodePart.length - sufLength - 1
         );
         const value = part.substring(preLength, part.length - sufLength);
-        params[name] = decodeURIComponent(value);
+        rawParams[name] = decodeURIComponent(value);
       } else {
         const name = nodePart.substring(1);
-        params[name] = decodeURIComponent(part);
+        rawParams[name] = decodeURIComponent(part);
       }
     } else if (node.kind === SEGMENT_TYPE_OPTIONAL_PARAM) {
       if (leaf.skipped & 1 << nodeIndex) {
         partIndex--;
+        pathIndex = currentPathIndex - 1;
         continue;
       }
       nodeParts ??= leaf.node.fullPath.split("/");
-      const nodePart = nodeParts[nodeIndex];
+      const nodePart = nodeParts[segmentCount];
       const preLength = node.prefix?.length ?? 0;
       const sufLength = node.suffix?.length ?? 0;
       const name = nodePart.substring(
@@ -1332,7 +1466,7 @@ function extractParams(path, parts, leaf) {
         nodePart.length - sufLength - 1
       );
       const value = node.suffix || node.prefix ? part.substring(preLength, part.length - sufLength) : part;
-      if (value) params[name] = decodeURIComponent(value);
+      if (value) rawParams[name] = decodeURIComponent(value);
     } else if (node.kind === SEGMENT_TYPE_WILDCARD) {
       const n = node;
       const value = path.substring(
@@ -1340,12 +1474,21 @@ function extractParams(path, parts, leaf) {
         path.length - (n.suffix?.length ?? 0)
       );
       const splat = decodeURIComponent(value);
-      params["*"] = splat;
-      params._splat = splat;
+      rawParams["*"] = splat;
+      rawParams._splat = splat;
       break;
     }
   }
-  return params;
+  if (leaf.rawParams) Object.assign(rawParams, leaf.rawParams);
+  return [
+    rawParams,
+    {
+      part: partIndex,
+      node: nodeIndex,
+      path: pathIndex,
+      segment: segmentCount
+    }
+  ];
 }
 function buildRouteBranch(route) {
   const list = [route];
@@ -1365,6 +1508,8 @@ function buildBranch(node) {
   return list;
 }
 function getNodeMatch(path, parts, segmentTree, fuzzy) {
+  if (path === "/" && segmentTree.index)
+    return { node: segmentTree.index, skipped: 0 };
   const trailingSlash = !last(parts);
   const pathIsIndex = trailingSlash && path !== "/";
   const partsLength = parts.length - (trailingSlash ? 1 : 0);
@@ -1384,22 +1529,55 @@ function getNodeMatch(path, parts, segmentTree, fuzzy) {
   let bestMatch = null;
   while (stack.length) {
     const frame = stack.pop();
-    let { node, index, skipped, depth, statics, dynamics, optionals } = frame;
-    if (fuzzy && node.notFound && isFrameMoreSpecific(bestFuzzy, frame)) {
+    const { node, index, skipped, depth, statics, dynamics, optionals } = frame;
+    let { extract, rawParams, parsedParams } = frame;
+    if (node.skipOnParamError) {
+      const result = validateMatchParams(path, parts, frame);
+      if (!result) continue;
+      rawParams = frame.rawParams;
+      extract = frame.extract;
+      parsedParams = frame.parsedParams;
+    }
+    if (fuzzy && node.route && node.kind !== SEGMENT_TYPE_INDEX && isFrameMoreSpecific(bestFuzzy, frame)) {
       bestFuzzy = frame;
     }
     const isBeyondPath = index === partsLength;
     if (isBeyondPath) {
-      if (node.route && (!pathIsIndex || node.isIndex)) {
-        if (isFrameMoreSpecific(bestMatch, frame)) {
-          bestMatch = frame;
-        }
-        if (statics === partsLength && node.isIndex) return bestMatch;
+      if (node.route && !pathIsIndex && isFrameMoreSpecific(bestMatch, frame)) {
+        bestMatch = frame;
       }
-      if (!node.optional && !node.wildcard) continue;
+      if (!node.optional && !node.wildcard && !node.index && !node.pathless)
+        continue;
     }
     const part = isBeyondPath ? void 0 : parts[index];
     let lowerPart;
+    if (isBeyondPath && node.index) {
+      const indexFrame = {
+        node: node.index,
+        index,
+        skipped,
+        depth: depth + 1,
+        statics,
+        dynamics,
+        optionals,
+        extract,
+        rawParams,
+        parsedParams
+      };
+      let indexValid = true;
+      if (node.index.skipOnParamError) {
+        const result = validateMatchParams(path, parts, indexFrame);
+        if (!result) indexValid = false;
+      }
+      if (indexValid) {
+        if (statics === partsLength && !dynamics && !optionals && !skipped) {
+          return indexFrame;
+        }
+        if (isFrameMoreSpecific(bestMatch, indexFrame)) {
+          bestMatch = indexFrame;
+        }
+      }
+    }
     if (node.wildcard && isFrameMoreSpecific(wildcardMatch, frame)) {
       for (const segment of node.wildcard) {
         const { prefix, suffix } = segment;
@@ -1414,15 +1592,23 @@ function getNodeMatch(path, parts, segmentTree, fuzzy) {
           const casePart = segment.caseSensitive ? end : end.toLowerCase();
           if (casePart !== suffix) continue;
         }
-        wildcardMatch = {
+        const frame2 = {
           node: segment,
-          index,
+          index: partsLength,
           skipped,
           depth,
           statics,
           dynamics,
-          optionals
+          optionals,
+          extract,
+          rawParams,
+          parsedParams
         };
+        if (segment.skipOnParamError) {
+          const result = validateMatchParams(path, parts, frame2);
+          if (!result) continue;
+        }
+        wildcardMatch = frame2;
         break;
       }
     }
@@ -1438,7 +1624,10 @@ function getNodeMatch(path, parts, segmentTree, fuzzy) {
           depth: nextDepth,
           statics,
           dynamics,
-          optionals
+          optionals,
+          extract,
+          rawParams,
+          parsedParams
         });
       }
       if (!isBeyondPath) {
@@ -1457,7 +1646,10 @@ function getNodeMatch(path, parts, segmentTree, fuzzy) {
             depth: nextDepth,
             statics,
             dynamics,
-            optionals: optionals + 1
+            optionals: optionals + 1,
+            extract,
+            rawParams,
+            parsedParams
           });
         }
       }
@@ -1478,7 +1670,10 @@ function getNodeMatch(path, parts, segmentTree, fuzzy) {
           depth: depth + 1,
           statics,
           dynamics: dynamics + 1,
-          optionals
+          optionals,
+          extract,
+          rawParams,
+          parsedParams
         });
       }
     }
@@ -1494,7 +1689,10 @@ function getNodeMatch(path, parts, segmentTree, fuzzy) {
           depth: depth + 1,
           statics: statics + 1,
           dynamics,
-          optionals
+          optionals,
+          extract,
+          rawParams,
+          parsedParams
         });
       }
     }
@@ -1508,7 +1706,28 @@ function getNodeMatch(path, parts, segmentTree, fuzzy) {
           depth: depth + 1,
           statics: statics + 1,
           dynamics,
-          optionals
+          optionals,
+          extract,
+          rawParams,
+          parsedParams
+        });
+      }
+    }
+    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,
+          parsedParams
         });
       }
     }
@@ -1524,17 +1743,27 @@ function getNodeMatch(path, parts, segmentTree, fuzzy) {
       sliceIndex += parts[i].length;
     }
     const splat = sliceIndex === path.length ? "/" : path.slice(sliceIndex);
-    return {
-      node: bestFuzzy.node,
-      skipped: bestFuzzy.skipped,
-      "**": decodeURIComponent(splat)
-    };
+    bestFuzzy.rawParams ??= {};
+    bestFuzzy.rawParams["**"] = decodeURIComponent(splat);
+    return bestFuzzy;
   }
   return null;
 }
+function validateMatchParams(path, parts, frame) {
+  try {
+    const [rawParams, state] = extractParams(path, parts, frame);
+    frame.rawParams = rawParams;
+    frame.extract = state;
+    const parsed = frame.node.parse(rawParams);
+    frame.parsedParams = Object.assign({}, frame.parsedParams, parsed);
+    return true;
+  } catch {
+    return null;
+  }
+}
 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.isIndex > prev.node.isIndex || next.node.isIndex === prev.node.isIndex && 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.depth > prev.depth)));
 }
 
 function joinPaths(paths) {
@@ -1645,19 +1874,32 @@ function resolvePath({
   if (key && cache) cache.set(key, result);
   return result;
 }
-function encodeParam(key, params, decodeCharMap) {
+function compileDecodeCharMap(pathParamsAllowedCharacters) {
+  const charMap = new Map(
+    pathParamsAllowedCharacters.map((char) => [encodeURIComponent(char), char])
+  );
+  const pattern = Array.from(charMap.keys()).map((key) => key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+  const regex = new RegExp(pattern, "g");
+  return (encoded) => encoded.replace(regex, (match) => charMap.get(match) ?? match);
+}
+function encodeParam(key, params, decoder) {
   const value = params[key];
   if (typeof value !== "string") return value;
   if (key === "_splat") {
-    return encodeURI(value);
+    if (/^[a-zA-Z0-9\-._~!/]*$/.test(value)) return value;
+    return value.split("/").map((segment) => encodePathParam(segment, decoder)).join("/");
   } else {
-    return encodePathParam(value, decodeCharMap);
+    return encodePathParam(value, decoder);
   }
 }
 function interpolatePath({
   path,
   params,
-  decodeCharMap
+  decoder,
+  // `server` is marked @internal and stripped from .d.ts by `stripInternal`.
+  // We avoid destructuring it in the function signature so the emitted
+  // declaration doesn't reference a property that no longer exists.
+  ...rest
 }) {
   let isMissingParams = false;
   const usedParams = {};
@@ -1693,7 +1935,7 @@ function interpolatePath({
         }
         continue;
       }
-      const value = encodeParam("_splat", params, decodeCharMap);
+      const value = encodeParam("_splat", params, decoder);
       joined += "/" + prefix + value + suffix;
       continue;
     }
@@ -1705,7 +1947,7 @@ function interpolatePath({
       usedParams[key] = params[key];
       const prefix = path.substring(start, segment[1]);
       const suffix = path.substring(segment[4], end);
-      const value = encodeParam(key, params, decodeCharMap) ?? "undefined";
+      const value = encodeParam(key, params, decoder) ?? "undefined";
       joined += "/" + prefix + value + suffix;
       continue;
     }
@@ -1716,7 +1958,7 @@ function interpolatePath({
       usedParams[key] = valueRaw;
       const prefix = path.substring(start, segment[1]);
       const suffix = path.substring(segment[4], end);
-      const value = encodeParam(key, params, decodeCharMap) ?? "";
+      const value = encodeParam(key, params, decoder) ?? "";
       joined += "/" + prefix + value + suffix;
       continue;
     }
@@ -1725,14 +1967,9 @@ function interpolatePath({
   const interpolatedPath = joined || "/";
   return { usedParams, interpolatedPath, isMissingParams };
 }
-function encodePathParam(value, decodeCharMap) {
-  let encoded = encodeURIComponent(value);
-  if (decodeCharMap) {
-    for (const [encodedChar, char] of decodeCharMap) {
-      encoded = encoded.replaceAll(encodedChar, char);
-    }
-  }
-  return encoded;
+function encodePathParam(value, decoder) {
+  const encoded = encodeURIComponent(value);
+  return decoder?.(encoded) ?? encoded;
 }
 
 function notFound(options = {}) {
@@ -1777,7 +2014,16 @@ function createScrollRestorationCache() {
     // This setter is simply to make sure that we set the sessionStorage right
     // after the state is updated. It doesn't necessarily need to be a functional
     // update.
-    set: (updater) => (state = functionalUpdate(updater, state) || state, safeSessionStorage.setItem(storageKey, JSON.stringify(state)))
+    set: (updater) => {
+      state = functionalUpdate(updater, state) || state;
+      try {
+        safeSessionStorage.setItem(storageKey, JSON.stringify(state));
+      } catch {
+        console.warn(
+          "[ts-router] Could not persist scroll restoration state to sessionStorage."
+        );
+      }
+    }
   };
 }
 const scrollRestorationCache = createScrollRestorationCache();
@@ -1858,14 +2104,14 @@ function restoreScroll({
   ignoreScroll = false;
 }
 function setupScrollRestoration(router, force) {
-  if (!scrollRestorationCache && !router.isServer) {
+  if (!scrollRestorationCache && true) {
     return;
   }
   const shouldScrollRestoration = force ?? router.options.scrollRestoration ?? false;
   if (shouldScrollRestoration) {
     router.isScrollRestoring = true;
   }
-  if (router.isServer || router.isScrollRestorationSetup || !scrollRestorationCache) {
+  if (router.isScrollRestorationSetup || !scrollRestorationCache) {
     return;
   }
   router.isScrollRestorationSetup = true;
@@ -2033,7 +2279,12 @@ const rootRouteId = "__root__";
 
 function redirect(opts) {
   opts.statusCode = opts.statusCode || opts.code || 307;
-  if (!opts.reloadDocument && typeof opts.href === "string") {
+  if (!opts._builtLocation && typeof opts.href === "string" && isDangerousProtocol(opts.href)) {
+    throw new Error(
+      `Redirect blocked: unsafe protocol in href "${opts.href}". Only ${SAFE_URL_PROTOCOLS.join(", ")} protocols are allowed.`
+    );
+  }
+  if (!opts._builtLocation && !opts.reloadDocument && typeof opts.href === "string") {
     try {
       new URL(opts.href);
       opts.reloadDocument = true;
@@ -2067,6 +2318,20 @@ const triggerOnReady = (inner) => {
 const resolvePreload = (inner, matchId) => {
   return !!(inner.preload && !inner.router.state.matches.some((d) => d.id === matchId));
 };
+const buildMatchContext = (inner, index, includeCurrentMatch = true) => {
+  const context = {
+    ...inner.router.options.context ?? {}
+  };
+  const end = includeCurrentMatch ? index : index - 1;
+  for (let i = 0; i <= end; i++) {
+    const innerMatch = inner.matches[i];
+    if (!innerMatch) continue;
+    const m = inner.router.getMatch(innerMatch.id);
+    if (!m) continue;
+    Object.assign(context, m.__routeContext, m.__beforeLoadContext);
+  }
+  return context;
+};
 const _handleNotFound = (inner, err) => {
   const routeCursor = inner.router.routesById[err.routeId ?? ""] ?? inner.router.routeTree;
   if (!routeCursor.options.notFoundComponent && inner.router.options?.defaultNotFoundComponent) {
@@ -2102,6 +2367,7 @@ const handleRedirectAndNotFound = (inner, match, err) => {
     inner.updateMatch(match.id, (prev) => ({
       ...prev,
       status,
+      context: buildMatchContext(inner, match.index),
       isFetching: false,
       error: err
     }));
@@ -2123,10 +2389,7 @@ const handleRedirectAndNotFound = (inner, match, err) => {
 };
 const shouldSkipLoader = (inner, matchId) => {
   const match = inner.router.getMatch(matchId);
-  if (!inner.router.isServer && match._nonReactive.dehydrated) {
-    return true;
-  }
-  if (inner.router.isServer && match.ssr === false) {
+  if (match._nonReactive.dehydrated) {
     return true;
   }
   return false;
@@ -2160,63 +2423,10 @@ const handleSerialError = (inner, index, err, routerCode) => {
     };
   });
 };
-const isBeforeLoadSsr = (inner, matchId, index, route) => {
-  const existingMatch = inner.router.getMatch(matchId);
-  const parentMatchId = inner.matches[index - 1]?.id;
-  const parentMatch = parentMatchId ? inner.router.getMatch(parentMatchId) : void 0;
-  if (inner.router.isShell()) {
-    existingMatch.ssr = route.id === rootRouteId;
-    return;
-  }
-  if (parentMatch?.ssr === false) {
-    existingMatch.ssr = false;
-    return;
-  }
-  const parentOverride = (tempSsr2) => {
-    if (tempSsr2 === true && parentMatch?.ssr === "data-only") {
-      return "data-only";
-    }
-    return tempSsr2;
-  };
-  const defaultSsr = inner.router.options.defaultSsr ?? true;
-  if (route.options.ssr === void 0) {
-    existingMatch.ssr = parentOverride(defaultSsr);
-    return;
-  }
-  if (typeof route.options.ssr !== "function") {
-    existingMatch.ssr = parentOverride(route.options.ssr);
-    return;
-  }
-  const { search, params } = existingMatch;
-  const ssrFnContext = {
-    search: makeMaybe(search, existingMatch.searchError),
-    params: makeMaybe(params, existingMatch.paramsError),
-    location: inner.location,
-    matches: inner.matches.map((match) => ({
-      index: match.index,
-      pathname: match.pathname,
-      fullPath: match.fullPath,
-      staticData: match.staticData,
-      id: match.id,
-      routeId: match.routeId,
-      search: makeMaybe(match.search, match.searchError),
-      params: makeMaybe(match.params, match.paramsError),
-      ssr: match.ssr
-    }))
-  };
-  const tempSsr = route.options.ssr(ssrFnContext);
-  if (isPromise(tempSsr)) {
-    return tempSsr.then((ssr) => {
-      existingMatch.ssr = parentOverride(ssr ?? defaultSsr);
-    });
-  }
-  existingMatch.ssr = parentOverride(tempSsr ?? defaultSsr);
-  return;
-};
 const setupPendingTimeout = (inner, matchId, route, match) => {
   if (match._nonReactive.pendingTimeout !== void 0) return;
   const pendingMs = route.options.pendingMs ?? inner.router.options.defaultPendingMs;
-  const shouldPending = !!(inner.onReady && !inner.router.isServer && !resolvePreload(inner, matchId) && (route.options.loader || route.options.beforeLoad || routeNeedsPreload(route)) && typeof pendingMs === "number" && pendingMs !== Infinity && (route.options.pendingComponent ?? inner.router.options?.defaultPendingComponent));
+  const shouldPending = !!(inner.onReady && true && !resolvePreload(inner, matchId) && (route.options.loader || route.options.beforeLoad || routeNeedsPreload(route)) && typeof pendingMs === "number" && pendingMs !== Infinity && (route.options.pendingComponent ?? inner.router.options?.defaultPendingComponent));
   if (shouldPending) {
     const pendingTimeout = setTimeout(() => {
       triggerOnReady(inner);
@@ -2252,10 +2462,6 @@ const executeBeforeLoad = (inner, matchId, index, route) => {
   }
   setupPendingTimeout(inner, matchId, route, match);
   const abortController = new AbortController();
-  const parentMatchId = inner.matches[index - 1]?.id;
-  const parentMatch = parentMatchId ? inner.router.getMatch(parentMatchId) : void 0;
-  const parentMatchContext = parentMatch?.context ?? inner.router.options.context ?? void 0;
-  const context = { ...parentMatchContext, ...match.__routeContext };
   let isPending = false;
   const pending = () => {
     if (isPending) return;
@@ -2264,8 +2470,10 @@ const executeBeforeLoad = (inner, matchId, index, route) => {
       ...prev,
       isFetching: "beforeLoad",
       fetchCount: prev.fetchCount + 1,
-      abortController,
-      context
+      abortController
+      // Note: We intentionally don't update context here.
+      // Context should only be updated after beforeLoad resolves to avoid
+      // components seeing incomplete context during async beforeLoad execution.
     }));
   };
   const resolve = () => {
@@ -2284,6 +2492,10 @@ const executeBeforeLoad = (inner, matchId, index, route) => {
     return;
   }
   match._nonReactive.beforeLoadPromise = createControlledPromise();
+  const context = {
+    ...buildMatchContext(inner, index, false),
+    ...match.__routeContext
+  };
   const { search, params, cause } = match;
   const preload = resolvePreload(inner, matchId);
   const beforeLoadFnContext = {
@@ -2300,6 +2512,7 @@ const executeBeforeLoad = (inner, matchId, index, route) => {
     buildLocation: inner.router.buildLocation,
     cause: preload ? "preload" : cause,
     matches: inner.matches,
+    routeId: route.id,
     ...inner.router.options.additionalContext
   };
   const updateContext = (beforeLoadContext2) => {
@@ -2318,11 +2531,7 @@ const executeBeforeLoad = (inner, matchId, index, route) => {
       pending();
       inner.updateMatch(matchId, (prev) => ({
         ...prev,
-        __beforeLoadContext: beforeLoadContext2,
-        context: {
-          ...prev.context,
-          ...beforeLoadContext2
-        }
+        __beforeLoadContext: beforeLoadContext2
       }));
       resolve();
     });
@@ -2347,10 +2556,6 @@ const handleBeforeLoad = (inner, index) => {
   const { id: matchId, routeId } = inner.matches[index];
   const route = inner.router.looseRoutesById[routeId];
   const serverSsr = () => {
-    if (inner.router.isServer) {
-      const maybePromise = isBeforeLoadSsr(inner, matchId, index, route);
-      if (isPromise(maybePromise)) return maybePromise.then(queueExecution);
-    }
     return queueExecution();
   };
   const execute = () => executeBeforeLoad(inner, matchId, index, route);
@@ -2370,6 +2575,7 @@ const executeHead = (inner, matchId, route) => {
     return;
   }
   const assetContext = {
+    ssr: inner.router.options.ssr,
     matches: inner.matches,
     match,
     params: match.params,
@@ -2397,18 +2603,7 @@ const executeHead = (inner, matchId, route) => {
 const getLoaderContext = (inner, matchId, index, route) => {
   const parentMatchPromise = inner.matchPromises[index - 1];
   const { params, loaderDeps, abortController, cause } = inner.router.getMatch(matchId);
-  let context = inner.router.options.context ?? {};
-  for (let i = 0; i <= index; i++) {
-    const innerMatch = inner.matches[i];
-    if (!innerMatch) continue;
-    const m = inner.router.getMatch(innerMatch.id);
-    if (!m) continue;
-    context = {
-      ...context,
-      ...m.__routeContext ?? {},
-      ...m.__beforeLoadContext ?? {}
-    };
-  }
+  const context = buildMatchContext(inner, index);
   const preload = resolvePreload(inner, matchId);
   return {
     params,
@@ -2431,7 +2626,7 @@ const runLoader = async (inner, matchId, index, route) => {
   try {
     const match = inner.router.getMatch(matchId);
     try {
-      if (!inner.router.isServer || match.ssr === true) {
+      if (!(isServer ?? inner.router.isServer) || match.ssr === true) {
         loadRouteChunk(route);
       }
       const loaderResult = route.options.loader?.(
@@ -2460,21 +2655,33 @@ const runLoader = async (inner, matchId, index, route) => {
         }
       }
       if (route._lazyPromise) await route._lazyPromise;
-      const headResult = executeHead(inner, matchId, route);
-      const head = headResult ? await headResult : void 0;
       const pendingPromise = match._nonReactive.minPendingPromise;
       if (pendingPromise) await pendingPromise;
       if (route._componentsPromise) await route._componentsPromise;
       inner.updateMatch(matchId, (prev) => ({
         ...prev,
         error: void 0,
+        context: buildMatchContext(inner, index),
         status: "success",
         isFetching: false,
-        updatedAt: Date.now(),
-        ...head
+        updatedAt: Date.now()
       }));
     } catch (e) {
       let error = e;
+      if (error?.name === "AbortError") {
+        if (match.abortController.signal.aborted) {
+          match._nonReactive.loaderPromise?.resolve();
+          match._nonReactive.loaderPromise = void 0;
+          return;
+        }
+        inner.updateMatch(matchId, (prev) => ({
+          ...prev,
+          status: prev.status === "pending" ? "success" : prev.status,
+          isFetching: false,
+          context: buildMatchContext(inner, index)
+        }));
+        return;
+      }
       const pendingPromise = match._nonReactive.minPendingPromise;
       if (pendingPromise) await pendingPromise;
       if (isNotFound(e)) {
@@ -2491,51 +2698,57 @@ const runLoader = async (inner, matchId, index, route) => {
           onErrorError
         );
       }
-      const headResult = executeHead(inner, matchId, route);
-      const head = headResult ? await headResult : void 0;
       inner.updateMatch(matchId, (prev) => ({
         ...prev,
         error,
+        context: buildMatchContext(inner, index),
         status: "error",
-        isFetching: false,
-        ...head
+        isFetching: false
       }));
     }
   } catch (err) {
     const match = inner.router.getMatch(matchId);
     if (match) {
-      const headResult = executeHead(inner, matchId, route);
-      if (headResult) {
-        const head = await headResult;
-        inner.updateMatch(matchId, (prev) => ({
-          ...prev,
-          ...head
-        }));
-      }
       match._nonReactive.loaderPromise = void 0;
     }
     handleRedirectAndNotFound(inner, match, err);
   }
 };
 const loadRouteMatch = async (inner, index) => {
+  async function handleLoader(preload, prevMatch, match2, route2) {
+    const age = Date.now() - prevMatch.updatedAt;
+    const staleAge = preload ? route2.options.preloadStaleTime ?? inner.router.options.defaultPreloadStaleTime ?? 3e4 : route2.options.staleTime ?? inner.router.options.defaultStaleTime ?? 0;
+    const shouldReloadOption = route2.options.shouldReload;
+    const shouldReload = typeof shouldReloadOption === "function" ? shouldReloadOption(getLoaderContext(inner, matchId, index, route2)) : shouldReloadOption;
+    const { status, invalid } = match2;
+    loaderShouldRunAsync = status === "success" && (invalid || (shouldReload ?? age > staleAge));
+    if (preload && route2.options.preload === false) ;
+    else if (loaderShouldRunAsync && !inner.sync) {
+      loaderIsRunningAsync = true;
+      (async () => {
+        try {
+          await runLoader(inner, matchId, index, route2);
+          const match3 = inner.router.getMatch(matchId);
+          match3._nonReactive.loaderPromise?.resolve();
+          match3._nonReactive.loadPromise?.resolve();
+          match3._nonReactive.loaderPromise = void 0;
+        } catch (err) {
+          if (isRedirect(err)) {
+            await inner.router.navigate(err.options);
+          }
+        }
+      })();
+    } else if (status !== "success" || loaderShouldRunAsync && inner.sync) {
+      await runLoader(inner, matchId, index, route2);
+    }
+  }
   const { id: matchId, routeId } = inner.matches[index];
   let loaderShouldRunAsync = false;
   let loaderIsRunningAsync = false;
   const route = inner.router.looseRoutesById[routeId];
-  if (shouldSkipLoader(inner, matchId)) {
-    if (inner.router.isServer) {
-      const headResult = executeHead(inner, matchId, route);
-      if (headResult) {
-        const head = await headResult;
-        inner.updateMatch(matchId, (prev) => ({
-          ...prev,
-          ...head
-        }));
-      }
-      return inner.router.getMatch(matchId);
-    }
-  } else {
+  if (shouldSkipLoader(inner, matchId)) ; else {
     const prevMatch = inner.router.getMatch(matchId);
+    const preload = resolvePreload(inner, matchId);
     if (prevMatch._nonReactive.loaderPromise) {
       if (prevMatch.status === "success" && !inner.sync && !prevMatch.preload) {
         return prevMatch;
@@ -2546,13 +2759,11 @@ const loadRouteMatch = async (inner, index) => {
       if (error) {
         handleRedirectAndNotFound(inner, match2, error);
       }
+      if (match2.status === "pending") {
+        await handleLoader(preload, prevMatch, match2, route);
+      }
     } else {
-      const age = Date.now() - prevMatch.updatedAt;
-      const preload = resolvePreload(inner, matchId);
-      const staleAge = preload ? route.options.preloadStaleTime ?? inner.router.options.defaultPreloadStaleTime ?? 3e4 : route.options.staleTime ?? inner.router.options.defaultStaleTime ?? 0;
-      const shouldReloadOption = route.options.shouldReload;
-      const shouldReload = typeof shouldReloadOption === "function" ? shouldReloadOption(getLoaderContext(inner, matchId, index, route)) : shouldReloadOption;
-      const nextPreload = !!preload && !inner.router.state.matches.some((d) => d.id === matchId);
+      const nextPreload = preload && !inner.router.state.matches.some((d) => d.id === matchId);
       const match2 = inner.router.getMatch(matchId);
       match2._nonReactive.loaderPromise = createControlledPromise();
       if (nextPreload !== match2.preload) {
@@ -2561,36 +2772,7 @@ const loadRouteMatch = async (inner, index) => {
           preload: nextPreload
         }));
       }
-      const { status, invalid } = match2;
-      loaderShouldRunAsync = status === "success" && (invalid || (shouldReload ?? age > staleAge));
-      if (preload && route.options.preload === false) ;
-      else if (loaderShouldRunAsync && !inner.sync) {
-        loaderIsRunningAsync = true;
-        (async () => {
-          try {
-            await runLoader(inner, matchId, index, route);
-            const match3 = inner.router.getMatch(matchId);
-            match3._nonReactive.loaderPromise?.resolve();
-            match3._nonReactive.loadPromise?.resolve();
-            match3._nonReactive.loaderPromise = void 0;
-          } catch (err) {
-            if (isRedirect(err)) {
-              await inner.router.navigate(err.options);
-            }
-          }
-        })();
-      } else if (status !== "success" || loaderShouldRunAsync && inner.sync) {
-        await runLoader(inner, matchId, index, route);
-      } else {
-        const headResult = executeHead(inner, matchId, route);
-        if (headResult) {
-          const head = await headResult;
-          inner.updateMatch(matchId, (prev) => ({
-            ...prev,
-            ...head
-          }));
-        }
-      }
+      await handleLoader(preload, prevMatch, match2, route);
     }
   }
   const match = inner.router.getMatch(matchId);
@@ -2618,7 +2800,7 @@ async function loadMatches(arg) {
   const inner = Object.assign(arg, {
     matchPromises: []
   });
-  if (!inner.router.isServer && inner.router.state.matches.some((d) => d._forcePending)) {
+  if (inner.router.state.matches.some((d) => d._forcePending)) {
     triggerOnReady(inner);
   }
   try {
@@ -2630,7 +2812,38 @@ async function loadMatches(arg) {
     for (let i = 0; i < max; i++) {
       inner.matchPromises.push(loadRouteMatch(inner, i));
     }
-    await Promise.all(inner.matchPromises);
+    const results = await Promise.allSettled(inner.matchPromises);
+    const failures = results.filter(
+      (result) => result.status === "rejected"
+    ).map((result) => result.reason);
+    let firstNotFound;
+    for (const err of failures) {
+      if (isRedirect(err)) {
+        throw err;
+      }
+      if (!firstNotFound && isNotFound(err)) {
+        firstNotFound = err;
+      }
+    }
+    for (const match of inner.matches) {
+      const { id: matchId, routeId } = match;
+      const route = inner.router.looseRoutesById[routeId];
+      try {
+        const headResult = executeHead(inner, matchId, route);
+        if (headResult) {
+          const head = await headResult;
+          inner.updateMatch(matchId, (prev) => ({
+            ...prev,
+            ...head
+          }));
+        }
+      } catch (err) {
+        console.error(`Error executing head for route ${routeId}:`, err);
+      }
+    }
+    if (firstNotFound) {
+      throw firstNotFound;
+    }
     const readyPromise = triggerOnReady(inner);
     if (isPromise(readyPromise)) await readyPromise;
   } catch (err) {
@@ -2678,12 +2891,6 @@ async function loadRouteChunk(route) {
   }
   return route._componentsPromise;
 }
-function makeMaybe(value, error) {
-  if (error) {
-    return { status: "error", error };
-  }
-  return { status: "success", value };
-}
 function routeNeedsPreload(route) {
   for (const componentType of componentTypes) {
     if (route.options[componentType]?.preload) {
@@ -2810,15 +3017,13 @@ class RouterCore {
         ...newOptions
       };
       this.isServer = this.options.isServer ?? typeof document === "undefined";
-      this.pathParamsDecodeCharMap = this.options.pathParamsAllowedCharacters ? new Map(
-        this.options.pathParamsAllowedCharacters.map((char) => [
-          encodeURIComponent(char),
-          char
-        ])
-      ) : void 0;
+      if (this.options.pathParamsAllowedCharacters)
+        this.pathParamsDecoder = compileDecodeCharMap(
+          this.options.pathParamsAllowedCharacters
+        );
       if (!this.history || this.options.history && this.options.history !== this.history) {
         if (!this.options.history) {
-          if (!this.isServer) {
+          {
             this.history = createBrowserHistory();
           }
         } else {
@@ -2827,7 +3032,7 @@ class RouterCore {
       }
       this.origin = this.options.origin;
       if (!this.origin) {
-        if (!this.isServer && window?.origin && window.origin !== "null") {
+        if (window?.origin && window.origin !== "null") {
           this.origin = window.origin;
         } else {
           this.origin = "http://localhost";
@@ -2838,20 +3043,27 @@ class RouterCore {
       }
       if (this.options.routeTree !== this.routeTree) {
         this.routeTree = this.options.routeTree;
-        this.buildRouteTree();
+        let processRouteTreeResult;
+        {
+          this.resolvePathCache = createLRUCache(1e3);
+          processRouteTreeResult = this.buildRouteTree();
+        }
+        this.setRoutes(processRouteTreeResult);
       }
       if (!this.__store && this.latestLocation) {
-        this.__store = new Store(getInitialRouterState(this.latestLocation), {
-          onUpdate: () => {
-            this.__store.state = {
-              ...this.state,
-              cachedMatches: this.state.cachedMatches.filter(
-                (d) => !["redirected"].includes(d.status)
-              )
-            };
-          }
-        });
-        setupScrollRestoration(this);
+        {
+          this.__store = new Store(getInitialRouterState(this.latestLocation), {
+            onUpdate: () => {
+              this.__store.state = {
+                ...this.state,
+                cachedMatches: this.state.cachedMatches.filter(
+                  (d) => !["redirected"].includes(d.status)
+                )
+              };
+            }
+          });
+          setupScrollRestoration(this);
+        }
       }
       let needsLocationUpdate = false;
       const nextBasepath = this.options.basepath ?? "/";
@@ -2861,7 +3073,8 @@ class RouterCore {
       if (basepathChanged || rewriteChanged) {
         this.basepath = nextBasepath;
         const rewrites = [];
-        if (trimPath(nextBasepath) !== "") {
+        const trimmed = trimPath(nextBasepath);
+        if (trimmed && trimmed !== "/") {
           rewrites.push(
             rewriteBasepath({
               basepath: nextBasepath
@@ -2896,7 +3109,7 @@ class RouterCore {
       );
     };
     this.buildRouteTree = () => {
-      const { routesById, routesByPath, processedTree } = processRouteTree(
+      const result = processRouteTree(
         this.routeTree,
         this.options.caseSensitive,
         (route, i) => {
@@ -2906,18 +3119,9 @@ class RouterCore {
         }
       );
       if (this.options.routeMasks) {
-        processRouteMasks(this.options.routeMasks, processedTree);
-      }
-      this.routesById = routesById;
-      this.routesByPath = routesByPath;
-      this.processedTree = processedTree;
-      const notFoundRoute = this.options.notFoundRoute;
-      if (notFoundRoute) {
-        notFoundRoute.init({
-          originalIndex: 99999999999
-        });
-        this.routesById[notFoundRoute.id] = notFoundRoute;
+        processRouteMasks(this.options.routeMasks, result.processedTree);
       }
+      return result;
     };
     this.subscribe = (eventType, fn) => {
       const listener = {
@@ -2938,24 +3142,43 @@ class RouterCore {
     };
     this.parseLocation = (locationToParse, previousLocation) => {
       const parse = ({
+        pathname,
+        search,
+        hash,
         href,
         state
       }) => {
+        if (!this.rewrite && !/[ \x00-\x1f\x7f\u0080-\uffff]/.test(pathname)) {
+          const parsedSearch2 = this.options.parseSearch(search);
+          const searchStr2 = this.options.stringifySearch(parsedSearch2);
+          return {
+            href: pathname + searchStr2 + hash,
+            publicHref: href,
+            pathname: decodePath(pathname).path,
+            external: false,
+            searchStr: searchStr2,
+            search: replaceEqualDeep(
+              previousLocation?.search,
+              parsedSearch2
+            ),
+            hash: decodePath(hash.slice(1)).path,
+            state: replaceEqualDeep(previousLocation?.state, state)
+          };
+        }
         const fullUrl = new URL(href, this.origin);
         const url = executeRewriteInput(this.rewrite, fullUrl);
         const parsedSearch = this.options.parseSearch(url.search);
         const searchStr = this.options.stringifySearch(parsedSearch);
         url.search = searchStr;
         const fullPath = url.href.replace(url.origin, "");
-        const { pathname, hash } = url;
         return {
           href: fullPath,
           publicHref: href,
-          url: url.href,
-          pathname: decodePath(pathname),
+          pathname: decodePath(url.pathname).path,
+          external: !!this.rewrite && url.origin !== this.origin,
           searchStr,
           search: replaceEqualDeep(previousLocation?.search, parsedSearch),
-          hash: hash.split("#").reverse()[0] ?? "",
+          hash: decodePath(url.hash.slice(1)).path,
           state: replaceEqualDeep(previousLocation?.state, state)
         };
       };
@@ -2973,7 +3196,6 @@ class RouterCore {
       }
       return location;
     };
-    this.resolvePathCache = createLRUCache(1e3);
     this.resolvePathWithBase = (from, path) => {
       const resolvedPath = resolvePath({
         base: from,
@@ -3028,15 +3250,12 @@ class RouterCore {
     this.buildLocation = (opts) => {
       const build = (dest = {}) => {
         const currentLocation = dest._fromLocation || this.pendingBuiltLocation || this.latestLocation;
-        const allCurrentLocationMatches = this.matchRoutes(currentLocation, {
-          _buildLocation: true
-        });
-        const lastMatch = last(allCurrentLocationMatches);
+        const lightweightResult = this.matchRoutesLightweight(currentLocation);
         if (dest.from && false) ;
-        const defaultedFromPath = dest.unsafeRelative === "path" ? currentLocation.pathname : dest.from ?? lastMatch.fullPath;
+        const defaultedFromPath = dest.unsafeRelative === "path" ? currentLocation.pathname : dest.from ?? lightweightResult.fullPath;
         const fromPath = this.resolvePathWithBase(defaultedFromPath, ".");
-        const fromSearch = lastMatch.search;
-        const fromParams = { ...lastMatch.params };
+        const fromSearch = lightweightResult.search;
+        const fromParams = { ...lightweightResult.params };
         const nextTo = dest.to ? this.resolvePathWithBase(fromPath, `${dest.to}`) : this.resolvePathWithBase(fromPath, ".");
         const nextParams = dest.params === false || dest.params === null ? {} : (dest.params ?? true) === true ? fromParams : Object.assign(
           fromParams,
@@ -3044,15 +3263,22 @@ class RouterCore {
         );
         const interpolatedNextTo = interpolatePath({
           path: nextTo,
-          params: nextParams
+          params: nextParams,
+          decoder: this.pathParamsDecoder,
+          server: this.isServer
         }).interpolatedPath;
-        const destRoutes = this.matchRoutes(interpolatedNextTo, void 0, {
-          _buildLocation: true
-        }).map((d) => this.looseRoutesById[d.routeId]);
+        const destMatchResult = this.getMatchedRoutes(interpolatedNextTo);
+        let destRoutes = destMatchResult.matchedRoutes;
+        const isGlobalNotFound = destMatchResult.foundRoute ? destMatchResult.foundRoute.path !== "/" && destMatchResult.routeParams["**"] : trimPathRight(interpolatedNextTo);
+        if (isGlobalNotFound && this.options.notFoundRoute) {
+          destRoutes = [...destRoutes, this.options.notFoundRoute];
+        }
+        let changedParams = false;
         if (Object.keys(nextParams).length > 0) {
           for (const route of destRoutes) {
             const fn = route.options.params?.stringify ?? route.options.stringifyParams;
             if (fn) {
+              changedParams = true;
               Object.assign(nextParams, fn(nextParams));
             }
           }
@@ -3062,12 +3288,13 @@ class RouterCore {
           // This preserves the original parameter syntax including optional parameters
           nextTo
         ) : decodePath(
-          interpolatePath({
+          !changedParams ? interpolatedNextTo : interpolatePath({
             path: nextTo,
             params: nextParams,
-            decodeCharMap: this.pathParamsDecodeCharMap
+            decoder: this.pathParamsDecoder,
+            server: this.isServer
           }).interpolatedPath
-        );
+        ).path;
         let nextSearch = fromSearch;
         if (opts._includeValidateSearch && this.options.search?.strict) {
           const validatedSearch = {};
@@ -3100,17 +3327,32 @@ class RouterCore {
         let nextState = dest.state === true ? currentLocation.state : dest.state ? functionalUpdate(dest.state, currentLocation.state) : {};
         nextState = replaceEqualDeep(currentLocation.state, nextState);
         const fullPath = `${nextPathname}${searchStr}${hashStr}`;
-        const url = new URL(fullPath, this.origin);
-        const rewrittenUrl = executeRewriteOutput(this.rewrite, url);
+        let href;
+        let publicHref;
+        let external = false;
+        if (this.rewrite) {
+          const url = new URL(fullPath, this.origin);
+          const rewrittenUrl = executeRewriteOutput(this.rewrite, url);
+          href = url.href.replace(url.origin, "");
+          if (rewrittenUrl.origin !== this.origin) {
+            publicHref = rewrittenUrl.href;
+            external = true;
+          } else {
+            publicHref = rewrittenUrl.pathname + rewrittenUrl.search + rewrittenUrl.hash;
+          }
+        } else {
+          href = encodePathLikeUrl(fullPath);
+          publicHref = href;
+        }
         return {
-          publicHref: rewrittenUrl.pathname + rewrittenUrl.search + rewrittenUrl.hash,
-          href: fullPath,
-          url: rewrittenUrl.href,
+          publicHref,
+          href,
           pathname: nextPathname,
           search: nextSearch,
           searchStr,
           state: nextState,
           hash: hash ?? "",
+          external,
           unmaskOnReload: dest.unmaskOnReload
         };
       };
@@ -3125,12 +3367,17 @@ class RouterCore {
               this.processedTree
             );
             if (match) {
-              Object.assign(params, match.params);
-              const { from: _from, ...maskProps } = match.route;
+              Object.assign(params, match.rawParams);
+              const {
+                from: _from,
+                params: maskParams,
+                ...maskProps
+              } = match.route;
+              const nextParams = maskParams === false || maskParams === null ? {} : (maskParams ?? true) === true ? params : Object.assign(params, functionalUpdate(maskParams, params));
               maskedDest = {
                 from: opts.from,
                 ...maskProps,
-                params
+                params: nextParams
               };
               maskedNext = build(maskedDest);
             }
@@ -3149,7 +3396,7 @@ class RouterCore {
       }
       return buildWithMatches(opts);
     };
-    this.commitLocation = ({
+    this.commitLocation = async ({
       viewTransition,
       ignoreBlocker,
       ...next
@@ -3179,7 +3426,13 @@ class RouterCore {
       if (isSameUrl && isSameState()) {
         this.load();
       } else {
-        let { maskedLocation, hashScrollIntoView, ...nextHistory } = next;
+        let {
+          // eslint-disable-next-line prefer-const
+          maskedLocation,
+          // eslint-disable-next-line prefer-const
+          hashScrollIntoView,
+          ...nextHistory
+        } = next;
         if (maskedLocation) {
           nextHistory = {
             ...maskedLocation,
@@ -3232,7 +3485,9 @@ class RouterCore {
         const parsed = parseHref(href, {
           __TSR_index: replace ? currentIndex : currentIndex + 1
         });
-        rest.to = parsed.pathname;
+        const hrefUrl = new URL(parsed.pathname, this.origin);
+        const rewrittenUrl = executeRewriteInput(this.rewrite, hrefUrl);
+        rest.to = rewrittenUrl.pathname;
         rest.search = this.options.parseSearch(parsed.search);
         rest.hash = parsed.hash.slice(1);
       }
@@ -3256,18 +3511,33 @@ class RouterCore {
       });
       return commitPromise;
     };
-    this.navigate = async ({ to, reloadDocument, href, ...rest }) => {
-      if (!reloadDocument && href) {
+    this.navigate = async ({
+      to,
+      reloadDocument,
+      href,
+      publicHref,
+      ...rest
+    }) => {
+      let hrefIsUrl = false;
+      if (href) {
         try {
           new URL(`${href}`);
-          reloadDocument = true;
+          hrefIsUrl = true;
         } catch {
         }
       }
+      if (hrefIsUrl && !reloadDocument) {
+        reloadDocument = true;
+      }
       if (reloadDocument) {
-        if (!href) {
+        if (to !== void 0 || !href) {
           const location = this.buildLocation({ to, ...rest });
-          href = location.url;
+          href = href ?? location.publicHref;
+          publicHref = publicHref ?? location.publicHref;
+        }
+        const reloadHref = !hrefIsUrl && publicHref ? publicHref : href;
+        if (isDangerousProtocol(reloadHref)) {
+          return Promise.resolve();
         }
         if (!rest.ignoreBlocker) {
           const historyWithBlockers = this.history;
@@ -3287,9 +3557,9 @@ class RouterCore {
           }
         }
         if (rest.replace) {
-          window.location.replace(href);
+          window.location.replace(reloadHref);
         } else {
-          window.location.href = href;
+          window.location.href = reloadHref;
         }
         return Promise.resolve();
       }
@@ -3303,30 +3573,6 @@ class RouterCore {
     this.beforeLoad = () => {
       this.cancelMatches();
       this.updateLatestLocation();
-      if (this.isServer) {
-        const nextLocation = this.buildLocation({
-          to: this.latestLocation.pathname,
-          search: true,
-          params: true,
-          hash: true,
-          state: true,
-          _includeValidateSearch: true
-        });
-        const normalizeUrl = (url) => {
-          try {
-            return encodeURI(decodeURI(url));
-          } catch {
-            return url;
-          }
-        };
-        if (trimPath(normalizeUrl(this.latestLocation.href)) !== trimPath(normalizeUrl(nextLocation.href))) {
-          let href = nextLocation.url;
-          if (this.origin && href.startsWith(this.origin)) {
-            href = href.replace(this.origin, "") || "/";
-          }
-          throw redirect({ href });
-        }
-      }
       const pendingMatches = this.matchRoutes(this.latestLocation);
       this.__store.setState((s) => ({
         ...s,
@@ -3433,7 +3679,7 @@ class RouterCore {
           } catch (err) {
             if (isRedirect(err)) {
               redirect2 = err;
-              if (!this.isServer) {
+              {
                 this.navigate({
                   ...redirect2.options,
                   replace: true,
@@ -3477,7 +3723,7 @@ class RouterCore {
     };
     this.startViewTransition = (fn) => {
       const shouldViewTransition = this.shouldViewTransition ?? this.options.defaultViewTransition;
-      delete this.shouldViewTransition;
+      this.shouldViewTransition = void 0;
       if (shouldViewTransition && typeof document !== "undefined" && "startViewTransition" in document && typeof document.startViewTransition === "function") {
         let startViewTransitionParams;
         if (typeof shouldViewTransition === "object" && this.isViewTransitionTypesSupported) {
@@ -3542,15 +3788,26 @@ class RouterCore {
       this.shouldViewTransition = false;
       return this.load({ sync: opts?.sync });
     };
+    this.getParsedLocationHref = (location) => {
+      return location.publicHref || "/";
+    };
     this.resolveRedirect = (redirect2) => {
-      if (!redirect2.options.href) {
-        const location = this.buildLocation(redirect2.options);
-        let href = location.url;
-        if (this.origin && href.startsWith(this.origin)) {
-          href = href.replace(this.origin, "") || "/";
-        }
-        redirect2.options.href = location.href;
+      const locationHeader = redirect2.headers.get("Location");
+      if (!redirect2.options.href || redirect2.options._builtLocation) {
+        const location = redirect2.options._builtLocation ?? this.buildLocation(redirect2.options);
+        const href = this.getParsedLocationHref(location);
+        redirect2.options.href = href;
         redirect2.headers.set("Location", href);
+      } else if (locationHeader) {
+        try {
+          const url = new URL(locationHeader);
+          if (this.origin && url.origin === this.origin) {
+            const href = url.pathname + url.search + url.hash;
+            redirect2.options.href = href;
+            redirect2.headers.set("Location", href);
+          }
+        } catch {
+        }
       }
       if (!redirect2.headers.get("Location")) {
         redirect2.headers.set("Location", redirect2.options.href);
@@ -3676,14 +3933,14 @@ class RouterCore {
         return false;
       }
       if (location.params) {
-        if (!deepEqual(match.params, location.params, { partial: true })) {
+        if (!deepEqual(match.rawParams, location.params, { partial: true })) {
           return false;
         }
       }
       if (opts?.includeSearch ?? true) {
-        return deepEqual(baseLocation.search, next.search, { partial: true }) ? match.params : false;
+        return deepEqual(baseLocation.search, next.search, { partial: true }) ? match.rawParams : false;
       }
-      return match.params;
+      return match.rawParams;
     };
     this.hasNotFoundMatch = () => {
       return this.__store.state.matches.some(
@@ -3714,12 +3971,33 @@ class RouterCore {
   get state() {
     return this.__store.state;
   }
+  setRoutes({
+    routesById,
+    routesByPath,
+    processedTree
+  }) {
+    this.routesById = routesById;
+    this.routesByPath = routesByPath;
+    this.processedTree = processedTree;
+    const notFoundRoute = this.options.notFoundRoute;
+    if (notFoundRoute) {
+      notFoundRoute.init({
+        originalIndex: 99999999999
+      });
+      this.routesById[notFoundRoute.id] = notFoundRoute;
+    }
+  }
   get looseRoutesById() {
     return this.routesById;
   }
+  getParentContext(parentMatch) {
+    const parentMatchId = parentMatch?.id;
+    const parentContext = !parentMatchId ? this.options.context ?? void 0 : parentMatch.context ?? this.options.context ?? void 0;
+    return parentContext;
+  }
   matchRoutesInternal(next, opts) {
     const matchedRoutesResult = this.getMatchedRoutes(next.pathname);
-    const { foundRoute, routeParams } = matchedRoutesResult;
+    const { foundRoute, routeParams, parsedParams } = matchedRoutesResult;
     let { matchedRoutes } = matchedRoutesResult;
     let isGlobalNotFound = false;
     if (
@@ -3735,41 +4013,28 @@ class RouterCore {
         isGlobalNotFound = true;
       }
     }
-    const globalNotFoundRouteId = (() => {
-      if (!isGlobalNotFound) {
-        return void 0;
-      }
-      if (this.options.notFoundMode !== "root") {
-        for (let i = matchedRoutes.length - 1; i >= 0; i--) {
-          const route = matchedRoutes[i];
-          if (route.children) {
-            return route.id;
-          }
-        }
-      }
-      return rootRouteId;
-    })();
-    const matches = [];
-    const getParentContext = (parentMatch) => {
-      const parentMatchId = parentMatch?.id;
-      const parentContext = !parentMatchId ? this.options.context ?? void 0 : parentMatch.context ?? this.options.context ?? void 0;
-      return parentContext;
-    };
-    matchedRoutes.forEach((route, index) => {
+    const globalNotFoundRouteId = isGlobalNotFound ? findGlobalNotFoundRouteId(this.options.notFoundMode, matchedRoutes) : void 0;
+    const matches = new Array(matchedRoutes.length);
+    const previousMatchesByRouteId = new Map(
+      this.state.matches.map((match) => [match.routeId, match])
+    );
+    for (let index = 0; index < matchedRoutes.length; index++) {
+      const route = matchedRoutes[index];
       const parentMatch = matches[index - 1];
-      const [preMatchSearch, strictMatchSearch, searchError] = (() => {
+      let preMatchSearch;
+      let strictMatchSearch;
+      let searchError;
+      {
         const parentSearch = parentMatch?.search ?? next.search;
         const parentStrictSearch = parentMatch?._strictSearch ?? void 0;
         try {
           const strictSearch = validateSearch(route.options.validateSearch, { ...parentSearch }) ?? void 0;
-          return [
-            {
-              ...parentSearch,
-              ...strictSearch
-            },
-            { ...parentStrictSearch, ...strictSearch },
-            void 0
-          ];
+          preMatchSearch = {
+            ...parentSearch,
+            ...strictSearch
+          };
+          strictMatchSearch = { ...parentStrictSearch, ...strictSearch };
+          searchError = void 0;
         } catch (err) {
           let searchParamError = err;
           if (!(err instanceof SearchParamError)) {
@@ -3780,9 +4045,11 @@ class RouterCore {
           if (opts?.throwOnError) {
             throw searchParamError;
           }
-          return [parentSearch, {}, searchParamError];
+          preMatchSearch = parentSearch;
+          strictMatchSearch = {};
+          searchError = searchParamError;
         }
-      })();
+      }
       const loaderDeps = route.options.loaderDeps?.({
         search: preMatchSearch
       }) ?? "";
@@ -3790,7 +4057,8 @@ class RouterCore {
       const { interpolatedPath, usedParams } = interpolatePath({
         path: route.fullPath,
         params: routeParams,
-        decodeCharMap: this.pathParamsDecodeCharMap
+        decoder: this.pathParamsDecoder,
+        server: this.isServer
       });
       const matchId = (
         // route.id for disambiguation
@@ -3799,30 +4067,22 @@ class RouterCore {
         loaderDepsHash
       );
       const existingMatch = this.getMatch(matchId);
-      const previousMatch = this.state.matches.find(
-        (d) => d.routeId === route.id
-      );
+      const previousMatch = previousMatchesByRouteId.get(route.id);
       const strictParams = existingMatch?._strictParams ?? usedParams;
       let paramsError = void 0;
       if (!existingMatch) {
-        const strictParseParams = route.options.params?.parse ?? route.options.parseParams;
-        if (strictParseParams) {
-          try {
-            Object.assign(
-              strictParams,
-              strictParseParams(strictParams)
-            );
-          } catch (err) {
-            if (isNotFound(err) || isRedirect(err)) {
-              paramsError = err;
-            } else {
-              paramsError = new PathParamError(err.message, {
-                cause: err
-              });
-            }
-            if (opts?.throwOnError) {
-              throw paramsError;
-            }
+        try {
+          extractStrictParams(route, usedParams, parsedParams, strictParams);
+        } catch (err) {
+          if (isNotFound(err) || isRedirect(err)) {
+            paramsError = err;
+          } else {
+            paramsError = new PathParamError(err.message, {
+              cause: err
+            });
+          }
+          if (opts?.throwOnError) {
+            throw paramsError;
           }
         }
       }
@@ -3833,7 +4093,7 @@ class RouterCore {
         match = {
           ...existingMatch,
           cause,
-          params: previousMatch ? replaceEqualDeep(previousMatch.params, routeParams) : routeParams,
+          params: previousMatch?.params ?? routeParams,
           _strictParams: strictParams,
           search: previousMatch ? replaceEqualDeep(previousMatch.search, preMatchSearch) : replaceEqualDeep(existingMatch.search, preMatchSearch),
           _strictSearch: strictMatchSearch
@@ -3842,10 +4102,10 @@ class RouterCore {
         const status = route.options.loader || route.options.beforeLoad || route.lazyFn || routeNeedsPreload(route) ? "pending" : "success";
         match = {
           id: matchId,
-          ssr: this.isServer ? void 0 : route.options.ssr,
+          ssr: route.options.ssr,
           index,
           routeId: route.id,
-          params: previousMatch ? replaceEqualDeep(previousMatch.params, routeParams) : routeParams,
+          params: previousMatch?.params ?? routeParams,
           _strictParams: strictParams,
           pathname: interpolatedPath,
           updatedAt: Date.now(),
@@ -3880,20 +4140,23 @@ class RouterCore {
         match.globalNotFound = globalNotFoundRouteId === route.id;
       }
       match.searchError = searchError;
-      const parentContext = getParentContext(parentMatch);
+      const parentContext = this.getParentContext(parentMatch);
       match.context = {
         ...parentContext,
         ...match.__routeContext,
         ...match.__beforeLoadContext
       };
-      matches.push(match);
-    });
-    matches.forEach((match, index) => {
+      matches[index] = match;
+    }
+    for (let index = 0; index < matches.length; index++) {
+      const match = matches[index];
       const route = this.looseRoutesById[match.routeId];
       const existingMatch = this.getMatch(match.id);
-      if (!existingMatch && opts?._buildLocation !== true) {
+      const previousMatch = previousMatchesByRouteId.get(match.routeId);
+      match.params = previousMatch ? replaceEqualDeep(previousMatch.params, routeParams) : routeParams;
+      if (!existingMatch) {
         const parentMatch = matches[index - 1];
-        const parentContext = getParentContext(parentMatch);
+        const parentContext = this.getParentContext(parentMatch);
         if (route.options.context) {
           const contextFnContext = {
             deps: match.loaderDeps,
@@ -3905,7 +4168,8 @@ class RouterCore {
             cause: match.cause,
             abortController: match.abortController,
             preload: !!match.preload,
-            matches
+            matches,
+            routeId: route.id
           };
           match.__routeContext = route.options.context(contextFnContext) ?? void 0;
         }
@@ -3915,9 +4179,56 @@ class RouterCore {
           ...match.__beforeLoadContext
         };
       }
-    });
+    }
     return matches;
   }
+  /**
+   * Lightweight route matching for buildLocation.
+   * Only computes fullPath, accumulated search, and params - skipping expensive
+   * operations like AbortController, ControlledPromise, loaderDeps, and full match objects.
+   */
+  matchRoutesLightweight(location) {
+    const { matchedRoutes, routeParams, parsedParams } = this.getMatchedRoutes(
+      location.pathname
+    );
+    const lastRoute = last(matchedRoutes);
+    const accumulatedSearch = { ...location.search };
+    for (const route of matchedRoutes) {
+      try {
+        Object.assign(
+          accumulatedSearch,
+          validateSearch(route.options.validateSearch, accumulatedSearch)
+        );
+      } catch {
+      }
+    }
+    const lastStateMatch = last(this.state.matches);
+    const canReuseParams = lastStateMatch && lastStateMatch.routeId === lastRoute.id && location.pathname === this.state.location.pathname;
+    let params;
+    if (canReuseParams) {
+      params = lastStateMatch.params;
+    } else {
+      const strictParams = { ...routeParams };
+      for (const route of matchedRoutes) {
+        try {
+          extractStrictParams(
+            route,
+            routeParams,
+            parsedParams ?? {},
+            strictParams
+          );
+        } catch {
+        }
+      }
+      params = strictParams;
+    }
+    return {
+      matchedRoutes,
+      fullPath: lastRoute.fullPath,
+      search: accumulatedSearch,
+      params
+    };
+  }
 }
 class SearchParamError extends Error {
 }
@@ -3971,13 +4282,15 @@ function getMatchedRoutes({
   const routeParams = {};
   const trimmedPath = trimPathRight(pathname);
   let foundRoute = void 0;
+  let parsedParams = void 0;
   const match = findRouteMatch(trimmedPath, processedTree, true);
   if (match) {
     foundRoute = match.route;
-    Object.assign(routeParams, match.params);
+    Object.assign(routeParams, match.rawParams);
+    parsedParams = Object.assign({}, match.parsedParams);
   }
   const matchedRoutes = match?.branch || [routesById[rootRouteId]];
-  return { matchedRoutes, routeParams, foundRoute };
+  return { matchedRoutes, routeParams, foundRoute, parsedParams };
 }
 function applySearchMiddleware({
   search,
@@ -3985,79 +4298,112 @@ function applySearchMiddleware({
   destRoutes,
   _includeValidateSearch
 }) {
-  const allMiddlewares = destRoutes.reduce(
-    (acc, route) => {
-      const middlewares = [];
-      if ("search" in route.options) {
-        if (route.options.search?.middlewares) {
-          middlewares.push(...route.options.search.middlewares);
+  const middleware = buildMiddlewareChain(destRoutes);
+  return middleware(search, dest, _includeValidateSearch ?? false);
+}
+function buildMiddlewareChain(destRoutes) {
+  const context = {
+    dest: null,
+    _includeValidateSearch: false,
+    middlewares: []
+  };
+  for (const route of destRoutes) {
+    if ("search" in route.options) {
+      if (route.options.search?.middlewares) {
+        context.middlewares.push(...route.options.search.middlewares);
+      }
+    } else if (route.options.preSearchFilters || route.options.postSearchFilters) {
+      const legacyMiddleware = ({ search, next }) => {
+        let nextSearch = search;
+        if ("preSearchFilters" in route.options && route.options.preSearchFilters) {
+          nextSearch = route.options.preSearchFilters.reduce(
+            (prev, next2) => next2(prev),
+            search
+          );
         }
-      } else if (route.options.preSearchFilters || route.options.postSearchFilters) {
-        const legacyMiddleware = ({
-          search: search2,
-          next
-        }) => {
-          let nextSearch = search2;
-          if ("preSearchFilters" in route.options && route.options.preSearchFilters) {
-            nextSearch = route.options.preSearchFilters.reduce(
-              (prev, next2) => next2(prev),
-              search2
-            );
-          }
-          const result = next(nextSearch);
-          if ("postSearchFilters" in route.options && route.options.postSearchFilters) {
-            return route.options.postSearchFilters.reduce(
-              (prev, next2) => next2(prev),
-              result
-            );
-          }
+        const result = next(nextSearch);
+        if ("postSearchFilters" in route.options && route.options.postSearchFilters) {
+          return route.options.postSearchFilters.reduce(
+            (prev, next2) => next2(prev),
+            result
+          );
+        }
+        return result;
+      };
+      context.middlewares.push(legacyMiddleware);
+    }
+    if (route.options.validateSearch) {
+      const validate = ({ search, next }) => {
+        const result = next(search);
+        if (!context._includeValidateSearch) return result;
+        try {
+          const validatedSearch = {
+            ...result,
+            ...validateSearch(route.options.validateSearch, result) ?? void 0
+          };
+          return validatedSearch;
+        } catch {
           return result;
-        };
-        middlewares.push(legacyMiddleware);
-      }
-      if (_includeValidateSearch && route.options.validateSearch) {
-        const validate = ({ search: search2, next }) => {
-          const result = next(search2);
-          try {
-            const validatedSearch = {
-              ...result,
-              ...validateSearch(route.options.validateSearch, result) ?? void 0
-            };
-            return validatedSearch;
-          } catch {
-            return result;
-          }
-        };
-        middlewares.push(validate);
-      }
-      return acc.concat(middlewares);
-    },
-    []
-  ) ?? [];
-  const final = ({ search: search2 }) => {
+        }
+      };
+      context.middlewares.push(validate);
+    }
+  }
+  const final = ({ search }) => {
+    const dest = context.dest;
     if (!dest.search) {
       return {};
     }
     if (dest.search === true) {
-      return search2;
+      return search;
     }
-    return functionalUpdate(dest.search, search2);
+    return functionalUpdate(dest.search, search);
   };
-  allMiddlewares.push(final);
-  const applyNext = (index, currentSearch) => {
-    if (index >= allMiddlewares.length) {
+  context.middlewares.push(final);
+  const applyNext = (index, currentSearch, middlewares) => {
+    if (index >= middlewares.length) {
       return currentSearch;
     }
-    const middleware = allMiddlewares[index];
+    const middleware = middlewares[index];
     const next = (newSearch) => {
-      return applyNext(index + 1, newSearch);
+      return applyNext(index + 1, newSearch, middlewares);
     };
     return middleware({ search: currentSearch, next });
   };
-  return applyNext(0, search);
+  return function middleware(search, dest, _includeValidateSearch) {
+    context.dest = dest;
+    context._includeValidateSearch = _includeValidateSearch;
+    return applyNext(0, search, context.middlewares);
+  };
+}
+function findGlobalNotFoundRouteId(notFoundMode, routes) {
+  if (notFoundMode !== "root") {
+    for (let i = routes.length - 1; i >= 0; i--) {
+      const route = routes[i];
+      if (route.children) {
+        return route.id;
+      }
+    }
+  }
+  return rootRouteId;
+}
+function extractStrictParams(route, referenceParams, parsedParams, accumulatedParams) {
+  const parseParams = route.options.params?.parse ?? route.options.parseParams;
+  if (parseParams) {
+    if (route.options.skipRouteOnParseError) {
+      for (const key in referenceParams) {
+        if (key in parsedParams) {
+          accumulatedParams[key] = parsedParams[key];
+        }
+      }
+    } else {
+      const result = parseParams(accumulatedParams);
+      Object.assign(accumulatedParams, result);
+    }
+  }
 }
 
-const TSR_DEFERRED_PROMISE = Symbol.for("TSR_DEFERRED_PROMISE");
+const TSR_DEFERRED_PROMISE = /* @__PURE__ */ Symbol.for("TSR_DEFERRED_PROMISE");
 function defer(_promise, options) {
   const promise = _promise;
   if (promise[TSR_DEFERRED_PROMISE]) {
@@ -4122,7 +4468,7 @@ class BaseRoute {
       this._path = path;
       this._id = id;
       this._fullPath = fullPath;
-      this._to = fullPath;
+      this._to = trimPathRight(fullPath);
     };
     this.addChildren = (children) => {
       return this._addFileChildren(children);
@@ -4151,6 +4497,7 @@ class BaseRoute {
       this.lazyFn = lazyFn;
       return this;
     };
+    this.redirect = (opts) => redirect({ from: this.fullPath, ...opts });
     this.options = options || {};
     this.isRoot = !options?.getParentRoute;
     if (options?.id && options?.path) {
@@ -4175,6 +4522,7 @@ class BaseRouteApi {
     this.notFound = (opts) => {
       return notFound({ routeId: this.id, ...opts });
     };
+    this.redirect = (opts) => redirect({ from: this.id, ...opts });
     this.id = id;
   }
 }
@@ -4197,12 +4545,13 @@ function retainSearchParams(keys) {
     if (keys === true) {
       return { ...search, ...result };
     }
+    const copy = { ...result };
     keys.forEach((key) => {
-      if (!(key in result)) {
-        result[key] = search[key];
+      if (!(key in copy)) {
+        copy[key] = search[key];
       }
     });
-    return result;
+    return copy;
   };
 }
 function stripSearchParams(input) {
@@ -4210,7 +4559,7 @@ function stripSearchParams(input) {
     if (input === true) {
       return {};
     }
-    const result = next(search);
+    const result = { ...next(search) };
     if (Array.isArray(input)) {
       input.forEach((key) => {
         delete result[key];
@@ -4228,16 +4577,63 @@ function stripSearchParams(input) {
   };
 }
 
-var K=(s=>(s[s.AggregateError=1]="AggregateError",s[s.ArrowFunction=2]="ArrowFunction",s[s.ErrorPrototypeStack=4]="ErrorPrototypeStack",s[s.ObjectAssign=8]="ObjectAssign",s[s.BigIntTypedArray=16]="BigIntTypedArray",s))(K||{});var B="__SEROVAL_REFS__";var V=new Map;typeof globalThis!="undefined"?Object.defineProperty(globalThis,B,{value:V,configurable:true,writable:false,enumerable:false}):typeof window!="undefined"?Object.defineProperty(window,B,{value:V,configurable:true,writable:false,enumerable:false}):typeof self!="undefined"?Object.defineProperty(self,B,{value:V,configurable:true,writable:false,enumerable:false}):typeof global!="undefined"&&Object.defineProperty(global,B,{value:V,configurable:true,writable:false,enumerable:false});var X=()=>{let e={p:0,s:0,f:0};return e.p=new Promise((r,t)=>{e.s=r,e.f=t;}),e},un=(e,r)=>{e.s(r),e.p.s=1,e.p.v=r;},cn=(e,r)=>{e.f(r),e.p.s=2,e.p.v=r;};X.toString();un.toString();cn.toString();var Rr=(e,r)=>{let t=atob(r),n=new Uint8Array(e);for(let a=0;a<e;a++)n[a]=t.charCodeAt(a);return n.buffer};Rr.toString();var te=(t=>(t[t.Vanilla=1]="Vanilla",t[t.Cross=2]="Cross",t))(te||{});var no=()=>T;no.toString();
+var L=(i=>(i[i.AggregateError=1]="AggregateError",i[i.ArrowFunction=2]="ArrowFunction",i[i.ErrorPrototypeStack=4]="ErrorPrototypeStack",i[i.ObjectAssign=8]="ObjectAssign",i[i.BigIntTypedArray=16]="BigIntTypedArray",i[i.RegExp=32]="RegExp",i))(L||{});var U="__SEROVAL_REFS__";var j=new Map;typeof globalThis!="undefined"?Object.defineProperty(globalThis,U,{value:j,configurable:true,writable:false,enumerable:false}):typeof window!="undefined"?Object.defineProperty(window,U,{value:j,configurable:true,writable:false,enumerable:false}):typeof self!="undefined"?Object.defineProperty(self,U,{value:j,configurable:true,writable:false,enumerable:false}):typeof global!="undefined"&&Object.defineProperty(global,U,{value:j,configurable:true,writable:false,enumerable:false});var re=()=>{let e={p:0,s:0,f:0};return e.p=new Promise((r,t)=>{e.s=r,e.f=t;}),e},vn=(e,r)=>{e.s(r),e.p.s=1,e.p.v=r;},Cn=(e,r)=>{e.f(r),e.p.s=2,e.p.v=r;};re.toString();vn.toString();Cn.toString();var Or=e=>{let r=atob(e),t=r.length,n=new Uint8Array(t);for(let a=0;a<t;a++)n[a]=r.charCodeAt(a);return n.buffer};Or.toString();var ae=(t=>(t[t.Vanilla=1]="Vanilla",t[t.Cross=2]="Cross",t))(ae||{});var Eo=()=>T;Eo.toString();
 
 function createSerializationAdapter(opts) {
   return opts;
 }
 
 const React$f = await importShared('react');
-function useAwaited({
-  promise: _promise
-}) {
+
+const REACT_USE = "use";
+const reactUse = React$f[REACT_USE];
+function useStableCallback(fn) {
+  const fnRef = React$f.useRef(fn);
+  fnRef.current = fn;
+  const ref = React$f.useRef((...args) => fnRef.current(...args));
+  return ref.current;
+}
+const useLayoutEffect = typeof window !== "undefined" ? React$f.useLayoutEffect : React$f.useEffect;
+function usePrevious(value) {
+  const ref = React$f.useRef({
+    value,
+    prev: null
+  });
+  const current = ref.current.value;
+  if (value !== current) {
+    ref.current = {
+      value,
+      prev: current
+    };
+  }
+  return ref.current.prev;
+}
+function useIntersectionObserver(ref, callback, intersectionObserverOptions = {}, options = {}) {
+  React$f.useEffect(() => {
+    if (!ref.current || options.disabled || typeof IntersectionObserver !== "function") {
+      return;
+    }
+    const observer = new IntersectionObserver(([entry]) => {
+      callback(entry);
+    }, intersectionObserverOptions);
+    observer.observe(ref.current);
+    return () => {
+      observer.disconnect();
+    };
+  }, [callback, intersectionObserverOptions, options.disabled, ref]);
+}
+function useForwardedRef(ref) {
+  const innerRef = React$f.useRef(null);
+  React$f.useImperativeHandle(ref, () => innerRef.current, []);
+  return innerRef;
+}
+
+const React$e = await importShared('react');
+function useAwaited({ promise: _promise }) {
+  if (reactUse) {
+    const data = reactUse(_promise);
+    return data;
+  }
   const promise = defer(_promise);
   if (promise[TSR_DEFERRED_PROMISE].status === "pending") {
     throw promise;
@@ -4245,21 +4641,21 @@ function useAwaited({
   if (promise[TSR_DEFERRED_PROMISE].status === "error") {
     throw promise[TSR_DEFERRED_PROMISE].error;
   }
-  return [promise[TSR_DEFERRED_PROMISE].data, promise];
+  return promise[TSR_DEFERRED_PROMISE].data;
 }
 function Await(props) {
   const inner = /* @__PURE__ */ jsxRuntimeExports.jsx(AwaitInner, { ...props });
   if (props.fallback) {
-    return /* @__PURE__ */ jsxRuntimeExports.jsx(React$f.Suspense, { fallback: props.fallback, children: inner });
+    return /* @__PURE__ */ jsxRuntimeExports.jsx(React$e.Suspense, { fallback: props.fallback, children: inner });
   }
   return inner;
 }
 function AwaitInner(props) {
-  const [data] = useAwaited(props);
+  const data = useAwaited(props);
   return props.children(data);
 }
 
-const React$e = await importShared('react');
+const React$d = await importShared('react');
 
 function CatchBoundary(props) {
   const errorComponent = props.errorComponent ?? ErrorComponent;
@@ -4270,7 +4666,7 @@ function CatchBoundary(props) {
       onCatch: props.onCatch,
       children: ({ error, reset }) => {
         if (error) {
-          return React$e.createElement(errorComponent, {
+          return React$d.createElement(errorComponent, {
             error,
             reset
           });
@@ -4280,7 +4676,7 @@ function CatchBoundary(props) {
     }
   );
 }
-class CatchBoundaryImpl extends React$e.Component {
+class CatchBoundaryImpl extends React$d.Component {
   constructor() {
     super(...arguments);
     this.state = { error: null };
@@ -4314,7 +4710,7 @@ class CatchBoundaryImpl extends React$e.Component {
   }
 }
 function ErrorComponent({ error }) {
-  const [show, setShow] = React$e.useState(false);
+  const [show, setShow] = React$d.useState(false);
   return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { style: { padding: ".5rem", maxWidth: "100%" }, children: [
     /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { style: { display: "flex", alignItems: "center", gap: ".5rem" }, children: [
       /* @__PURE__ */ jsxRuntimeExports.jsx("strong", { style: { fontSize: "1rem" }, children: "Something went wrong!" }),
@@ -4534,9 +4930,9 @@ function getOwnKeys(obj) {
   );
 }
 
-const React$d = await importShared('react');
+const React$c = await importShared('react');
 
-const routerContext = React$d.createContext(null);
+const routerContext = React$c.createContext(null);
 function getRouterContext() {
   if (typeof document === "undefined") {
     return routerContext;
@@ -4548,9 +4944,9 @@ function getRouterContext() {
   return routerContext;
 }
 
-const React$c = await importShared('react');
+const React$b = await importShared('react');
 function useRouter(opts) {
-  const value = React$c.useContext(getRouterContext());
+  const value = React$b.useContext(getRouterContext());
   warning(
     !((opts?.warn ?? true) && !value));
   return value;
@@ -4562,7 +4958,10 @@ function useRouterState(opts) {
     warn: opts?.router === void 0
   });
   const router = opts?.router || contextRouter;
-  const previousResult = useRef(void 0);
+  const previousResult = (
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    useRef(void 0)
+  );
   return useStore(router.__store, (state) => {
     if (opts?.select) {
       if (opts.structuralSharing ?? router.options.defaultStructuralSharing) {
@@ -4579,16 +4978,16 @@ function useRouterState(opts) {
   });
 }
 
-const React$b = await importShared('react');
+const React$a = await importShared('react');
 
-const matchContext = React$b.createContext(void 0);
-const dummyMatchContext = React$b.createContext(
+const matchContext = React$a.createContext(void 0);
+const dummyMatchContext = React$a.createContext(
   void 0
 );
 
-const React$a = await importShared('react');
+const React$9 = await importShared('react');
 function useMatch(opts) {
-  const nearestMatchId = React$a.useContext(
+  const nearestMatchId = React$9.useContext(
     opts.from ? dummyMatchContext : matchContext
   );
   const matchSelection = useRouterState({
@@ -4656,49 +5055,6 @@ function useSearch(opts) {
   });
 }
 
-const React$9 = await importShared('react');
-
-function useStableCallback(fn) {
-  const fnRef = React$9.useRef(fn);
-  fnRef.current = fn;
-  const ref = React$9.useRef((...args) => fnRef.current(...args));
-  return ref.current;
-}
-const useLayoutEffect = typeof window !== "undefined" ? React$9.useLayoutEffect : React$9.useEffect;
-function usePrevious(value) {
-  const ref = React$9.useRef({
-    value,
-    prev: null
-  });
-  const current = ref.current.value;
-  if (value !== current) {
-    ref.current = {
-      value,
-      prev: current
-    };
-  }
-  return ref.current.prev;
-}
-function useIntersectionObserver(ref, callback, intersectionObserverOptions = {}, options = {}) {
-  React$9.useEffect(() => {
-    if (!ref.current || options.disabled || typeof IntersectionObserver !== "function") {
-      return;
-    }
-    const observer = new IntersectionObserver(([entry]) => {
-      callback(entry);
-    }, intersectionObserverOptions);
-    observer.observe(ref.current);
-    return () => {
-      observer.disconnect();
-    };
-  }, [callback, intersectionObserverOptions, options.disabled, ref]);
-}
-function useForwardedRef(ref) {
-  const innerRef = React$9.useRef(null);
-  React$9.useImperativeHandle(ref, () => innerRef.current, []);
-  return innerRef;
-}
-
 const React$8 = await importShared('react');
 function useNavigate(_defaultOpts) {
   const router = useRouter();
@@ -4730,8 +5086,6 @@ const React$7 = await importShared('react');
 const {flushSync} = await importShared('react-dom');
 function useLinkProps(options, forwardedRef) {
   const router = useRouter();
-  const [isTransitioning, setIsTransitioning] = React$7.useState(false);
-  const hasRenderFetched = React$7.useRef(false);
   const innerRef = useForwardedRef(forwardedRef);
   const {
     // custom props
@@ -4770,6 +5124,7 @@ function useLinkProps(options, forwardedRef) {
     _fromLocation,
     ...propsSafeToSpread
   } = options;
+  const isHydrated = useHydrated();
   const currentSearch = useRouterState({
     select: (s) => s.location.search,
     structuralSharing: true
@@ -4798,34 +5153,38 @@ function useLinkProps(options, forwardedRef) {
     () => router.buildLocation({ ..._options }),
     [router, _options]
   );
-  const hrefOption = React$7.useMemo(() => {
-    if (disabled) {
-      return void 0;
-    }
-    let href = next.maskedLocation ? next.maskedLocation.url : next.url;
-    let external = false;
-    if (router.origin) {
-      if (href.startsWith(router.origin)) {
-        href = router.history.createHref(href.replace(router.origin, "")) || "/";
-      } else {
-        external = true;
-      }
-    }
-    return { href, external };
-  }, [disabled, next.maskedLocation, next.url, router.origin, router.history]);
+  const hrefOptionPublicHref = next.maskedLocation ? next.maskedLocation.publicHref : next.publicHref;
+  const hrefOptionExternal = next.maskedLocation ? next.maskedLocation.external : next.external;
+  const hrefOption = React$7.useMemo(
+    () => getHrefOption(
+      hrefOptionPublicHref,
+      hrefOptionExternal,
+      router.history,
+      disabled
+    ),
+    [disabled, hrefOptionExternal, hrefOptionPublicHref, router.history]
+  );
   const externalLink = React$7.useMemo(() => {
     if (hrefOption?.external) {
+      if (isDangerousProtocol(hrefOption.href)) {
+        return void 0;
+      }
       return hrefOption.href;
     }
+    const safeInternal = isSafeInternal(to);
+    if (safeInternal) return void 0;
+    if (typeof to !== "string" || to.indexOf(":") === -1) return void 0;
     try {
       new URL(to);
+      if (isDangerousProtocol(to)) {
+        if (false) ;
+        return void 0;
+      }
       return to;
     } catch {
     }
     return void 0;
   }, [to, hrefOption]);
-  const preload = options.reloadDocument || externalLink ? false : userPreload ?? router.options.defaultPreload;
-  const preloadDelay = userPreloadDelay ?? router.options.defaultPreloadDelay ?? 0;
   const isActive = useRouterState({
     select: (s) => {
       if (externalLink) return false;
@@ -4862,11 +5221,27 @@ function useLinkProps(options, forwardedRef) {
         }
       }
       if (activeOptions?.includeHash) {
-        return s.location.hash === next.hash;
+        return isHydrated && s.location.hash === next.hash;
       }
       return true;
     }
   });
+  const resolvedActiveProps = isActive ? functionalUpdate(activeProps, {}) ?? STATIC_ACTIVE_OBJECT : STATIC_EMPTY_OBJECT;
+  const resolvedInactiveProps = isActive ? STATIC_EMPTY_OBJECT : functionalUpdate(inactiveProps, {}) ?? STATIC_EMPTY_OBJECT;
+  const resolvedClassName = [
+    className,
+    resolvedActiveProps.className,
+    resolvedInactiveProps.className
+  ].filter(Boolean).join(" ");
+  const resolvedStyle = (style || resolvedActiveProps.style || resolvedInactiveProps.style) && {
+    ...style,
+    ...resolvedActiveProps.style,
+    ...resolvedInactiveProps.style
+  };
+  const [isTransitioning, setIsTransitioning] = React$7.useState(false);
+  const hasRenderFetched = React$7.useRef(false);
+  const preload = options.reloadDocument || externalLink ? false : userPreload ?? router.options.defaultPreload;
+  const preloadDelay = userPreloadDelay ?? router.options.defaultPreloadDelay ?? 0;
   const doPreload = React$7.useCallback(() => {
     router.preloadRoute({ ..._options }).catch((err) => {
       console.warn(err);
@@ -4968,18 +5343,6 @@ function useLinkProps(options, forwardedRef) {
       timeoutMap.delete(eventTarget);
     }
   };
-  const resolvedActiveProps = isActive ? functionalUpdate(activeProps, {}) ?? STATIC_ACTIVE_OBJECT : STATIC_EMPTY_OBJECT;
-  const resolvedInactiveProps = isActive ? STATIC_EMPTY_OBJECT : functionalUpdate(inactiveProps, {}) ?? STATIC_EMPTY_OBJECT;
-  const resolvedClassName = [
-    className,
-    resolvedActiveProps.className,
-    resolvedInactiveProps.className
-  ].filter(Boolean).join(" ");
-  const resolvedStyle = (style || resolvedActiveProps.style || resolvedInactiveProps.style) && {
-    ...style,
-    ...resolvedActiveProps.style,
-    ...resolvedInactiveProps.style
-  };
   return {
     ...propsSafeToSpread,
     ...resolvedActiveProps,
@@ -4997,7 +5360,7 @@ function useLinkProps(options, forwardedRef) {
     ...resolvedClassName && { className: resolvedClassName },
     ...disabled && STATIC_DISABLED_PROPS,
     ...isActive && STATIC_ACTIVE_PROPS,
-    ...isTransitioning && STATIC_TRANSITIONING_PROPS
+    ...isHydrated && isTransitioning && STATIC_TRANSITIONING_PROPS
   };
 }
 const STATIC_EMPTY_OBJECT = {};
@@ -5016,6 +5379,22 @@ const composeHandlers = (handlers) => (e) => {
     handler(e);
   }
 };
+function getHrefOption(publicHref, external, history, disabled) {
+  if (disabled) return void 0;
+  if (external) {
+    return { href: publicHref, external: true };
+  }
+  return {
+    href: history.createHref(publicHref) || "/",
+    external: false
+  };
+}
+function isSafeInternal(to) {
+  if (typeof to !== "string") return false;
+  const zero = to.charCodeAt(0);
+  if (zero === 47) return to.charCodeAt(1) !== 47;
+  return zero === 46;
+}
 function createLink(Comp) {
   return React$7.forwardRef(function CreatedLink(props, ref) {
     return /* @__PURE__ */ jsxRuntimeExports.jsx(Link, { ...props, _asChild: Comp, ref });
@@ -5024,25 +5403,15 @@ function createLink(Comp) {
 const Link = React$7.forwardRef(
   (props, ref) => {
     const { _asChild, ...rest } = props;
-    const {
-      type: _type,
-      ref: innerRef,
-      ...linkProps
-    } = useLinkProps(rest, ref);
+    const { type: _type, ...linkProps } = useLinkProps(rest, ref);
     const children = typeof rest.children === "function" ? rest.children({
       isActive: linkProps["data-status"] === "active"
     }) : rest.children;
-    if (_asChild === void 0) {
-      delete linkProps.disabled;
+    if (!_asChild) {
+      const { disabled: _, ...rest2 } = linkProps;
+      return React$7.createElement("a", rest2, children);
     }
-    return React$7.createElement(
-      _asChild ? _asChild : "a",
-      {
-        ...linkProps,
-        ref: innerRef
-      },
-      children
-    );
+    return React$7.createElement(_asChild, linkProps, children);
   }
 );
 function isCtrlEvent(e) {
@@ -5157,7 +5526,7 @@ class Route extends BaseRoute {
         return /* @__PURE__ */ jsxRuntimeExports.jsx(Link, { ref, from: this.fullPath, ...props });
       }
     );
-    this.$$typeof = Symbol.for("react.memo");
+    this.$$typeof = /* @__PURE__ */ Symbol.for("react.memo");
   }
 }
 function createRoute(options) {
@@ -5220,7 +5589,7 @@ class RootRoute extends BaseRootRoute {
         return /* @__PURE__ */ jsxRuntimeExports.jsx(Link, { ref, from: this.fullPath, ...props });
       }
     );
-    this.$$typeof = Symbol.for("react.memo");
+    this.$$typeof = /* @__PURE__ */ Symbol.for("react.memo");
   }
 }
 function createRootRoute(options) {
@@ -5304,7 +5673,7 @@ class LazyRoute {
       return useNavigate({ from: router.routesById[this.options.id].fullPath });
     };
     this.options = opts;
-    this.$$typeof = Symbol.for("react.memo");
+    this.$$typeof = /* @__PURE__ */ Symbol.for("react.memo");
   }
 }
 function createLazyRoute(id) {
@@ -5358,7 +5727,11 @@ function lazyRouteComponent(importer, exportName) {
       throw error;
     }
     if (!comp) {
-      throw load();
+      if (reactUse) {
+        reactUse(load());
+      } else {
+        throw load();
+      }
     }
     return React$6.createElement(comp, props);
   };
@@ -5400,7 +5773,7 @@ function Transitioner() {
       state: true,
       _includeValidateSearch: true
     });
-    if (trimPathRight(router.latestLocation.href) !== trimPathRight(nextLocation.href)) {
+    if (trimPathRight(router.latestLocation.publicHref) !== trimPathRight(nextLocation.publicHref)) {
       router.commitLocation({ ...nextLocation, replace: true });
     }
     return () => {
@@ -5506,51 +5879,17 @@ function renderRouteNotFound(router, route, data) {
 }
 
 function ScriptOnce({ children }) {
-  const router = useRouter();
-  if (!router.isServer) {
+  useRouter();
+  {
     return null;
   }
-  return /* @__PURE__ */ jsxRuntimeExports.jsx(
-    "script",
-    {
-      nonce: router.options.ssr?.nonce,
-      className: "$tsr",
-      dangerouslySetInnerHTML: {
-        __html: children + ';typeof $_TSR !== "undefined" && $_TSR.c()'
-      }
-    }
-  );
 }
 
 function ScrollRestoration$1() {
   const router = useRouter();
-  if (!router.isScrollRestoring || !router.isServer) {
+  if (!router.isScrollRestoring || true) {
     return null;
   }
-  if (typeof router.options.scrollRestoration === "function") {
-    const shouldRestore = router.options.scrollRestoration({
-      location: router.latestLocation
-    });
-    if (!shouldRestore) {
-      return null;
-    }
-  }
-  const getKey = router.options.getScrollRestorationKey || defaultGetScrollRestorationKey;
-  const userKey = getKey(router.latestLocation);
-  const resolvedKey = userKey !== defaultGetScrollRestorationKey(router.latestLocation) ? userKey : void 0;
-  const restoreScrollOptions = {
-    storageKey,
-    shouldScrollRestoration: true
-  };
-  if (resolvedKey) {
-    restoreScrollOptions.key = resolvedKey;
-  }
-  return /* @__PURE__ */ jsxRuntimeExports.jsx(
-    ScriptOnce,
-    {
-      children: `(${restoreScroll.toString()})(${JSON.stringify(restoreScrollOptions)})`
-    }
-  );
 }
 
 const React$4 = await importShared('react');
@@ -5560,13 +5899,16 @@ const Match = React$4.memo(function MatchImpl({
   const router = useRouter();
   const matchState = useRouterState({
     select: (s) => {
-      const match = s.matches.find((d) => d.id === matchId);
+      const matchIndex = s.matches.findIndex((d) => d.id === matchId);
+      const match = s.matches[matchIndex];
       invariant(
         match);
       return {
         routeId: match.routeId,
         ssr: match.ssr,
-        _displayPending: match._displayPending
+        _displayPending: match._displayPending,
+        resetKey: s.loadedAt,
+        parentRouteId: s.matches[matchIndex - 1]?.routeId
       };
     },
     structuralSharing: true
@@ -5587,21 +5929,12 @@ const Match = React$4.memo(function MatchImpl({
   );
   const ResolvedCatchBoundary = routeErrorComponent ? CatchBoundary : SafeFragment;
   const ResolvedNotFoundBoundary = routeNotFoundComponent ? CatchNotFound : SafeFragment;
-  const resetKey = useRouterState({
-    select: (s) => s.loadedAt
-  });
-  const parentRouteId = useRouterState({
-    select: (s) => {
-      const index = s.matches.findIndex((d) => d.id === matchId);
-      return s.matches[index - 1]?.routeId;
-    }
-  });
   const ShellComponent = route.isRoot ? route.options.shellComponent ?? SafeFragment : SafeFragment;
   return /* @__PURE__ */ jsxRuntimeExports.jsxs(ShellComponent, { children: [
     /* @__PURE__ */ jsxRuntimeExports.jsx(matchContext.Provider, { value: matchId, children: /* @__PURE__ */ jsxRuntimeExports.jsx(ResolvedSuspenseBoundary, { fallback: pendingElement, children: /* @__PURE__ */ jsxRuntimeExports.jsx(
       ResolvedCatchBoundary,
       {
-        getResetKey: () => resetKey,
+        getResetKey: () => matchState.resetKey,
         errorComponent: routeErrorComponent || ErrorComponent,
         onCatch: (error, errorInfo) => {
           if (isNotFound(error)) throw error;
@@ -5620,7 +5953,7 @@ const Match = React$4.memo(function MatchImpl({
         )
       }
     ) }) }),
-    parentRouteId === rootRouteId && router.options.scrollRestoration ? /* @__PURE__ */ jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [
+    matchState.parentRouteId === rootRouteId && router.options.scrollRestoration ? /* @__PURE__ */ jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [
       /* @__PURE__ */ jsxRuntimeExports.jsx(OnRendered, {}),
       /* @__PURE__ */ jsxRuntimeExports.jsx(ScrollRestoration$1, {})
     ] }) : null
@@ -5671,6 +6004,7 @@ const MatchInner = React$4.memo(function MatchInnerImpl({
           id: match2.id,
           status: match2.status,
           error: match2.error,
+          invalid: match2.invalid,
           _forcePending: match2._forcePending,
           _displayPending: match2._displayPending
         }
@@ -5697,7 +6031,7 @@ const MatchInner = React$4.memo(function MatchInnerImpl({
     if (pendingMinMs) {
       const routerMatch = router.getMatch(match.id);
       if (routerMatch && !routerMatch._nonReactive.minPendingPromise) {
-        if (!router.isServer) {
+        {
           const minPendingPromise = createControlledPromise();
           routerMatch._nonReactive.minPendingPromise = minPendingPromise;
           setTimeout(() => {
@@ -5718,19 +6052,6 @@ const MatchInner = React$4.memo(function MatchInnerImpl({
     throw router.getMatch(match.id)?._nonReactive.loadPromise;
   }
   if (match.status === "error") {
-    if (router.isServer) {
-      const RouteErrorComponent = (route.options.errorComponent ?? router.options.defaultErrorComponent) || ErrorComponent;
-      return /* @__PURE__ */ jsxRuntimeExports.jsx(
-        RouteErrorComponent,
-        {
-          error: match.error,
-          reset: void 0,
-          info: {
-            componentStack: ""
-          }
-        }
-      );
-    }
     throw match.error;
   }
   return out;
@@ -5778,9 +6099,9 @@ function Matches() {
   const rootRoute = router.routesById[rootRouteId];
   const PendingComponent = rootRoute.options.pendingComponent ?? router.options.defaultPendingComponent;
   const pendingElement = PendingComponent ? /* @__PURE__ */ jsxRuntimeExports.jsx(PendingComponent, {}) : null;
-  const ResolvedSuspense = router.isServer || typeof document !== "undefined" && router.ssr ? SafeFragment : React$3.Suspense;
+  const ResolvedSuspense = typeof document !== "undefined" && router.ssr ? SafeFragment : React$3.Suspense;
   const inner = /* @__PURE__ */ jsxRuntimeExports.jsxs(ResolvedSuspense, { fallback: pendingElement, children: [
-    !router.isServer && /* @__PURE__ */ jsxRuntimeExports.jsx(Transitioner, {}),
+    /* @__PURE__ */ jsxRuntimeExports.jsx(Transitioner, {}),
     /* @__PURE__ */ jsxRuntimeExports.jsx(MatchesInner, {})
   ] });
   return router.options.InnerWrap ? /* @__PURE__ */ jsxRuntimeExports.jsx(router.options.InnerWrap, { children: inner }) : inner;
@@ -6138,7 +6459,7 @@ function Script({
   attrs,
   children
 }) {
-  const router = useRouter();
+  useRouter();
   React$1.useEffect(() => {
     if (attrs?.src) {
       const normSrc = (() => {
@@ -6206,34 +6527,20 @@ function Script({
     }
     return void 0;
   }, [attrs, children]);
-  if (!router.isServer) {
+  {
+    const { src, ...rest } = attrs || {};
     return /* @__PURE__ */ jsxRuntimeExports.jsx(
       "script",
       {
         suppressHydrationWarning: true,
-        dangerouslySetInnerHTML: { __html: "" }
-      }
-    );
-  }
-  if (attrs?.src && typeof attrs.src === "string") {
-    return /* @__PURE__ */ jsxRuntimeExports.jsx("script", { ...attrs, suppressHydrationWarning: true });
-  }
-  if (typeof children === "string") {
-    return /* @__PURE__ */ jsxRuntimeExports.jsx(
-      "script",
-      {
-        ...attrs,
-        dangerouslySetInnerHTML: { __html: children },
-        suppressHydrationWarning: true
+        dangerouslySetInnerHTML: { __html: "" },
+        ...rest
       }
     );
   }
-  return null;
 }
 
 const React = await importShared('react');
-
-const {createElement: createElement$1} = await importShared('react');
 const useTags = () => {
   const router = useRouter();
   const nonce = router.options.ssr?.nonce;
@@ -6258,6 +6565,18 @@ const useTags = () => {
               children: m.title
             };
           }
+        } else if ("script:ld+json" in m) {
+          try {
+            const json = JSON.stringify(m["script:ld+json"]);
+            resultMeta.push({
+              tag: "script",
+              attrs: {
+                type: "application/ld+json"
+              },
+              children: escapeHtml(json)
+            });
+          } catch {
+          }
         } else {
           const attribute = m.name ?? m.property;
           if (attribute) {
@@ -6338,9 +6657,11 @@ const useTags = () => {
   const styles = useRouterState({
     select: (state) => state.matches.map((match) => match.styles).flat(1).filter(Boolean).map(({ children, ...attrs }) => ({
       tag: "style",
-      attrs,
-      children,
-      nonce
+      attrs: {
+        ...attrs,
+        nonce
+      },
+      children
     })),
     structuralSharing: true
   });
@@ -6368,12 +6689,6 @@ const useTags = () => {
     }
   );
 };
-function HeadContent() {
-  const tags = useTags();
-  const router = useRouter();
-  const nonce = router.options.ssr?.nonce;
-  return tags.map((tag) => /* @__PURE__ */ createElement$1(Asset, { ...tag, key: `tsr-meta-${JSON.stringify(tag)}`, nonce }));
-}
 function uniqBy(arr, fn) {
   const seen = /* @__PURE__ */ new Set();
   return arr.filter((item) => {
@@ -6386,6 +6701,14 @@ function uniqBy(arr, fn) {
   });
 }
 
+const {createElement: createElement$1} = await importShared('react');
+function HeadContent() {
+  const tags = useTags();
+  const router = useRouter();
+  const nonce = router.options.ssr?.nonce;
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(jsxRuntimeExports.Fragment, { children: tags.map((tag) => /* @__PURE__ */ createElement$1(Asset, { ...tag, key: `tsr-meta-${JSON.stringify(tag)}`, nonce })) });
+}
+
 const {createElement} = await importShared('react');
 const Scripts = () => {
   const router = useRouter();
@@ -6435,5 +6758,5 @@ const Scripts = () => {
   return /* @__PURE__ */ jsxRuntimeExports.jsx(jsxRuntimeExports.Fragment, { children: allScripts.map((asset, i) => /* @__PURE__ */ createElement(Asset, { ...asset, key: `tsr-scripts-${asset.tag}-${i}` })) });
 };
 
-export { Asset, Await, Block, CatchBoundary, CatchNotFound, ClientOnly, DefaultGlobalNotFound, ErrorComponent, FileRoute, FileRouteLoader, HeadContent, LazyRoute, Link, Match, MatchRoute, Matches, Navigate, NotFoundRoute, Outlet, PathParamError, RootRoute, Route, RouteApi, Router, RouterContextProvider, RouterProvider, ScriptOnce, Scripts, ScrollRestoration, SearchParamError, TSR_DEFERRED_PROMISE, cleanPath, componentTypes, composeRewrites, createBrowserHistory, createControlledPromise, createFileRoute, createHashHistory, createHistory, createLazyFileRoute, createLazyRoute, createLink, createMemoryHistory, createRootRoute, createRootRouteWithContext, createRoute, createRouteMask, createRouter, createRouterConfig, createSerializationAdapter, deepEqual, defaultParseSearch, defaultSerializeError, defaultStringifySearch, defer, functionalUpdate, getInitialRouterState, getRouteApi, getRouterContext, interpolatePath, isMatch, isNotFound, isPlainArray, isPlainObject, isRedirect, joinPaths, lazyFn, lazyRouteComponent, linkOptions, matchContext, notFound, parseSearchWith, redirect, replaceEqualDeep, resolvePath, retainSearchParams, rootRouteId, rootRouteWithContext, stringifySearchWith, stripSearchParams, trimPath, trimPathLeft, trimPathRight, useAwaited, useBlocker, useCanGoBack, useChildMatches, useElementScrollRestoration, useHydrated, useLayoutEffect, useLinkProps, useLoaderData, useLoaderDeps, useLocation, useMatch, useMatchRoute, useMatches, useNavigate, useParams, useParentMatches, useRouteContext, useRouter, useRouterState, useSearch, useStableCallback };
-//# sourceMappingURL=react-router-CNzDweD5.js.map
+export { Asset, Await, Block, CatchBoundary, CatchNotFound, ClientOnly, DefaultGlobalNotFound, ErrorComponent, FileRoute, FileRouteLoader, HeadContent, LazyRoute, Link, Match, MatchRoute, Matches, Navigate, NotFoundRoute, Outlet, PathParamError, RootRoute, Route, RouteApi, Router, RouterContextProvider, RouterProvider, ScriptOnce, Scripts, ScrollRestoration, SearchParamError, TSR_DEFERRED_PROMISE, cleanPath, componentTypes, composeRewrites, createBrowserHistory, createControlledPromise, createFileRoute, createHashHistory, createHistory, createLazyFileRoute, createLazyRoute, createLink, createMemoryHistory, createRootRoute, createRootRouteWithContext, createRoute, createRouteMask, createRouter, createRouterConfig, createSerializationAdapter, deepEqual, defaultParseSearch, defaultSerializeError, defaultStringifySearch, defer, functionalUpdate, getInitialRouterState, getRouteApi, getRouterContext, interpolatePath, isMatch, isNotFound, isPlainArray, isPlainObject, isRedirect, joinPaths, lazyFn, lazyRouteComponent, linkOptions, matchContext, notFound, parseSearchWith, redirect, replaceEqualDeep, resolvePath, retainSearchParams, rootRouteId, rootRouteWithContext, stringifySearchWith, stripSearchParams, trimPath, trimPathLeft, trimPathRight, useAwaited, useBlocker, useCanGoBack, useChildMatches, useElementScrollRestoration, useHydrated, useLayoutEffect, useLinkProps, useLoaderData, useLoaderDeps, useLocation, useMatch, useMatchRoute, useMatches, useNavigate, useParams, useParentMatches, useRouteContext, useRouter, useRouterState, useSearch, useStableCallback, useTags };
+//# sourceMappingURL=react-router-BPEAtEJI.js.map