@markless/router 0.4.0 → 0.6.0

package/dist/typescript-plugin.js

@@ -1,6 +1,6 @@
 import { extname, isAbsolute, normalize, relative, resolve } from "pathe";
 //#region src/typescript-plugin/index.ts
-const PAGE_EXTENSIONS = new Set([".tsrx", ".mdx"]);
+const PAGE_EXTENSIONS = /* @__PURE__ */ new Set([".tsrx", ".mdx"]);
 function init(modules) {
 	const typeScript = modules.typescript;
 	return { create(info) {
@@ -15,7 +15,8 @@ function init(modules) {
 		const projectRoot = getProjectRoot(typeScript, info);
 		const pagesDir = resolvePagesDir(getConfiguredProjectRoot(info) ?? projectRoot, pluginConfig);
 		proxy.getCompletionsAtPosition = (fileName, position, options, formattingSettings) => {
-			return withRouteHrefCompletions(typeScript, info, pagesDir, fileName, position, languageService.getCompletionsAtPosition(fileName, position, options, formattingSettings));
+			const completions = languageService.getCompletionsAtPosition(fileName, position, options, formattingSettings);
+			return withRouteHrefCompletions(typeScript, info, pagesDir, fileName, position, completions);
 		};
 		return proxy;
 	} };
@@ -57,7 +58,7 @@ function isRouteHrefCompletionContext(typeScript, info, fileName, position) {
 }
 function isInsideStringLikeToken(typeScript, source, position) {
 	const scanner = typeScript.createScanner(typeScript.ScriptTarget.Latest, false, typeScript.LanguageVariant.JSX, source);
-	const stringLikeTokens = new Set([
+	const stringLikeTokens = /* @__PURE__ */ new Set([
 		typeScript.SyntaxKind.StringLiteral,
 		typeScript.SyntaxKind.NoSubstitutionTemplateLiteral,
 		typeScript.SyntaxKind.TemplateHead,
@@ -164,13 +165,15 @@ function routeHrefCompletion(fileId) {
 }
 function isReservedOrUnsupportedPage(fileId) {
 	const extension = extname(fileId);
-	const routeFile = normalize(fileId.slice(0, -extension.length));
+	const withoutExtension = fileId.slice(0, -extension.length);
+	const routeFile = normalize(withoutExtension);
 	const segments = routeFile === "." ? [] : routeFile.split("/").filter(Boolean);
-	return segments[0] === "api" || segments.length === 1 && (segments[0] === "404" || segments[0] === "500");
+	return segments.length === 1 && (segments[0] === "404" || segments[0] === "500");
 }
 function routeFromFileId(fileId) {
 	const extension = extname(fileId);
-	const routeFile = normalize(fileId.slice(0, -extension.length));
+	const withoutExtension = fileId.slice(0, -extension.length);
+	const routeFile = normalize(withoutExtension);
 	const segments = routeFile === "." ? [] : routeFile.split("/").filter(Boolean);
 	if (segments.at(-1) === "index") segments.pop();
 	const params = [];

package/dist/vite/route-href.d.ts

@@ -1,4 +1,3 @@
 //#region src/vite/entries/route-href.d.ts
-declare function __marklessRouteHref(pattern: string, params: Readonly<Record<string, unknown>>): string;
-//#endregion
-export { __marklessRouteHref };
+export declare function __marklessRouteHref(pattern: string, params: Readonly<Record<string, unknown>>): string;
+//#endregion

package/dist/vite/route-href.js

@@ -1,18 +1,2 @@
-//#region src/vite/entries/route-href.ts
-const routeParamPattern = /\[\.\.\.([A-Za-z_$][\w$]*)\]|\[([A-Za-z_$][\w$]*)\]/g;
-function __marklessRouteHref(pattern, params) {
-	return pattern.replace(routeParamPattern, (_match, catchAll, dynamic) => {
-		const name = catchAll || dynamic;
-		const value = params?.[name];
-		if (catchAll) return encodeCatchAllParam(pattern, value);
-		if (value === null || value === void 0) throw new Error(`Typed route error: ${pattern} requires params:\n- ${name}`);
-		return encodeURIComponent(String(value));
-	});
-}
-function encodeCatchAllParam(pattern, value) {
-	const segments = Array.isArray(value) ? value : value === null || value === void 0 ? [] : String(value).split("/");
-	if (segments.length === 0 || segments.some((segment) => String(segment) === "")) throw new Error(`Typed route error: ${pattern} requires a non-empty catch-all param.`);
-	return segments.map((segment) => encodeURIComponent(String(segment))).join("/");
-}
-//#endregion
+import { t as __marklessRouteHref } from "../route-href-CGooO_g6.js";
 export { __marklessRouteHref };

package/dist/vite/runtime/create-route-discovery.d.ts

@@ -1,8 +1,7 @@
 //#region src/vite/runtime/create-route-discovery.d.ts
-interface RouteDiscovery {
+export interface RouteDiscovery {
   readonly pageModuleLoaders: Record<string, () => Promise<unknown>>;
   readonly routeFileIds: readonly string[];
 }
-declare function createRouteDiscovery(discoveredPageModuleLoaders: Record<string, () => Promise<unknown>>): RouteDiscovery;
-//#endregion
-export { RouteDiscovery, createRouteDiscovery };
+export declare function createRouteDiscovery(discoveredPageModuleLoaders: Record<string, () => Promise<unknown>>): RouteDiscovery;
+//#endregion

package/dist/vite/runtime/create-route-discovery.js

@@ -1,4 +1,4 @@
-import { i as normalizeRouteFileId } from "../../route-manifest-DPgGIyrS.js";
+import { o as normalizeRouteFileId } from "../../route-manifest-DMizh42B.js";
 //#region src/vite/runtime/create-route-discovery.ts
 function createRouteDiscovery(discoveredPageModuleLoaders) {
 	const pageModuleLoaders = Object.fromEntries(Object.entries(discoveredPageModuleLoaders).map(([file, loader]) => [normalizeRouteFileId(file), loader]));

package/dist/vite/runtime/create-server-entry.d.ts

@@ -1,21 +1,43 @@
+import { z as RouteManifest } from "../../index-BjxpxRL7.js";
 import { ModulePreloadInput } from "@markless/web/render-to-string";
-
 //#region src/vite/runtime/create-server-entry.d.ts
-interface ServerEntryOptions {
+export interface ServerEntryOptions {
   readonly dev?: boolean;
+  readonly base?: string;
   readonly navigationEntryPath?: string;
+  readonly prefetch?: boolean;
   readonly resumeEntryPath?: string;
   readonly prerenderWakeEntryPath?: string;
   readonly routeModulePreloads?: Record<string, readonly ModulePreloadInput[]>;
   readonly routeSsrModulePreloads?: Record<string, readonly ModulePreloadInput[]>;
   readonly routeStylesheets?: Record<string, readonly string[]>;
+  readonly documentStylesheets?: readonly string[];
+  readonly importMap?: string;
   readonly documentModuleLoader: (() => Promise<unknown>) | undefined;
+  readonly documentNavigation?: 'client' | 'document';
   readonly pageModuleLoaders: Record<string, () => Promise<unknown>>;
   readonly routeFileIds: readonly string[];
   readonly render?: 'streaming' | 'blocking';
+  readonly navigation?: 'fragment' | 'render';
+  readonly fragmentEntryPath?: string;
+  readonly fragmentEntryImports?: readonly string[];
+  readonly fragmentNavigationSource?: string;
+  readonly fragmentNavigationRunSource?: string;
+  readonly linkBridgePaths?: readonly [withoutHashLinks: string, withHashLinks: string];
 }
-declare function createServerEntry(options: ServerEntryOptions): {
+export type LinkBridgeOptions = Pick<ServerEntryOptions, 'base' | 'navigationEntryPath' | 'prefetch' | 'documentNavigation' | 'navigation' | 'fragmentEntryPath' | 'fragmentEntryImports' | 'fragmentNavigationSource' | 'fragmentNavigationRunSource' | 'routeFileIds'> & {
+  readonly debug?: boolean;
+};
+/** The link bridge modules a built app's pages import; the build writes them as static client files. */
+export declare function routerLinkBridgeModules(options: LinkBridgeOptions, manifest?: RouteManifest): LinkBridgeFiles | undefined;
+export declare function createServerEntry(options: ServerEntryOptions): {
   fetch: (request: Request) => Promise<Response>;
+  linkBridgeModules: LinkBridgeFiles | undefined;
 };
-//#endregion
-export { ServerEntryOptions, createServerEntry };
+export interface LinkBridgeModule {
+  readonly path: string;
+  readonly source: string;
+}
+/** The two page-imported bridges (without and with '#/' links), then any file they load later. */
+export type LinkBridgeFiles = readonly [withoutHashLinks: LinkBridgeModule, withHashLinks: LinkBridgeModule, ...later: LinkBridgeModule[]];
+//#endregion

package/dist/vite/runtime/create-server-entry.js

@@ -1,400 +1,2 @@
-import { t as __marklessDebugBootstrapSource } from "../../debug-channel-CSzo-Zj8.js";
-import { i as normalizeRouteFileId, n as matchRouteManifest, t as buildRouteManifestFromFileIds } from "../../route-manifest-DPgGIyrS.js";
-import { renderToString } from "@markless/web/render-to-string";
-import { renderToStream } from "@markless/web/render-to-stream";
-import { normalizeMarklessDevError, renderMarklessDevErrorDocument } from "@markless/bundler/dev-error";
-//#region src/vite/runtime/create-server-entry.ts
-const DOCUMENT_CHILDREN_PLACEHOLDER = "__markless_router_document_children__";
-function createServerEntry(options) {
-	const manifest = buildRouteManifestFromFileIds(options.routeFileIds);
-	assertCurrentRouteAssets(options);
-	async function fetch(request) {
-		const url = new URL(request.url);
-		if (isNitroApiPathname(url.pathname)) return new Response("Not found", { status: 404 });
-		const match = matchRouteManifest(url.pathname, manifest);
-		if (!match) return renderStatusPage(url, manifest.statusPages.notFound, 404, "Not found");
-		try {
-			return await renderPage(url, match.route.file, match.params, 200);
-		} catch (error) {
-			console.error("[markless-router] page render failed:", error);
-			if (options.dev) return renderDevelopmentError(url, error);
-			try {
-				return await renderStatusPage(url, manifest.statusPages.error, 500, "Internal Server Error");
-			} catch (errorPageError) {
-				console.error("[markless-router] error page render failed:", errorPageError);
-				return new Response("Internal Server Error", {
-					status: 500,
-					headers: { "content-type": "text/plain;charset=utf-8" }
-				});
-			}
-		}
-	}
-	function renderDevelopmentError(url, error) {
-		const headers = {
-			"cache-control": "no-store",
-			"content-type": "text/html;charset=utf-8"
-		};
-		try {
-			const payload = normalizeMarklessDevError(error, { id: `navigation:${url.pathname}` });
-			return new Response(renderMarklessDevErrorDocument(payload), {
-				status: 500,
-				headers
-			});
-		} catch {
-			return new Response(escapeHtml(flattenError(error)), {
-				status: 500,
-				headers: {
-					...headers,
-					"content-type": "text/plain;charset=utf-8"
-				}
-			});
-		}
-	}
-	async function renderStatusPage(url, file, status, fallbackText) {
-		if (!file) return new Response(fallbackText, { status });
-		return renderPage(url, file, {}, status);
-	}
-	async function renderPage(url, file, params, status) {
-		const loadPageModule = options.pageModuleLoaders[file];
-		if (!loadPageModule) return new Response(`Page module not found: ${file}`, { status: 500 });
-		const pageModule = await loadPageModule();
-		const pageProps = {
-			params,
-			url: {
-				href: url.href,
-				pathname: url.pathname,
-				search: url.search
-			},
-			status
-		};
-		const documentModule = options.documentModuleLoader ? await options.documentModuleLoader() : void 0;
-		const headers = { "content-type": "text/html;charset=utf-8" };
-		const baseArtifact = pageModule.default;
-		const renderSsr = baseArtifact?.renderSsr ?? pageModule.marklessRenderSsr;
-		if (!renderSsr) {
-			const shell = await renderDocumentShell(documentModule, pageProps, "");
-			const message = `Page module must export an Markless compiled artifact: ${escapeHtml(file)}`;
-			return new Response(fillDocumentChildren(shell, message), {
-				status,
-				headers
-			});
-		}
-		const pageArtifact = routedPageArtifact(renderSsr, baseArtifact, pageProps, file, options.navigationEntryPath, options.routeStylesheets?.[file]);
-		const routedArtifact = options.prerenderWakeEntryPath ? {
-			...pageArtifact,
-			prerenderWakeModuleUrl: options.prerenderWakeEntryPath
-		} : pageArtifact;
-		const renderOptions = {
-			props: pageProps,
-			resumeModuleUrl: options.resumeEntryPath ?? baseArtifact?.resumeModuleUrl,
-			modulePreloads: (html) => modulePreloadsForPage(file, html, pageProps.url.href, manifest, options.routeModulePreloads, options.routeSsrModulePreloads)
-		};
-		if (options.render === "blocking") {
-			const pageHtml = splitLeadingHeadHtml(await renderToString(routedArtifact, renderOptions));
-			const shell = await renderDocumentShell(documentModule, pageProps, pageHtml.headHtml);
-			return new Response(fillDocumentChildren(shell, pageHtml.bodyHtml), {
-				status,
-				headers
-			});
-		}
-		const stream = await renderToStream(routedArtifact, renderOptions);
-		const pageHtml = splitLeadingHeadHtml(stream.shell);
-		const shell = await renderDocumentShell(documentModule, pageProps, pageHtml.headHtml);
-		if (stream.pendingArmCount === 0) return new Response(fillDocumentChildren(shell, pageHtml.bodyHtml), {
-			status,
-			headers
-		});
-		const placeholderAt = shell.indexOf(DOCUMENT_CHILDREN_PLACEHOLDER);
-		const prefix = placeholderAt === -1 ? shell : shell.slice(0, placeholderAt) + pageHtml.bodyHtml;
-		const suffix = placeholderAt === -1 ? "" : shell.slice(placeholderAt + 37);
-		const encoder = new TextEncoder();
-		let cancelled = false;
-		let completed = false;
-		const body = new ReadableStream({
-			async start(controller) {
-				controller.enqueue(encoder.encode(prefix));
-				try {
-					for await (const chunk of stream.appends()) {
-						if (cancelled) return;
-						controller.enqueue(encoder.encode(chunk));
-					}
-				} catch (error) {
-					if (cancelled) return;
-					console.error("[markless-router] streaming settle failed:", error);
-					controller.error(error);
-					completed = true;
-					return;
-				}
-				if (cancelled) return;
-				controller.enqueue(encoder.encode(suffix));
-				controller.close();
-				completed = true;
-			},
-			cancel(reason) {
-				if (completed) return;
-				cancelled = true;
-				stream.cancel(reason);
-			}
-		});
-		return new Response(body, {
-			status,
-			headers
-		});
-	}
-	return { fetch };
-}
-function flattenError(error) {
-	if (error instanceof Error) return error.message;
-	if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") return error.message;
-	return String(error);
-}
-function assertCurrentRouteAssets(options) {
-	if (options.routeStylesheets === void 0) return;
-	const routeMaps = [
-		["navigation", options.routeModulePreloads ?? {}],
-		["SSR", options.routeSsrModulePreloads ?? {}],
-		["style", options.routeStylesheets]
-	];
-	const expected = [...new Set(options.routeFileIds.map(normalizeRouteFileId))].filter((file) => /^pages\/.+\.(?:tsrx|mdx)$/.test(file)).toSorted();
-	for (const [label, routes] of routeMaps) {
-		const actual = Object.keys(routes).toSorted();
-		if (JSON.stringify(actual) !== JSON.stringify(expected)) throw new Error(`Markless Router ${label} client-asset routes are stale; expected ${JSON.stringify(expected)}, received ${JSON.stringify(actual)}. Rebuild the client environment before the server environment.`);
-	}
-}
-function routedPageArtifact(renderSsr, baseArtifact, pageProps, file, navigationEntryPath, stylesheetHrefs) {
-	const headInjections = [...baseArtifact?.headInjections ?? [], ...(stylesheetHrefs ?? []).map((href) => ({
-		tag: "link",
-		location: "head",
-		attributes: {
-			rel: "stylesheet",
-			href
-		}
-	}))];
-	return {
-		resumeModuleUrl: baseArtifact?.resumeModuleUrl,
-		inlineResumerSources: baseArtifact?.inlineResumerSources,
-		storageSeeds: baseArtifact?.storageSeeds,
-		...headInjections.length > 0 ? { headInjections } : {},
-		async renderSsr(renderProps, renderContext) {
-			const output = await renderSsr(renderProps ?? pageProps, renderContext);
-			if (!output) return { html: "" };
-			const routeScript = output.state || output.view ? renderRouteScript(file) : "";
-			const linkBridge = navigationEntryPath ? renderLinkBridgeScript(navigationEntryPath) : "";
-			const stateWithProps = withPagePropsCell(output.state, pageProps);
-			return routeScript || linkBridge || stateWithProps !== output.state ? {
-				...output,
-				state: stateWithProps,
-				html: `${output.html}${routeScript}${linkBridge}`
-			} : output;
-		}
-	};
-}
-function withPagePropsCell(state, props) {
-	if (!state || typeof state !== "object") return state;
-	const cells = state.cells;
-	if (!Array.isArray(cells) || cells.some((cell) => cell?.graphNodeId === "prop:props")) return state;
-	return {
-		...state,
-		cells: [...cells, {
-			graphNodeId: "prop:props",
-			name: "props",
-			valueKind: "object",
-			directValue: props
-		}]
-	};
-}
-function modulePreloadsForPage(file, html, baseHref, manifest, routeModulePreloads, routeSsrModulePreloads) {
-	const preloads = [];
-	const seen = /* @__PURE__ */ new Set();
-	addModulePreloads(preloads, seen, routeSsrModulePreloads?.[file]);
-	if (!routeModulePreloads || !html.includes("data-markless-router-link")) return preloads.length > 0 ? preloads : void 0;
-	for (const href of routerLinkHrefs(html)) {
-		const url = parseSameOriginUrl(href, baseHref);
-		const match = url && matchRouteManifest(url.pathname, manifest);
-		addModulePreloads(preloads, seen, match && routeModulePreloads[match.route.file]);
-	}
-	return preloads.length > 0 ? preloads : void 0;
-}
-function routerLinkHrefs(html) {
-	return [...html.matchAll(/<a\b(?=[^>]*\bdata-markless-router-link(?:[\s=>]|$))(?=[^>]*\bhref="([^"]*)")[^>]*>/g)].map((match) => unescapeHtmlAttribute(match[1] ?? ""));
-}
-function parseSameOriginUrl(href, base) {
-	try {
-		const current = new URL(base);
-		const url = new URL(href, current);
-		return url.origin === current.origin ? url : void 0;
-	} catch {
-		return;
-	}
-}
-function unescapeHtmlAttribute(value) {
-	return value.replaceAll("&quot;", "\"").replaceAll("&gt;", ">").replaceAll("&lt;", "<").replaceAll("&amp;", "&");
-}
-function addModulePreloads(preloads, seen, items) {
-	for (const preload of items ?? []) {
-		const preloadHref = typeof preload === "string" ? preload : preload.href;
-		if (!preloadHref || seen.has(preloadHref)) continue;
-		seen.add(preloadHref);
-		preloads.push(preload);
-	}
-}
-function splitLeadingHeadHtml(html) {
-	const containerStart = html.indexOf("<div data-async-container");
-	if (containerStart <= 0) return {
-		bodyHtml: html,
-		headHtml: ""
-	};
-	return {
-		bodyHtml: html.slice(containerStart),
-		headHtml: html.slice(0, containerStart)
-	};
-}
-async function renderDocumentShell(documentModule, pageProps, headHtml) {
-	const attributes = htmlAttributes(documentModule, pageProps);
-	const documentHtml = await renderDocumentModule(documentModule, {
-		...pageProps,
-		children: DOCUMENT_CHILDREN_PLACEHOLDER
-	});
-	if (documentHtml !== void 0) return [
-		"<!doctype html>",
-		`<html${renderAttributes(attributes)}>`,
-		insertHeadHtml(documentHtml, headHtml),
-		"</html>"
-	].join("");
-	return [
-		"<!doctype html>",
-		`<html${renderAttributes(attributes)}>`,
-		"<head>",
-		"<meta charset=\"utf-8\">",
-		"<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">",
-		headHtml,
-		"</head>",
-		"<body>",
-		DOCUMENT_CHILDREN_PLACEHOLDER,
-		"</body>",
-		"</html>"
-	].join("");
-}
-function fillDocumentChildren(documentShell, children) {
-	const at = documentShell.indexOf(DOCUMENT_CHILDREN_PLACEHOLDER);
-	if (at === -1) return documentShell;
-	return documentShell.slice(0, at) + children + documentShell.slice(at + 37);
-}
-async function renderDocumentModule(documentModule, props) {
-	const output = await documentModule?.default?.renderSsr?.(props);
-	assertDocumentStorageFree(output);
-	return output?.html;
-}
-function assertDocumentStorageFree(output) {
-	const storage = documentStorageRecords(output?.state);
-	if (storage.length === 0) return;
-	const keys = storage.map((record) => record.key).join(", ");
-	throw new Error(`MARKLESS_ROUTER_DOCUMENT_STORAGE_UNSUPPORTED: the document declares storage cells (${keys}), but the router serves only the document's HTML, so their state payload never reaches the browser and they can never resume. Declare storage() at module scope in a component the page renders instead.`);
-}
-function documentStorageRecords(state) {
-	if (!state || typeof state !== "object") return [];
-	const storage = state.storage;
-	return Array.isArray(storage) ? storage : [];
-}
-function insertHeadHtml(documentHtml, headHtml) {
-	if (!headHtml) return documentHtml;
-	const headEnd = documentHtml.indexOf("</head>");
-	if (headEnd === -1) return `${headHtml}${documentHtml}`;
-	return `${documentHtml.slice(0, headEnd)}${headHtml}${documentHtml.slice(headEnd)}`;
-}
-function renderRouteScript(file) {
-	return `<script type="@markless/core/route">${escapeScriptJson({ file })}<\/script>`;
-}
-function renderLinkBridgeScript(resumeEntryPath) {
-	const debugBootstrap = typeof __MARKLESS_DEBUG_ENABLED__ !== "undefined" && __MARKLESS_DEBUG_ENABLED__ ? `<script data-markless-router-debug-bootstrap>${escapeInlineScript(`(() => {
-	const d = document;
-	const s = d.currentScript;
-	const r = s && s.closest('[data-async-container]');
-	if (!r) return;
-	try { globalThis[Symbol.for('markless.debug.channel.v1.bootstrap')] = ${__marklessDebugBootstrapSource()}(r, 'ssr-inline', false); } catch {}
-})();`)}<\/script>` : "";
-	const debugRegistration = typeof __MARKLESS_DEBUG_ENABLED__ !== "undefined" && __MARKLESS_DEBUG_ENABLED__ ? `
-	try {
-		const key = Symbol.for('markless.debug.channel.v1.bootstrap');
-		const md = globalThis[key];
-		if (md) { md.router('ssr-link-bridge'); md.activate(); }
-	} catch {}` : "";
-	return `${debugBootstrap}<script data-markless-router-link-resumer>${escapeInlineScript(`(() => {
-	const d = document;
-	const s = d.currentScript;
-	const r = s && s.closest('[data-async-container]');
-	if (!r || r.__marklessRouterLinkResumerStarted) return;
-	r.__marklessRouterLinkResumerStarted = true;
-	const linkAttr = 'data-markless-router-link';
-	const replaceAttr = 'data-markless-router-replace';
-	const scrollAttr = 'data-markless-router-scroll';
-	const anchorFrom = (event) => {
-		const target = event.composedPath && event.composedPath()[0] || event.target;
-		return target && target.closest ? target.closest('a[href]') : target && target.parentElement && target.parentElement.closest ? target.parentElement.closest('a[href]') : null;
-	};
-	const sameOrigin = (href) => {
-		try {
-			const url = new URL(href, location.href);
-			return url.origin === location.origin ? url : null;
-		} catch {
-			return null;
-		}
-	};
-	if (location.hash && location.hash.startsWith('#/')) {
-		import(${JSON.stringify(resumeEntryPath)}).catch(() => {});
-	}
-	r.addEventListener('click', async (event) => {
-		if (event.defaultPrevented || event.button !== 0 || event.metaKey || event.altKey || event.ctrlKey || event.shiftKey) return;
-		const anchor = anchorFrom(event);
-		if (!anchor || !anchor.hasAttribute(linkAttr) || anchor.hasAttribute('download')) return;
-		const target = anchor.getAttribute('target');
-		if (target && target !== '_self') return;
-		if (anchor.relList && anchor.relList.contains('external')) return;
-		const url = sameOrigin(anchor.href);
-		if (!url) return;
-		event.preventDefault();
-		try {
-			const mod = await import(${JSON.stringify(resumeEntryPath)});
-			const navigate = mod.navigateMarklessRouterLink;
-			if (typeof navigate === 'function') {
-				await navigate({
-					href: url.href,
-					replace: anchor.hasAttribute(replaceAttr),
-					scroll: anchor.getAttribute(scrollAttr) === 'manual' ? 'manual' : undefined,
-				});
-			} else {
-				location.assign(url.href);
-			}
-		} catch (error) {
-			setTimeout(() => { throw error; });
-			location.assign(url.href);
-		}
-	}, true);${debugRegistration}
-})();`)}<\/script>`;
-}
-function htmlAttributes(documentModule, pageProps) {
-	const attributes = documentModule?.__marklessRouterHtmlAttributes?.(pageProps) ?? { lang: "en" };
-	const normalized = {};
-	for (const [name, value] of Object.entries(attributes)) {
-		if (value === false || value === null || value === void 0) continue;
-		normalized[name] = String(value);
-	}
-	return normalized;
-}
-function renderAttributes(attributes) {
-	return Object.entries(attributes).map(([name, value]) => ` ${name}="${escapeHtml(value)}"`).join("");
-}
-function escapeHtml(value) {
-	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;");
-}
-function escapeScriptJson(value) {
-	return JSON.stringify(value).replaceAll("<", "\\u003c");
-}
-function escapeInlineScript(value) {
-	return value.replace(/<\/script/gi, "<\\/script");
-}
-function isNitroApiPathname(pathname) {
-	return pathname === "/api" || pathname.startsWith("/api/");
-}
-//#endregion
-export { createServerEntry };
+import { n as routerLinkBridgeModules, t as createServerEntry } from "../../create-server-entry-DaYssO9x.js";
+export { createServerEntry, routerLinkBridgeModules };