@v-office/website-headless 0.2.0 → 1.0.0

package/dist/enhance/index.d.mts

@@ -1,184 +1,505 @@
-//#region src/enhance/carousel.d.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.
- */
-export declare function initImageCarousels(selector?: string): void;
-export declare function initRentalCarousel(viewport: HTMLElement): void;
+import { An as LngLat, Mn as MapPoint, _a as EnhancePart, a as PlaceMarker, ba as GateMarkers, ga as ENHANCE_PARTS, jn as MapBounds, s as ClusterOptions, va as EnhanceParts, wn as SameSpotLayout, ya as GATE_MARKERS } from "../index-CPMXjfFH.mjs";
+//#region src/enhance/lifecycle.d.ts
+/** Removes everything a binder added. Safe to call more than once. */
+type Dispose = () => void;
 //#endregion
-//#region src/enhance/overlay.d.ts
-/**
- * The rental page's history-integrated overlay — one controller, two callers.
- *
- * WHY IT EXISTS. The amenities modal and the description modal each carried
- * their own copy of this, and the two were identical: diffed after renaming the
- * modal noun, they differed in line wrapping and nothing else. Roughly seventy
- * lines of history handling, scroll locking, ESC and focus written twice, which
- * is two places for the same behaviour to be corrected in and one of them to be
- * forgotten.
- *
- * WHAT IT DOES NOT DECIDE. Nothing visual. The card, the backdrop, the header
- * bar and the scroll region are the component's; this file opens and closes
- * them. It also states no selectors of its own — every one is passed in, so the
- * markup and the string that finds it stay in the same file and a grep for
- * `data-amenities-overlay` still lands on the component that owns it.
- *
- * WHY `hidden` AND NOT `<dialog>`. This controller inherited the mechanism
- * rather than choosing it: every overlay on the page — the gallery lightbox,
- * the fullscreen viewer, the floor plan, the map — shows and hides by toggling
- * the `hidden` attribute, — see the view-transition helper below for why that stayed when
- * the fades went in. A second mechanism here would mean two ways to open a
- * layer on one page and two ways for the crossfade to have to work. Moving all
- * five onto `<dialog>` is a real question and a separate one; moving one is
- * not an improvement.
- *
- * WHY THE HISTORY ENTRY. A modal that swallows the back button is the single
- * worst thing a phone page can do: the gesture that means „go back" navigates
- * away from the rental instead of closing what is over it. Opening pushes one
- * state, and every close routes through `history.back()`, so the X, the ESC
- * key, a click beside the card, the browser's own button and the trackpad
- * swipe all take the same path and leave the history stack level.
- *
- * NOT ADOPTED BY THE OTHER TWO OVERLAYS on the rental page, and both for a stated
- * reason.
- * `RentalMap` is a fullscreen layer with no backdrop to click, no scroll region
- * to reset and unconditional focus on open; taking it would mean three option
- * flags to describe one caller, which is the API bending rather than the
- * callers converging. `RentalGallery`'s controller is `is:inline` and cannot
- * import anything at all — see the note in `gallery.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. */
-export declare function withViewTransition(mutate: () => void): void;
-/** Install the page's single pair of modality listeners. Safe to call often. */
-export declare function trackInputModality(): void;
-/** Focus `el` only when the last real input was a keyboard one. */
-export declare function focusForKeyboard(el: HTMLElement | null): void;
-/** Every selector the controller needs, stated by the caller. Each is scoped to
- *  `root`, so two overlays on one page cannot reach into each other. */
-interface HistoryOverlayOptions {
-  /** The component's own root — the element that wraps BOTH the page-side
-   *  trigger and the overlay, so one lookup finds everything. */
-  root: string;
-  /** The dimmed backdrop. It carries the `hidden` toggle, and a click that
-   *  lands on it rather than on the card inside dismisses. */
-  overlay: string;
-  /** The inner scroll region, reset to the top on close. It is not the card:
-   *  the card is the clip and the header, the block inside it is the scroller. */
-  scroller: string;
-  /** The trigger on the page. */
-  open: string;
-  /** The X in the overlay's header. */
-  close: string;
-  /** Value stored on the pushed history entry, so a close can tell ITS OWN
-   *  state from someone else's before calling `back()`. Unique per overlay. */
-  historyKey: string;
-}
-/** Bind one overlay. Returns silently when the markup is not on this page, so
- *  a component whose overlay self-hides costs nothing. */
-export declare function initHistoryOverlay(options: HistoryOverlayOptions): void;
+//#region src/enhance/favorites.d.ts
+/** Which Merkliste the hearts write to. */
+interface FavoritesBinding {
+  /** `favoritesStorageKey(namespace)`: the site's one key (no default, so no guest loses a list). */
+  storageKey: string;
+}
+/** Bind every heart and badge under `root` (enhance() passes its root; late-rendered hearts are painted as
+ *  they appear):
+ *  - a heart is `[data-fav]` or `[data-part="favorite"]`; its rental id is `data-fav-id`, else the enclosing
+ *    `[data-result-card]`'s value (a heart without an id does nothing). It gets `aria-pressed` and
+ *    `data-saved`; every heart of one rental repaints together (a gallery's mobile and desktop copies);
+ *  - a click toggles the rental, unless another handler already took the click (`defaultPrevented`: a React
+ *    heart toggles the same store itself). Either way the pressed heart's glyph (its `svg`, else the button)
+ *    gets `data-fav-burst="save|remove"` until its animation ends: a press is an event, so this is not CSS on
+ *    `aria-pressed` (that would burst every saved heart on page load);
+ *  - a badge is `[data-fav-badge]` or `[data-part="favorite-badge"]`: its text is the saved count, it
+ *    carries `data-active="true"` while the count is above 0 and no `data-active` at 0 (hidden at 0: a
+ *    "0" badge reads as broken; the kits wrote the value, so both `[data-active]` and
+ *    `[data-active="true"]` match) and `data-fav-bump="on"` after each change; its `aria-label` is
+ *    `data-template` ({count}), or `data-template-one` for one;
+ *  - every change in the store, whoever made it (another tab included, through the `storage` event),
+ *    dispatches FAVORITES_EVENT (`merkliste:changed`, `{ id, saved }`) on window for site scripts.
+ *  Binding a root twice is a no-op. */
+type BindFavorites = (root: ParentNode, options: FavoritesBinding) => Dispose;
+/** See {@link BindFavorites}. */
+export declare const bindFavorites: BindFavorites;
+//#endregion
+//#region src/enhance/share.d.ts
+/** Where the shared link points. */
+interface ShareOptions {
+  /** Canonical origin. Default: the button's `data-share-origin` (the site's configured origin), else the
+   *  page's own origin. */
+  origin?: string;
+  /** Query parameters to drop besides the tracking parameters. */
+  strip?: readonly string[];
+}
+/** Bind one `[data-part="share"]` (or legacy `[data-share]`) button. The native share sheet opens on
+ *  touch-primary devices only (a desktop visitor clicking "share" wants the link, not a system dialog);
+ *  elsewhere the link goes to the clipboard, and where that is blocked a prompt shows it to copy by hand.
+ *  A dismissed share sheet is a decision, not a failure: nothing else happens. After a copy the button
+ *  carries `data-state="done"` for 2 s, its `[data-share-idle]` / `[data-share-done]` children swap
+ *  (`hidden`), and the `[data-part="share-status"]` (or `[data-share-live]`) live region announces its
+ *  `data-message` (else the done label's text). The title is `data-share-title`, else the document's.
+ *  Binding twice is a no-op. */
+type BindShare = (button: HTMLElement, options?: ShareOptions) => Dispose;
+/** See {@link BindShare}. */
+export declare const bindShare: BindShare;
+//#endregion
+//#region src/enhance/enhance.d.ts
+/** Which engine families enhance() binds. Each is on by default; pass false where the site binds one
+ *  itself. Favorites need the site's storage key and are off without it. */
+interface EnhanceOptions {
+  /** `[data-part="strip"]` and the legacy `.card-images` strips (bound when the browser is idle: binding
+   *  every row and card at once was a long task in front of the first photo's paint). */
+  strips?: boolean;
+  /** `[data-part="rental-gallery"]` galleries with their strips and layers. */
+  galleries?: boolean;
+  /** `<dialog data-part="layer">` layers (description, amenities, any site dialog on the contract). */
+  layers?: boolean;
+  /** `[data-part="reveal"]` "show more" lists. */
+  reveals?: boolean;
+  /** `[data-part="clamp"]` line-clamped texts. */
+  clamps?: boolean;
+  /** `[data-part="share"]` / `[data-share]` buttons; an object sets their options. */
+  share?: boolean | ShareOptions;
+  /** The lazy-photo fade inside every gallery. */
+  imageFade?: boolean;
+  /** `{ storageKey }` binds the `[data-fav]` hearts and badges below the root; false or absent skips. */
+  favorites?: false | FavoritesBinding;
+}
+/** Bind everything below `root` (default `document`). Idempotent: an element already bound (by an earlier
+ *  call or a hydrated component's useEnhance) is left alone and stays its first binder's, so a second call
+ *  binds only what is new and its Dispose unbinds only that. */
+type Enhance = (root?: ParentNode, options?: EnhanceOptions) => Dispose;
+/** See {@link Enhance}. */
+export declare const enhance: Enhance;
+//#endregion
+//#region src/enhance/layers.d.ts
+/** How one dialog behaves. */
+interface LayerOptions {
+  /** The URL hash while open. Default: the dialog's id (one of the two is required; binding throws without). */
+  name?: string;
+  /** The inner scroller, reset to the top before the dialog closes (after closing it has no box, so a reset
+   *  then is a silent no-op and the layer reopens where it was left). Default: its `[data-part="layer-body"]`. */
+  scroller?: HTMLElement | null;
+  /** Close on a click that lands on the dialog's own box, outside its card. Default true. */
+  closeOnBackdrop?: boolean;
+  /** After opening; receives the element that opened it (the gallery reads its photo index). */
+  onOpen?: (opener: HTMLElement | null) => void;
+  /** Before closing, while layout can still be read (the viewer's current photo). */
+  onClose?: () => void;
+}
+/** A bound dialog. */
+interface LayerHandle {
+  /** Open (no-op when open), pushing the layer's history entry. */
+  open(opener?: HTMLElement | null): void;
+  /** Close through history.back() when the layer's entry is on top, else directly. */
+  close(): void;
+  /** Whether the layer is open. */
+  readonly isOpen: boolean;
+  /** Remove every listener; an open layer closes without touching history (the page is being left). */
+  dispose: Dispose;
+}
+/** Bind one dialog. Openers are `[data-part="layer-open"][aria-controls=<dialog id>]` anywhere in the
+ *  document; closers are `[data-part="layer-close"]` inside it. Body scroll is locked while any layer is
+ *  open; focus moves in (to the first closer) and back only after keyboard input. Binding a dialog twice
+ *  returns the first handle. */
+type BindLayer = (dialog: HTMLDialogElement, options?: LayerOptions) => LayerHandle;
+/** See {@link BindLayer}. */
+export declare const bindLayer: BindLayer;
+//#endregion
+//#region src/enhance/strip.d.ts
+/** How a strip steps and ends. Each option may also come from the markup: `data-paging`, `data-edges`
+ *  on the strip root; an option passed here wins over the markup. */
+interface StripOptions {
+  /** "page": every item is the track's width (card photos, the mobile gallery, the viewer).
+   *  "snap": items of any width, stepped to the nearest item start (rental rows, review cards). Default "page". */
+  paging?: "page" | "snap";
+  /** "stop": the arrows disable at the ends (the strip root carries `data-engaged` once first scrolled, so
+   *  CSS can hide a disabled arrow until then and grey it in place after; a click cannot fall through to
+   *  the card link where an arrow was). "wrap": next after the last returns to the first. Default "stop". */
+  edges?: "stop" | "wrap";
+  /** Mouse drag (2 px threshold) with a suppressor for the click that ends it. Default: paging === "snap". */
+  drag?: boolean;
+  /** Hand the next item its `data-src` / `data-srcset` on pointer, touch, focus or scroll intent, so photos
+   *  2–5 of a card are not fetched at page start (the browser's lazy-load distance applies sideways too).
+   *  Default true. */
+  deferSlides?: boolean;
+}
+/** A bound strip. */
+interface StripHandle {
+  /** The current item among the items that have a box. */
+  readonly index: number;
+  /** The number of items that have a box (a hidden tile does not count). */
+  readonly total: number;
+  /** Scroll to an item (clamped). "instant" overrides a CSS `scroll-behavior: smooth` (an assignment under
+   *  smooth scrolling silently never moved a strip); "smooth" becomes instant under reduced motion.
+   *  Default: "instant" for page strips, "smooth" for snap strips. A strip without a box ignores it. */
+  goTo(index: number, how?: "instant" | "smooth"): void;
+  /** One item back or forward, wrapping when `edges` is "wrap". */
+  step(delta: 1 | -1): void;
+  /** Back to the start (a tab switch swapped the items). */
+  reset(): void;
+  /** Remove every listener and observer. */
+  dispose: Dispose;
+}
+/** Bind one strip: `root` is a `[data-part="strip"]` (or the legacy `.card-images`) holding a
+ *  `[data-part="strip-track"]` (legacy `[data-img-track]`), the horizontal scroller, and optional
+ *  `strip-prev` / `strip-next` (`data-img-prev` / `data-img-next`), `strip-dots` (`data-dots`, one child
+ *  per item) and `strip-counter`. Items are the track's `[data-part="strip-item"]`s, else its children.
+ *  The engine writes state attributes only, never a class: `data-current` on the current item,
+ *  `data-active` on its dot, `disabled` on the arrows, `data-engaged` / `data-dragging` on the root, the
+ *  dots' `aria-label` and the counter's text from their `data-template` ({current}, {count}). Binding
+ *  waits until the track has children; binding a strip twice returns the first handle. */
+type BindStrip = (root: HTMLElement, options?: StripOptions) => StripHandle;
+/** See {@link BindStrip}. */
+export declare const bindStrip: BindStrip;
 //#endregion
 //#region src/enhance/gallery.d.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.
- */
-/** One overlay the gallery can open. Absent markup → not bound, no error. */
-interface GalleryLayer {
-  /** Stable name, used for this layer's history entry. */
-  name: string;
-  /** The panel that carries the `hidden` toggle. */
-  panel: string;
-  /** Everything that opens it. */
-  open: string;
-  /** The X inside it. */
-  close?: string;
-  /** Backdrop: a click that lands on it and not on the card inside dismisses. */
-  backdrop?: string;
-  /** Inner scroll region, reset to the top on close. Not the card — the card is
-   *  the clip and the header, the block inside it is the scroller. */
-  scroller?: string;
-  /** This layer is the photo viewer: its openers carry an image index and it
-   *  drives `track`. */
-  opensAt?: "index";
-  /** Preload the panel's image on the first hover/focus of any opener, so the
-   *  panel does not open onto an empty surface while the bytes arrive. */
-  warmOnIntent?: boolean;
-  /** Publish the panel image's real aspect ratio as `--fp-ar` once known, so a
-   *  wrong width/height guess does not size the box. */
-  fitImage?: string;
-}
-interface GalleryOptions {
-  /** The element wrapping every trigger and every layer, so one lookup finds
-   *  them all and two galleries on a page cannot reach into each other. */
-  root: string;
-  /** Horizontal scroll-snap track inside the viewer layer. */
-  track?: string;
-  trackPrev?: string;
-  trackNext?: string;
-  /** Element whose text becomes `n / total`. */
-  counter?: string;
-  /** A page-level carousel kept in sync with the viewer on close. */
-  carousel?: string;
-  carouselCounter?: string;
-  /** Attribute on a viewer opener carrying its image index. */
-  indexAttr?: string;
-  /** Outermost first. */
-  layers: GalleryLayer[];
-}
-/** Bind one gallery. Returns silently when its root is not on this page. */
-export declare function initGallery(options: GalleryOptions): void;
+/** Bind one `[data-part="rental-gallery"]`:
+ *  - every strip inside it (the mobile strip, the viewer, paged floor plans) as a page strip;
+ *  - its `<dialog>`s `rental-gallery-grid`, `rental-gallery-viewer`, `rental-floorplan` as layers;
+ *    any element inside the gallery whose `aria-controls` names one of them opens it (mosaic tiles,
+ *    "all photos", grid photos, strip photos, the floor-plan button); an opener of the viewer carries
+ *    `data-index` (0-based photo), else the viewer opens on the photo the mobile strip shows;
+ *  - the viewer lands on that photo once it has a width (up to 5 frames, never on photo 1 by accident),
+ *    steps with the arrow keys, and on close the mobile strip returns to the photo last viewed;
+ *  - the floor-plan images publish their natural ratio as `--fp-ar`, and the floor plan is warmed on the
+ *    first hover or focus of its opener (srcset before src, so the warm-up fetches what the dialog shows).
+ *  The per-photo caption and counter follow the photo, not the scroll event: the strip marks the photo
+ *  more than half on screen with `data-current`. Binding twice is a no-op. */
+type BindGallery = (root: HTMLElement) => Dispose;
+/** See {@link BindGallery}. */
+export declare const bindGallery: BindGallery;
+//#endregion
+//#region src/enhance/reveal.d.ts
+/** How a reveal list grows. */
+interface RevealOptions {
+  /** Items each "more" press reveals. Default: all that remain. The markup may say `data-step` on the root. */
+  step?: number;
+  /** A `reveal-less` control hides the revealed items again. Default: true when the markup renders a
+   *  `[data-part="reveal-less"]` (a rendered control that could never work would be a dead button). */
+  collapsible?: boolean;
+}
+/** Bind one `[data-part="reveal"]`: its `[data-part="reveal-item"][hidden]` items are revealed by
+ *  `[data-part="reveal-more"]`, which hides itself when nothing remains; `reveal-less` (shown once something
+ *  is revealed) hides them again. The root carries `data-open` while revealed items show. Focus lands on the
+ *  first revealed item for keyboard users. Binding twice is a no-op. */
+type BindReveal = (root: HTMLElement, options?: RevealOptions) => Dispose;
+/** Bind one `[data-part="clamp"]`: `[data-part="clamp-toggle"]` shows only while
+ *  `[data-part="clamp-text"]` overflows its line clamp (re-measured on resize) and toggles `data-expanded`
+ *  on the root and `aria-expanded` on itself; the clamp itself is CSS on the root's state. Binding twice is
+ *  a no-op. */
+type BindClamp = (root: HTMLElement) => Dispose;
+/** See {@link BindReveal}. */
+export declare const bindReveal: BindReveal;
+/** See {@link BindClamp}. */
+export declare const bindClamp: BindClamp;
+//#endregion
+//#region src/enhance/image-fade.d.ts
+/** Bind one root (enhance() binds every `[data-part="rental-gallery"]`). The root carries `data-image-fade`
+ *  while bound: that attribute arms the CSS that keeps an unmarked lazy image transparent, so without the
+ *  engine every photo simply shows. A lazy image gets `data-loaded="fade"` when it lands, `"cache"` when it
+ *  was already decoded at bind (nothing arrived, so nothing animates) or when it failed (a 404 must not stay
+ *  invisible and take its alt text with it). One capture listener covers the photos inside closed layers,
+ *  which only start fetching once their layer opens. Binding twice is a no-op. */
+type BindImageFade = (root: HTMLElement) => Dispose;
+/** See {@link BindImageFade}. */
+export declare const bindImageFade: BindImageFade;
+//#endregion
+//#region src/enhance/motion.d.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. The look (named groups, timing) is the site's stylesheet's.
+ *  An aborted transition is expected (a hidden tab, a second transition) and swallowed: it says the
+ *  fade did not happen, never that `mutate` did not run. */
+type WithViewTransition = (mutate: () => void) => void;
+/** Install the page's one pair of input-modality listeners (pointer vs keyboard). Reference-counted:
+ *  every binder that moves focus claims it and releases it through the Dispose; the listeners go with
+ *  the last release. */
+type TrackInputModality = () => Dispose;
+/** Focus `element` only when the last real input was the keyboard. Moving focus into a layer is right
+ *  for a keyboard user and wrong for a thumb: iOS paints a ring on a tapped button after a programmatic
+ *  focus, which `:focus-visible` cannot prevent. Needs `trackInputModality()` to have been claimed. */
+type FocusForKeyboard = (element: HTMLElement) => void;
+/** See {@link WithViewTransition}. */
+export declare const withViewTransition: WithViewTransition;
+/** See {@link TrackInputModality}. */
+export declare const trackInputModality: TrackInputModality;
+/** See {@link FocusForKeyboard}. */
+export declare const focusForKeyboard: FocusForKeyboard;
+//#endregion
+//#region src/enhance/map/card-hover.d.ts
+/** Delegated on the document, so it works with any grid (a site's own included) and survives every
+ *  re-render: `onHover(id)` when the pointer or focus enters a `[data-result-card="<id>"]`, `onHover(null)`
+ *  when it leaves every card or the window; called once per change. Focus counts like hover, so keyboard
+ *  users get the same highlight. */
+type ObserveResultCardHover = (onHover: (id: string | null) => void) => Dispose;
+/** See {@link ObserveResultCardHover}. */
+export declare const observeResultCardHover: ObserveResultCardHover;
+//#endregion
+//#region src/enhance/map/maplibre.d.ts
+/** The library: its Map, Marker and Popup constructors. */
+interface MapLibreLike {
+  /** `new maplibregl.Map(options)`. */
+  Map: new (options: Record<string, unknown> & {
+    container: HTMLElement;
+  }) => MapLike;
+  /** `new maplibregl.Marker(options)`. */
+  Marker: new (options: {
+    element: HTMLElement;
+    anchor?: "center" | "bottom";
+    offset?: readonly [number, number];
+  }) => MarkerLike;
+  /** `new maplibregl.Popup(options)`. */
+  Popup: new (options: Record<string, unknown>) => PopupLike;
+}
+/** A map instance. */
+interface MapLike {
+  /** Subscribe to a map event ("load", "moveend", "render", "click", "zoomstart"). */
+  on(type: string, listener: (event?: unknown) => void): void;
+  /** Unsubscribe a listener `on` registered (the binders do on dispose: the caller owns the map and may
+   *  keep it across rebinds). */
+  off(type: string, listener: (event?: unknown) => void): void;
+  /** Subscribe to the next occurrence of a map event. */
+  once(type: string, listener: () => void): void;
+  /** The visible area. */
+  getBounds(): {
+    getWest(): number;
+    getSouth(): number;
+    getEast(): number;
+    getNorth(): number;
+  };
+  /** The element the map renders into. */
+  getContainer(): HTMLElement;
+  /** Frame bounds (`[[w, s], [e, n]]`). */
+  fitBounds(bounds: unknown, options: Record<string, unknown>): void;
+  /** Animate the camera. */
+  easeTo(options: Record<string, unknown>): void;
+  /** One zoom step in. */
+  zoomIn(): void;
+  /** One zoom step out. */
+  zoomOut(): void;
+  /** Re-measure the container. */
+  resize(): void;
+  /** Destroy the map. */
+  remove(): void;
+  /** Add a source. */
+  addSource(id: string, source: Record<string, unknown>): void;
+  /** A source by id. */
+  getSource(id: string): GeoJsonSourceLike | undefined;
+  /** Add a style layer. */
+  addLayer(layer: Record<string, unknown>): void;
+  /** The source's features in the loaded tiles (a feature repeats across tiles). */
+  querySourceFeatures(id: string): ReadonlyArray<{
+    properties: Record<string, unknown>;
+    geometry: {
+      coordinates: unknown;
+    };
+  }>;
+  /** Whether the source's tiles are loaded. */
+  isSourceLoaded(id: string): boolean;
+}
+/** A GeoJSON source. */
+interface GeoJsonSourceLike {
+  /** Replace the data. */
+  setData(data: unknown): void;
+  /** The zoom at which a cluster breaks apart. */
+  getClusterExpansionZoom(clusterId: number): Promise<number>;
+  /** The points inside a cluster. */
+  getClusterLeaves(clusterId: number, limit: number, offset: number): Promise<ReadonlyArray<{
+    properties: Record<string, unknown>;
+  }>>;
+}
+/** An HTML marker. */
+interface MarkerLike {
+  /** Position it. */
+  setLngLat(at: readonly [number, number]): MarkerLike;
+  /** Pixel offset (folded into MapLibre's own transform). */
+  setOffset(offset: readonly [number, number]): MarkerLike;
+  /** Show it on a map. */
+  addTo(map: MapLike): MarkerLike;
+  /** Take it off the map. */
+  remove(): void;
+}
+/** A popup. */
+interface PopupLike {
+  /** Position it. */
+  setLngLat(at: readonly [number, number]): PopupLike;
+  /** Its content. */
+  setDOMContent(node: Node): PopupLike;
+  /** Show it on a map. */
+  addTo(map: MapLike): PopupLike;
+  /** Close it. */
+  remove(): void;
+}
+/** Supplied by the caller: `() => import("maplibre-gl")`. Called at most once per page, however many maps
+ *  build (the first loader handed in is the one used). */
+type MapLibreLoader = () => Promise<MapLibreLike | {
+  default: MapLibreLike;
+}>;
+//#endregion
+//#region src/enhance/map/place-markers.d.ts
+/** The markers and how they look and speak. */
+interface PlaceMarkersOptions {
+  /** One per spot (`mergePlaces` already joined places on one spot). */
+  markers: readonly PlaceMarker[];
+  /** "bottom" for a teardrop pin (its tip on the spot), "center" for a dot. */
+  anchor: "bottom" | "center";
+  /** Render each marker's body (`data-part="map-marker"`). */
+  render: (body: HTMLSpanElement, marker: PlaceMarker) => void;
+  /** Popup text per marker (the caller joins the names), shown on activation; null = a silent marker
+   *  (a `div`, not a button). One popup at a time; a map click closes it. */
+  popup: ((marker: PlaceMarker) => string) | null;
+}
+/** Put the markers on the map; the Dispose takes them and the popup off. */
+type BindPlaceMarkers = (map: MapLike, lib: MapLibreLike, options: PlaceMarkersOptions) => Dispose;
+/** See {@link BindPlaceMarkers}. */
+export declare const bindPlaceMarkers: BindPlaceMarkers;
+//#endregion
+//#region src/enhance/map/result-markers.d.ts
+/** A marker on screen. The body carries `data-part` "map-pin" (with `data-id`), "map-cluster" or "map-group"
+ *  (with `data-leaf-ids`, "|"-joined, for the list → map hover; a group also `data-expanded` while open). */
+type ResultMarker = {
+  /** One rental. */
+  kind: "pin";
+  /** `p<id>`. */
+  key: string;
+  /** The rental id. */
+  id: string;
+  /** Render the pin here. */
+  body: HTMLSpanElement;
+  /** The element MapLibre positions (the button; put the accessible name here). */
+  shell: HTMLElement;
+} | {
+  /** A cluster of the source (`c<cluster_id>`) or a same-spot group (`g<key>`). */
+  kind: "cluster" | "group";
+  /** `c<cluster_id>` / `g<key>`. */
+  key: string;
+  /** Rentals inside (a cluster sums its groups' sizes). */
+  count: number;
+  /** The rentals inside; a cluster's resolve asynchronously (empty until then, then onMarkers again). */
+  leafIds: readonly string[];
+  /** Render the bubble here. */
+  body: HTMLSpanElement;
+  /** The element MapLibre positions. */
+  shell: HTMLElement;
+};
+/** What the markers show and whom they tell. */
+interface ResultMarkersOptions {
+  /** The pins (ResultsMapState.points). */
+  points: readonly MapPoint[];
+  /** Same-spot offsets and groups (ResultsMapState.layout). */
+  layout: SameSpotLayout;
+  /** false = no clustering. With `whenPriced`, a priced set clusters with those settings. */
+  cluster: false | ClusterOptions;
+  /** The pins carry prices (ResultsMapState.priced). */
+  priced: boolean;
+  /** The on-screen markers changed (a marker came or went, a cluster's leaves resolved); not called per frame. */
+  onMarkers: (markers: readonly ResultMarker[]) => void;
+  /** A pin was activated: a release within CLICK_TOLERANCE_PX of the press, or Enter/Space. */
+  onPin: (id: string) => void;
+  /** A group bubble was activated (the caller toggles it, then calls `expand`). */
+  onGroup: (key: string) => void;
+  /** A map click outside every marker, or a zoom start (a fanned group no longer sits on its spot). */
+  onBackground: () => void;
+}
+/** The bound markers. */
+interface ResultMarkers {
+  /** New points or layout (favourites, campaign chips, a measured pin width). */
+  update(points: readonly MapPoint[], layout: SameSpotLayout, priced: boolean): void;
+  /** Fan one group out on its circle around its spot (and centre the map on it), or collapse (null). */
+  expand(groupKey: string | null, pinWidthPx: number): void;
+  /** Take every marker off the map and stop listening (the map itself stays the caller's). */
+  dispose(): void;
+}
+/** A clustered GeoJSON source (cluster counts sum group sizes through `clusterProperties`), an invisible
+ *  circle layer so the source loads, and the HTML-marker diff on every `render`, keyed `c<cluster_id>` /
+ *  `p<id>` / `g<key>` and deduped across tiles. A cluster activation eases to its expansion zoom. */
+type BindResultMarkers = (map: MapLike, lib: MapLibreLike, options: ResultMarkersOptions) => ResultMarkers;
+/** See {@link BindResultMarkers}. */
+export declare const bindResultMarkers: BindResultMarkers;
+//#endregion
+//#region src/enhance/map/surface.d.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. */
+export declare const CLICK_TOLERANCE_PX: 12;
+/** How a surface frames itself when it is built. */
+type MapCamera = {
+  center: LngLat;
+  zoom: number;
+} |
+/** A thunk: a surface built later frames what exists by then. */
+{
+  bounds: () => MapBounds;
+  padding: number;
+  maxZoom: number;
+};
+/** One surface. */
+interface MapSurfaceOptions {
+  /** The element MapLibre renders into. */
+  container: HTMLElement;
+  /** `() => import("maplibre-gl")`. */
+  load: MapLibreLoader;
+  /** Vector-tile style URL. */
+  styleUrl: string;
+  /** The first frame. */
+  camera: MapCamera;
+  /** Wheel over the map zooms it instead of scrolling the page. */
+  scrollZoom: boolean;
+  /** "near": build once the container is within `nearMargin` of the viewport AND has a real width.
+   *  "demand": build on `build()` only (layers, click-to-load). */
+  start: "near" | "demand";
+  /** IntersectionObserver rootMargin. Default "100% 0px" (one screen of lead). */
+  nearMargin?: string;
+  /** The map has loaded its style: put contents on it. Runs once per surface. */
+  onReady?: (map: MapLike, lib: MapLibreLike) => void;
+  /** After every moveend and every size change; a 0×0 container reports `bounds: null` (a hidden map must
+   *  not filter the list). `byGuest`: pointer, wheel, touch or key input on the container, or a zoom
+   *  button (`zoomIn`/`zoomOut`), since the previous report; a programmatic `fit()` never is. */
+  onView?: (bounds: MapBounds | null, byGuest: boolean) => void;
+}
+/** A surface. */
+interface MapSurface {
+  /** Build now if not built (no-op when built or building); resolves once the map exists. */
+  build(): Promise<void>;
+  /** The map, or null while not built. */
+  map(): MapLike | null;
+  /** One zoom step in; counts as the guest's move. */
+  zoomIn(): void;
+  /** One zoom step out; counts as the guest's move. */
+  zoomOut(): void;
+  /** Programmatic, no animation; never counts as the guest's move. */
+  fit(bounds: MapBounds, padding: number, maxZoom: number): void;
+  /** Re-measure after a layer reopens (its container was resized while hidden). */
+  resize(): void;
+  /** Remove the map and every observer and listener. */
+  destroy(): void;
+}
+/** One MapLibre map on one container, with `attributionControl: { compact: false }` always (the compact
+ *  credit collapses on the first touch and the OSM credit disappears) and `clickTolerance` 12. */
+type CreateMapSurface = (options: MapSurfaceOptions) => MapSurface;
+/** The marker element in two nodes: a shell MapLibre rewrites every frame (its inline transform positions
+ *  the marker; anything CSS puts there is overwritten, and `scale` scales the translation with it) and a
+ *  body for every visual (rotation, scale, the hover pop), which carries `data-part`. Never style the shell.
+ *  A "button" shell is `type="button"`. */
+type MarkerElement = (spec: {
+  tag: "button" | "div";
+  part: string;
+}) => {
+  el: HTMLElement;
+  body: HTMLSpanElement;
+};
+/** See {@link CreateMapSurface}. */
+export declare const createMapSurface: CreateMapSurface;
+/** See {@link MarkerElement}. */
+export declare const markerElement: MarkerElement;
 //#endregion
-export type { GalleryLayer, GalleryOptions, HistoryOverlayOptions };
+export { type Dispose, ENHANCE_PARTS, type EnhanceOptions, type EnhancePart, type EnhanceParts, type FavoritesBinding, GATE_MARKERS, type GateMarkers, type GeoJsonSourceLike, type LayerHandle, type LayerOptions, type MapCamera, type MapLibreLike, type MapLibreLoader, type MapLike, type MapSurface, type MapSurfaceOptions, type MarkerLike, type PlaceMarkersOptions, type PopupLike, type ResultMarker, type ResultMarkers, type ResultMarkersOptions, type RevealOptions, type ShareOptions, type StripHandle, type StripOptions };