@charset "UTF-8";
/* =============================================================================
   The Luxembourg Advantage. [figma] node 747:4457 — 1440x800.

   A peeking-slide carousel that LOOPS: the active slide is 1160x510, centred in
   the 1440 frame, and its neighbours are 800x400 sitting 40 either side, so
   ~100 of each is visible and the rest runs off the edge. There is always a
   peek on both sides — rail.js clones the slide set and teleports the scroll
   position at the seams, so the rail never reaches an end and the prev/next
   controls are never disabled.

   Slide copy sits on the image under a bottom-to-black gradient.
   ========================================================================== */

.lux {
	/* [figma] node 747:4457 — the active card is 1160x510 and its neighbours
	   are 800x400. Below 1440 both shrink with the viewport; the design is
	   desktop-only, so the vw floors are ours. */
	--lux-slide-w: min(72.5rem, 92vw);       /* 1160 [figma] */
	--lux-peek-w: min(50rem, 82vw);          /* 800 [figma] */
	--lux-slide-h: calc(var(--lux-slide-w) * 510 / 1160);
	/* The peek is NOT a scaled-down active card: [figma] draws it 800x400
	   (ratio 2), where a proportional shrink of 1160x510 would be 800x352.
	   Measured off a render of the node — the peeks occupy rows 268..667. */
	--lux-peek-h: calc(var(--lux-peek-w) * 400 / 800);

	/* [figma] linear-gradient(-61.15deg, #004F7A 0.5%, #053150 99%) */
	background-image: linear-gradient(151.15deg, var(--color-navy-glow) 0%, #053150 100%);
	color: var(--color-on-dark);
	overflow: hidden;
}

.lux__head {
	display: flex;
	align-items: flex-end;
	justify-content: space-between;
	gap: var(--space-8);
	margin-block-end: var(--space-12);
}

.lux__title {
	color: var(--color-on-dark);
}

.lux__controls {
	display: none;
	flex: none;
	gap: var(--space-3);
}

@media (min-width: 64em) {
	.lux__controls { display: flex; }
}

/* [figma] 60px SOLID WHITE discs with a navy arrow — not outlined. */
.lux__control {
	display: flex;
	align-items: center;
	justify-content: center;
	width: 3.75rem;
	height: 3.75rem;
	border: 0;
	border-radius: var(--radius-full);
	background-color: var(--color-white);
	color: var(--color-navy);
	transition:
		background-color var(--duration) var(--ease),
		border-color var(--duration) var(--ease),
		opacity var(--duration) var(--ease);
}

/* Hover-capable pointers only: on a phone a tap leaves :hover stuck on the
   arrow until the next tap elsewhere. */
@media (hover: hover) {
	.lux__control:hover:not(:disabled) {
		background-color: var(--color-crimson);
		color: var(--color-white);
	}
}

/* The rail loops, so this state is reachable in exactly one case: a single
   slide, where there is nothing to navigate to. */
.lux__control:disabled {
	opacity: 0.3;
	cursor: default;
}

/* --- Rail ------------------------------------------------------------------

   A native horizontal scroller, so swipe, trackpad, wheel and keyboard come
   free. rail.js clones the slide set to make the loop and teleports the scroll
   position by one copy at the seams.

   Scroll snapping is deliberately NOT used here (the journey rail still snaps).
   Mandatory snap re-snaps after a teleport and recomputes its snap points on
   every frame the slide widths animate — the two things this rail does most.
   rail.js re-centres in JS instead, once a user-driven scroll has settled. */

.lux__rail {
	display: flex;
	/* [figma] 40 between the active card and each peek: peek right edge 100 ->
	   active left edge 140, active right edge 1300 -> peek left edge 1340. */
	gap: var(--space-10);
	list-style: none;
	overflow-x: auto;
	overscroll-behavior-x: contain;           /* an endless rail must not chain to the page */
	scrollbar-width: none;
	/* [figma] the 800x400 neighbours sit vertically centred against the
	   1160x510 active slide. */
	align-items: center;
	margin-block: 0;
	margin-inline: calc(var(--gutter) * -1);
	padding-block: 0 var(--space-4);
	padding-inline: var(--gutter);

	/* Hold the rail at the ACTIVE card's height. Without this the rail is only
	   as tall as its tallest child, so mid-transition — when the outgoing slide
	   has shrunk and the incoming one has not yet grown — the whole container
	   dips and springs back (Domagoj, 2026-09-02). */
	min-height: calc(var(--lux-slide-h) + var(--space-4));
}

.lux__rail::-webkit-scrollbar { display: none; }

/* [figma] the active slide is 1160x510, its neighbours 800x400, and the size
   swaps as you navigate.

   The rail's own layout is driven by WIDTH alone — the card's height is
   animated on the child (.lux-slide), inside a rail whose min-height already
   holds the tall state, so it never moves anything else. Animating the rail's
   width and min-height together is what made this stutter.

   The duration and curve are shared by every slide, and by the height, ON
   PURPOSE: the card has to resize as one object, and the loop's teleport is
   only invisible while every slide runs on identical timing. Do not give the
   active state its own transition. */
.lux__slide {
	flex: none;
	width: var(--lux-peek-w);
	transition: width 520ms cubic-bezier(0.22, 0.61, 0.36, 1);
}

.lux__slide.is-active {
	width: var(--lux-slide-w);
}

/* Clones (`.lux__slide--clone`) are structurally identical to the real slides
   and are styled identically on purpose — they exist only so the loop always
   has a peek on both sides. rail.js takes them out of the accessibility tree
   and out of tab order. */

/* Until the controller has cloned the set and placed the scroll position there
   is nothing to animate, and letting the clones animate into shape would show
   as a shuffle on load. */
.lux__rail:not([data-lsb-rail-ready]) .lux__slide,
.lux__rail:not([data-lsb-rail-ready]) .lux-slide {
	transition: none;
}

.lux__slide.is-active .lux-slide {
	height: var(--lux-slide-h);              /* 510 [figma] */
}

/* Only the slide in focus carries its copy, as drawn. */
.lux-slide__body { transition: opacity var(--duration) var(--ease); }
.lux__slide:not(.is-active) .lux-slide__body { opacity: 0; }

/* --- Slide ----------------------------------------------------------------- */

/* The peek keeps its full corner radius — the rail's own overflow clips it at
   the frame edge exactly as the design does, but the inner corners stay rounded
   so it reads as a card rather than a sliced strip. */
.lux-slide {
	position: relative;
	display: flex;
	align-items: flex-end;
	width: 100%;
	/* Height is explicit rather than an aspect-ratio because the two states
	   have DIFFERENT ratios, and a ratio swap would jump. It runs on the same
	   duration and curve as the slide's width so the card resizes as one. */
	height: var(--lux-peek-h);               /* 400 [figma] */
	transition: height 520ms cubic-bezier(0.22, 0.61, 0.36, 1);
	border-radius: var(--radius-lg);         /* 18 [figma] */
	overflow: hidden;
	isolation: isolate;
}

.lux-slide > picture {
	position: absolute;
	inset: 0;
	z-index: 0;
}

.lux-slide__image {
	width: 100%;
	height: 100%;
	object-fit: cover;
}

/* [figma] linear-gradient(to bottom, rgba(0,0,0,0), #000) */
.lux-slide__scrim {
	position: absolute;
	inset: 0;
	z-index: 1;
	/* [figma] node 747:4458 — a plain linear ramp, transparent to full black.
	   MEASURED off a render of the node by compositing maths (a = 1 - C/B):
	     0% 0.008 | 25% 0.250 | 50% 0.500 | 75% 0.744 | 98% 0.979
	   i.e. exactly linear. An earlier pass "corrected" this to 48%/0.88 on a
	   visual impression — the card only LOOKS clear in the middle because a
	   bright photo still reads through 50% black. Do not eyeball this one. */
	background-image: linear-gradient(to bottom, rgb(0 0 0 / 0) 0%, rgb(0 0 0 / 1) 100%);
}

.lux-slide__body {
	position: relative;
	z-index: 2;
	padding: var(--space-8);
	max-width: 48rem;
}

@media (min-width: 64em) {
	.lux-slide__body {
		padding: 0 4.0625rem 3.5625rem;      /* [figma] copy inset 65 from the slide */
	}
}

/* [figma] Montserrat Regular 30 — the eighth type family in the file. Mapped to
   Geist with the other sans faces. */
.lux-slide__title {
	font-family: var(--font-body);
	font-size: var(--fs-ui-xl);
	font-weight: var(--fw-regular);
	line-height: var(--lh-tight);
	color: var(--color-on-dark);
}

/* [figma] Montserrat Regular 20/26 -> Geist. */
.lux-slide__text {
	margin-block-start: var(--space-5);
	max-width: 48rem;
	font-family: var(--font-body);
	font-size: var(--fs-copy-20);
	line-height: 1.3;                        /* 26 / 20 [figma] */
	color: var(--color-on-dark);
}

/* --- Phones ------------------------------------------------------------------
   (Domagoj, 2026-09-25.) The desktop geometry does not survive 390: the active
   card keeps its 1160x510 ratio and ends up ~160px tall, clipping its own
   copy. So on a phone every slide is the SAME size — a 4:5 portrait card at
   84vw — and the grow/shrink is done with `transform`, which never touches
   layout:

   - the track stays perfectly periodic, so rail.js's fold is exact (with
     active width == peek width its offsetOf is a plain pitch), and marking a
     slide active cannot move a snap point (hard rules 19 and 21);
   - the rail can snap natively, because nothing resizes under it.

   Where scroll-driven animations exist, the scale and the copy's fade are tied
   to each card's position in the rail, so they track the finger through a
   swipe instead of waiting for it to stop. Elsewhere the same look runs off
   .is-active on the rail's 520ms curve. */
@media (max-width: 47.99em) {
	.lux {
		--lux-slide-w: 84vw;
		--lux-peek-w: 84vw;
		--lux-slide-h: calc(var(--lux-slide-w) * 5 / 4);
		--lux-peek-h: var(--lux-slide-h);
		--lux-ease: cubic-bezier(0.22, 0.61, 0.36, 1);
	}

	/* The arrows move under the rail: beside the heading they squeezed it
	   onto three lines. */
	.lux {
		position: relative;
		padding-block-end: calc(var(--space-14) + 2.75rem + var(--space-4));
	}

	.lux__head {
		margin-block-end: var(--space-8);
	}

	.lux__controls {
		position: absolute;
		inset-inline: 0;
		bottom: var(--space-14);
		display: flex;
		justify-content: center;
		gap: var(--space-3);
	}

	.lux__control {
		width: 2.75rem;                          /* 44 */
		height: 2.75rem;
	}

	.lux__rail {
		gap: var(--space-2);
		scroll-snap-type: x mandatory;
	}

	.lux__slide {
		scroll-snap-align: center;
	}

	.lux-slide {
		transform: scale(0.9);
		transition: transform 520ms var(--lux-ease);
	}

	.lux__slide.is-active .lux-slide {
		transform: none;
	}

	.lux-slide__body {
		padding: var(--space-6);
		transition:
			opacity 520ms var(--lux-ease),
			transform 520ms var(--lux-ease);
	}

	.lux__slide:not(.is-active) .lux-slide__body {
		transform: translateY(var(--space-4)) scale(0.94);
	}

	.lux-slide__title {
		font-size: var(--fs-editorial-lg);       /* 24 */
	}

	.lux-slide__text {
		margin-block-start: var(--space-3);
		font-size: var(--fs-ui-sm);          /* 14 */
		line-height: 1.5;
	}

	@supports (animation-timeline: view()) {
		.lux-slide {
			transition: none;
			animation: lux-card-focus linear both;
			animation-timeline: view(inline);
		}

		.lux-slide__body {
			transition: none;
			animation: lux-copy-focus linear both;
			animation-timeline: view(inline);
		}
	}
}

/* 50% of a card's view timeline is the card centred in the rail; its
   neighbours sit near 4% and 96%. */
@keyframes lux-card-focus {
	0%, 100% { transform: scale(0.9); }
	50%      { transform: none; }
}

@keyframes lux-copy-focus {
	0%, 32%, 68%, 100% { opacity: 0; transform: translateY(var(--space-4)) scale(0.94); }
	50%                { opacity: 1; transform: none; }
}

@media (max-width: 47.99em) and (prefers-reduced-motion: reduce) {
	.lux-slide,
	.lux-slide__body {
		animation: none;
		transition: none;
	}

	.lux-slide { transform: none; }
}
