@octane-xplat/ui 0.3.0 → 0.4.0

package/dist/web/ui17.js

@@ -1,45 +1,249 @@
-import { __s, bag5, clone, createElement, delegateEvents, hookSlots, queueRefAttach, queueRefDetach, setEventHandler, template, useEffect, useMemo, useRef } from "octane";
-import { bindSignalChild, enableSignalBindings, replaceRef, setClassNameIfChanged } from "octane/internal/client";
-//#region src/Modal.web.tsrx
-enableSignalBindings(1, true);
-delegateEvents(["close"]);
-var _t$0 = /* @__PURE__ */ template("<dialog></dialog>");
-var _hs$ = /* @__PURE__ */ hookSlots(3);
-var _rm$1 = [
-	"r",
-	"b",
-	"a"
-];
-var Modal = /* @__PURE__ */ __s(function Modal(props, __s, __extra) {
-	const el = useRef(null, _hs$ + 0);
-	const content = useMemo(() => props.component ? createElement(props.component, props.params ?? {}) : props.children, [props], _hs$ + 1);
-	const presentation = props.presentation;
-	const className = presentation === "sheet" ? "vx-modal vx-modal--sheet" : presentation === "dialog" ? "vx-modal vx-modal--dialog" : presentation === "fullscreen" || !presentation && props.fullscreen ? "vx-modal vx-modal--fullscreen" : "vx-modal";
-	useEffect(() => {
-		const d = el.current;
-		if (!d) return;
-		if (props.open && !d.open) d.showModal();
-		else if (!props.open && d.open) d.close();
-	}, [props.open], _hs$ + 2);
-	if (__s.block.pending && !__s.block.crossRenderUpdate) return;
-	let _b = __s.slots[0];
-	if (_b === void 0) {
-		let _m0, _m1;
-		const _root = clone(_t$0);
-		queueRefAttach(__s, _m1 = el, _m0 = _root);
-		(__s.cleanups ??= []).push(() => _b && queueRefDetach(_b.b, _b.a));
-		setEventHandler(_root, "$$close", () => props.onClose?.());
-		_b = bag5(__s, _root, _m0, _m1, void 0, null, void 0);
-		__s.refFields = _rm$1;
-	} else {
-		{
-			const _r = el;
-			if (_r !== _b.b) _b.b = replaceRef(__s, _b.b, _r, _b.a);
+//#region src/route-table.ts
+var EXT = /\.(tsrx|tsx|ts|mts|cts|js|mjs|cjs|jsx)$/;
+var SUFFIX = /\.(web|native|ios|android)$/;
+var PARAM = /^\[(.+)\]$/;
+var PRESENT = /\+(modal|fade|push)$/;
+/** Internal error carrier used by the public `redirect()` helper. Keeping
+* this in the shared route table gives both platform leaves the same guard
+* behavior without importing a platform runtime. */
+var RouteRedirect = class extends Error {
+	route;
+	constructor(route) {
+		super("route redirect");
+		this.route = route;
+		this.name = "RouteRedirect";
+	}
+};
+/** Component pick rule for route/layout modules: default export, then a
+*  `screen` named export, then a single function export. Route files use
+*  named exports (decision #13) — a lone component is unambiguous.
+*  route-config exports are reserved metadata, never the screen. */
+function pick(mod, file) {
+	if (typeof mod?.default === "function") return mod.default;
+	if (typeof mod?.screen === "function") return mod.screen;
+	const fns = Object.keys(mod ?? {}).filter((k) => typeof mod[k] === "function" && ![
+		"loader",
+		"beforeLoad",
+		"head"
+	].includes(k));
+	if (fns.length === 1) return mod[fns[0]];
+	console.warn("[octane-xplat] route file " + file + (fns.length ? ` has ${fns.length} component-shaped exports (${fns.join(", ")}) — add a default or 'screen' export` : " has no component export") + " — skipped");
+}
+function deriveRouteManifest(files, prefer, dir = "app") {
+	const prefix = dir.replace(/^\.?\/?/, "").replace(/\/+$/, "") + "/";
+	const seen = /* @__PURE__ */ new Map();
+	const layoutRank = /* @__PURE__ */ new Map();
+	const layouts = {};
+	const loaders = {};
+	const warned = /* @__PURE__ */ new Set();
+	for (const key of Object.keys(files).sort()) {
+		let rel = key.replace(/^\.?\//, "");
+		if (rel.startsWith(prefix)) rel = rel.slice(prefix.length);
+		rel = rel.replace(EXT, "");
+		const parts = rel.split("/");
+		let base = parts[parts.length - 1];
+		const sm = SUFFIX.exec(base);
+		const suffix = sm?.[1];
+		if (sm) base = base.slice(0, base.length - sm[0].length);
+		if (suffix && !prefer.includes(suffix)) continue;
+		const rank = suffix ? prefer.indexOf(suffix) : prefer.length;
+		const pm = PRESENT.exec(base);
+		const presentation = pm?.[1];
+		if (pm) base = base.slice(0, base.length - pm[0].length);
+		if (base === "_layout") {
+			const d = parts.slice(0, -1).join("/");
+			const prev = layoutRank.get(d);
+			if (prev !== void 0 && prev <= rank) continue;
+			const component = pick(files[key], key);
+			if (component) {
+				layouts[d] = component;
+				layoutRank.set(d, rank);
+			}
+			continue;
+		}
+		const segs = parts.slice(0, -1).concat(base);
+		if (segs[segs.length - 1] === "index") segs.pop();
+		const segments = segs.map((s) => {
+			const p = PARAM.exec(s);
+			return p ? ":" + p[1] : s;
+		});
+		const name = segments.join("/") || "index";
+		const meta = {
+			name,
+			segments,
+			params: segments.filter((s) => s.startsWith(":")).map((s) => s.slice(1)),
+			file: key,
+			presentation
+		};
+		const loader = files[key]?.loader;
+		if (typeof loader === "function") meta.loader = loader;
+		const beforeLoad = files[key]?.beforeLoad;
+		if (typeof beforeLoad === "function") meta.beforeLoad = beforeLoad;
+		if (files[key]?.head && (typeof files[key].head === "object" || typeof files[key].head === "function")) meta.head = files[key].head;
+		const prev = seen.get(name);
+		if (prev && prev.rank <= rank) {
+			if (prev.rank === rank && !warned.has(name)) {
+				warned.add(name);
+				console.warn(`[octane-xplat] route '${name}' is defined by both ${prev.meta.file} and ${key} — keeping ${prev.meta.file}`);
+			}
+			continue;
+		}
+		const component = pick(files[key], key);
+		if (component) seen.set(name, {
+			rank,
+			meta,
+			component
+		});
+	}
+	const screens = {};
+	const routes = [];
+	for (const { meta, component } of seen.values()) {
+		screens[meta.name] = component;
+		routes.push(meta);
+		if (meta.loader) loaders[meta.name] = meta.loader;
+	}
+	routes.sort((a, b) => b.segments.reduce((n, s) => n + (s.startsWith(":") ? 1 : 2), 0) - a.segments.reduce((n, s) => n + (s.startsWith(":") ? 1 : 2), 0) || a.name.localeCompare(b.name));
+	return {
+		screens,
+		routes,
+		layouts,
+		loaders
+	};
+}
+/** Match URL path segments against a manifest — returns the winning meta
+*  plus extracted params, or null. First hit wins (routes are pre-sorted
+*  by specificity). */
+function matchRoute(routes, segs) {
+	for (const meta of routes) {
+		if (meta.segments.length !== segs.length) continue;
+		const params = {};
+		let ok = true;
+		for (let i = 0; i < segs.length; i++) {
+			const p = meta.segments[i];
+			if (p.startsWith(":")) params[p.slice(1)] = decodeRouteParam(decodeURIComponent(segs[i]));
+			else if (p !== segs[i]) {
+				ok = false;
+				break;
+			}
 		}
-		setEventHandler(_b.a, "$$close", () => props.onClose?.());
+		if (ok) return {
+			meta,
+			params
+		};
+	}
+	return null;
+}
+/** Serialize a Route to a URL path (no origin): manifest routes substitute
+*  `:param` segments from params (leftover params → query string);
+*  non-manifest names keep the legacy `/<stack>/<name>?params` shape. */
+function buildRoutePath(routes, r) {
+	const meta = routes.find((m) => m.name === r.name);
+	let segs;
+	let rest = r.params;
+	if (meta) {
+		segs = meta.segments.map((s) => {
+			if (!s.startsWith(":")) return s;
+			const v = r.params[s.slice(1)];
+			if (v === void 0) console.warn(`[octane-xplat] route '${r.name}' pushed without path param ${s}`);
+			return encodeURIComponent(encodeRouteParam(v, r.name, s.slice(1)));
+		});
+		rest = Object.fromEntries(Object.entries(r.params).filter(([k]) => !meta.params.includes(k)));
+	} else segs = [r.name];
+	const q = Object.entries(rest).map(([k, v]) => encodeURIComponent(k) + "=" + encodeURIComponent(encodeRouteParam(v, r.name, k))).join("&");
+	return (((r.stack === "root" ? "" : "/" + r.stack) + "/" + segs.join("/")).replace(/\/+$/, "") || "/") + (q ? "?" + q : "");
+}
+var JSON_PARAM_PREFIX = "json:";
+/** Route codegen exposes string params, but the low-level Route shape remains
+* open for compatibility. Preserve accidental object params on web instead
+* of silently turning them into `[object Object]`; generated APIs still keep
+* callers on scalar strings. */
+function encodeRouteParam(value, routeName, key) {
+	if (value === void 0 || value === null || [
+		"string",
+		"number",
+		"boolean"
+	].includes(typeof value)) return String(value ?? "");
+	console.warn(`[octane-xplat] route '${routeName}' param '${key}' is non-scalar; JSON-encoding it for the URL`);
+	try {
+		return JSON_PARAM_PREFIX + JSON.stringify(value);
+	} catch {
+		console.warn(`[octane-xplat] route '${routeName}' param '${key}' could not be JSON-encoded; using an empty value`);
+		return "";
+	}
+}
+function decodeRouteParam(value) {
+	if (!value.startsWith(JSON_PARAM_PREFIX)) return value;
+	try {
+		return JSON.parse(value.slice(5));
+	} catch {
+		return value;
+	}
+}
+/** `?a=1&b=2` → params — shared code carries no URLSearchParams
+*  (invariant 4: no DOM globals on the native path). */
+function parseQueryString(qs) {
+	const params = {};
+	if (!qs) return params;
+	for (const pair of qs.split("&")) {
+		if (!pair) continue;
+		const eq = pair.indexOf("=");
+		const k = eq === -1 ? pair : pair.slice(0, eq);
+		const v = eq === -1 ? "" : pair.slice(eq + 1);
+		params[decodeURIComponent(k)] = decodeRouteParam(decodeURIComponent(v));
+	}
+	return params;
+}
+/** Full URL or path → canonical path for matching. `https://x/a/b?y` →
+*  `/a/b?y`; custom-scheme links keep their host as the first segment —
+*  `textcoral://post/5` → `/post/5` (the common app-scheme convention). */
+function linkPath(url) {
+	const m = /^[a-z][a-z0-9+.-]*:(\/\/)?/i.exec(url);
+	let rest = m ? url.slice(m[0].length) : url;
+	if (m?.[1] && /^https?:\/\//i.test(m[0])) rest = rest.replace(/^[^/?#]*/, "");
+	return "/" + rest.replace(/^\/+/, "");
+}
+/** Match a URL path+query against the manifest into a Route — the shared
+*  half of web's URL parse and native's deep-link handling. Whole-path
+*  match wins ('/demo/x' → root 'demo/:id'); a non-matching first segment
+*  is the stack prefix ('/demos/demo/x' → stack 'demos'). Unmatched names
+*  fall through as literal routes for pre-manifest callers. */
+function matchUrl(routes, url) {
+	const [p, qs] = url.split("?");
+	const segs = p.split("/").filter(Boolean);
+	const query = parseQueryString(qs);
+	if (!segs.length) return null;
+	const finish = (stack, m, fallbackName) => ({
+		stack,
+		name: m ? m.meta.name : fallbackName,
+		params: {
+			...query,
+			...m?.params
+		},
+		presentation: m?.meta.presentation
+	});
+	const root = matchRoute(routes, segs);
+	if (root) return finish("root", root, segs.join("/"));
+	if (segs.length > 1) {
+		const named = matchRoute(routes, segs.slice(1));
+		if (named) return finish(segs[0], named, segs[1]);
+		return finish(segs[0], null, segs[1]);
+	}
+	return finish("root", null, segs[0]);
+}
+/** Layout components wrapping a route name, outermost → innermost —
+*  'chat/room' picks up `app/chat/_layout.tsrx`, 'a/b/c' chains 'a' then
+*  'a/b'. The '' root layout is the app's own shell (entry renders it)
+*  and never joins a chain. Leaves apply the chain at render: native
+*  wraps each pushed Page's component, web wraps the outlet's resolved
+*  element. */
+function layoutChain(layouts, name) {
+	const segs = name.split("/");
+	const chain = [];
+	for (let i = 1; i < segs.length; i++) {
+		const L = layouts[segs.slice(0, i).join("/")];
+		if (L) chain.push(L);
 	}
-	_b.c = setClassNameIfChanged(className, _b.c, _b.a);
-	_b.f = bindSignalChild(__s, _b.f, 1, _b.a, content, "b:386c9c7e", null, void 0, void 0, void 0, true);
-});
+	return chain;
+}
 //#endregion
-export { Modal };
+export { RouteRedirect, buildRoutePath, deriveRouteManifest, layoutChain, linkPath, matchRoute, matchUrl, parseQueryString };

package/dist/web/ui18.js

@@ -1,31 +1,240 @@
-import { createRoot } from "octane";
-//#region src/modal-service.web.ts
-/** Open a component in a document-level dialog and resolve with close(value). */
-var openModal = (Component, params, options = {}) => new Promise((resolve) => {
-	const dialog = document.createElement("dialog");
-	dialog.className = options.presentation === "sheet" ? "vx-modal vx-modal--sheet" : options.presentation === "dialog" ? "vx-modal vx-modal--dialog" : options.presentation === "fullscreen" || !options.presentation && options.fullscreen ? "vx-modal vx-modal--fullscreen" : "vx-modal";
-	document.body.appendChild(dialog);
-	const root = createRoot(dialog);
-	let finished = false;
-	const finish = (result) => {
-		if (finished) return;
-		finished = true;
-		root.unmount();
-		dialog.remove();
-		resolve(result);
+import { RouteRedirect, buildRoutePath, layoutChain, linkPath, matchUrl } from "./ui17.js";
+import { hookSlots, useSyncExternalStore } from "octane";
+//#region src/route.web.ts
+var screens = {};
+var routes = [];
+var routeLayouts = {};
+var routeLoaders = {};
+/** Register the app's name → screen table. On web the table feeds
+*  `screenFor` — the fallback outlet resolution in Tabs when no
+*  `resolveScreen` prop is given; on native `pushRoute` resolves
+*  `route.name` through it. `manifest` (from deriveRouteManifest) enables
+*  path-param matching — call once from the shared routes module. */
+function registerScreens(table, manifest) {
+	screens = table;
+	routes = manifest ?? [];
+	if (current !== void 0) {
+		current = parse();
+		emit();
+	}
+}
+/** One-call registration for route-dir apps — screens + URL patterns +
+*  layouts all come from deriveRouteManifest. */
+function registerRoutes(manifest) {
+	registerScreens(manifest.screens, manifest.routes);
+	routeLayouts = manifest.layouts;
+	routeLoaders = manifest.loaders ?? {};
+	applyHead(read());
+}
+function screenFor(name) {
+	return screens[name];
+}
+/** Directory layouts wrapping a route, outermost → innermost — outlets
+*  wrap their resolved element with these (`_layout.tsrx` files). */
+function layoutsFor(name) {
+	return layoutChain(routeLayouts, name);
+}
+var listeners = /* @__PURE__ */ new Set();
+var current;
+var modalRoute = null;
+var historyDepth = history.state?.__octaneXplatDepth ?? 0;
+var ROUTE_HEAD_ATTR = "data-octane-xplat-route-head";
+var scrollPositions = /* @__PURE__ */ new Map();
+var lastKey = location.pathname + location.search;
+var scrollKey = () => location.pathname + location.search;
+var saveScroll = () => scrollPositions.set(lastKey, window.scrollY);
+var restoreScroll = () => {
+	const y = scrollPositions.get(scrollKey());
+	if (y !== void 0) requestAnimationFrame(() => window.scrollTo(0, y));
+};
+function parse() {
+	return matchUrl(routes, location.pathname + location.search);
+}
+function read() {
+	if (current === void 0) current = parse();
+	return current;
+}
+function emit() {
+	listeners.forEach((l) => l());
+}
+function metaFor(name) {
+	return routes.find((meta) => meta.name === name);
+}
+function headFor(r) {
+	const head = r ? metaFor(r.name)?.head : void 0;
+	return typeof head === "function" ? head(r?.params ?? {}) : head;
+}
+function applyHead(r) {
+	if (typeof document === "undefined") return;
+	const head = headFor(r);
+	if (!head) {
+		document.querySelectorAll(`meta[${ROUTE_HEAD_ATTR}]`).forEach((node) => node.remove());
+		return;
+	}
+	if (head.title !== void 0) document.title = head.title;
+	document.querySelectorAll(`meta[${ROUTE_HEAD_ATTR}]`).forEach((node) => node.remove());
+	for (const [name, content] of Object.entries(head.meta ?? {})) {
+		const tag = document.createElement("meta");
+		tag.setAttribute("name", name);
+		tag.setAttribute("content", content);
+		tag.setAttribute(ROUTE_HEAD_ATTR, "");
+		document.head.appendChild(tag);
+	}
+}
+function contextFor(r) {
+	return r.context ?? {};
+}
+async function prepareRoute(r, redirects = 0) {
+	const beforeLoad = metaFor(r.name)?.beforeLoad;
+	if (!beforeLoad) {
+		commitRoute(r);
+		return;
+	}
+	if (redirects > 16) {
+		console.warn(`[octane-xplat] beforeLoad redirect loop for '${r.name}'`);
+		return;
+	}
+	try {
+		const returned = await beforeLoad({
+			params: r.params,
+			context: contextFor(r)
+		});
+		const context = returned ? {
+			...contextFor(r),
+			...returned
+		} : contextFor(r);
+		commitRoute({
+			...r,
+			context
+		});
+	} catch (e) {
+		if (e instanceof RouteRedirect) {
+			await prepareRoute(e.route, redirects + 1);
+			return;
+		}
+		console.warn(`[octane-xplat] beforeLoad('${r.name}') rejected: ${e?.message ?? e}`);
+	}
+}
+function redirect(r) {
+	throw new RouteRedirect(r);
+}
+function pushRoute(r) {
+	if (metaFor(r.name)?.beforeLoad) {
+		prepareRoute(r);
+		return;
+	}
+	commitRoute(r);
+}
+function commitRoute(r) {
+	const route = {
+		...r,
+		presentation: r.presentation ?? presentationFor(r.name)
 	};
-	const close = (result) => {
-		if (finished) return;
-		if (dialog.open) dialog.close();
-		finish(result);
-	};
-	dialog.addEventListener("close", () => finish());
-	dialog.addEventListener("cancel", () => finish());
-	root.render(Component, {
-		params,
-		close
-	});
-	dialog.showModal();
+	const loader = routeLoaders[route.name] ?? routes.find((meta) => meta.name === route.name)?.loader;
+	if (loader && !Object.prototype.hasOwnProperty.call(route, "loaderData") && !Object.prototype.hasOwnProperty.call(route, "loaderError")) {
+		Promise.resolve().then(() => loader(route.params)).then((loaderData) => commitRoute({
+			...route,
+			loaderData
+		}), (loaderError) => commitRoute({
+			...route,
+			loaderError
+		}));
+		return;
+	}
+	saveScroll();
+	historyDepth += 1;
+	history.pushState({ __octaneXplatDepth: historyDepth }, "", buildRoutePath(routes, route));
+	lastKey = scrollKey();
+	if (route.presentation === "modal") modalRoute = route;
+	else {
+		current = route;
+		modalRoute = null;
+	}
+	applyHead(modalRoute ?? current ?? null);
+	emit();
+}
+function presentationFor(name) {
+	return routes.find((m) => m.name === name)?.presentation;
+}
+/** Web history is one linear stack — back pops whatever route is current;
+*  per-stack pops aren't expressible, so `stack` is accepted for parity
+*  and ignored. A pushed modal is the top entry, so back dismisses it. */
+function popRoute(_stack = "root") {
+	history.back();
+}
+window.addEventListener("popstate", () => {
+	saveScroll();
+	historyDepth = history.state?.__octaneXplatDepth ?? 0;
+	lastKey = scrollKey();
+	modalRoute = null;
+	current = parse();
+	applyHead(current);
+	restoreScroll();
+	emit();
 });
+/** Current route if it targets `stack`, else null. */
+function routeFor(stack) {
+	const c = read();
+	return c && c.stack === stack ? c : null;
+}
+/** Web has one linear browser history; expose its active route stack for parity. */
+function routeStacks() {
+	const route = read();
+	return route ? [route.stack] : [];
+}
+/** The route active at boot — for deep-link tab selection. */
+function currentRoute() {
+	return read();
+}
+/** The modal route overlaying the current one, if any. */
+function currentModalRoute() {
+	return modalRoute;
+}
+/** Deep-link entry, web half — the URL *is* the route state, so this is a
+*  plain pushRoute of the matched path (parity with the native leaf, where
+*  apps wire `onDeepLink(pushDeepLink)`). */
+function pushDeepLink(url) {
+	const r = matchUrl(routes, linkPath(url));
+	if (!r) {
+		console.warn(`[octane-xplat] pushDeepLink('${url}') dropped — no route matches.`);
+		return false;
+	}
+	pushRoute(r);
+	return true;
+}
+/** URL for a Route — Link's href and shareable-path helper. */
+function hrefFor(r) {
+	return buildRoutePath(routes, r);
+}
+function useRoute(stack) {
+	return useSyncExternalStore((cb) => {
+		listeners.add(cb);
+		return () => listeners.delete(cb);
+	}, () => routeFor(stack), _h$0);
+}
+/** Whether the selected conceptual stack has an in-app route to pop. A
+* browser's pre-app history is intentionally not counted. */
+function canGoBack(stack = "root") {
+	const route = read();
+	return historyDepth > 0 && route?.stack === stack;
+}
+function useCanGoBack(stack = "root") {
+	return useSyncExternalStore((cb) => {
+		listeners.add(cb);
+		return () => listeners.delete(cb);
+	}, () => canGoBack(stack), _h$1);
+}
+/** The modal route overlaying the shell — outlets render it above their
+*  normal content (URL preserved underneath). */
+function useModalRoute() {
+	return useSyncExternalStore((cb) => {
+		listeners.add(cb);
+		return () => listeners.delete(cb);
+	}, () => modalRoute, _h$2);
+}
+var _hs$ = /* @__PURE__ */ hookSlots(3);
+var _h$0 = /* @__PURE__ */ Symbol(_hs$);
+var _h$1 = /* @__PURE__ */ Symbol(_hs$ + 1);
+var _h$2 = /* @__PURE__ */ Symbol(_hs$ + 2);
 //#endregion
-export { openModal };
+export { canGoBack, currentModalRoute, currentRoute, hrefFor, layoutsFor, popRoute, pushDeepLink, pushRoute, redirect, registerRoutes, registerScreens, routeFor, routeStacks, screenFor, useCanGoBack, useModalRoute, useRoute };

package/dist/web/ui19.js

@@ -1,11 +1,37 @@
-//#region src/cx.ts
-/** NS `className` splits on ' ' only, and the universal driver applies the
-*  prop via `String(value)` — an array would arrive comma-joined and match
-*  no class at all. Native leaves normalize through cx() before handing
-*  className to an intrinsic. (The DOM renderer already flattens arrays,
-*  so web leaves don't need this.) */
-function cx(...parts) {
-	return parts.flat(Infinity).filter(Boolean).join(" ");
-}
+import { hrefFor, pushRoute, useRoute } from "./ui18.js";
+import { __s, bag5, clone, delegateEvents, hookSlots, setEventHandler, template, withSlot } from "octane";
+import { bindSignalAttribute, bindSignalChild, compilerMemoRegion, enableSignalBindings, hookMemoCreate, hookMemoEqual, hookMemoPublish1, setURLAttribute, updateFreshClassAttr } from "octane/internal/client";
+//#region src/NavLink.web.tsrx
+enableSignalBindings(1, true);
+delegateEvents(["click"]);
+var _t$0 = /* @__PURE__ */ template("<a></a>", 3);
+var _hs$ = /* @__PURE__ */ hookSlots(1);
+var _h$0 = /* @__PURE__ */ Symbol(_hs$);
+var NavLink = /* @__PURE__ */ __s(function NavLink(props, __s, __extra) {
+	const __memoRegion = compilerMemoRegion(__s, _hs$ + 0);
+	let __hk = __memoRegion.hooks;
+	if (__hk === void 0) __memoRegion.hooks = __hk = hookMemoCreate(3);
+	let __hkd0;
+	const current = withSlot(_h$0, useRoute, props.route.stack);
+	const active = !!current && current.name === props.route.name && Object.keys(current.params).length === Object.keys(props.route.params).length && Object.entries(props.route.params).every(([key, value]) => String(current.params[key]) === String(value));
+	const href = (__hkd0 = props, __hk[0] !== true || !hookMemoEqual(__hk[1], __hkd0) ? hookMemoPublish1(__hk, 0, hrefFor(props.route), __hkd0) : __hk[2]);
+	const navigate = (event) => {
+		if (event.defaultPrevented || event.button !== 0 || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) return;
+		event.preventDefault();
+		pushRoute(props.route);
+	};
+	if (__s.block.pending && !__s.block.crossRenderUpdate) return;
+	let _b = __s.slots[0];
+	if (_b === void 0) {
+		let _m1;
+		const _root = clone(_t$0);
+		_m1 = _root;
+		setEventHandler(_root, "$$click", navigate);
+		_b = bag5(__s, _root, void 0, _m1, void 0, null, void 0);
+	} else setEventHandler(_b.b, "$$click", navigate);
+	_b.a = bindSignalAttribute(__s, _b.a, _b.b, "href", href, "b:3f52d87a", setURLAttribute);
+	_b.c = updateFreshClassAttr([props.className, active ? props.activeClassName : ""], _b.c, _b.b);
+	_b.f = bindSignalChild(__s, _b.f, 1, _b.b, props.children, "b:49899ddc", null, void 0, void 0, void 0, true);
+});
 //#endregion
-export { cx };
+export { NavLink };