@v-office/website-headless 0.1.1 → 1.0.0

package/dist/parts-CS1VBrPt.mjs

@@ -0,0 +1,648 @@
+//#region src/store/store.ts
+/** See {@link CreateStore}. */
+const createStore = function createStore(initial) {
+	let state = initial;
+	const listeners = /* @__PURE__ */ new Set();
+	return {
+		getState: () => state,
+		setState(next) {
+			const value = typeof next === "function" ? next(state) : next;
+			if (value === state) return;
+			state = value;
+			for (const listener of Array.from(listeners)) listener(state);
+		},
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		}
+	};
+};
+//#endregion
+//#region src/shared/registry.ts
+function space(namespace) {
+	const holder = globalThis;
+	const symbol = Symbol.for(`@v-office/website-headless/${namespace}`);
+	holder[symbol] ??= {
+		entries: /* @__PURE__ */ new Map(),
+		watchers: /* @__PURE__ */ new Map()
+	};
+	return holder[symbol];
+}
+function notify(target, key, value) {
+	for (const watcher of Array.from(target.watchers.get(key) ?? [])) watcher(value);
+}
+/** See {@link AcquireShared}. */
+const acquireShared = function acquireShared(namespace, key, create, dispose) {
+	const target = space(namespace);
+	let entry = target.entries.get(key);
+	if (entry) {
+		clearTimeout(entry.pending);
+		entry.pending = void 0;
+		entry.claims += 1;
+	} else {
+		const value = create();
+		entry = {
+			value,
+			destroy: () => dispose(value),
+			claims: 1,
+			pending: void 0
+		};
+		target.entries.set(key, entry);
+		notify(target, key, entry.value);
+	}
+	const claimed = entry;
+	let released = false;
+	return {
+		value: claimed.value,
+		release() {
+			if (released) return;
+			released = true;
+			claimed.claims -= 1;
+			if (claimed.claims > 0) return;
+			claimed.pending = setTimeout(() => {
+				if (claimed.claims > 0 || target.entries.get(key) !== claimed) return;
+				target.entries.delete(key);
+				notify(target, key, null);
+				claimed.destroy();
+			}, 0);
+		}
+	};
+};
+/** See {@link ConnectShared}. */
+const connectShared = function connectShared(namespace, key, onValue) {
+	const target = space(namespace);
+	const watcher = onValue;
+	const watchers = target.watchers.get(key) ?? /* @__PURE__ */ new Set();
+	target.watchers.set(key, watchers);
+	watchers.add(watcher);
+	onValue(target.entries.get(key)?.value ?? null);
+	return () => {
+		watchers.delete(watcher);
+		if (watchers.size === 0) target.watchers.delete(key);
+	};
+};
+//#endregion
+//#region src/shared/text.ts
+/** See {@link DefineCopy}. */
+const defineCopy = () => (copy) => copy;
+/** See {@link FillTemplate}. */
+const fillTemplate = function fillTemplate(template, values) {
+	const byName = values;
+	return template.replace(/\{(\w+)\}/g, (token, name) => Object.hasOwn(byName, name) ? String(byName[name]) : token);
+};
+//#endregion
+//#region src/shared/price-label.ts
+/** A run of digits with grouping or decimal separators between them (apostrophes and the no-break
+*  spaces Intl uses for grouping included). */
+const NUMBER_RUN = /\d(?:[\d.,'’  ]*\d)?/g;
+const SEPARATOR = /[.,'’  ]/;
+/** The one amount in `label`, or null for any shape this module does not read. */
+function readAmount(label) {
+	const runs = [...label.matchAll(NUMBER_RUN)];
+	const run = runs.length === 1 ? runs[0] : void 0;
+	if (!run) return null;
+	const text = run[0];
+	const start = run.index;
+	const end = start + text.length;
+	const last = [...text].findLastIndex((char) => SEPARATOR.test(char));
+	const tail = text.slice(last + 1);
+	if (last === -1 || tail.length === 3) return {
+		start,
+		end,
+		units: text
+	};
+	const separator = text.charAt(last);
+	if (tail.length !== 2 || separator !== "." && separator !== ",") return null;
+	return {
+		start,
+		end,
+		units: text.slice(0, last),
+		decimal: {
+			separator,
+			cents: tail
+		}
+	};
+}
+const digitsOf = (units) => units.replace(/\D/g, "");
+/** `units` plus one, keeping its grouping ("1.999" → "2.000"). An ungrouped amount that gains a fourth
+*  digit ("999,50" → "1.000") is grouped with the separator the decimal implies, because Intl groups
+*  four-digit amounts in both fleet locales; an amount already written ungrouped stays ungrouped. */
+function incrementUnits(units, separator) {
+	const digits = digitsOf(units);
+	const next = String(Number(digits) + 1);
+	const inferred = digits.length <= 3 ? separator === "," ? "." : "," : "";
+	const group = units.match(/\D/)?.[0] ?? inferred;
+	return group ? next.replace(/\B(?=(\d{3})+$)/g, group) : next;
+}
+/** See {@link FormatPriceLabel}. */
+const formatPriceLabel = function formatPriceLabel(label, cents) {
+	const amount = readAmount(label);
+	const decimal = amount?.decimal;
+	if (!amount || !decimal || cents === "show") return label;
+	if (cents === "hide-zero" && decimal.cents !== "00") return label;
+	const units = cents === "round" && Number(decimal.cents) >= 50 ? incrementUnits(amount.units, decimal.separator) : amount.units;
+	return label.slice(0, amount.start) + units + label.slice(amount.end);
+};
+/** See {@link ParsePriceLabel}. */
+const parsePriceLabel = function parsePriceLabel(label) {
+	const amount = label ? readAmount(label) : null;
+	if (!amount) return null;
+	return Number(`${digitsOf(amount.units)}.${amount.decimal?.cents ?? "00"}`);
+};
+//#endregion
+//#region src/shared/tracking.ts
+/** utm_*, mtm_*, pk_*, gad_*, gclid, gbraid, wbraid, dclid, fbclid, msclkid, mc_eid, ref, _gl. Not
+*  global (no `lastIndex` state); its `source` is safe to inline into a `<head>` script. */
+const TRACKING_PARAM_PATTERN = /^(?:utm_|mtm_|pk_|gad_|(?:gclid|gbraid|wbraid|dclid|fbclid|msclkid|mc_eid|ref|_gl)$)/;
+/** See {@link IsTrackingParam}. */
+const isTrackingParam = function isTrackingParam(key) {
+	return TRACKING_PARAM_PATTERN.test(key);
+};
+/** Delete every key `drop` names. The keys are collected BEFORE deleting: deleting while iterating
+*  `searchParams.keys()` shifts the list under the iterator, so the key after a deleted one was skipped
+*  and a tracking parameter survived — the one thing this exists to prevent. */
+function dropKeys(params, drop) {
+	for (const key of new Set(params.keys())) if (drop(key)) params.delete(key);
+}
+/** See {@link WithoutTracking}. */
+const withoutTracking = function withoutTracking(search) {
+	const params = new URLSearchParams(search);
+	dropKeys(params, isTrackingParam);
+	return params.toString();
+};
+/** See {@link ShareUrl}. */
+const shareUrl = function shareUrl(location, options = {}) {
+	const extra = new Set(options.strip ?? []);
+	const url = new URL(location.pathname + location.search, options.origin || location.origin);
+	dropKeys(url.searchParams, (key) => isTrackingParam(key) || extra.has(key));
+	url.hash = "";
+	return url.href;
+};
+//#endregion
+//#region src/shared/storage.ts
+const PROBE_KEY = "@v-office/website-headless:probe";
+/** See {@link BrowserStorage}. */
+const browserStorage = function browserStorage(kind) {
+	try {
+		const storage = kind === "local" ? globalThis.localStorage : globalThis.sessionStorage;
+		if (!storage) return null;
+		storage.setItem(PROBE_KEY, "1");
+		storage.removeItem(PROBE_KEY);
+		return storage;
+	} catch {
+		return null;
+	}
+};
+//#endregion
+//#region src/favorites/favorites.ts
+/** The window event every site script listens to (`detail: FavoritesChange`); kept verbatim. The
+*  `./enhance` binder dispatches it from `onChange`. */
+const FAVORITES_EVENT = "merkliste:changed";
+/** See {@link FavoritesStorageKey}. */
+const favoritesStorageKey = function favoritesStorageKey(namespace) {
+	if (namespace.trim() === "") throw new TypeError("favoritesStorageKey needs the site's storage namespace (non-empty).");
+	return `${namespace}-merkliste`;
+};
+/** The stored ids; corrupt JSON, a non-array or a refused read is an empty list. */
+function readIds(storage, key) {
+	try {
+		const parsed = JSON.parse(storage?.getItem(key) ?? "[]");
+		return new Set(Array.isArray(parsed) ? parsed.filter((id) => typeof id === "string") : []);
+	} catch {
+		return /* @__PURE__ */ new Set();
+	}
+}
+function writeIds(storage, key, ids) {
+	try {
+		storage?.setItem(key, JSON.stringify([...ids]));
+	} catch {}
+}
+/** Every id whose saved state differs between `before` and `after`. */
+function changesBetween(before, after) {
+	return [...[...after].filter((id) => !before.has(id)).map((id) => ({
+		id,
+		saved: true
+	})), ...[...before].filter((id) => !after.has(id)).map((id) => ({
+		id,
+		saved: false
+	}))];
+}
+/** See {@link CreateFavorites}. */
+const createFavorites = function createFavorites(options) {
+	const { storageKey } = options;
+	const storage = options.storage === void 0 ? browserStorage("local") : options.storage;
+	const store = createStore({ ids: readIds(storage, storageKey) });
+	let disposed = false;
+	/** Move to `next`, persist unless it came from storage, and report each changed id. */
+	const commit = (next, persist) => {
+		if (disposed) return;
+		const changes = changesBetween(store.getState().ids, next);
+		if (changes.length === 0) return;
+		if (persist) writeIds(storage, storageKey, next);
+		store.setState({ ids: next });
+		for (const change of changes) options.onChange?.(change);
+	};
+	const ids = () => store.getState().ids;
+	const set = (id, saved) => {
+		const next = new Set(ids());
+		if (saved) next.add(id);
+		else next.delete(id);
+		commit(next, true);
+	};
+	return {
+		getState: store.getState,
+		subscribe: store.subscribe,
+		ids,
+		has: (id) => ids().has(id),
+		toggle(id) {
+			const saved = !ids().has(id);
+			set(id, saved);
+			return saved;
+		},
+		set,
+		prune(known) {
+			commit(new Set([...ids()].filter((id) => known.has(id))), true);
+		},
+		reload() {
+			commit(readIds(storage, storageKey), false);
+		},
+		dispose() {
+			disposed = true;
+		}
+	};
+};
+/** See {@link AcquireFavorites}. */
+const acquireFavorites = function acquireFavorites(options) {
+	const claim = acquireShared("favorites", options.storageKey, () => {
+		const listeners = /* @__PURE__ */ new Set();
+		return {
+			favorites: createFavorites({
+				storageKey: options.storageKey,
+				...options.storage === void 0 ? {} : { storage: options.storage },
+				onChange: (change) => {
+					for (const listener of Array.from(listeners)) listener(change);
+				}
+			}),
+			listeners
+		};
+	}, (shared) => shared.favorites.dispose());
+	const { favorites, listeners } = claim.value;
+	const listener = options.onChange ? (change) => options.onChange?.(change) : null;
+	if (listener) listeners.add(listener);
+	return {
+		favorites,
+		release() {
+			if (listener) listeners.delete(listener);
+			claim.release();
+		}
+	};
+};
+//#endregion
+//#region src/map/constants.ts
+/** OpenFreeMap "Bright": free for commercial use, no key, no rate limit, OSM data. A third-party
+*  request (the visitor's IP reaches the tile host), which is why the map components load tiles
+*  on click by default. A brand style is a JSON file the site hosts. */
+const DEFAULT_MAP_STYLE_URL = "https://tiles.openfreemap.org/styles/bright";
+/** Pins closer than this are "the same spot": below it their pills overlap at every usable zoom,
+*  and the feeds' distinct pins sit at least 18 m apart, so 12 m splits cleanly (measured). */
+const SAME_SPOT_METERS = 12;
+/** The list's re-settle pulse after a guest map move that changed the in-view set. A perceived-
+*  responsiveness transition (the re-filter itself is instant), NOT simulated latency. */
+const RELOAD_FLASH_MS = 220;
+//#endregion
+//#region src/map/points.ts
+/** See {@link MapPoints}. */
+const mapPoints = (items, options = {}) => {
+	const cents = options.cents ?? "hide-zero";
+	return items.flatMap((item) => {
+		if (!item.coords) return [];
+		const total = item.price?.total ?? null;
+		return [{
+			id: item.id,
+			at: [item.coords.lng, item.coords.lat],
+			label: total !== null && options.price !== "hidden" ? formatPriceLabel(total, cents) : null,
+			sortValue: parsePriceLabel(total)
+		}];
+	});
+};
+/** See {@link HasMapPoints}. */
+const hasMapPoints = (items) => {
+	return items.some((item) => item.coords !== null && item.coords !== void 0);
+};
+//#endregion
+//#region src/map/same-spot.ts
+const CASCADE_STEP = {
+	x: 13,
+	y: 9
+};
+/** Steps from the centre before a cascade stops spreading (only a 7+ stack would reach it, and
+*  those sit on a circle). */
+const CASCADE_CAP = 3;
+const CIRCLE_FROM = 6;
+const GROUP_FROM = 3;
+const MIN_RADIUS_PX = 38;
+const PIN_GAP_PX = 12;
+const EARTH_RADIUS_M = 6371e3;
+/** See {@link DistanceMeters}. */
+const distanceMeters = (a, b) => {
+	const rad = (degrees) => degrees * Math.PI / 180;
+	const dLat = rad(b[1] - a[1]);
+	const dLng = rad(b[0] - a[0]);
+	const h = Math.sin(dLat / 2) ** 2 + Math.cos(rad(a[1])) * Math.cos(rad(b[1])) * Math.sin(dLng / 2) ** 2;
+	return 2 * EARTH_RADIUS_M * Math.asin(Math.sqrt(h));
+};
+/** Round half away from zero, so a cascade is symmetric around the true position. */
+function roundSymmetric(value) {
+	return Math.sign(value) * Math.round(Math.abs(value)) || 0;
+}
+/** See {@link CircleOffsets}. */
+const circleOffsets = (count, pinWidthPx) => {
+	const radius = Math.max(MIN_RADIUS_PX, (pinWidthPx + PIN_GAP_PX) * count / (2 * Math.PI));
+	return Array.from({ length: count }, (_, k) => {
+		const angle = -Math.PI / 2 + 2 * Math.PI * k / count;
+		return [roundSymmetric(Math.cos(angle) * radius), roundSymmetric(Math.sin(angle) * radius)];
+	});
+};
+function cascadeOffsets(count) {
+	const mid = (count - 1) / 2;
+	return Array.from({ length: count }, (_, k) => {
+		const step = Math.max(-3, Math.min(CASCADE_CAP, k - mid));
+		return [roundSymmetric(step * CASCADE_STEP.x), roundSymmetric(step * CASCADE_STEP.y)];
+	});
+}
+/** Spots with more than one pin, each measured against its first pin (result order). */
+function spots(points) {
+	const used = /* @__PURE__ */ new Set();
+	const out = [];
+	points.forEach((anchor, i) => {
+		if (used.has(i)) return;
+		const spot = [anchor];
+		for (let j = i + 1; j < points.length; j += 1) {
+			const other = points[j];
+			if (!other || used.has(j) || distanceMeters(anchor.at, other.at) > 12) continue;
+			used.add(j);
+			spot.push(other);
+		}
+		if (spot.length > 1) out.push(spot);
+	});
+	return out;
+}
+/** Cheapest first (unpriced last), then result order (sort is stable). */
+function cheapestFirst(spot) {
+	return [...spot].sort((a, b) => (a.sortValue ?? Number.POSITIVE_INFINITY) - (b.sortValue ?? Number.POSITIVE_INFINITY));
+}
+function place(offsets, spot, layout) {
+	spot.forEach((point, k) => {
+		const offset = layout[k];
+		if (offset) offsets[point.id] = offset;
+	});
+}
+/** See {@link LayoutSameSpot}. */
+const layoutSameSpot = (points, options) => {
+	const offsets = {};
+	const groups = [];
+	for (const spot of spots(points)) if (options.mode === "group" && spot.length >= GROUP_FROM) {
+		const ids = cheapestFirst(spot).map((point) => point.id);
+		groups.push({
+			key: `g:${[...ids].sort().join(",")}`,
+			at: spot[0]?.at ?? [0, 0],
+			ids
+		});
+	} else if (options.mode === "fan" && spot.length >= CIRCLE_FROM) {
+		const ordered = cheapestFirst(spot);
+		place(offsets, ordered, circleOffsets(ordered.length, options.pinWidthPx));
+	} else place(offsets, spot, cascadeOffsets(spot.length));
+	return {
+		offsets,
+		groups
+	};
+};
+//#endregion
+//#region src/map/frame.ts
+const DEFAULT_FIT = {
+	padding: 56,
+	maxZoom: 12,
+	excludeOutliers: true
+};
+/** Generous on purpose: a second real region (two islands) stays well below it; the case it
+*  exists for sits at about a thousand times the median distance. */
+const OUTLIER_FACTOR = 10;
+/** Below this the median distance describes one point, not a set: a two-hit search shows both. */
+const OUTLIER_MIN_POINTS = 4;
+function median(values) {
+	const sorted = [...values].sort((a, b) => a - b);
+	const mid = Math.floor(sorted.length / 2);
+	return sorted.length % 2 ? sorted[mid] ?? 0 : ((sorted[mid - 1] ?? 0) + (sorted[mid] ?? 0)) / 2;
+}
+/** The points that aim the camera. Degrees, not metres: only distances are compared with each
+*  other, so the projection does not matter. */
+function framed(points, excludeOutliers) {
+	if (!excludeOutliers || points.length < OUTLIER_MIN_POINTS) return points;
+	const centre = [median(points.map((point) => point.at[0])), median(points.map((point) => point.at[1]))];
+	const distances = points.map((point) => Math.hypot(point.at[0] - centre[0], point.at[1] - centre[1]));
+	const limit = median(distances) * OUTLIER_FACTOR;
+	const kept = points.filter((_, i) => (distances[i] ?? 0) <= limit);
+	return kept.length > 0 ? kept : points;
+}
+/** See {@link FrameFor}. */
+const frameFor = (points, options = {}) => {
+	const aim = framed(points, options.excludeOutliers ?? DEFAULT_FIT.excludeOutliers);
+	if (aim.length === 0) return null;
+	const lngs = aim.map((point) => point.at[0]);
+	const lats = aim.map((point) => point.at[1]);
+	return [[Math.min(...lngs), Math.min(...lats)], [Math.max(...lngs), Math.max(...lats)]];
+};
+/** See {@link IdsInView}. */
+const idsInView = (points, bounds) => {
+	const [[west, south], [east, north]] = bounds;
+	return points.filter(({ at: [lng, lat] }) => lng >= west && lng <= east && lat >= south && lat <= north).map((point) => point.id);
+};
+//#endregion
+//#region src/map/controller.ts
+/** The kit's cluster settings (count-only bubbles). */
+const DEFAULT_CLUSTER = {
+	radius: 54,
+	maxZoom: 11
+};
+/** A dot's width, until a pill was measured. */
+const DOT_WIDTH_PX = 20;
+function pointsKey(points) {
+	return points.map((point) => `${point.id}@${point.at.join(",")}=${point.label ?? ""}`).join("|");
+}
+/** See {@link CreateResultsMapController}. */
+const createResultsMapController = (source, options = {}) => {
+	const listFollowsMap = options.listFollowsMap ?? true;
+	const mode = options.sameSpot ?? "fan";
+	const reports = {
+		inline: null,
+		fullscreen: null
+	};
+	let pinWidth = DOT_WIDTH_PX;
+	let currentKey = "";
+	/** The in-view set last handed to the list (null = no viewport filter). */
+	let applied = null;
+	let pulse = null;
+	let released = false;
+	const statusOf = (points) => source.getState().status === "loading" ? "waiting" : points.length > 0 ? "ready" : "empty";
+	const initialPoints = mapPoints(source.getState().matched, options.pins);
+	currentKey = pointsKey(initialPoints);
+	const store = createStore({
+		status: statusOf(initialPoints),
+		points: initialPoints,
+		priced: initialPoints.some((point) => point.label !== null),
+		layout: layoutSameSpot(initialPoints, {
+			mode,
+			pinWidthPx: pinWidth
+		}),
+		frame: frameFor(initialPoints, options.fit),
+		frameVersion: 0,
+		openId: null,
+		expandedGroup: null,
+		guestMoved: false
+	});
+	const update = (patch) => store.setState({
+		...store.getState(),
+		...patch
+	});
+	const driving = () => reports.fullscreen ? "fullscreen" : "inline";
+	/** Rule 2: the set the list should follow now, or null for no filter. */
+	function wanted() {
+		const bounds = reports[driving()];
+		if (!listFollowsMap || !store.getState().guestMoved || !bounds) return null;
+		return idsInView(store.getState().points, bounds);
+	}
+	function stopPulse() {
+		if (!pulse) return;
+		clearTimeout(pulse);
+		pulse = null;
+		source.setReloading(false);
+	}
+	function handOver(ids) {
+		applied = ids ? ids.join("|") : null;
+		source.setViewport(ids ? new Set(ids) : null);
+	}
+	/** Rule 3 with `withPulse`, rule 4 (and every non-guest change) without. */
+	function follow(withPulse) {
+		const ids = wanted();
+		if ((ids ? ids.join("|") : null) === applied) return stopPulse();
+		if (!withPulse || ids === null) {
+			stopPulse();
+			return handOver(ids);
+		}
+		if (pulse) clearTimeout(pulse);
+		else source.setReloading(true);
+		pulse = setTimeout(() => {
+			pulse = null;
+			handOver(ids);
+			source.setReloading(false);
+		}, 220);
+	}
+	function onSource() {
+		const points = mapPoints(source.getState().matched, options.pins);
+		const key = pointsKey(points);
+		const previous = store.getState();
+		if (key === currentKey) {
+			const status = statusOf(points);
+			if (status !== previous.status) update({ status });
+			return;
+		}
+		currentKey = key;
+		const layout = layoutSameSpot(points, {
+			mode,
+			pinWidthPx: pinWidth
+		});
+		update({
+			status: statusOf(points),
+			points,
+			priced: points.some((point) => point.label !== null),
+			layout,
+			frame: frameFor(points, options.fit),
+			frameVersion: previous.guestMoved ? previous.frameVersion : previous.frameVersion + 1,
+			openId: previous.openId !== null && points.some((point) => point.id === previous.openId) ? previous.openId : null,
+			expandedGroup: layout.groups.some((group) => group.key === previous.expandedGroup) ? previous.expandedGroup : null
+		});
+		if (previous.guestMoved) follow(false);
+	}
+	function report(surface, view) {
+		reports[surface] = view.bounds;
+		if (view.byGuest && !store.getState().guestMoved) {
+			update({ guestMoved: true });
+			if (options.regionScope === "release-on-move" && !released) {
+				released = true;
+				source.releaseRegionScope();
+			}
+		}
+		follow(view.byGuest && surface === driving());
+	}
+	const unsubscribe = source.subscribe(onSource);
+	return {
+		getState: () => store.getState(),
+		subscribe: (listener) => store.subscribe(listener),
+		report,
+		setPinWidth: (px) => {
+			if (px === pinWidth || !(px > 0)) return;
+			pinWidth = px;
+			update({ layout: layoutSameSpot(store.getState().points, {
+				mode,
+				pinWidthPx: px
+			}) });
+		},
+		openPin: (id) => update({ openId: id }),
+		closePopup: () => update({ openId: null }),
+		toggleGroup: (key) => update({ expandedGroup: key === null || key === store.getState().expandedGroup ? null : key }),
+		dispose: () => {
+			unsubscribe();
+			stopPulse();
+			if (applied !== null) handOver(null);
+		}
+	};
+};
+//#endregion
+//#region src/enhance/parts.ts
+const ENHANCE_PARTS = {
+	strip: "strip",
+	stripTrack: "strip-track",
+	stripItem: "strip-item",
+	stripPrev: "strip-prev",
+	stripNext: "strip-next",
+	stripDots: "strip-dots",
+	stripCounter: "strip-counter",
+	layer: "layer",
+	layerOpen: "layer-open",
+	layerClose: "layer-close",
+	layerBody: "layer-body",
+	reveal: "reveal",
+	revealItem: "reveal-item",
+	revealMore: "reveal-more",
+	revealLess: "reveal-less",
+	clamp: "clamp",
+	clampText: "clamp-text",
+	clampToggle: "clamp-toggle",
+	share: "share",
+	shareStatus: "share-status",
+	favorite: "favorite",
+	favoriteBadge: "favorite-badge",
+	gallery: "rental-gallery",
+	galleryTile: "rental-gallery-tile",
+	galleryAll: "rental-gallery-all",
+	galleryGrid: "rental-gallery-grid",
+	galleryViewer: "rental-gallery-viewer",
+	galleryCaption: "rental-gallery-caption",
+	galleryCounter: "rental-gallery-counter",
+	floorplanOpen: "rental-floorplan-open",
+	floorplan: "rental-floorplan"
+};
+const GATE_MARKERS = {
+	stats: "data-rental-stats",
+	descriptionStart: "data-rental-description",
+	descriptionEnd: "data-rental-description-end",
+	amenities: "data-rental-amenities",
+	amenitiesModal: "data-amenities-modal",
+	amenitiesEnd: "data-amenities-overlay-end",
+	roomAttribute: "data-room-attr",
+	reviewCard: "data-review-card"
+};
+//#endregion
+export { connectShared as A, shareUrl as C, defineCopy as D, parsePriceLabel as E, fillTemplate as O, isTrackingParam as S, formatPriceLabel as T, acquireFavorites as _, DEFAULT_FIT as a, browserStorage as b, circleOffsets as c, hasMapPoints as d, mapPoints as f, FAVORITES_EVENT as g, SAME_SPOT_METERS as h, createResultsMapController as i, createStore as j, acquireShared as k, distanceMeters as l, RELOAD_FLASH_MS as m, GATE_MARKERS as n, frameFor as o, DEFAULT_MAP_STYLE_URL as p, DEFAULT_CLUSTER as r, idsInView as s, ENHANCE_PARTS as t, layoutSameSpot as u, createFavorites as v, withoutTracking as w, TRACKING_PARAM_PATTERN as x, favoritesStorageKey as y };