@v-office/website-headless 0.2.0 → 1.1.0

package/dist/enhance/index.mjs

@@ -1,237 +1,160 @@
-//#region src/enhance/carousel.ts
-/**
-* Per-card image carousel: drives the prev/next chevrons by calling
-* `scrollTo` on the natively-scrolling image track (overflow-x: auto
-* with scroll-snap on the track on touch devices, or scroll-snap
-* none + JS-driven scrollTo on hover-capable devices).
-*
-* Native scroll matters for two reasons:
-*   1. Lazy-loaded `<img loading="lazy">` only triggers load when
-*      the image enters the visible viewport via real scroll. With
-*      transform-based shifting, the browser doesn't recognize the
-*      image as "in view", so subsequent images stay un-loaded
-*      (white squares) when the user clicks next.
-*   2. The scroll-snap behavior native scroll provides on touch is
-*      what the iOS swipe momentum/snap relies on; transform-based
-*      shifting can't reproduce it.
-*
-* Dots are optional and only updated when present. Their accessible label
-* follows `data-label-template` on the dots list (`{count}` images,
-* `{current}` shown) — the component renders the template from its copy, so
-* the enhancer carries no language of its own.
-*/
-function initImageCarousels(selector = ".card-images") {
-	document.querySelectorAll(selector).forEach((el) => {
-		const track = el.querySelector("[data-img-track]");
-		if (!track) return;
-		if (track.dataset.imgCarouselBound === "true") return;
-		track.dataset.imgCarouselBound = "true";
-		const dotsList = el.querySelector("[data-dots]");
-		const dots = dotsList ? Array.from(dotsList.querySelectorAll("li")) : [];
-		const prevBtn = el.querySelector("[data-img-prev]");
-		const nextBtn = el.querySelector("[data-img-next]");
-		const total = track.children.length;
-		if (total === 0) return;
-		const currentIndex = () => {
-			const w = track.clientWidth;
-			if (w === 0) return 0;
-			return Math.round(track.scrollLeft / w);
-		};
-		const updateButtons = (idx) => {
-			if (prevBtn) prevBtn.disabled = idx <= 0;
-			if (nextBtn) nextBtn.disabled = idx >= total - 1;
-		};
-		const updateDots = (idx) => {
-			if (!dotsList || !dots.length) return;
-			dots.forEach((d, i) => {
-				if (i === idx) {
-					d.className = "h-1.5 w-4 rounded-full transition-all duration-300 bg-[color:var(--color-white)]";
-					d.setAttribute("data-active", "true");
-				} else {
-					d.className = "h-1.5 w-1.5 rounded-full transition-all duration-300 bg-[color:var(--color-white)]/55";
-					d.removeAttribute("data-active");
-				}
-			});
-			const template = dotsList.dataset.labelTemplate;
-			if (template) dotsList.setAttribute("aria-label", template.replace(/\{current\}/g, String(idx + 1)).replace(/\{count\}/g, String(total)));
-		};
-		const goTo = (idx) => {
-			const clamped = Math.max(0, Math.min(total - 1, idx));
-			track.scrollLeft = clamped * track.clientWidth;
-			updateButtons(clamped);
-			updateDots(clamped);
-		};
-		if (prevBtn) prevBtn.addEventListener("click", (e) => {
-			e.preventDefault();
-			e.stopPropagation();
-			goTo(currentIndex() - 1);
-		});
-		if (nextBtn) nextBtn.addEventListener("click", (e) => {
-			e.preventDefault();
-			e.stopPropagation();
-			goTo(currentIndex() + 1);
-		});
-		let engaged = false;
-		track.addEventListener("scroll", () => {
-			if (!engaged) {
-				engaged = true;
-				el.classList.add("is-engaged");
-			}
-			const idx = currentIndex();
-			updateButtons(idx);
-			updateDots(idx);
-		}, { passive: true });
-		updateButtons(0);
-		updateDots(0);
+import { C as shareUrl, O as fillTemplate, _ as acquireFavorites, c as circleOffsets, g as FAVORITES_EVENT, n as GATE_MARKERS, r as DEFAULT_CLUSTER, t as ENHANCE_PARTS } from "../parts-CS1VBrPt.mjs";
+//#region src/enhance/dom.ts
+/** See {@link PartSelector}. */
+const partSelector = (...parts) => parts.map((part) => `[data-part="${part}"]`).join(", ");
+/** See {@link SelectAll}. */
+const selectAll = (root, selector) => {
+	return [...root instanceof HTMLElement && root.matches(selector) ? [root] : [], ...root.querySelectorAll(selector)];
+};
+/** See {@link SelectOwned}. */
+const selectOwned = (scope, selector, owner) => [...scope.querySelectorAll(selector)].filter((element) => element.closest(owner) === scope);
+/** See {@link OnIdle}. */
+const onIdle = (task) => {
+	if (typeof window.requestIdleCallback === "function") {
+		const handle = window.requestIdleCallback(task, { timeout: 500 });
+		return () => window.cancelIdleCallback(handle);
+	}
+	const handle = window.setTimeout(task, 0);
+	return () => window.clearTimeout(handle);
+};
+/** See {@link PrefersReducedMotion}. */
+const prefersReducedMotion = () => typeof window.matchMedia === "function" && window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+/** See {@link HasBox}. */
+const hasBox = (element) => element.getClientRects().length > 0;
+//#endregion
+//#region src/enhance/lifecycle.ts
+/** See {@link Listen}. */
+const listen = (target, type, handler, options) => {
+	const listener = handler;
+	target.addEventListener(type, listener, options);
+	return () => target.removeEventListener(type, listener, options);
+};
+/** See {@link Combine}. */
+const combine = (disposes) => {
+	let done = false;
+	return () => {
+		if (done) return;
+		done = true;
+		for (const dispose of [...disposes].reverse()) dispose();
+	};
+};
+const bound = /* @__PURE__ */ new WeakMap();
+/** See {@link BindOnce}. */
+const bindOnce = (key, family, create) => {
+	const families = bound.get(key) ?? /* @__PURE__ */ new Map();
+	bound.set(key, families);
+	const existing = families.get(family);
+	if (existing) return existing;
+	const handle = create();
+	const teardown = handle.dispose;
+	handle.dispose = combine([teardown, () => families.delete(family)]);
+	families.set(family, handle);
+	return handle;
+};
+/** See {@link IsBound}. */
+const isBound = (key, family) => bound.get(key)?.has(family) ?? false;
+//#endregion
+//#region src/enhance/favorites.ts
+const HEART = `[data-fav], ${partSelector(ENHANCE_PARTS.favorite)}`;
+const BADGE = `[data-fav-badge], ${partSelector(ENHANCE_PARTS.favoriteBadge)}`;
+/** See {@link BindFavorites}. */
+const bindFavorites = (root, options) => bindOnce(root, "favorites", () => ({ dispose: createFavoritesBinding(root, options.storageKey) })).dispose;
+function createFavoritesBinding(root, storageKey) {
+	const onChange = (change) => {
+		if (favorites.ids().size > 0) for (const badge of selectAll(root, BADGE)) replay(badge, "data-fav-bump", "on");
+		window.dispatchEvent(new CustomEvent(FAVORITES_EVENT, { detail: change }));
+	};
+	const { favorites, release } = acquireFavorites({
+		storageKey,
+		onChange
 	});
-}
-const DRAG_THRESHOLD_PX = 2;
-function initRentalCarousel(viewport) {
-	if (viewport.dataset.carouselBound === "true") return;
-	viewport.dataset.carouselBound = "true";
-	const findActiveTrack = () => viewport.querySelector(".rental-track:not([hidden])");
-	const tabsBlock = viewport.closest("[data-rental-tabs]");
-	const prevBtn = tabsBlock?.querySelector("[data-rental-prev]");
-	const nextBtn = tabsBlock?.querySelector("[data-rental-next]");
-	/**
-	* Sync prev/next button disabled state to the current native scroll
-	* position. The native scroll engine reports scrollLeft on every
-	* scroll frame; we just compare it to the bounds.
-	*/
-	const updateArrowButtons = () => {
-		if (!prevBtn && !nextBtn) return;
-		const max = viewport.scrollWidth - viewport.clientWidth;
-		if (prevBtn) prevBtn.disabled = viewport.scrollLeft <= 1;
-		if (nextBtn) nextBtn.disabled = viewport.scrollLeft >= max - 1;
-	};
-	/**
-	* Step the carousel forward or back by one card. Finds the card
-	* closest to the current scroll position, picks the neighbour in
-	* `direction`, and asks the browser to smoothly scroll there.
-	* scroll-snap CSS handles the snap; we just provide the target.
-	*
-	* Forward edge case: stepping to the last card would crop its
-	* right side (offsetLeft places card-left at port-start, card-
-	* right past port-end). When direction is forward AND we're
-	* landing on the last card, scroll to the maximum scrollLeft
-	* instead so the card is right-aligned (matches the
-	* `:last-child { scroll-snap-align: end }` CSS rule).
-	*/
-	const stepBy = (direction) => {
-		const track = findActiveTrack();
-		if (!track) return;
-		const cards = Array.from(track.children);
-		if (cards.length === 0) return;
-		const cs = getComputedStyle(viewport);
-		const padStart = parseFloat(cs.scrollPaddingInlineStart) || 0;
-		let currentIdx = 0;
-		let bestDist = Math.abs(cards[0].offsetLeft - padStart - viewport.scrollLeft);
-		for (let i = 1; i < cards.length; i++) {
-			const snapPoint = cards[i].offsetLeft - padStart;
-			const d = Math.abs(snapPoint - viewport.scrollLeft);
-			if (d < bestDist) {
-				bestDist = d;
-				currentIdx = i;
-			}
-		}
-		const newIdx = Math.max(0, Math.min(cards.length - 1, currentIdx + direction));
-		const max = viewport.scrollWidth - viewport.clientWidth;
-		const cardTarget = cards[newIdx].offsetLeft - padStart;
-		const target = direction > 0 && newIdx === cards.length - 1 && cardTarget < max ? max : cardTarget;
-		viewport.scrollTo({
-			left: target,
-			behavior: "smooth"
-		});
+	const paintAll = () => {
+		for (const heart of selectAll(root, HEART)) paintHeart(heart, favorites);
+		for (const badge of selectAll(root, BADGE)) paintBadge(badge, favorites.ids().size);
 	};
-	let isDown = false;
-	let dragging = false;
-	let startX = 0;
-	let startScrollLeft = 0;
-	let pointerId = null;
-	let suppressNextClick = false;
-	let suppressTimer = null;
-	const armClickSuppressor = () => {
-		suppressNextClick = true;
-		if (suppressTimer !== null) window.clearTimeout(suppressTimer);
-		suppressTimer = window.setTimeout(() => {
-			suppressNextClick = false;
-			suppressTimer = null;
-		}, 350);
-	};
-	const onPointerMove = (e) => {
-		if (!isDown || pointerId !== e.pointerId) return;
-		const dx = e.clientX - startX;
-		if (!dragging) {
-			if (Math.abs(dx) < DRAG_THRESHOLD_PX) return;
-			dragging = true;
-			viewport.classList.add("is-dragging");
-			const sel = window.getSelection?.();
-			if (sel) sel.removeAllRanges();
+	const onClick = (event) => {
+		const heart = event.target instanceof Element ? event.target.closest(HEART) : null;
+		const id = heart ? heartId(heart) : null;
+		if (!heart || !id) return;
+		if (!event.defaultPrevented) {
+			event.preventDefault();
+			event.stopPropagation();
+			favorites.toggle(id);
 		}
-		e.preventDefault();
-		viewport.scrollLeft = startScrollLeft - dx;
-	};
-	const onPointerEnd = (e) => {
-		if (!isDown || pointerId !== e.pointerId) return;
-		if (dragging) armClickSuppressor();
-		document.removeEventListener("pointermove", onPointerMove);
-		document.removeEventListener("pointerup", onPointerEnd);
-		document.removeEventListener("pointercancel", onPointerEnd);
-		isDown = false;
-		dragging = false;
-		pointerId = null;
-		viewport.classList.remove("is-dragging");
-	};
-	const onPointerDown = (e) => {
-		if (e.pointerType !== "mouse") return;
-		if (e.button !== 0) return;
-		isDown = true;
-		dragging = false;
-		startX = e.clientX;
-		startScrollLeft = viewport.scrollLeft;
-		pointerId = e.pointerId;
-		document.addEventListener("pointermove", onPointerMove, { passive: false });
-		document.addEventListener("pointerup", onPointerEnd);
-		document.addEventListener("pointercancel", onPointerEnd);
-	};
-	viewport.addEventListener("pointerdown", onPointerDown);
-	document.addEventListener("click", (e) => {
-		if (!suppressNextClick) return;
-		const t = e.target;
-		if (!t || !viewport.contains(t)) return;
-		e.preventDefault();
-		e.stopPropagation();
-		suppressNextClick = false;
-		if (suppressTimer !== null) {
-			window.clearTimeout(suppressTimer);
-			suppressTimer = null;
+		replay(heart.querySelector("svg") ?? heart, "data-fav-burst", favorites.has(id) ? "save" : "remove");
+	};
+	const onStorage = (event) => {
+		if (event.key === storageKey) favorites.reload();
+	};
+	paintAll();
+	return combine([
+		release,
+		favorites.subscribe(paintAll),
+		listen(root, "click", onClick),
+		listen(window, "storage", onStorage),
+		paintArrivals(root, favorites)
+	]);
+}
+/** The rental a heart belongs to: its own `data-fav-id`, else the result card around it. */
+function heartId(heart) {
+	return heart.dataset["favId"] || heart.closest("[data-result-card]")?.getAttribute("data-result-card") || null;
+}
+function paintHeart(heart, favorites) {
+	const id = heartId(heart);
+	if (!id) return;
+	const saved = favorites.has(id);
+	heart.setAttribute("aria-pressed", String(saved));
+	heart.toggleAttribute("data-saved", saved);
+}
+function paintBadge(badge, count) {
+	badge.textContent = String(count);
+	if (count > 0) badge.setAttribute("data-active", "true");
+	else badge.removeAttribute("data-active");
+	const template = count === 1 ? badge.dataset["templateOne"] ?? badge.dataset["template"] : badge.dataset["template"];
+	if (count > 0) badge.removeAttribute("aria-hidden");
+	else badge.setAttribute("aria-hidden", "true");
+	if (count > 0 && template) badge.setAttribute("aria-label", fillTemplate(template, { count }));
+	else badge.removeAttribute("aria-label");
+}
+/** Hearts rendered after binding (an island committing its cards) get their state as they arrive. */
+function paintArrivals(root, favorites) {
+	const target = root instanceof Document ? root.documentElement : root;
+	if (!(target instanceof Node)) return () => {};
+	const observer = new MutationObserver((records) => {
+		for (const record of records) for (const node of record.addedNodes) {
+			if (!(node instanceof HTMLElement)) continue;
+			for (const heart of selectAll(node, HEART)) paintHeart(heart, favorites);
+			for (const badge of selectAll(node, BADGE)) paintBadge(badge, favorites.ids().size);
 		}
-	}, { capture: true });
-	viewport.addEventListener("scroll", updateArrowButtons, { passive: true });
-	if (prevBtn) prevBtn.addEventListener("click", () => stepBy(-1));
-	if (nextBtn) nextBtn.addEventListener("click", () => stepBy(1));
-	viewport.addEventListener("rental-track-changed", () => {
-		viewport.scrollLeft = 0;
-		updateArrowButtons();
 	});
-	requestAnimationFrame(updateArrowButtons);
+	observer.observe(target, {
+		childList: true,
+		subtree: true
+	});
+	return () => observer.disconnect();
+}
+/** Restart an animation that may already run (a fast double tap answers the second press too): remove the
+*  attribute, flush layout, set it again; it comes off when the animation ends. Without the site's
+*  keyframes nothing moves, and the attribute still comes and goes. */
+function replay(element, attribute, value) {
+	element.removeAttribute(attribute);
+	element.getBoundingClientRect();
+	element.setAttribute(attribute, value);
+	element.addEventListener("animationend", () => element.removeAttribute(attribute), { once: true });
 }
 //#endregion
-//#region src/enhance/overlay.ts
-/** Run `mutate` inside a view transition where the browser has one and the
-*  visitor has not asked for less motion; run it directly otherwise. */
-function withViewTransition(mutate) {
+//#region src/enhance/motion.ts
+/** See {@link WithViewTransition}. */
+const withViewTransition = (mutate) => {
 	const doc = document;
-	if (typeof window.matchMedia === "function" && window.matchMedia("(prefers-reduced-motion: reduce)").matches || typeof doc.startViewTransition !== "function") {
+	if (prefersReducedMotion() || typeof doc.startViewTransition !== "function") {
 		mutate();
 		return;
 	}
 	const transition = doc.startViewTransition(mutate);
 	transition.ready.catch(() => {});
 	transition.finished.catch(() => {});
-}
-let lastInputWasKeyboard = false;
-let tracked = false;
+};
 const KEYBOARD_KEYS = /* @__PURE__ */ new Set([
 	"Tab",
 	"Enter",
@@ -244,294 +167,1287 @@ const KEYBOARD_KEYS = /* @__PURE__ */ new Set([
 	"Home",
 	"End"
 ]);
-/** Install the page's single pair of modality listeners. Safe to call often. */
-function trackInputModality() {
-	if (tracked) return;
-	tracked = true;
-	window.addEventListener("pointerdown", () => {
-		lastInputWasKeyboard = false;
-	}, { capture: true });
-	window.addEventListener("keydown", (e) => {
-		if (KEYBOARD_KEYS.has(e.key)) lastInputWasKeyboard = true;
-	}, { capture: true });
-}
-/** Focus `el` only when the last real input was a keyboard one. */
-function focusForKeyboard(el) {
-	if (lastInputWasKeyboard && el && typeof el.focus === "function") el.focus();
-}
-/** Bind one overlay. Returns silently when the markup is not on this page, so
-*  a component whose overlay self-hides costs nothing. */
-function initHistoryOverlay(options) {
-	const root = document.querySelector(options.root);
-	if (!root) return;
-	const overlay = root.querySelector(options.overlay);
-	const scroller = root.querySelector(options.scroller);
-	const openBtn = root.querySelector(options.open);
-	const closeBtn = root.querySelector(options.close);
-	if (!overlay || !scroller || !openBtn || !closeBtn) return;
-	trackInputModality();
+let keyboard = false;
+let claims = 0;
+let removeListeners = () => {};
+/** See {@link TrackInputModality}. */
+const trackInputModality = () => {
+	claims += 1;
+	if (claims === 1) removeListeners = combine([listen(window, "pointerdown", () => keyboard = false, { capture: true }), listen(window, "keydown", (event) => {
+		if (KEYBOARD_KEYS.has(event.key)) keyboard = true;
+	}, { capture: true })]);
+	let released = false;
+	return () => {
+		if (released) return;
+		released = true;
+		claims -= 1;
+		if (claims === 0) removeListeners();
+	};
+};
+/** See {@link FocusForKeyboard}. */
+const focusForKeyboard = (element) => {
+	if (keyboard && element.isConnected) element.focus();
+};
+/** See {@link LastInputWasKeyboard}. */
+const lastInputWasKeyboard = () => keyboard;
+//#endregion
+//#region src/enhance/layers.ts
+const OPEN = partSelector(ENHANCE_PARTS.layerOpen);
+const CLOSE = partSelector(ENHANCE_PARTS.layerClose);
+const BODY = partSelector(ENHANCE_PARTS.layerBody);
+/** See {@link BindLayer}. */
+const bindLayer = (dialog, options = {}) => bindOnce(dialog, "layer", () => createLayer(dialog, options));
+function createLayer(dialog, options) {
+	const name = options.name ?? dialog.id;
+	if (!name) throw new Error("bindLayer: the dialog needs an id or options.name (it names the URL hash).");
+	const hash = `#${name}`;
+	const scroller = options.scroller === void 0 ? dialog.querySelector(BODY) : options.scroller;
+	const ownsHash = () => location.hash === hash;
+	let open = false;
 	let returnFocus = null;
-	const openModal = () => {
-		returnFocus = document.activeElement;
+	let unlock = () => {};
+	const show = (opener) => {
+		open = true;
+		returnFocus = opener ?? (document.activeElement instanceof HTMLElement ? document.activeElement : null);
+		unlock = lockScroll();
 		withViewTransition(() => {
-			overlay.removeAttribute("hidden");
-			document.body.style.overflow = "hidden";
+			if (!dialog.open) dialog.showModal();
+			settleFocus(dialog);
+			options.onOpen?.(opener);
 		});
-		history.pushState({ layer: options.historyKey }, "");
-		requestAnimationFrame(() => focusForKeyboard(closeBtn));
 	};
-	const closeModalInternal = () => {
-		withViewTransition(() => {
-			scroller.scrollTop = 0;
-			overlay.setAttribute("hidden", "");
-			document.body.style.overflow = "";
+	const hide = (native) => {
+		if (!open) return;
+		open = false;
+		options.onClose?.();
+		if (scroller) scroller.scrollTop = 0;
+		if (!native) withViewTransition(() => dialog.close());
+		unlock();
+		if (returnFocus) focusForKeyboard(returnFocus);
+	};
+	const handle = {
+		open(opener = null) {
+			if (open) return;
+			history.pushState(history.state, "", hash);
+			show(opener);
+		},
+		close() {
+			if (!open) return;
+			if (ownsHash()) history.back();
+			else hide(false);
+		},
+		get isOpen() {
+			return open;
+		},
+		dispose: () => {}
+	};
+	const onDocumentClick = (event) => {
+		const opener = event.target instanceof Element ? event.target.closest(OPEN) : null;
+		if (!opener || opener.getAttribute("aria-controls") !== dialog.id) return;
+		event.preventDefault();
+		handle.open(opener);
+	};
+	const onDialogClick = (event) => {
+		const target = event.target;
+		if (target === dialog) {
+			if (options.closeOnBackdrop ?? true) handle.close();
+			return;
+		}
+		const closer = target instanceof Element ? target.closest(CLOSE) : null;
+		if (closer && closer.closest("dialog") === dialog) handle.close();
+	};
+	const onCancel = (event) => {
+		event.preventDefault();
+		handle.close();
+	};
+	const onNativeClose = () => {
+		if (!open) return;
+		hide(true);
+		if (ownsHash()) history.back();
+	};
+	const onPopState = () => {
+		if (ownsHash() && !open) show(null);
+		else if (!ownsHash() && open) hide(false);
+	};
+	const release = combine([
+		trackInputModality(),
+		listen(document, "click", onDocumentClick),
+		listen(dialog, "click", onDialogClick),
+		listen(dialog, "cancel", onCancel),
+		listen(dialog, "close", onNativeClose),
+		listen(window, "popstate", onPopState)
+	]);
+	handle.dispose = () => {
+		release();
+		if (!open) return;
+		open = false;
+		dialog.close();
+		unlock();
+	};
+	if (ownsHash()) {
+		history.replaceState(history.state, "", location.pathname + location.search);
+		handle.open(null);
+	}
+	return handle;
+}
+/** showModal() focuses the first focusable element. Keep it for keyboard users on the first closer; a tap
+*  gets no focus move at all (a ring on a button nobody aimed at). */
+function settleFocus(dialog) {
+	const closer = dialog.querySelector(CLOSE);
+	if (lastInputWasKeyboard()) {
+		if (closer) focusForKeyboard(closer);
+		return;
+	}
+	const focused = document.activeElement;
+	if (focused instanceof HTMLElement && dialog.contains(focused)) focused.blur();
+}
+let locks = 0;
+let previousOverflow = "";
+/** Lock the page's scroll while any layer is open; the Dispose releases this claim. */
+function lockScroll() {
+	locks += 1;
+	if (locks === 1) {
+		previousOverflow = document.body.style.overflow;
+		document.body.style.overflow = "hidden";
+	}
+	let released = false;
+	return () => {
+		if (released) return;
+		released = true;
+		locks -= 1;
+		if (locks === 0) document.body.style.overflow = previousOverflow;
+	};
+}
+//#endregion
+//#region src/enhance/strip.ts
+/** Strip roots, the legacy kit card markup included. Internal to ./enhance. */
+const STRIP_ROOT = `${partSelector(ENHANCE_PARTS.strip)}, .card-images`;
+const TRACK = `${partSelector(ENHANCE_PARTS.stripTrack)}, [data-img-track]`;
+const ITEM = partSelector(ENHANCE_PARTS.stripItem);
+const PREV = `${partSelector(ENHANCE_PARTS.stripPrev)}, [data-img-prev]`;
+const NEXT = `${partSelector(ENHANCE_PARTS.stripNext)}, [data-img-next]`;
+const DOTS = `${partSelector(ENHANCE_PARTS.stripDots)}, [data-dots]`;
+const COUNTER = partSelector(ENHANCE_PARTS.stripCounter);
+const DEFAULT_COUNTER = "{current} / {count}";
+const DRAG_THRESHOLD_PX = 2;
+const CLICK_SUPPRESS_MS = 350;
+/** See {@link BindStrip}. */
+const bindStrip = (root, options = {}) => bindOnce(root, "strip", () => createStrip(root, settingsFor(root, options)));
+function settingsFor(root, options) {
+	const paging = options.paging ?? (root.dataset["paging"] === "snap" ? "snap" : "page");
+	return {
+		paging,
+		edges: options.edges ?? (root.dataset["edges"] === "wrap" ? "wrap" : "stop"),
+		drag: options.drag ?? paging === "snap",
+		deferSlides: options.deferSlides ?? true
+	};
+}
+function createStrip(root, settings) {
+	const own = (selector) => selectOwned(root, selector, STRIP_ROOT)[0] ?? null;
+	const track = own(TRACK);
+	const controls = {
+		prev: own(PREV),
+		next: own(NEXT),
+		dots: own(DOTS),
+		counter: own(COUNTER)
+	};
+	const items = () => track ? visibleItems(track) : [];
+	const index = () => track ? currentIndex(track, items(), settings.paging) : 0;
+	const paint = () => {
+		if (!track) return;
+		const list = items();
+		const current = currentIndex(track, list, settings.paging);
+		for (const item of allItems(track)) item.toggleAttribute("data-current", item === list[current]);
+		paintArrows(controls.prev, controls.next, edgesOf(track, current, list.length, settings), settings.edges);
+		paintDots(controls.dots, current, list.length);
+		paintCounter(controls.counter, current, list.length);
+	};
+	const goTo = (target, how) => {
+		if (!track || track.clientWidth === 0) return;
+		const list = items();
+		if (list.length === 0) return;
+		const at = clamp(target, 0, list.length - 1);
+		const left = settings.paging === "page" ? at * track.clientWidth : snapOffsets(track, list)[at] ?? 0;
+		const smooth = (how ?? (settings.paging === "page" ? "instant" : "smooth")) === "smooth";
+		track.scrollTo({
+			left,
+			behavior: smooth && !prefersReducedMotion() ? "smooth" : "instant"
 		});
-		focusForKeyboard(returnFocus);
+		paint();
 	};
-	const closeModal = () => {
-		if (history.state && history.state.layer === options.historyKey) history.back();
-		else closeModalInternal();
+	const step = (delta) => {
+		if (!track) return;
+		const list = items();
+		if (list.length === 0) return;
+		const current = currentIndex(track, list, settings.paging);
+		const edge = edgesOf(track, current, list.length, settings);
+		const leaving = delta > 0 ? edge.atEnd : edge.atStart;
+		if (leaving && settings.edges === "stop") return;
+		goTo(leaving ? delta > 0 ? 0 : list.length - 1 : current + delta);
+	};
+	const handle = {
+		get index() {
+			return index();
+		},
+		get total() {
+			return items().length;
+		},
+		goTo,
+		step,
+		reset: () => goTo(0, "instant"),
+		dispose: () => {}
 	};
-	openBtn.addEventListener("click", openModal);
-	closeBtn.addEventListener("click", closeModal);
-	overlay.addEventListener("click", (e) => {
-		if (e.target === overlay) closeModal();
+	if (!track) return handle;
+	const disposes = [];
+	const start = () => {
+		disposes.push(bindArrow(controls.prev, () => step(-1)), bindArrow(controls.next, () => step(1)), listen(track, "scroll", () => {
+			root.toggleAttribute("data-engaged", true);
+			paint();
+		}, { passive: true }));
+		if (settings.drag) disposes.push(bindDrag(root, track));
+		if (settings.deferSlides) disposes.push(bindDeferredSlides(root, track, () => upcoming(track, items(), settings.paging)));
+		paint();
+	};
+	if (track.children.length > 0) start();
+	else disposes.push(whenFilled(track, start));
+	handle.dispose = combine(disposes);
+	return handle;
+}
+/** The track's items, whether or not they render. */
+function allItems(track) {
+	const marked = selectOwned(track, ITEM, TRACK);
+	return marked.length > 0 ? marked : [...track.children].filter((child) => child instanceof HTMLElement);
+}
+/** The items that render a box: a hidden tile reports offsetLeft 0 and would make an arrow dead. */
+function visibleItems(track) {
+	return allItems(track).filter(hasBox);
+}
+function currentIndex(track, list, paging) {
+	if (list.length === 0) return 0;
+	if (paging === "page") {
+		const width = track.clientWidth;
+		return width === 0 ? 0 : clamp(Math.round(track.scrollLeft / width), 0, list.length - 1);
+	}
+	const offsets = snapOffsets(track, list);
+	const distance = (at) => Math.abs((offsets[at] ?? 0) - track.scrollLeft);
+	return offsets.reduce((best, _, at) => distance(at) < distance(best) ? at : best, 0);
+}
+/** Per item, the scroll position that puts it at the track's start, honouring the scroll padding, clamped to
+*  the scrollable range (the last items cannot reach the start). */
+function snapOffsets(track, list) {
+	const padding = scrollPaddingStart(track);
+	const origin = track.getBoundingClientRect().left - track.scrollLeft;
+	const max = maxScroll(track);
+	return list.map((item) => clamp(item.getBoundingClientRect().left - origin - padding, 0, max));
+}
+const measuredPadding = /* @__PURE__ */ new WeakMap();
+/** The used value of `scroll-padding-inline-start` in px. A `max()`/`calc()` value reads back unresolved,
+*  and parseFloat of it is NaN (cards landed hundreds of px off): such a value is measured once per value
+*  and track width on a probe, never on every scroll frame. */
+function scrollPaddingStart(track) {
+	const value = getComputedStyle(track).scrollPaddingInlineStart;
+	if (!value || value === "auto") return 0;
+	if (/^-?\d+(\.\d+)?px$/.test(value)) return Number.parseFloat(value);
+	const key = `${value}|${track.clientWidth}`;
+	const cached = measuredPadding.get(track);
+	if (cached?.key === key) return cached.px;
+	const probe = document.createElement("div");
+	probe.style.cssText = `display:block;flex:none;height:0;visibility:hidden;width:${value}`;
+	track.append(probe);
+	const width = probe.getBoundingClientRect().width;
+	probe.remove();
+	const px = Number.isFinite(width) ? width : 0;
+	measuredPadding.set(track, {
+		key,
+		px
 	});
-	document.addEventListener("keydown", (e) => {
-		if (!overlay.hasAttribute("hidden") && e.key === "Escape") {
-			e.preventDefault();
-			closeModal();
-		}
+	return px;
+}
+function maxScroll(track) {
+	return Math.max(0, track.scrollWidth - track.clientWidth);
+}
+/** Where the strip stands: a page strip by its index, a snap strip by its scroll position (several items
+*  share the last screen, so the last index is never reached there). */
+function edgesOf(track, current, total, settings) {
+	if (total <= 1) return {
+		atStart: true,
+		atEnd: true
+	};
+	if (settings.paging === "page") return {
+		atStart: current <= 0,
+		atEnd: current >= total - 1
+	};
+	return {
+		atStart: track.scrollLeft <= 1,
+		atEnd: track.scrollLeft >= maxScroll(track) - 1
+	};
+}
+/** The item the visitor is about to reach (one past the current), for the deferred photos. */
+function upcoming(track, list, paging) {
+	if (paging === "page" && track.clientWidth > 0) return Math.ceil(track.scrollLeft / track.clientWidth) + 1;
+	return currentIndex(track, list, paging) + 1;
+}
+function paintArrows(prev, next, edge, edges) {
+	const single = edge.atStart && edge.atEnd;
+	setDisabled(prev, single || edges === "stop" && edge.atStart);
+	setDisabled(next, single || edges === "stop" && edge.atEnd);
+}
+function setDisabled(control, disabled) {
+	if (!control) return;
+	if (control instanceof HTMLButtonElement) control.disabled = disabled;
+	else control.toggleAttribute("aria-disabled", disabled);
+}
+function paintDots(dots, current, total) {
+	if (!dots) return;
+	[...dots.children].forEach((dot, at) => {
+		if (at === current) dot.setAttribute("data-active", "true");
+		else dot.removeAttribute("data-active");
+	});
+	const template = dots.dataset["template"];
+	if (template) dots.setAttribute("aria-label", fillTemplate(template, {
+		current: current + 1,
+		count: total
+	}));
+}
+function paintCounter(counter, current, total) {
+	if (!counter || total === 0) return;
+	counter.textContent = fillTemplate(counter.dataset["template"] ?? DEFAULT_COUNTER, {
+		current: current + 1,
+		count: total
 	});
-	window.addEventListener("popstate", () => {
-		if (!overlay.hasAttribute("hidden")) closeModalInternal();
+}
+/** Arrows sit inside a card link: the click must step the strip and nothing else. */
+function bindArrow(control, onPress) {
+	if (!control) return () => {};
+	return listen(control, "click", (event) => {
+		event.preventDefault();
+		event.stopPropagation();
+		onPress();
 	});
 }
+/** Wait for the first child (an island that fills its strip after mount), then start once. */
+function whenFilled(track, start) {
+	const observer = new MutationObserver(() => {
+		if (track.children.length === 0) return;
+		observer.disconnect();
+		start();
+	});
+	observer.observe(track, { childList: true });
+	return () => observer.disconnect();
+}
+/** Mouse drag for desktop (touch and pen scroll natively). The drag stays where it is released; the
+*  click that ends a drag is swallowed so a stretched card link does not navigate. */
+function bindDrag(root, track) {
+	let suppressUntil = 0;
+	let stopDrag = () => {};
+	const onPointerDown = (down) => {
+		if (down.pointerType !== "mouse" || down.button !== 0) return;
+		const startX = down.clientX;
+		const startLeft = track.scrollLeft;
+		let dragging = false;
+		const onMove = (move) => {
+			if (move.pointerId !== down.pointerId) return;
+			const dx = move.clientX - startX;
+			if (!dragging && Math.abs(dx) < DRAG_THRESHOLD_PX) return;
+			if (!dragging) {
+				dragging = true;
+				root.toggleAttribute("data-dragging", true);
+				window.getSelection()?.removeAllRanges();
+			}
+			move.preventDefault();
+			track.scrollLeft = startLeft - dx;
+		};
+		const onEnd = (end) => {
+			if (end.pointerId !== down.pointerId) return;
+			if (dragging) suppressUntil = performance.now() + CLICK_SUPPRESS_MS;
+			root.removeAttribute("data-dragging");
+			stopDrag();
+		};
+		stopDrag = combine([
+			listen(document, "pointermove", onMove, { passive: false }),
+			listen(document, "pointerup", onEnd),
+			listen(document, "pointercancel", onEnd)
+		]);
+	};
+	const onClick = (event) => {
+		if (performance.now() > suppressUntil) return;
+		suppressUntil = 0;
+		event.preventDefault();
+		event.stopPropagation();
+	};
+	return combine([
+		listen(track, "pointerdown", onPointerDown),
+		listen(root, "click", onClick, { capture: true }),
+		() => stopDrag()
+	]);
+}
+/** Promote deferred photos one item ahead of the visitor: a pointer over the strip, a finger on it or focus
+*  inside it gives the next item its source; scrolling gives every item up to one past the one arriving. */
+function bindDeferredSlides(root, track, upTo) {
+	const promote = () => {
+		allItems(track).filter(hasBox).slice(0, upTo() + 1).forEach(promoteImages);
+	};
+	return combine([
+		listen(root, "pointerover", promote, { passive: true }),
+		listen(root, "touchstart", promote, { passive: true }),
+		listen(root, "focusin", promote),
+		listen(track, "scroll", promote, { passive: true })
+	]);
+}
+/** srcset before src, so the browser picks from the set and never fetches the fallback first. The image
+*  keeps loading="lazy", so the browser still owns when it fetches. */
+function promoteImages(item) {
+	for (const image of item.querySelectorAll("img[data-src]")) {
+		const srcset = image.dataset["srcset"];
+		if (srcset) image.srcset = srcset;
+		image.src = image.dataset["src"] ?? image.src;
+		image.removeAttribute("data-src");
+		image.removeAttribute("data-srcset");
+	}
+}
+function clamp(value, min, max) {
+	return Math.min(max, Math.max(min, value));
+}
 //#endregion
 //#region src/enhance/gallery.ts
-/**
-* The gallery's layered overlays, as an engine the component configures.
-*
-* WHAT IT OWNS: opening and closing a stack of layers, the browser-history
-* entry each one pushes, the scroll lock, layered ESC, focus on open and
-* restore on close, the lazily-loaded photo reveal, the scroll-snap viewer's
-* index and its prev/next stepping, and keeping a page-level carousel on the
-* photo the visitor was last looking at.
-*
-* WHAT IT DECIDES: nothing visual. It states **no selector of its own** — every
-* one is passed in, the rule `overlay.ts` already set, so the markup and the
-* string that finds it stay in the same file and a grep for
-* `data-gallery-lightbox` still lands on the component that owns it. It sets no
-* class, reads no colour and renders no markup.
-*
-* WHY THE LAYERS ARE A LIST. The controller this replaces hardcoded its three
-* layers and their nesting order in three separate places — the `popstate`
-* handler, the `keydown` handler and the body-scroll restore — and opened with
-* `if (!lightbox || !lightboxClose || !fullscreen || !fsTrack) return`. A page
-* that opens the viewer straight from the photos, with no intermediate grid,
-* therefore got **no gallery at all** and no error saying so. That is not a
-* hypothetical composition: it is the obvious one for a site whose photos are
-* already a full-width strip. Layers are now whatever the caller lists,
-* outermost first, and a layer whose markup is absent is simply not bound.
-*
-* WHY IT IS A MODULE AND NOT `is:inline`. It was inline from the gallery's first
-* commit with no reason recorded, and the cost was stated in two places: the
-* four-line copy of `withViewTransition` it had to carry, and the third copy of
-* the input-modality listeners `overlay.ts` names in its own header. An
-* `is:inline` script is processed by neither Vite nor Astro and can import
-* nothing, so both copies were forced rather than chosen.
-*
-* The one thing that changes by importing: the emitted script crosses Vite's
-* `assetsInlineLimit` (4096 bytes), so Astro links it as an external module
-* instead of writing it into the page. Any gate that located MARKUP by
-* searching the built HTML was, until it read markup only, able to match the
-* selector literals in the inlined source — see the note in the blueprints'
-* `fact-check.py`. That is fixed there rather than worked around here.
-*/
-function bindLazyReveal(root) {
-	root.querySelectorAll("img[loading=\"lazy\"]").forEach((img) => {
-		if (img.complete) img.dataset["loaded"] = "cache";
+const DIALOGS = {
+	grid: `dialog${partSelector(ENHANCE_PARTS.galleryGrid)}`,
+	viewer: `dialog${partSelector(ENHANCE_PARTS.galleryViewer)}`,
+	floorplan: `dialog${partSelector(ENHANCE_PARTS.floorplan)}`
+};
+const LAYER_OPEN = partSelector(ENHANCE_PARTS.layerOpen);
+const LANDING_FRAMES = 5;
+/** See {@link BindGallery}. */
+const bindGallery = (root) => bindOnce(root, "gallery", () => ({ dispose: createGallery(root) })).dispose;
+function createGallery(root) {
+	const strips = [...root.querySelectorAll(STRIP_ROOT)].map((strip) => ({
+		element: strip,
+		handle: bindStrip(strip, { paging: "page" })
+	}));
+	const stripIn = (scope) => strips.find(({ element }) => element.closest("dialog") === scope)?.handle ?? null;
+	const pageStrip = stripIn(null);
+	const viewer = root.querySelector(DIALOGS.viewer);
+	const viewerStrip = viewer ? stripIn(viewer) : null;
+	const viewerTrack = viewer?.querySelector(partSelector(ENHANCE_PARTS.stripTrack)) ?? null;
+	const floorplan = root.querySelector(DIALOGS.floorplan);
+	let lastViewed = null;
+	const layers = /* @__PURE__ */ new Map();
+	for (const dialog of root.querySelectorAll(`${DIALOGS.grid}, ${DIALOGS.viewer}, ${DIALOGS.floorplan}`)) {
+		const viewerOptions = dialog === viewer && viewerStrip && viewerTrack ? {
+			onOpen: (opener) => landOn(viewerTrack, viewerStrip, photoIndex(opener) ?? pageStrip?.index ?? 0),
+			onClose: () => lastViewed = viewerStrip.index
+		} : {};
+		layers.set(dialog, bindLayer(dialog, viewerOptions));
+	}
+	const onViewerClosed = () => {
+		if (lastViewed === null) return;
+		pageStrip?.goTo(lastViewed, "instant");
+		lastViewed = null;
+	};
+	const onClick = (event) => {
+		const opener = openerOf(event.target, root);
+		if (!opener || opener.matches(LAYER_OPEN)) return;
+		const layer = layerFor(opener, layers);
+		if (!layer) return;
+		event.preventDefault();
+		layer.open(opener);
+	};
+	const onViewerKey = (event) => {
+		if (event.key !== "ArrowRight" && event.key !== "ArrowLeft") return;
+		event.preventDefault();
+		viewerStrip?.step(event.key === "ArrowRight" ? 1 : -1);
+	};
+	return combine([
+		...strips.map(({ handle }) => handle.dispose),
+		...[...layers.values()].map((layer) => layer.dispose),
+		listen(root, "click", onClick),
+		viewer ? listen(viewer, "keydown", onViewerKey) : () => {},
+		viewer ? listen(viewer, "close", onViewerClosed) : () => {},
+		floorplan ? publishRatios(floorplan) : () => {},
+		floorplan ? warmOnIntent(root, floorplan) : () => {}
+	]);
+}
+/** The nearest element (from a click target up to the gallery root) whose aria-controls names a dialog. */
+function openerOf(target, root) {
+	const opener = target instanceof Element ? target.closest("[aria-controls]") : null;
+	return opener && root.contains(opener) ? opener : null;
+}
+function layerFor(opener, layers) {
+	const id = opener.getAttribute("aria-controls");
+	for (const [dialog, layer] of layers) if (dialog.id === id) return layer;
+	return null;
+}
+function photoIndex(opener) {
+	const value = opener?.dataset["index"];
+	const index = value === void 0 ? NaN : Number(value);
+	return Number.isInteger(index) && index >= 0 ? index : null;
+}
+/** The viewer may still be closed in the first frame (a view transition runs the mutation once it has its
+*  snapshot), and a closed track has width 0, so 0 × index lands on photo 1. Wait for a real width, and give
+*  up after a handful of frames rather than spin: a viewer that never lays out has a problem this cannot fix. */
+function landOn(track, strip, index, attempt = 0) {
+	requestAnimationFrame(() => {
+		if (track.clientWidth === 0 && attempt < LANDING_FRAMES) {
+			landOn(track, strip, index, attempt + 1);
+			return;
+		}
+		strip.goTo(index, "instant");
 	});
-	root.classList.add("is-img-fade");
-	root.addEventListener("load", (e) => {
-		const img = e.target;
-		if (img instanceof HTMLImageElement && img.loading === "lazy" && !img.dataset["loaded"]) img.dataset["loaded"] = "fade";
-	}, true);
-	root.addEventListener("error", (e) => {
-		const img = e.target;
-		if (img instanceof HTMLImageElement && img.loading === "lazy") img.dataset["loaded"] = "cache";
-	}, true);
-}
-/** Bind one gallery. Returns silently when its root is not on this page. */
-function initGallery(options) {
-	const root = document.querySelector(options.root);
-	if (!root) return;
-	trackInputModality();
-	bindLazyReveal(root);
-	const q = (sel) => sel ? root.querySelector(sel) : null;
-	const track = q(options.track);
-	const carousel = q(options.carousel);
-	const counter = q(options.counter);
-	const carouselCounter = q(options.carouselCounter);
-	const indexAttr = options.indexAttr ?? "data-image-index";
-	const layers = [];
-	for (const spec of options.layers) {
-		const panel = q(spec.panel);
-		if (!panel) continue;
-		layers.push({
-			name: spec.name,
-			panel,
-			scroller: q(spec.scroller),
-			backdrop: q(spec.backdrop),
-			closeBtn: q(spec.close),
-			openers: Array.from(root.querySelectorAll(spec.open)),
-			isViewer: spec.opensAt === "index",
-			warmOnIntent: spec.warmOnIntent === true,
-			returnFocus: null
+}
+/** The plan's real ratio replaces the width/height guess: sizing keys on `--fp-ar`, so a guess that is off
+*  shows a correctly sized plan the moment the bytes arrive. */
+function publishRatios(floorplan) {
+	const publish = (image) => {
+		if (image.naturalWidth && image.naturalHeight) image.style.setProperty("--fp-ar", `${image.naturalWidth}/${image.naturalHeight}`);
+	};
+	const images = [...floorplan.querySelectorAll("img")];
+	images.filter((image) => image.complete).forEach(publish);
+	return combine(images.map((image) => listen(image, "load", () => publish(image))));
+}
+/** The floor plan is lazy, so nobody pays for a plan never opened, but it would open onto an empty surface
+*  while the bytes arrive. Hover, focus and (on a touchscreen) the tap itself put it in the HTTP cache. */
+function warmOnIntent(root, floorplan) {
+	const image = floorplan.querySelector("img");
+	if (!image || !floorplan.id) return () => {};
+	let warmed = false;
+	const warm = (event) => {
+		if (warmed || !(event.target instanceof Element)) return;
+		if (event.target.closest("[aria-controls]")?.getAttribute("aria-controls") !== floorplan.id) return;
+		warmed = true;
+		const preload = new Image();
+		if (image.srcset) preload.srcset = image.srcset;
+		if (image.sizes) preload.sizes = image.sizes;
+		preload.src = image.currentSrc || image.src;
+	};
+	return combine([listen(root, "pointerover", warm, { passive: true }), listen(root, "focusin", warm)]);
+}
+//#endregion
+//#region src/enhance/image-fade.ts
+/** See {@link BindImageFade}. */
+const bindImageFade = (root) => bindOnce(root, "image-fade", () => ({ dispose: createImageFade(root) })).dispose;
+function createImageFade(root) {
+	for (const image of root.querySelectorAll("img[loading=\"lazy\"]")) if (image.complete && (image.currentSrc || image.getAttribute("src"))) image.dataset["loaded"] = "cache";
+	root.toggleAttribute("data-image-fade", true);
+	const mark = (value) => (event) => {
+		const image = event.target;
+		if (image instanceof HTMLImageElement && image.getAttribute("loading") === "lazy" && !image.dataset["loaded"]) image.dataset["loaded"] = value;
+	};
+	return combine([
+		() => root.removeAttribute("data-image-fade"),
+		listen(root, "load", mark("fade"), { capture: true }),
+		listen(root, "error", mark("cache"), { capture: true })
+	]);
+}
+//#endregion
+//#region src/enhance/reveal.ts
+const REVEAL = partSelector(ENHANCE_PARTS.reveal);
+const CLAMP = partSelector(ENHANCE_PARTS.clamp);
+/** See {@link BindReveal}. */
+const bindReveal = (root, options = {}) => bindOnce(root, "reveal", () => ({ dispose: createReveal(root, options) })).dispose;
+/** See {@link BindClamp}. */
+const bindClamp = (root) => bindOnce(root, "clamp", () => ({ dispose: createClamp(root) })).dispose;
+function createReveal(root, options) {
+	const own = (part) => selectOwned(root, partSelector(part), REVEAL);
+	const collapsedItems = own(ENHANCE_PARTS.revealItem).filter((item) => item.hidden);
+	const more = own(ENHANCE_PARTS.revealMore)[0] ?? null;
+	const less = own(ENHANCE_PARTS.revealLess)[0] ?? null;
+	const step = options.step ?? positiveInteger(root.dataset["step"]) ?? Number.POSITIVE_INFINITY;
+	const collapsible = less !== null && (options.collapsible ?? true);
+	const paint = () => {
+		const remaining = collapsedItems.some((item) => item.hidden);
+		const revealed = collapsedItems.some((item) => !item.hidden);
+		if (more) {
+			more.hidden = !remaining;
+			more.setAttribute("aria-expanded", String(!remaining));
+		}
+		if (less) less.hidden = !(collapsible && revealed);
+		root.toggleAttribute("data-open", revealed);
+	};
+	const showMore = () => {
+		const next = collapsedItems.filter((item) => item.hidden).slice(0, step);
+		for (const item of next) item.hidden = false;
+		paint();
+		const first = next[0];
+		if (first) {
+			if (first.tabIndex < 0 && !first.hasAttribute("tabindex")) first.tabIndex = -1;
+			focusForKeyboard(first);
+		}
+	};
+	const showLess = () => {
+		for (const item of collapsedItems) item.hidden = true;
+		paint();
+		if (more) focusForKeyboard(more);
+	};
+	paint();
+	return combine([
+		trackInputModality(),
+		more ? listen(more, "click", showMore) : () => {},
+		less ? listen(less, "click", showLess) : () => {}
+	]);
+}
+function createClamp(root) {
+	const text = selectOwned(root, partSelector(ENHANCE_PARTS.clampText), CLAMP)[0];
+	const toggle = selectOwned(root, partSelector(ENHANCE_PARTS.clampToggle), CLAMP)[0];
+	if (!text || !toggle) return () => {};
+	const expanded = () => root.hasAttribute("data-expanded");
+	const measure = () => {
+		if (expanded()) return;
+		toggle.hidden = text.scrollHeight <= text.clientHeight + 1;
+	};
+	const onToggle = () => {
+		const next = !expanded();
+		root.toggleAttribute("data-expanded", next);
+		toggle.setAttribute("aria-expanded", String(next));
+		measure();
+	};
+	toggle.setAttribute("aria-expanded", String(expanded()));
+	measure();
+	const observer = new ResizeObserver(measure);
+	observer.observe(text);
+	return combine([listen(toggle, "click", onToggle), () => observer.disconnect()]);
+}
+function positiveInteger(value) {
+	const parsed = value === void 0 ? NaN : Number(value);
+	return Number.isInteger(parsed) && parsed > 0 ? parsed : null;
+}
+//#endregion
+//#region src/enhance/share.ts
+/** Share buttons, the legacy kit attribute included. Internal to ./enhance. */
+const SHARE_BUTTON = `${partSelector(ENHANCE_PARTS.share)}, [data-share]`;
+const STATUS = `${partSelector(ENHANCE_PARTS.shareStatus)}, [data-share-live]`;
+const DONE_MS = 2e3;
+/** See {@link BindShare}. */
+const bindShare = (button, options = {}) => bindOnce(button, "share", () => ({ dispose: createShare(button, options) })).dispose;
+function createShare(button, options) {
+	let timer = 0;
+	const onClick = async () => {
+		const url = shareUrl(location, {
+			origin: options.origin || button.dataset["shareOrigin"] || location.origin,
+			...options.strip ? { strip: options.strip } : {}
 		});
-		if (spec.fitImage) {
-			const img = panel.querySelector(spec.fitImage);
-			if (img) {
-				const applyRatio = () => {
-					if (!img.naturalWidth || !img.naturalHeight) return;
-					img.style.setProperty("--fp-ar", `${img.naturalWidth}/${img.naturalHeight}`);
-				};
-				if (img.complete) applyRatio();
-				img.addEventListener("load", applyRatio, { once: true });
-			}
+		if (prefersNativeShare() && await nativeShare(button, url)) return;
+		try {
+			await navigator.clipboard.writeText(url);
+		} catch {
+			window.prompt(button.getAttribute("aria-label") ?? button.textContent?.trim() ?? "", url);
+			return;
 		}
+		window.clearTimeout(timer);
+		showDone(button, true);
+		timer = window.setTimeout(() => showDone(button, false), DONE_MS);
+	};
+	return combine([listen(button, "click", () => void onClick()), () => {
+		window.clearTimeout(timer);
+		showDone(button, false);
+	}]);
+}
+/** The OS share sheet is the expected pattern on a phone or tablet, not with mouse and hover (even where
+*  `navigator.share` exists). */
+function prefersNativeShare() {
+	return typeof navigator.share === "function" && typeof window.matchMedia === "function" && window.matchMedia("(hover: none) and (pointer: coarse)").matches;
+}
+/** True when the sheet handled it (shared or dismissed); false to fall back to the clipboard. */
+async function nativeShare(button, url) {
+	try {
+		await navigator.share({
+			title: button.dataset["shareTitle"] || document.title,
+			url
+		});
+		return true;
+	} catch (error) {
+		return error instanceof DOMException && error.name === "AbortError";
 	}
-	if (!layers.length) return;
-	const total = layers.find((l) => l.isViewer)?.openers.length || root.querySelectorAll(`[${indexAttr}]`).length;
-	const isOpen = (l) => !l.panel.hasAttribute("hidden");
-	/** Innermost open layer — the one a back gesture or ESC should close. */
-	const innermostOpen = () => {
-		for (let i = layers.length - 1; i >= 0; i -= 1) {
-			const l = layers[i];
-			if (l && isOpen(l)) return l;
-		}
-		return null;
+}
+function showDone(button, done) {
+	if (done) button.setAttribute("data-state", "done");
+	else button.removeAttribute("data-state");
+	const idle = button.querySelector("[data-share-idle]");
+	const doneLabel = button.querySelector("[data-share-done]");
+	if (idle) idle.hidden = done;
+	if (doneLabel) doneLabel.hidden = !done;
+	const status = button.querySelector(STATUS);
+	if (status) status.textContent = done ? status.dataset["message"] ?? doneLabel?.textContent?.trim() ?? "" : "";
+}
+//#endregion
+//#region src/enhance/enhance.ts
+const GALLERY = partSelector(ENHANCE_PARTS.gallery);
+/** See {@link Enhance}. */
+const enhance = (root = document, options = {}) => {
+	const disposes = [];
+	const each = (selector, family, bind) => {
+		for (const element of selectAll(root, selector)) if (!isBound(element, family)) disposes.push(bind(element));
 	};
-	const currentIdx = () => {
-		if (!track) return 0;
-		const w = track.clientWidth;
-		return w === 0 ? 0 : Math.round(track.scrollLeft / w);
+	if (options.galleries ?? true) each(GALLERY, "gallery", bindGallery);
+	if (options.imageFade ?? true) each(GALLERY, "image-fade", bindImageFade);
+	if (options.layers ?? true) each(`dialog${partSelector(ENHANCE_PARTS.layer)}`, "layer", (dialog) => {
+		if (!(dialog instanceof HTMLDialogElement)) return () => {};
+		return bindLayer(dialog).dispose;
+	});
+	if (options.reveals ?? true) each(partSelector(ENHANCE_PARTS.reveal), "reveal", (element) => bindReveal(element));
+	if (options.clamps ?? true) each(partSelector(ENHANCE_PARTS.clamp), "clamp", bindClamp);
+	const share = options.share ?? true;
+	if (share !== false) each(SHARE_BUTTON, "share", (button) => bindShare(button, share === true ? {} : share));
+	if (options.favorites && !isBound(root, "favorites")) disposes.push(bindFavorites(root, options.favorites));
+	if (options.strips ?? true) disposes.push(onIdle(() => each(STRIP_ROOT, "strip", (strip) => bindStrip(strip).dispose)));
+	return combine(disposes);
+};
+//#endregion
+//#region src/enhance/map/card-hover.ts
+/** See {@link ObserveResultCardHover}. */
+const observeResultCardHover = (onHover) => {
+	let current = null;
+	const report = (id) => {
+		if (id === current) return;
+		current = id;
+		onHover(id);
 	};
-	const setCounter = (el, idx) => {
-		if (el) el.textContent = `${idx + 1} / ${total}`;
+	const cardOf = (target) => target instanceof Element ? target.closest("[data-result-card]")?.getAttribute("data-result-card") ?? null : null;
+	return combine([
+		listen(document, "pointerover", (event) => report(cardOf(event.target))),
+		listen(document, "focusin", (event) => report(cardOf(event.target))),
+		listen(document, "pointerout", (event) => {
+			if (event.relatedTarget === null) report(null);
+		}),
+		listen(document, "focusout", (event) => {
+			if (event.relatedTarget === null) report(null);
+		})
+	]);
+};
+//#endregion
+//#region src/enhance/map/maplibre.ts
+let pending = null;
+/** See {@link LoadMapLibre}. */
+const loadMapLibre = (load) => {
+	pending ??= load().then((module) => "default" in module ? module.default : module, (error) => {
+		pending = null;
+		throw error;
+	});
+	return pending;
+};
+//#endregion
+//#region src/enhance/map/surface.ts
+/** Moves shorter than this between press and release are a click, on the map (`clickTolerance`) AND on a
+*  pin: one number in two places, because two thresholds deciding the same thing disagreed (MapLibre's
+*  default 3 px started a drag that carried the pin away from under the pointer). Half a pin's width:
+*  the blur that aiming itself has. */
+const CLICK_TOLERANCE_PX = 12;
+const GUEST_INPUT = [
+	"mousedown",
+	"wheel",
+	"touchstart",
+	"keydown"
+];
+/** See {@link CreateMapSurface}. */
+const createMapSurface = (options) => {
+	let map = null;
+	let building = null;
+	let destroyed = false;
+	let byGuest = false;
+	const cleanups = [];
+	const report = () => {
+		if (!map) return;
+		const { clientWidth, clientHeight } = options.container;
+		const guest = byGuest;
+		byGuest = false;
+		options.onView?.(clientWidth === 0 || clientHeight === 0 ? null : boundsOf(map), guest);
 	};
-	const openLayer = (layer, idx) => {
-		layer.returnFocus = document.activeElement;
-		withViewTransition(() => {
-			layer.panel.removeAttribute("hidden");
-			document.body.style.overflow = "hidden";
+	const create = async () => {
+		await whenWide(options.container, cleanups);
+		const lib = await loadMapLibre(options.load);
+		if (destroyed || map) return;
+		const created = new lib.Map({
+			container: options.container,
+			style: options.styleUrl,
+			scrollZoom: options.scrollZoom,
+			attributionControl: { compact: false },
+			clickTolerance: 12,
+			...cameraOptions(options.camera)
 		});
-		history.pushState({ layer: `${options.root}:${layer.name}` }, "");
-		const landOn = (attempt) => {
-			if (!(layer.isViewer && track && typeof idx === "number")) {
-				focusForKeyboard(layer.closeBtn);
-				return;
-			}
-			const w = track.clientWidth;
-			if (w === 0 && attempt < 5) {
-				requestAnimationFrame(() => landOn(attempt + 1));
-				return;
-			}
-			track.scrollTo({
-				left: idx * w,
-				behavior: "auto"
+		map = created;
+		created.once("load", () => {
+			if (!destroyed) options.onReady?.(created, lib);
+		});
+		created.on("moveend", report);
+		cleanups.push(...GUEST_INPUT.map((type) => listen(options.container, type, () => byGuest = true, { passive: true })), observeSize(options.container, report));
+	};
+	const surface = {
+		build: () => building ??= create(),
+		map: () => map,
+		zoomIn: () => {
+			byGuest = true;
+			map?.zoomIn();
+		},
+		zoomOut: () => {
+			byGuest = true;
+			map?.zoomOut();
+		},
+		fit: (bounds, padding, maxZoom) => {
+			byGuest = false;
+			map?.fitBounds(bounds, {
+				padding,
+				maxZoom,
+				animate: false
 			});
-			setCounter(counter, idx);
-			focusForKeyboard(layer.closeBtn);
-		};
-		requestAnimationFrame(() => landOn(0));
+		},
+		resize: () => map?.resize(),
+		destroy: () => {
+			destroyed = true;
+			combine(cleanups)();
+			map?.remove();
+			map = null;
+		}
 	};
-	const closeLayerInternal = (layer) => {
-		const lastIdx = layer.isViewer ? currentIdx() : null;
-		withViewTransition(() => {
-			if (layer.scroller) layer.scroller.scrollTop = 0;
-			layer.panel.setAttribute("hidden", "");
-			if (!layers.some((l) => l !== layer && isOpen(l))) document.body.style.overflow = "";
+	if (options.start === "near") cleanups.push(whenNear(options.container, options.nearMargin ?? "100% 0px", () => void surface.build()));
+	return surface;
+};
+/** See {@link MarkerElement}. */
+const markerElement = ({ tag, part }) => {
+	const el = document.createElement(tag);
+	if (el instanceof HTMLButtonElement) el.type = "button";
+	const body = document.createElement("span");
+	body.dataset["part"] = part;
+	el.append(body);
+	return {
+		el,
+		body
+	};
+};
+/** See {@link BindActivation}. */
+const bindActivation = (element, onActivate) => {
+	let start = null;
+	return combine([
+		listen(element, "pointerdown", (event) => {
+			start = {
+				x: event.clientX,
+				y: event.clientY
+			};
+			try {
+				element.setPointerCapture(event.pointerId);
+			} catch {}
+		}),
+		listen(element, "pointercancel", () => start = null),
+		listen(element, "pointerup", (event) => {
+			if (!start) return;
+			const moved = Math.hypot(event.clientX - start.x, event.clientY - start.y);
+			start = null;
+			if (moved > 12) return;
+			event.stopPropagation();
+			onActivate();
+		}),
+		listen(element, "click", (event) => {
+			event.stopPropagation();
+			if (event.detail === 0) onActivate();
+		})
+	]);
+};
+function cameraOptions(camera) {
+	if ("center" in camera) return {
+		center: camera.center,
+		zoom: camera.zoom
+	};
+	return {
+		bounds: camera.bounds(),
+		fitBoundsOptions: {
+			padding: camera.padding,
+			maxZoom: camera.maxZoom
+		}
+	};
+}
+function boundsOf(map) {
+	const bounds = map.getBounds();
+	return [[bounds.getWest(), bounds.getSouth()], [bounds.getEast(), bounds.getNorth()]];
+}
+/** MapLibre measures during init and a zero-width container renders broken: wait for a width. */
+function whenWide(container, cleanups) {
+	if (container.clientWidth > 0) return Promise.resolve();
+	return new Promise((resolve) => {
+		const observer = new ResizeObserver(() => {
+			if (container.clientWidth === 0) return;
+			observer.disconnect();
+			resolve();
 		});
-		if (lastIdx !== null && carousel && carousel.clientWidth > 0) {
-			carousel.scrollTo({
-				left: lastIdx * carousel.clientWidth,
-				behavior: "auto"
-			});
-			setCounter(carouselCounter, lastIdx);
+		observer.observe(container);
+		cleanups.push(() => observer.disconnect());
+	});
+}
+/** Run `task` once, the first time `element` comes within `margin` of the viewport. */
+function whenNear(element, margin, task) {
+	const observer = new IntersectionObserver((entries) => {
+		if (!entries.some((entry) => entry.isIntersecting)) return;
+		observer.disconnect();
+		task();
+	}, { rootMargin: margin });
+	observer.observe(element);
+	return () => observer.disconnect();
+}
+/** Report after every size change once built (a layer closing to 0×0, a breakpoint hiding the map). */
+function observeSize(container, onChange) {
+	let first = true;
+	const observer = new ResizeObserver(() => {
+		if (first) {
+			first = false;
+			return;
 		}
-		focusForKeyboard(layer.returnFocus);
+		onChange();
+	});
+	observer.observe(container);
+	return () => observer.disconnect();
+}
+//#endregion
+//#region src/enhance/map/place-markers.ts
+/** Popup distance from the spot: above a teardrop's head, beside a dot. */
+const POPUP_OFFSET = {
+	bottom: 36,
+	center: 14
+};
+/** See {@link BindPlaceMarkers}. */
+const bindPlaceMarkers = (map, lib, options) => {
+	let popup = null;
+	let disposed = false;
+	const closePopup = () => {
+		popup?.remove();
+		popup = null;
 	};
-	const closeLayer = (layer) => {
-		if (history.state && history.state.layer === `${options.root}:${layer.name}`) history.back();
-		else closeLayerInternal(layer);
+	const openPopup = (marker, text) => {
+		closePopup();
+		const content = document.createElement("p");
+		content.dataset["part"] = "map-popup";
+		content.textContent = text;
+		popup = new lib.Popup({
+			closeButton: false,
+			closeOnClick: false,
+			offset: POPUP_OFFSET[options.anchor]
+		}).setLngLat(marker.at).setDOMContent(content).addTo(map);
 	};
-	const step = (delta) => {
-		if (!track) return;
-		const next = Math.min(total - 1, Math.max(0, currentIdx() + delta));
-		track.scrollTo({
-			left: next * track.clientWidth,
-			behavior: "smooth"
+	const placed = options.markers.map((marker) => {
+		const { el, body } = markerElement({
+			tag: options.popup ? "button" : "div",
+			part: "map-marker"
 		});
+		options.render(body, marker);
+		const instance = new lib.Marker({
+			element: el,
+			anchor: options.anchor
+		}).setLngLat(marker.at).addTo(map);
+		const text = options.popup?.(marker);
+		const release = text ? bindActivation(el, () => openPopup(marker, text)) : () => {};
+		return combine([release, () => instance.remove()]);
+	});
+	const onMapClick = () => {
+		if (!disposed) closePopup();
 	};
-	layers.forEach((layer) => {
-		let warmed = false;
-		const warm = () => {
-			if (warmed) return;
-			warmed = true;
-			const img = layer.panel.querySelector("img");
-			if (!img) return;
-			const pre = new Image();
-			if (img.srcset) pre.srcset = img.srcset;
-			if (img.sizes) pre.sizes = img.sizes;
-			pre.src = img.src;
+	map.on("click", onMapClick);
+	return combine([...placed, () => {
+		disposed = true;
+		map.off("click", onMapClick);
+		closePopup();
+	}]);
+};
+//#endregion
+//#region src/enhance/map/result-markers.ts
+const SOURCE = "voffice-results";
+const EMPTY = {
+	type: "FeatureCollection",
+	features: []
+};
+const NO_OFFSET = [0, 0];
+/** See {@link BindResultMarkers}. */
+const bindResultMarkers = (map, lib, options) => {
+	let { points, layout, priced } = options;
+	let expanded = null;
+	let pinWidth = 0;
+	let disposed = false;
+	let active = null;
+	const sources = /* @__PURE__ */ new Set();
+	const entries = /* @__PURE__ */ new Map();
+	let onScreen = [];
+	const groups = () => new Map(layout.groups.map((group) => [group.key, group]));
+	const publish = () => {
+		const sourceId = sourceIdFor(options.cluster, priced);
+		const data = featureCollection(points, layout);
+		if (sources.has(sourceId)) map.getSource(sourceId)?.setData(data);
+		else {
+			addSource(map, sourceId, options.cluster, priced, data);
+			sources.add(sourceId);
+		}
+		if (active && active !== sourceId) map.getSource(active)?.setData(EMPTY);
+		active = sourceId;
+	};
+	const notify = () => {
+		options.onMarkers(onScreen.flatMap((key) => entries.get(key)?.record ?? []));
+	};
+	const destroy = (key) => {
+		const entry = entries.get(key);
+		if (!entry) return;
+		entry.marker.remove();
+		entry.release();
+		entries.delete(key);
+	};
+	const create = (key, wanted) => {
+		const part = wanted.kind === "pin" ? "map-pin" : wanted.kind === "group" ? "map-group" : "map-cluster";
+		const { el: shell, body } = markerElement({
+			tag: "button",
+			part
+		});
+		const at = wanted.kind === "group" ? wanted.group.at : wanted.at;
+		const offset = wanted.kind === "pin" ? wanted.offset : NO_OFFSET;
+		const marker = new lib.Marker({
+			element: shell,
+			offset
+		}).setLngLat(at);
+		if (wanted.kind === "pin") {
+			body.dataset["id"] = wanted.id;
+			const release = bindActivation(shell, () => options.onPin(wanted.id));
+			return {
+				record: {
+					kind: "pin",
+					key,
+					id: wanted.id,
+					body,
+					shell
+				},
+				marker,
+				offset: String(offset),
+				release
+			};
+		}
+		if (wanted.kind === "group") {
+			const { group } = wanted;
+			body.dataset["leafIds"] = group.ids.join("|");
+			const release = bindActivation(shell, () => options.onGroup(group.key));
+			return {
+				record: {
+					kind: "group",
+					key,
+					count: group.ids.length,
+					leafIds: group.ids,
+					body,
+					shell
+				},
+				marker,
+				offset: String(offset),
+				release
+			};
+		}
+		const release = bindActivation(shell, () => zoomInto(map, active, wanted.clusterId, wanted.at));
+		resolveLeaves(map, active, wanted.clusterId, groups()).then((leafIds) => {
+			const entry = entries.get(key);
+			if (!entry || disposed || entry.record.kind === "pin") return;
+			entry.record = {
+				...entry.record,
+				leafIds
+			};
+			body.dataset["leafIds"] = leafIds.join("|");
+			if (onScreen.includes(key)) notify();
+		}, () => {});
+		return {
+			record: {
+				kind: "cluster",
+				key,
+				count: wanted.count,
+				leafIds: [],
+				body,
+				shell
+			},
+			marker,
+			offset: String(offset),
+			release
 		};
-		layer.openers.forEach((t) => {
-			if (layer.warmOnIntent) {
-				t.addEventListener("pointerenter", warm, { once: true });
-				t.addEventListener("focus", warm, { once: true });
+	};
+	const sync = () => {
+		if (disposed || !active || !map.isSourceLoaded(active)) return;
+		const wanted = wantedMarkers(map.querySourceFeatures(active), layout, groups(), expanded, pinWidth);
+		const shown = new Set(onScreen);
+		for (const [key, want] of wanted) {
+			const entry = entries.get(key) ?? create(key, want);
+			entries.set(key, entry);
+			const offset = want.kind === "pin" ? want.offset : NO_OFFSET;
+			if (entry.offset !== String(offset)) {
+				entry.marker.setOffset(offset);
+				entry.offset = String(offset);
 			}
-			t.addEventListener("click", () => {
-				const idx = layer.isViewer ? Number(t.getAttribute(indexAttr)) || 0 : void 0;
-				openLayer(layer, idx);
+			if (entry.record.kind === "group") entry.record.body.toggleAttribute("data-expanded", key === `g${expanded}`);
+			if (!shown.has(key)) entry.marker.addTo(map);
+		}
+		const next = [...wanted.keys()];
+		for (const key of shown) if (!wanted.has(key)) entries.get(key)?.marker.remove();
+		const changed = next.length !== onScreen.length || next.some((key, at) => key !== onScreen[at]);
+		onScreen = next;
+		if (changed) notify();
+	};
+	publish();
+	const onBackground = () => {
+		if (!disposed) options.onBackground();
+	};
+	map.on("render", sync);
+	map.on("click", onBackground);
+	map.on("zoomstart", onBackground);
+	return {
+		update(nextPoints, nextLayout, nextPriced) {
+			if (disposed) return;
+			points = nextPoints;
+			layout = nextLayout;
+			priced = nextPriced;
+			const kept = /* @__PURE__ */ new Set([...points.map((point) => `p${point.id}`), ...layout.groups.map((group) => `g${group.key}`)]);
+			for (const key of entries.keys()) if (!kept.has(key)) destroy(key);
+			onScreen = onScreen.filter((key) => entries.has(key));
+			publish();
+			sync();
+		},
+		expand(groupKey, pinWidthPx) {
+			if (disposed) return;
+			expanded = groupKey;
+			pinWidth = pinWidthPx;
+			const group = groupKey === null ? void 0 : groups().get(groupKey);
+			if (group) map.easeTo({
+				center: group.at,
+				duration: 300
 			});
-		});
-		if (layer.closeBtn) layer.closeBtn.addEventListener("click", () => closeLayer(layer));
-		if (layer.backdrop) layer.backdrop.addEventListener("click", (e) => {
-			if (e.target === layer.backdrop) closeLayer(layer);
-		});
+			sync();
+		},
+		dispose() {
+			if (disposed) return;
+			disposed = true;
+			map.off("render", sync);
+			map.off("click", onBackground);
+			map.off("zoomstart", onBackground);
+			for (const key of entries.keys()) destroy(key);
+			for (const sourceId of sources) map.getSource(sourceId)?.setData(EMPTY);
+			onScreen = [];
+		}
+	};
+};
+/** One source per cluster setting (a source's clustering is fixed when it is added, and a priced set may
+*  cluster wider than a set of dots). */
+function sourceIdFor(cluster, priced) {
+	const settings = clusterSettings(cluster, priced);
+	return settings ? `${SOURCE}-${settings.radius}-${settings.maxZoom}` : SOURCE;
+}
+function clusterSettings(cluster, priced) {
+	if (cluster === false) return null;
+	const radius = cluster.radius ?? DEFAULT_CLUSTER.radius;
+	const maxZoom = cluster.maxZoom ?? DEFAULT_CLUSTER.maxZoom;
+	if (!priced || !cluster.whenPriced) return {
+		radius,
+		maxZoom
+	};
+	return {
+		radius: cluster.whenPriced.radius ?? radius,
+		maxZoom: cluster.whenPriced.maxZoom ?? maxZoom
+	};
+}
+function addSource(map, id, cluster, priced, data) {
+	const settings = clusterSettings(cluster, priced);
+	map.addSource(id, {
+		type: "geojson",
+		data,
+		cluster: settings !== null,
+		...settings ? {
+			clusterRadius: settings.radius,
+			clusterMaxZoom: settings.maxZoom,
+			clusterProperties: { size: ["+", ["get", "size"]] }
+		} : {}
 	});
-	const prevBtn = q(options.trackPrev);
-	const nextBtn = q(options.trackNext);
-	if (prevBtn) prevBtn.addEventListener("click", () => step(-1));
-	if (nextBtn) nextBtn.addEventListener("click", () => step(1));
-	if (track && counter) track.addEventListener("scroll", () => setCounter(counter, currentIdx()), { passive: true });
-	if (carousel && carouselCounter) {
-		const sync = () => {
-			const w = carousel.clientWidth;
-			if (w === 0) return;
-			setCounter(carouselCounter, Math.round(carousel.scrollLeft / w));
-		};
-		carousel.addEventListener("scroll", sync, { passive: true });
-		sync();
-	}
-	window.addEventListener("popstate", () => {
-		const layer = innermostOpen();
-		if (layer) closeLayerInternal(layer);
+	map.addLayer({
+		id: `${id}-points`,
+		type: "circle",
+		source: id,
+		paint: {
+			"circle-radius": 0,
+			"circle-opacity": 0
+		}
 	});
-	document.addEventListener("keydown", (e) => {
-		const layer = innermostOpen();
-		if (!layer) return;
-		if (e.key === "Escape") {
-			e.preventDefault();
-			closeLayer(layer);
-			return;
+}
+/** Ungrouped points one feature each; a same-spot group one feature with its size, so a cluster that
+*  swallows it counts its rentals, not its bubble. */
+function featureCollection(points, layout) {
+	const grouped = new Set(layout.groups.flatMap((group) => group.ids));
+	const feature = (at, properties) => ({
+		type: "Feature",
+		geometry: {
+			type: "Point",
+			coordinates: [at[0], at[1]]
+		},
+		properties
+	});
+	return {
+		type: "FeatureCollection",
+		features: [...points.filter((point) => !grouped.has(point.id)).map((point) => feature(point.at, {
+			id: point.id,
+			size: 1
+		})), ...layout.groups.map((group) => feature(group.at, {
+			group: group.key,
+			size: group.ids.length
+		}))]
+	};
+}
+/** The markers the loaded features call for, keyed and deduped (a feature repeats in every tile it
+*  touches). An expanded group keeps its bubble as the anchor and adds its pins on a circle around it. */
+function wantedMarkers(features, layout, groups, expanded, pinWidth) {
+	const wanted = /* @__PURE__ */ new Map();
+	for (const { properties, geometry } of features) {
+		const at = lngLatOf(geometry.coordinates);
+		if (!at) continue;
+		if (properties["cluster"]) {
+			const clusterId = Number(properties["cluster_id"]);
+			const count = Number(properties["size"] ?? properties["point_count"]);
+			wanted.set(`c${clusterId}`, {
+				kind: "cluster",
+				clusterId,
+				at,
+				count
+			});
+			continue;
 		}
-		if (layer.isViewer && (e.key === "ArrowRight" || e.key === "ArrowLeft")) {
-			e.preventDefault();
-			step(e.key === "ArrowRight" ? 1 : -1);
+		const group = typeof properties["group"] === "string" ? groups.get(properties["group"]) : void 0;
+		if (group) {
+			wanted.set(`g${group.key}`, {
+				kind: "group",
+				group
+			});
+			if (group.key !== expanded) continue;
+			const offsets = circleOffsets(group.ids.length, pinWidth);
+			group.ids.forEach((id, at) => {
+				wanted.set(`p${id}`, {
+					kind: "pin",
+					id,
+					at: group.at,
+					offset: offsets[at] ?? NO_OFFSET
+				});
+			});
+			continue;
 		}
+		if (typeof properties["id"] !== "string") continue;
+		const id = properties["id"];
+		wanted.set(`p${id}`, {
+			kind: "pin",
+			id,
+			at,
+			offset: layout.offsets[id] ?? NO_OFFSET
+		});
+	}
+	return wanted;
+}
+function lngLatOf(coordinates) {
+	if (!Array.isArray(coordinates)) return null;
+	const [lng, lat] = coordinates;
+	return typeof lng === "number" && typeof lat === "number" ? [lng, lat] : null;
+}
+/** The rental ids inside a cluster (its groups' members included). */
+async function resolveLeaves(map, sourceId, clusterId, groups) {
+	const source = sourceId ? map.getSource(sourceId) : void 0;
+	if (!source) return [];
+	return (await source.getClusterLeaves(clusterId, Number.POSITIVE_INFINITY, 0)).flatMap(({ properties }) => {
+		if (typeof properties["group"] === "string") return [...groups.get(properties["group"])?.ids ?? []];
+		return typeof properties["id"] === "string" ? [properties["id"]] : [];
 	});
 }
+/** A cluster opens by easing to the zoom at which it breaks apart. */
+function zoomInto(map, sourceId, clusterId, at) {
+	(sourceId ? map.getSource(sourceId) : void 0)?.getClusterExpansionZoom(clusterId).then((zoom) => map.easeTo({
+		center: at,
+		zoom
+	}), () => {});
+}
 //#endregion
-export { focusForKeyboard, initGallery, initHistoryOverlay, initImageCarousels, initRentalCarousel, trackInputModality, withViewTransition };
+export { CLICK_TOLERANCE_PX, ENHANCE_PARTS, GATE_MARKERS, bindClamp, bindFavorites, bindGallery, bindImageFade, bindLayer, bindPlaceMarkers, bindResultMarkers, bindReveal, bindShare, bindStrip, createMapSurface, enhance, focusForKeyboard, markerElement, observeResultCardHover, trackInputModality, withViewTransition };