react-router 7.15.1 → 8.3.0

package/dist/production/lib/dom/ssr/errorBoundaries.d.ts

@@ -0,0 +1,27 @@
+
+import { Location } from "../../router/history.js";
+import * as React$1 from "react";
+
+//#region lib/dom/ssr/errorBoundaries.d.ts
+type RemixErrorBoundaryProps = React$1.PropsWithChildren<{
+  location: Location;
+  isOutsideRemixApp?: boolean;
+  error?: Error;
+}>;
+type RemixErrorBoundaryState = {
+  error: null | Error;
+  location: Location;
+};
+declare class RemixErrorBoundary extends React$1.Component<RemixErrorBoundaryProps, RemixErrorBoundaryState> {
+  constructor(props: RemixErrorBoundaryProps);
+  static getDerivedStateFromError(error: Error): {
+    error: Error;
+  };
+  static getDerivedStateFromProps(props: RemixErrorBoundaryProps, state: RemixErrorBoundaryState): {
+    error: Error | null;
+    location: Location<any>;
+  };
+  render(): string | number | bigint | boolean | Iterable<React$1.ReactNode> | Promise<string | number | bigint | boolean | React$1.ReactPortal | React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | Iterable<React$1.ReactNode> | null | undefined> | React$1.JSX.Element | null | undefined;
+}
+//#endregion
+export { RemixErrorBoundary };

package/dist/production/lib/dom/ssr/errorBoundaries.js

@@ -0,0 +1,87 @@
+/**
+ * react-router v8.3.0
+ *
+ * Copyright (c) Remix Software Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+import { isRouteErrorResponse } from "../../router/utils.js";
+import { Scripts, useFrameworkContext } from "./components.js";
+import * as React$1 from "react";
+//#region lib/dom/ssr/errorBoundaries.tsx
+var RemixErrorBoundary = class extends React$1.Component {
+	constructor(props) {
+		super(props);
+		this.state = {
+			error: props.error || null,
+			location: props.location
+		};
+	}
+	static getDerivedStateFromError(error) {
+		return { error };
+	}
+	static getDerivedStateFromProps(props, state) {
+		if (state.location !== props.location) return {
+			error: props.error || null,
+			location: props.location
+		};
+		return {
+			error: props.error || state.error,
+			location: state.location
+		};
+	}
+	render() {
+		if (this.state.error) return /* @__PURE__ */ React$1.createElement(RemixRootDefaultErrorBoundary, {
+			error: this.state.error,
+			isOutsideRemixApp: true
+		});
+		else return this.props.children;
+	}
+};
+/**
+* When app's don't provide a root level ErrorBoundary, we default to this.
+*/
+function RemixRootDefaultErrorBoundary({ error, isOutsideRemixApp }) {
+	let { nonce } = useFrameworkContext();
+	console.error(error);
+	let heyDeveloper = /* @__PURE__ */ React$1.createElement("script", {
+		nonce,
+		dangerouslySetInnerHTML: { __html: `
+        console.log(
+          "💿 Hey developer 👋. You can provide a way better UX than this when your app throws errors. Check out https://reactrouter.com/how-to/error-boundary for more information."
+        );
+      ` }
+	});
+	if (isRouteErrorResponse(error)) return /* @__PURE__ */ React$1.createElement(BoundaryShell, { title: "Unhandled Thrown Response!" }, /* @__PURE__ */ React$1.createElement("h1", { style: { fontSize: "24px" } }, error.status, " ", error.statusText), null);
+	let errorInstance;
+	if (error instanceof Error) errorInstance = error;
+	else {
+		let errorString = error == null ? "Unknown Error" : typeof error === "object" && "toString" in error ? error.toString() : JSON.stringify(error);
+		errorInstance = new Error(errorString);
+	}
+	return /* @__PURE__ */ React$1.createElement(BoundaryShell, {
+		title: "Application Error!",
+		isOutsideRemixApp
+	}, /* @__PURE__ */ React$1.createElement("h1", { style: { fontSize: "24px" } }, "Application Error"), /* @__PURE__ */ React$1.createElement("pre", { style: {
+		padding: "2rem",
+		background: "hsla(10, 50%, 50%, 0.1)",
+		color: "red",
+		overflow: "auto"
+	} }, errorInstance.stack), heyDeveloper);
+}
+function BoundaryShell({ title, renderScripts, isOutsideRemixApp, children }) {
+	let { routeModules } = useFrameworkContext();
+	if (routeModules.root?.Layout && !isOutsideRemixApp) return children;
+	return /* @__PURE__ */ React$1.createElement("html", { lang: "en" }, /* @__PURE__ */ React$1.createElement("head", null, /* @__PURE__ */ React$1.createElement("meta", { charSet: "utf-8" }), /* @__PURE__ */ React$1.createElement("meta", {
+		name: "viewport",
+		content: "width=device-width,initial-scale=1,viewport-fit=cover"
+	}), /* @__PURE__ */ React$1.createElement("title", null, title)), /* @__PURE__ */ React$1.createElement("body", null, /* @__PURE__ */ React$1.createElement("main", { style: {
+		fontFamily: "system-ui, sans-serif",
+		padding: "2rem"
+	} }, children, renderScripts ? /* @__PURE__ */ React$1.createElement(Scripts, null) : null)));
+}
+//#endregion
+export { BoundaryShell, RemixErrorBoundary, RemixRootDefaultErrorBoundary };

package/dist/production/lib/dom/ssr/fallback.js

@@ -0,0 +1,23 @@
+/**
+ * react-router v8.3.0
+ *
+ * Copyright (c) Remix Software Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+import { BoundaryShell } from "./errorBoundaries.js";
+import { useFrameworkContext } from "./components.js";
+import * as React$1 from "react";
+//#region lib/dom/ssr/fallback.tsx
+function RemixRootDefaultHydrateFallback() {
+	let { nonce } = useFrameworkContext();
+	return /* @__PURE__ */ React$1.createElement(BoundaryShell, {
+		title: "Loading...",
+		renderScripts: true
+	}, null);
+}
+//#endregion
+export { RemixRootDefaultHydrateFallback };

package/dist/production/lib/dom/ssr/fog-of-war.d.ts

@@ -0,0 +1,12 @@
+
+import { PatchRoutesOnNavigationFunction } from "../../router/utils.js";
+import { Router } from "../../router/router.js";
+import { RouteModules } from "./routeModules.js";
+import { AssetsManifest } from "./entry.js";
+import { ServerBuild } from "../../server-runtime/build.js";
+
+//#region lib/dom/ssr/fog-of-war.d.ts
+declare function getPatchRoutesOnNavigationFunction(getRouter: () => Router, manifest: AssetsManifest, routeModules: RouteModules, ssr: boolean, routeDiscovery: ServerBuild["routeDiscovery"], isSpaMode: boolean, basename: string | undefined): PatchRoutesOnNavigationFunction | undefined;
+declare function useFogOFWarDiscovery(router: Router, manifest: AssetsManifest, routeModules: RouteModules, ssr: boolean, routeDiscovery: ServerBuild["routeDiscovery"], isSpaMode: boolean): void;
+//#endregion
+export { getPatchRoutesOnNavigationFunction, useFogOFWarDiscovery };

package/dist/production/lib/dom/ssr/fog-of-war.js

@@ -0,0 +1,185 @@
+/**
+ * react-router v8.3.0
+ *
+ * Copyright (c) Remix Software Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+import { createPath } from "../../router/history.js";
+import { joinPaths, matchRoutesImpl } from "../../router/utils.js";
+import { createClientRoutes } from "./routes.js";
+import * as React$1 from "react";
+//#region lib/dom/ssr/fog-of-war.ts
+const nextPaths = /* @__PURE__ */ new Set();
+const discoveredPathsMaxSize = 1e3;
+const discoveredPaths = /* @__PURE__ */ new Set();
+const URL_LIMIT = 7680;
+function getPathsWithAncestors(paths) {
+	let result = /* @__PURE__ */ new Set();
+	paths.forEach((path) => {
+		if (!path.startsWith("/")) path = `/${path}`;
+		for (let i = 1; i < path.length; i++) if (path[i] === "/") result.add(path.slice(0, i));
+		result.add(path);
+	});
+	return Array.from(result);
+}
+function isFogOfWarEnabled(routeDiscovery, ssr) {
+	return routeDiscovery.mode === "lazy" && ssr === true;
+}
+function getPartialManifest({ sri, ...manifest }, router) {
+	let routeIds = new Set(router.state.matches.map((m) => m.route.id));
+	let segments = router.state.location.pathname.split("/").filter(Boolean);
+	let paths = ["/"];
+	segments.pop();
+	while (segments.length > 0) {
+		paths.push(`/${segments.join("/")}`);
+		segments.pop();
+	}
+	paths.forEach((path) => {
+		let matches = matchRoutesImpl(router.routes, path, router.basename || "/", false, router.branches);
+		if (matches) matches.forEach((m) => routeIds.add(m.route.id));
+	});
+	let initialRoutes = [...routeIds].reduce((acc, id) => Object.assign(acc, { [id]: manifest.routes[id] }), {});
+	return {
+		...manifest,
+		routes: initialRoutes,
+		sri: sri ? true : void 0
+	};
+}
+function getPatchRoutesOnNavigationFunction(getRouter, manifest, routeModules, ssr, routeDiscovery, isSpaMode, basename) {
+	if (!isFogOfWarEnabled(routeDiscovery, ssr)) return;
+	return async ({ path, patch, signal, fetcherKey }) => {
+		if (discoveredPaths.has(path)) return;
+		let { state } = getRouter();
+		await fetchAndApplyManifestPatches([path], fetcherKey ? window.location.href : createPath(state.navigation.location || state.location), manifest, routeModules, ssr, isSpaMode, basename, routeDiscovery.manifestPath, patch, signal);
+	};
+}
+function useFogOFWarDiscovery(router, manifest, routeModules, ssr, routeDiscovery, isSpaMode) {
+	React$1.useEffect(() => {
+		if (!isFogOfWarEnabled(routeDiscovery, ssr) || window.navigator?.connection?.saveData === true) return;
+		function registerElement(el) {
+			let path = el.tagName === "FORM" ? el.getAttribute("action") : el.getAttribute("href");
+			if (!path) return;
+			let pathname = el.tagName === "A" ? el.pathname : new URL(path, window.location.origin).pathname;
+			if (!discoveredPaths.has(pathname)) nextPaths.add(pathname);
+		}
+		async function fetchPatches() {
+			document.querySelectorAll("a[data-discover], form[data-discover]").forEach(registerElement);
+			let lazyPaths = Array.from(nextPaths.keys()).filter((path) => {
+				if (discoveredPaths.has(path)) {
+					nextPaths.delete(path);
+					return false;
+				}
+				return true;
+			});
+			if (lazyPaths.length === 0) return;
+			try {
+				await fetchAndApplyManifestPatches(lazyPaths, null, manifest, routeModules, ssr, isSpaMode, router.basename, routeDiscovery.manifestPath, router.patchRoutes);
+			} catch (e) {
+				console.error("Failed to fetch manifest patches", e);
+			}
+		}
+		let debouncedFetchPatches = debounce(fetchPatches, 100);
+		fetchPatches();
+		let observer = new MutationObserver(() => debouncedFetchPatches());
+		observer.observe(document.documentElement, {
+			subtree: true,
+			childList: true,
+			attributes: true,
+			attributeFilter: [
+				"data-discover",
+				"href",
+				"action"
+			]
+		});
+		return () => observer.disconnect();
+	}, [
+		ssr,
+		isSpaMode,
+		manifest,
+		routeModules,
+		router,
+		routeDiscovery
+	]);
+}
+function getManifestPath(_manifestPath, basename) {
+	let manifestPath = _manifestPath || "/__manifest";
+	return basename == null ? manifestPath : joinPaths([basename, manifestPath]);
+}
+const MANIFEST_VERSION_STORAGE_KEY = "react-router-manifest-version";
+async function handleClientVersionMismatch(needsReload, version, errorReloadPath) {
+	if (!needsReload) {
+		try {
+			sessionStorage.removeItem(MANIFEST_VERSION_STORAGE_KEY);
+		} catch {}
+		return false;
+	}
+	if (!errorReloadPath) {
+		console.warn("Detected a manifest version mismatch during eager route discovery. The next navigation/fetch to an undiscovered route will result in a new document navigation to sync up with the latest manifest.");
+		return true;
+	}
+	try {
+		if (sessionStorage.getItem(MANIFEST_VERSION_STORAGE_KEY) === version) {
+			console.error("Unable to discover routes due to manifest version mismatch.");
+			return true;
+		}
+		sessionStorage.setItem(MANIFEST_VERSION_STORAGE_KEY, version);
+	} catch {}
+	window.location.href = errorReloadPath;
+	console.warn("Detected manifest version mismatch, reloading...");
+	await new Promise(() => {});
+	return true;
+}
+async function fetchAndApplyManifestPatches(paths, errorReloadPath, manifest, routeModules, ssr, isSpaMode, basename, manifestPath, patchRoutes, signal) {
+	paths = getPathsWithAncestors(paths);
+	const searchParams = new URLSearchParams();
+	searchParams.set("paths", paths.sort().join(","));
+	searchParams.set("version", manifest.version);
+	let url = new URL(getManifestPath(manifestPath, basename), window.location.origin);
+	url.search = searchParams.toString();
+	if (url.toString().length > 7680) {
+		nextPaths.clear();
+		return;
+	}
+	let serverPatches;
+	try {
+		let res = await fetch(url, { signal });
+		if (!res.ok) throw new Error(`${res.status} ${res.statusText}`);
+		if (await handleClientVersionMismatch(res.status === 204 && res.headers.has("X-Remix-Reload-Document"), manifest.version, errorReloadPath)) return;
+		serverPatches = await res.json();
+	} catch (e) {
+		if (signal?.aborted) return;
+		throw e;
+	}
+	let knownRoutes = new Set(Object.keys(manifest.routes));
+	let patches = Object.values(serverPatches).reduce((acc, route) => {
+		if (route && !knownRoutes.has(route.id)) acc[route.id] = route;
+		return acc;
+	}, {});
+	Object.assign(manifest.routes, patches);
+	paths.forEach((p) => addToFifoQueue(p, discoveredPaths));
+	let parentIds = /* @__PURE__ */ new Set();
+	Object.values(patches).forEach((patch) => {
+		if (patch && (!patch.parentId || !patches[patch.parentId])) parentIds.add(patch.parentId);
+	});
+	parentIds.forEach((parentId) => patchRoutes(parentId || null, createClientRoutes(patches, routeModules, null, ssr, isSpaMode, parentId)));
+}
+function addToFifoQueue(path, queue) {
+	if (queue.size >= discoveredPathsMaxSize) {
+		let first = queue.values().next().value;
+		if (first !== void 0) queue.delete(first);
+	}
+	queue.add(path);
+}
+function debounce(callback, wait) {
+	let timeoutId;
+	return (...args) => {
+		window.clearTimeout(timeoutId);
+		timeoutId = window.setTimeout(() => callback(...args), wait);
+	};
+}
+//#endregion
+export { URL_LIMIT, getManifestPath, getPartialManifest, getPatchRoutesOnNavigationFunction, getPathsWithAncestors, handleClientVersionMismatch, isFogOfWarEnabled, useFogOFWarDiscovery };

package/dist/production/lib/dom/ssr/hydration.d.ts

@@ -0,0 +1,32 @@
+
+import { Path } from "../../router/history.js";
+import { DataRouteObject } from "../../router/utils.js";
+import { HydrationState, Router } from "../../router/router.js";
+import { ClientLoaderFunction } from "./routeModules.js";
+
+//#region lib/dom/ssr/hydration.d.ts
+declare function getHydrationData({
+  state,
+  routes,
+  getRouteInfo,
+  location,
+  basename,
+  isSpaMode
+}: {
+  state: {
+    loaderData?: Router["state"]["loaderData"];
+    actionData?: Router["state"]["actionData"];
+    errors?: Router["state"]["errors"];
+  };
+  routes: DataRouteObject[];
+  getRouteInfo: (routeId: string) => {
+    clientLoader: ClientLoaderFunction | undefined;
+    hasLoader: boolean;
+    hasHydrateFallback: boolean;
+  };
+  location: Path;
+  basename: string | undefined;
+  isSpaMode: boolean;
+}): HydrationState;
+//#endregion
+export { getHydrationData };

package/dist/production/lib/dom/ssr/hydration.js

@@ -0,0 +1,29 @@
+/**
+ * react-router v8.3.0
+ *
+ * Copyright (c) Remix Software Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+import { matchRoutes } from "../../router/utils.js";
+import { shouldHydrateRouteLoader } from "./routes.js";
+//#region lib/dom/ssr/hydration.tsx
+function getHydrationData({ state, routes, getRouteInfo, location, basename, isSpaMode }) {
+	let hydrationData = {
+		...state,
+		loaderData: { ...state.loaderData }
+	};
+	let initialMatches = matchRoutes(routes, location, basename);
+	if (initialMatches) for (let match of initialMatches) {
+		let routeId = match.route.id;
+		let routeInfo = getRouteInfo(routeId);
+		if (shouldHydrateRouteLoader(routeId, routeInfo.clientLoader, routeInfo.hasLoader, isSpaMode) && (routeInfo.hasHydrateFallback || !routeInfo.hasLoader)) delete hydrationData.loaderData[routeId];
+		else if (!routeInfo.hasLoader) hydrationData.loaderData[routeId] = null;
+	}
+	return hydrationData;
+}
+//#endregion
+export { getHydrationData };

package/dist/production/lib/dom/ssr/invariant.js

@@ -0,0 +1,16 @@
+/**
+ * react-router v8.3.0
+ *
+ * Copyright (c) Remix Software Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+//#region lib/dom/ssr/invariant.ts
+function invariant(value, message) {
+	if (value === false || value === null || typeof value === "undefined") throw new Error(message);
+}
+//#endregion
+export { invariant as default };

package/dist/production/lib/dom/ssr/links.js

@@ -0,0 +1,170 @@
+/**
+ * react-router v8.3.0
+ *
+ * Copyright (c) Remix Software Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+import { loadRouteModule } from "./routeModules.js";
+//#region lib/dom/ssr/links.ts
+/**
+* Gets all the links for a set of matches. The modules are assumed to have been
+* loaded already.
+*/
+function getKeyedLinksForMatches(matches, routeModules, manifest) {
+	return dedupeLinkDescriptors(matches.map((match) => {
+		let module = routeModules[match.route.id];
+		let route = manifest.routes[match.route.id];
+		return [route && route.css ? route.css.map((href) => ({
+			rel: "stylesheet",
+			href
+		})) : [], module?.links?.() || []];
+	}).flat(2), getModuleLinkHrefs(matches, manifest));
+}
+function getRouteCssDescriptors(route) {
+	if (!route.css) return [];
+	return route.css.map((href) => ({
+		rel: "stylesheet",
+		href
+	}));
+}
+async function prefetchRouteCss(route) {
+	if (!route.css) return;
+	let descriptors = getRouteCssDescriptors(route);
+	await Promise.all(descriptors.map(prefetchStyleLink));
+}
+async function prefetchStyleLinks(route, routeModule) {
+	if (!route.css && !routeModule.links || !isPreloadSupported()) return;
+	let descriptors = [];
+	if (route.css) descriptors.push(...getRouteCssDescriptors(route));
+	if (routeModule.links) descriptors.push(...routeModule.links());
+	if (descriptors.length === 0) return;
+	let styleLinks = [];
+	for (let descriptor of descriptors) if (!isPageLinkDescriptor(descriptor) && descriptor.rel === "stylesheet") styleLinks.push({
+		...descriptor,
+		rel: "preload",
+		as: "style"
+	});
+	await Promise.all(styleLinks.map(prefetchStyleLink));
+}
+async function prefetchStyleLink(descriptor) {
+	return new Promise((resolve) => {
+		if (descriptor.media && !window.matchMedia(descriptor.media).matches || document.querySelector(`link[rel="stylesheet"][href="${descriptor.href}"]`)) return resolve();
+		let link = document.createElement("link");
+		Object.assign(link, descriptor);
+		function removeLink() {
+			if (document.head.contains(link)) document.head.removeChild(link);
+		}
+		link.onload = () => {
+			removeLink();
+			resolve();
+		};
+		link.onerror = () => {
+			removeLink();
+			resolve();
+		};
+		document.head.appendChild(link);
+	});
+}
+function isPageLinkDescriptor(object) {
+	return object != null && typeof object.page === "string";
+}
+function isHtmlLinkDescriptor(object) {
+	if (object == null) return false;
+	if (object.href == null) return object.rel === "preload" && typeof object.imageSrcSet === "string" && typeof object.imageSizes === "string";
+	return typeof object.rel === "string" && typeof object.href === "string";
+}
+async function getKeyedPrefetchLinks(matches, manifest, routeModules) {
+	return dedupeLinkDescriptors((await Promise.all(matches.map(async (match) => {
+		let route = manifest.routes[match.route.id];
+		if (route) {
+			let mod = await loadRouteModule(route, routeModules);
+			return mod.links ? mod.links() : [];
+		}
+		return [];
+	}))).flat(1).filter(isHtmlLinkDescriptor).filter((link) => link.rel === "stylesheet" || link.rel === "preload").map((link) => link.rel === "stylesheet" ? {
+		...link,
+		rel: "prefetch",
+		as: "style"
+	} : {
+		...link,
+		rel: "prefetch"
+	}));
+}
+function getNewMatchesForLinks(page, nextMatches, currentMatches, manifest, location, mode) {
+	let isNew = (match, index) => {
+		if (!currentMatches[index]) return true;
+		return match.route.id !== currentMatches[index].route.id;
+	};
+	let matchPathChanged = (match, index) => {
+		return currentMatches[index].pathname !== match.pathname || currentMatches[index].route.path?.endsWith("*") && currentMatches[index].params["*"] !== match.params["*"];
+	};
+	if (mode === "assets") return nextMatches.filter((match, index) => isNew(match, index) || matchPathChanged(match, index));
+	if (mode === "data") return nextMatches.filter((match, index) => {
+		let manifestRoute = manifest.routes[match.route.id];
+		if (!manifestRoute || !manifestRoute.hasLoader) return false;
+		if (isNew(match, index) || matchPathChanged(match, index)) return true;
+		if (match.route.shouldRevalidate) {
+			let routeChoice = match.route.shouldRevalidate({
+				currentUrl: new URL(location.pathname + location.search + location.hash, window.origin),
+				currentParams: currentMatches[0]?.params || {},
+				nextUrl: new URL(page, window.origin),
+				nextParams: match.params,
+				defaultShouldRevalidate: true
+			});
+			if (typeof routeChoice === "boolean") return routeChoice;
+		}
+		return true;
+	});
+	return [];
+}
+function getModuleLinkHrefs(matches, manifest, { includeHydrateFallback } = {}) {
+	return dedupeHrefs(matches.map((match) => {
+		let route = manifest.routes[match.route.id];
+		if (!route) return [];
+		let hrefs = [route.module];
+		if (route.clientActionModule) hrefs = hrefs.concat(route.clientActionModule);
+		if (route.clientLoaderModule) hrefs = hrefs.concat(route.clientLoaderModule);
+		if (includeHydrateFallback && route.hydrateFallbackModule) hrefs = hrefs.concat(route.hydrateFallbackModule);
+		if (route.imports) hrefs = hrefs.concat(route.imports);
+		return hrefs;
+	}).flat(1));
+}
+function dedupeHrefs(hrefs) {
+	return [...new Set(hrefs)];
+}
+function sortKeys(obj) {
+	let sorted = {};
+	let keys = Object.keys(obj).sort();
+	for (let key of keys) sorted[key] = obj[key];
+	return sorted;
+}
+function dedupeLinkDescriptors(descriptors, preloads) {
+	let set = /* @__PURE__ */ new Set();
+	let preloadsSet = new Set(preloads);
+	return descriptors.reduce((deduped, descriptor) => {
+		if (preloads && !isPageLinkDescriptor(descriptor) && descriptor.as === "script" && descriptor.href && preloadsSet.has(descriptor.href)) return deduped;
+		let key = JSON.stringify(sortKeys(descriptor));
+		if (!set.has(key)) {
+			set.add(key);
+			deduped.push({
+				key,
+				link: descriptor
+			});
+		}
+		return deduped;
+	}, []);
+}
+let _isPreloadSupported;
+function isPreloadSupported() {
+	if (_isPreloadSupported !== void 0) return _isPreloadSupported;
+	let el = document.createElement("link");
+	_isPreloadSupported = el.relList.supports("preload");
+	el = null;
+	return _isPreloadSupported;
+}
+//#endregion
+export { getKeyedLinksForMatches, getKeyedPrefetchLinks, getModuleLinkHrefs, getNewMatchesForLinks, isPageLinkDescriptor, prefetchRouteCss, prefetchStyleLinks };

package/dist/production/lib/dom/ssr/markup.js

@@ -0,0 +1,24 @@
+/**
+ * react-router v8.3.0
+ *
+ * Copyright (c) Remix Software Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+//#region lib/dom/ssr/markup.ts
+const ESCAPE_LOOKUP = {
+	"&": "\\u0026",
+	">": "\\u003e",
+	"<": "\\u003c",
+	"\u2028": "\\u2028",
+	"\u2029": "\\u2029"
+};
+const ESCAPE_REGEX = /[&><\u2028\u2029]/g;
+function escapeHtml(html) {
+	return html.replace(ESCAPE_REGEX, (match) => ESCAPE_LOOKUP[match]);
+}
+//#endregion
+export { escapeHtml };