/* =============================================================================
   CARTE D'ACCÈS — plan vectoriel animé.

   Le SVG est INLINE dans la page, et non chargé par <img> : c'est la seule
   façon d'atteindre ses tracés depuis la CSS. Une image externe est une boîte
   opaque, on ne peut animer que le bloc entier.

   ── STRUCTURE DU PLAN ────────────────────────────────────────────────────────
   Les routes ne sont PAS des traits blancs : ce sont les vides entre les douze
   polygones jaunes. Aucun tracé progressif au stroke-dasharray n'est donc
   possible. La cascade exploite cette construction à l'endroit : chaque îlot
   grandit depuis son propre centre, les vides se resserrent, et les rues
   apparaissent en négatif.

   ── ORDRE DE LA CASCADE ──────────────────────────────────────────────────────
   Chaque îlot porte son rang en --i, écrit dans le SVG. Le rang est calculé par
   distance réelle à la pointe du pin (292,4 / 266,2 dans le repère du viewBox) :
   l'îlot du centre part en premier, celui de l'extrémité ouest en dernier,
   250 px plus loin. L'œil suit donc la propagation depuis La Maline vers le
   large, et non un ordre de calque arbitraire.

   ── COULEURS ─────────────────────────────────────────────────────────────────
   Le SVG n'appelle que --map-ilot / --map-ink / --map-paper, avec repli sur les
   couleurs système. La carte reste donc juste même si le mapping ci-dessous
   n'est jamais atteint.

   Une seule règle contextuelle, et elle ne sert qu'à éviter une disparition :
   sur une section JAUNE (.t-brand1), les îlots jaunes s'effaceraient dans le
   fond. On inverse alors le couple — îlots blancs, rues jaunes — et le plan se
   lit comme des blocs blancs posés sur le jaune de la section. Même logique que
   le bouton de la FAQ, et même motif : on n'inverse que là où la couleur
   disparaîtrait.

   ⚠️ La courbe --map-ease-soft reprend celle employée partout dans le projet
   (cubic-bezier(0.22, 1, 0.36, 1)). relay.css ne fournit PAS de tokens
   d'accélération : c'est le mécanisme de relais de flèche, rien d'autre.
   ============================================================================= */

.maline-carte {
	/* Concordance : ces deux valeurs doivent rester identiques aux défauts des
	   réglages Elementor (largeur 660, vitesse 100 %). Un réglage écrit TOUJOURS
	   sa valeur, même non touché, et écraserait ce repli s'ils divergeaient. */
	--carte-max: 660px;
	--map-k: 1;

	--map-ease-soft: cubic-bezier(0.22, 1, 0.36, 1);
	/* Léger dépassement à l'arrivée : les pastilles éclosent au lieu de
	   simplement apparaître. */
	--map-ease-back: cubic-bezier(0.34, 1.56, 0.64, 1);

	/* ─── COULEURS ────────────────────────────────────────────────────────────
	   ⚠️ DEUX ÉTAGES, et l'ordre compte.

	   Les réglages Elementor n'écrivent PAS --map-ilot directement, mais
	   --map-ilot-custom, consommé ici en premier terme d'un var(). Raison : la
	   règle contextuelle .t-brand1 plus bas a la même spécificité que le
	   sélecteur généré par Elementor. Si les deux écrivaient la même variable,
	   c'est l'ordre de chargement des feuilles qui trancherait — autant dire le
	   hasard. Avec cette couche, une couleur choisie l'emporte TOUJOURS, et
	   l'inversion contextuelle ne s'applique que si aucune n'est choisie. */
	--map-ilot: var(--map-ilot-custom, var(--brand-1));
	--map-ink: var(--ink);
	--map-paper: var(--paper);

	/* Le pin a ses propres tokens, repliés sur l'encre : sans eux, le recolorer
	   emporterait aussi les pastilles POI, les libellés et les flèches, qui
	   partagent la classe `cls-2` du SVG. */
	--map-pin: var(--map-pin-custom, var(--map-ink));
	--map-pin-fg: var(--map-pin-fg-custom, var(--map-paper));
	/* L'ombre au sol ne suit PAS le pin : elle reste en encre par défaut, quelle
	   que soit la couleur choisie pour la goutte. */
	--map-pin-base: var(--map-pin-base-custom, var(--map-ink));

	display: block;
	width: 100%;
	max-width: var(--carte-max);
	margin-inline: auto;
}

/* Section jaune : sans inversion, les îlots disparaîtraient dans le fond.
   ⚠️ Le repli passe par --map-ilot-custom, donc une couleur choisie dans
   l'éditeur reste prioritaire ici aussi. */
.t-brand1 .maline-carte {
	--map-ilot: var(--map-ilot-custom, var(--paper));
	--map-paper: var(--brand-1);
}

/* ⚠️ Un SVG inline n'est PAS un élément remplacé : sans ratio déclaré, il n'a
   pas de hauteur intrinsèque et la page ressaute au moment où il se dessine.
   Le ratio reprend exactement le viewBox du fichier. */
.maline-carte__frame {
	display: block;
	width: 100%;
	aspect-ratio: 495.19 / 444.94;
	margin: 0;
}

.maline-carte__frame > svg {
	display: block;
	width: 100%;
	height: 100%;
}

/* ─── État de départ ─────────────────────────────────────────────────────────
   Posé sur .maline-carte et non sur .is-in : tant que le script n'a pas donné
   le départ, le plan est invisible. Si le JS échoue, le repli plus bas le
   rétablit — le contenu n'est jamais perdu.
   -------------------------------------------------------------------------- */
.maline-carte .m-ilot,
.maline-carte .m-rue,
.maline-carte .m-poi,
.maline-carte .m-marker,
.maline-carte .m-pin,
.maline-carte .m-onde {
	opacity: 0;
}

/* ─── Couleur propre au pin ──────────────────────────────────────────────────
   ⚠️ Ces règles SURCHARGENT le <style> interne du SVG. Elles y parviennent par
   la spécificité : `.cls-2` seul vaut (0,0,1,0), les sélecteurs ci-dessous
   (0,0,3,0). Aucun !important n'est donc nécessaire.

   Le groupe #pin-maline contient la goutte, son ombre au sol (`cls-2`) et les
   lettres « RÉ » (`cls-4`). La goutte et les lettres doivent bouger ensemble :
   un pin jaune garderait sinon des lettres blanches, illisibles.

   ⚠️ L'OMBRE AU SOL EN EST EXCLUE. Elle porte la classe `m-pin-base`, posée à
   la main dans map.svg — et non repérée par son type de balise `<ellipse>`, qui
   ne survivrait pas à un réexport depuis Illustrator. Elle reste en encre : une
   ombre colorée comme l'objet qui la projette ne se lit plus comme une ombre.
   L'onde suit la base pour la même raison — elle se propage au sol, pas sur le
   pin.
   -------------------------------------------------------------------------- */
.maline-carte .m-pin .cls-2:not(.m-pin-base) { fill: var(--map-pin); }
.maline-carte .m-pin .cls-4 { fill: var(--map-pin-fg); }

.maline-carte .m-pin .m-pin-base,
.maline-carte .m-onde {
	fill: var(--map-pin-base);
}

/* transform-box: fill-box → l'origine se calcule sur la boîte du tracé, pas sur
   le viewBox entier. Sans lui, chaque îlot pivoterait autour du coin du plan. */
.maline-carte .m-ilot,
.maline-carte .m-poi,
.maline-carte .m-onde,
.maline-carte .m-pin {
	transform-box: fill-box;
	transform-origin: 50% 50%;
}

/* Le pin bascule sur sa POINTE, pas sur son centre : c'est elle qui touche le
   sol, et c'est ce qui rend l'écrasement crédible. */
.maline-carte .m-pin {
	transform-origin: 50% 100%;
}

/* ─── Déclenchement ──────────────────────────────────────────────────────────
   --map-k multiplie durées ET délais. Le rythme d'ensemble se règle donc d'une
   seule valeur, sans toucher aux proportions de la chorégraphie.
   -------------------------------------------------------------------------- */
.maline-carte.is-in .m-ilot {
	animation: malineCarteIlot calc(620ms * var(--map-k)) var(--map-ease-soft) both;
	animation-delay: calc(var(--i) * 45ms * var(--map-k));
}

.maline-carte.is-in .m-rue {
	animation: malineCarteFade calc(500ms * var(--map-k)) var(--map-ease-soft)
		calc(350ms * var(--map-k)) both;
}

.maline-carte.is-in .m-poi {
	animation: malineCartePoi calc(520ms * var(--map-k)) var(--map-ease-back) both;
	animation-delay: calc((500ms + var(--i) * 65ms) * var(--map-k));
}

.maline-carte.is-in .m-pin {
	animation: malineCartePin calc(850ms * var(--map-k)) calc(760ms * var(--map-k)) both;
}

.maline-carte.is-in .m-onde {
	animation: malineCarteOnde calc(700ms * var(--map-k)) var(--map-ease-soft)
		calc(1180ms * var(--map-k)) both;
}

/* Pastille « La Maline » et adresse : elles arrivent À L'IMPACT du pin, pas
   avant. C'est ce qui fait atterrir le regard au bon endroit. */
.maline-carte.is-in .m-marker {
	animation: malineCarteFade calc(450ms * var(--map-k)) var(--map-ease-soft)
		calc(1180ms * var(--map-k)) both;
}

/* ─── Keyframes ──────────────────────────────────────────────────────────── */
@keyframes malineCarteFade {
	from { opacity: 0; }
	to   { opacity: 1; }
}

@keyframes malineCarteIlot {
	from { opacity: 0; transform: scale(0.93); }
	to   { opacity: 1; transform: scale(1); }
}

@keyframes malineCartePoi {
	from { opacity: 0; transform: scale(0.86); }
	to   { opacity: 1; transform: scale(1); }
}

/* Chute puis rebond.
   L'accélération est déclarée PAR SEGMENT : la gravité accélère jusqu'à
   l'impact, chaque rebond suivant s'amortit. Une courbe unique sur toute
   l'animation donnerait une chute molle, sans poids.
   L'écrasement à l'impact (1.08 en largeur, 0.90 en hauteur) est ce qui fait
   lire la masse ; sans lui, le pin flotte. */
@keyframes malineCartePin {
	0% {
		opacity: 0;
		transform: translateY(-34px) scale(1);
		animation-timing-function: cubic-bezier(0.55, 0.06, 0.68, 0.19);
	}
	50% {
		opacity: 1;
		transform: translateY(0) scale(1.08, 0.9);
		animation-timing-function: cubic-bezier(0.22, 1, 0.36, 1);
	}
	62% {
		transform: translateY(-8px) scale(0.96, 1.05);
		animation-timing-function: cubic-bezier(0.55, 0.06, 0.68, 0.19);
	}
	78% {
		transform: translateY(0) scale(1.03, 0.97);
		animation-timing-function: cubic-bezier(0.22, 1, 0.36, 1);
	}
	88% {
		transform: translateY(-2.5px) scale(1);
		animation-timing-function: cubic-bezier(0.55, 0.06, 0.68, 0.19);
	}
	100% {
		opacity: 1;
		transform: translateY(0) scale(1);
	}
}

@keyframes malineCarteOnde {
	from { opacity: 0.4; transform: scale(0.35); }
	to   { opacity: 0;   transform: scale(2.6); }
}

/* ─── Repli si le script ne s'exécute pas ────────────────────────────────────
   Le script pose .js-ready dès qu'il prend la main. Sans lui — JS coupé, erreur
   réseau, navigateur ancien sans IntersectionObserver — la carte s'affiche
   simplement, sans animation. Elle ne reste JAMAIS invisible.
   -------------------------------------------------------------------------- */
.maline-carte:not(.js-ready) .m-ilot,
.maline-carte:not(.js-ready) .m-rue,
.maline-carte:not(.js-ready) .m-poi,
.maline-carte:not(.js-ready) .m-marker,
.maline-carte:not(.js-ready) .m-pin {
	opacity: 1;
}

/* ─── Mouvement réduit ───────────────────────────────────────────────────────
   La chorégraphie est un ornement : on la remplace par un fondu bref plutôt
   que de la supprimer, pour que l'arrivée reste perceptible sans déplacement.
   L'onde disparaît entièrement — c'est le seul élément qui n'existe pas dans
   la maquette.
   -------------------------------------------------------------------------- */
@media (prefers-reduced-motion: reduce) {
	.maline-carte.is-in .m-ilot,
	.maline-carte.is-in .m-rue,
	.maline-carte.is-in .m-poi,
	.maline-carte.is-in .m-marker,
	.maline-carte.is-in .m-pin {
		animation: malineCarteFade 0.2s linear both;
	}

	.maline-carte.is-in .m-onde {
		animation: none;
		opacity: 0;
	}
}
