/*
 * Lecteur Lizio — feuille de style.
 *
 * Deux thèmes, pilotés par la préférence système ou par `data-theme` sur la
 * racine. Le mode sombre n'est pas optionnel dans ce projet.
 *
 * Les cibles interactives font au moins 24 px (WCAG 2.2, critère 2.5.8) et
 * chacune a un état de focus visible.
 */

.lz {
  --lz-bg:        #f3f2f5;
  --lz-surface:   #ffffff;
  --lz-ink:       #1a1720;
  --lz-muted:     #6b6478;
  --lz-rule:      #e2dee8;
  /* L'ACCENT PEUT ÊTRE CELUI DE L'ÉDITEUR. `--marque` est posée par la page
     qui monte le lecteur quand l'organisation est en marque blanche
     (embed.blade.php, depuis Organization::brandPalette, contrastes garantis).
     Absente — le cas de loin le plus fréquent —, le rose Lizio reste, et rien
     n'a changé. */
  --lz-accent:    var(--marque, #b8005f);   /* brand-600 */
  --lz-shadow:    0 1px 2px rgba(20, 16, 26, .08), 0 12px 32px -14px rgba(20, 16, 26, .35);
  --lz-strip-bg:  #eceaf0;

  display: flex;
  flex-direction: column;
  height: 100%;
  min-height: 0;
  background: var(--lz-bg);
  color: var(--lz-ink);
  font: 400 15px/1.5 system-ui, -apple-system, "Segoe UI", sans-serif;
  -webkit-font-smoothing: antialiased;
}

@media (prefers-color-scheme: dark) {
  :root:not([data-theme="light"]) .lz {
    --lz-bg:       #121016;
    --lz-surface:  #1b1822;
    --lz-ink:      #ece8f0;
    --lz-muted:    #a49cb0;
    --lz-rule:     #2f2939;
    --lz-accent:   var(--marque, #f07cb4);   /* brand-300 */
    --lz-shadow:   0 1px 2px rgba(0, 0, 0, .5), 0 12px 32px -14px rgba(0, 0, 0, .8);
    --lz-strip-bg: #17141d;
  }
}
:root[data-theme="dark"] .lz {
  --lz-bg:       #121016;
  --lz-surface:  #1b1822;
  --lz-ink:      #ece8f0;
  --lz-muted:    #a49cb0;
  --lz-rule:     #2f2939;
  --lz-accent:   var(--marque, #f07cb4);   /* brand-300 */
  --lz-shadow:   0 1px 2px rgba(0, 0, 0, .5), 0 12px 32px -14px rgba(0, 0, 0, .8);
  --lz-strip-bg: #17141d;
}

.lz *, .lz *::before, .lz *::after { box-sizing: border-box; }

/* --- barre de titre --- */
.lz-bar {
  display: flex; align-items: baseline; justify-content: space-between;
  gap: 16px; padding: 10px 16px;
  border-bottom: 1px solid var(--lz-rule);
  background: var(--lz-surface);
  flex: 0 0 auto;
}
.lz-title   { font-weight: 600; letter-spacing: -.01em; }
.lz-counter { color: var(--lz-muted); font-variant-numeric: tabular-nums; font-size: 13.5px; }

/* --- scène --- */
.lz-stage {
  position: relative;
  flex: 1 1 auto;
  min-height: 0;
  display: flex; align-items: center; justify-content: center;
  padding: 20px 56px;
  cursor: pointer;
}
.lz-stage:focus-visible { outline: 2px solid var(--lz-accent); outline-offset: -4px; }

.lz-spread { display: flex; box-shadow: var(--lz-shadow); background: var(--lz-surface); }

/* UNE PLANCHE DE BORD NE PEINT PAS SA MOITIÉ VIDE.
   Le bloc porte le papier et son ombre, ce qui est juste tant qu'il est plein.
   Avec une case vide il fait deux pages de large : la moitié sans page
   devenait un rectangle blanc ombré à côté de la couverture — une page
   blanche, pas un livre fermé. On rend donc le bloc transparent et c'est la
   page réelle qui porte l'ombre, exactement là où elle se trouve. */
.lz-spread[data-creux] { background: none; box-shadow: none; }

/* LE CACHE DU TOURNAGE — voir _tourner().
   Il rend au fond de la scène la part de planche que la feuille ne couvre pas
   encore, le temps que le mouvement la découvre. Sous la feuille (`z-index` 3)
   et au-dessus des pages, pour que la feuille passe par-dessus lui pendant
   qu'il s'efface. Sa transition est posée au rendu : elle dépend de la durée
   du mode. */
.lz-cache {
  position: absolute;
  top: 0;
  height: 100%;
  z-index: 2;
  background: var(--lz-bg);
  pointer-events: none;
}
.lz-spread[data-creux] .lz-leaf:not(.lz-leaf--creux) { box-shadow: var(--lz-shadow); }

.lz-leaf {
  position: relative;
  overflow: hidden;
  background: var(--lz-surface);
}

/* LA CASE VIDE d'une planche de bord — la place que prendrait la page d'en
   face si le livre était ouvert.

   Elle garde la boîte, pas la matière : ni papier, ni ombre, ni coin. C'est
   ce qui laisse le dos au milieu de l'écran quand on regarde la couverture,
   et c'est aussi ce qui donne au bloc sa largeur entière, donc la hauteur des
   planches qui suivent — le livre ne grandit pas en s'ouvrant. */
.lz-leaf--creux {
  background: none;
  box-shadow: none;
}

/* Un fond neutre le temps du décodage, plutôt qu'un trou blanc clignotant.

   `pointer-events: none` N'EST PAS DÉCORATIF. Ce voile couvre toute la feuille
   et, à `opacity: 0`, il reste présent pour le pointeur : il interceptait donc
   TOUS les clics destinés aux zones posées par-dessus — liens du document,
   vidéos, formulaires. La fonction entière était inopérante à la souris, et
   ne se voyait pas, parce que `links` était presque toujours vide et qu'une
   zone au clavier, elle, fonctionnait. Même raison sur le disque d'attente. */
/* `:not(.lz-leaf--creux)` : la case vide d'une planche de bord n'a rien à
   charger, donc ni voile ni disque. L'exclusion est posée ICI plutôt que dans
   une règle d'annulation à côté : une annulation devrait à la fois gagner en
   spécificité et passer après, et elle se perd à la première retouche — c'est
   exactement ce qui est arrivé le 26/10/2026, le disque continuant de tourner
   en production à côté de la couverture. */
.lz-leaf:not(.lz-leaf--creux)::after {
  content: ""; position: absolute; inset: 0;
  pointer-events: none;
  background: var(--lz-rule); opacity: .5;
  transition: opacity .18s ease;
}
.lz-leaf.is-loaded::after { opacity: 0; }

/* L'INDICATEUR D'ATTENTE.
   Une page qui met 400 ms a arriver laisse un rectangle gris muet : on ne sait
   pas si ca charge ou si c'est casse. D'ou ce disque qui tourne.

   Il apparait avec 220 ms de RETARD, et c'est tout l'interet : une page deja en
   cache s'affiche bien avant, donc l'indicateur ne clignote pas pour rien. Un
   temoin qui s'allume a chaque tour de page est pire que pas de temoin -- on
   apprend a le voir comme du bruit.

   Pas de JavaScript : la classe `is-loaded` retire la feuille de la selection,
   ce qui suffit a effacer le disque. */
.lz-leaf:not(.is-loaded):not(.lz-leaf--creux)::before {
  content: ""; position: absolute; z-index: 1; pointer-events: none;
  top: 50%; left: 50%; width: 30px; height: 30px; margin: -15px 0 0 -15px;
  border: 3px solid var(--lz-rule);
  border-top-color: var(--lz-accent);
  border-radius: 50%;
  opacity: 0;
  animation: lz-apparait .2s ease 220ms forwards, lz-tourne .7s linear 220ms infinite;
}
@keyframes lz-tourne { to { transform: rotate(360deg); } }
@keyframes lz-apparait { to { opacity: 1; } }

@media (prefers-reduced-motion: reduce) {
  /* Pas de rotation, mais l'information reste : un disque qui respire. */
  .lz-leaf:not(.is-loaded):not(.lz-leaf--creux)::before {
    animation: lz-respire 1.4s ease-in-out 220ms infinite;
    border-color: var(--lz-accent);
  }
  @keyframes lz-respire { 0%, 100% { opacity: .25; } 50% { opacity: .8; } }
}

.lz-page { display: block; width: 100%; height: 100%; object-fit: contain; }

/* --- boutons de navigation --- */
.lz-nav {
  position: absolute; top: 50%; transform: translateY(-50%);
  width: 40px; height: 56px;            /* bien au-delà des 24 px exigés */
  display: grid; place-items: center;
  font-size: 26px; line-height: 1;
  color: var(--lz-ink);
  background: var(--lz-surface);
  border: 1px solid var(--lz-rule);
  border-radius: 6px;
  box-shadow: var(--lz-shadow);
  cursor: pointer;
}
.lz-nav-prev { left: 8px; }
.lz-nav-next { right: 8px; }
.lz-nav:hover:not(:disabled) { color: var(--lz-accent); border-color: var(--lz-accent); }
.lz-nav:focus-visible { outline: 2px solid var(--lz-accent); outline-offset: 2px; }
.lz-nav:disabled { opacity: .3; cursor: default; }

/* --- bandeau de miniatures --- */
.lz-strip {
  flex: 0 0 auto;
  display: flex; gap: 8px;
  padding: 10px 12px;
  overflow-x: auto; overflow-y: hidden;
  background: var(--lz-strip-bg);
  border-top: 1px solid var(--lz-rule);
  scrollbar-width: thin;
}
.lz-thumb {
  position: relative; flex: 0 0 auto;
  width: 44px; height: 66px;
  padding: 0; border: 1px solid var(--lz-rule); border-radius: 3px;
  background-color: var(--lz-surface);
  background-repeat: no-repeat;
  /* Les vignettes sont découpées dans une planche-contact : on la met à
     l'échelle de la cellule affichée. */
  transform-origin: top left;
  cursor: pointer;
  overflow: hidden;
}
.lz-thumb > * { pointer-events: none; }
.lz-thumb:hover { border-color: var(--lz-accent); }
.lz-thumb:focus-visible { outline: 2px solid var(--lz-accent); outline-offset: 2px; }
.lz-thumb.is-current { border-color: var(--lz-accent); box-shadow: 0 0 0 2px var(--lz-accent); }
.lz-thumb-n {
  position: absolute; left: 0; right: 0; bottom: 0;
  font-size: 9px; line-height: 13px; text-align: center;
  color: #fff; background: rgba(0, 0, 0, .55);
  font-variant-numeric: tabular-nums;
}

/* --- annonce pour les lecteurs d'écran --- */
.lz-live {
  position: absolute; width: 1px; height: 1px; margin: -1px;
  padding: 0; overflow: hidden; clip: rect(0 0 0 0); white-space: nowrap; border: 0;
}

@media (max-width: 820px) {
  .lz-stage { padding: 12px 44px; }
  .lz-nav { width: 34px; height: 48px; font-size: 22px; }
}

@media (prefers-reduced-motion: reduce) {
  .lz *, .lz *::before, .lz *::after {
    transition-duration: .01ms !important;
    animation-duration: .01ms !important;
  }
}

/* --- barre d'outils : zoom et plein écran --- */
.lz-tools { display: flex; align-items: center; gap: 4px; }
.lz-btn {
  min-width: 28px; height: 28px;      /* > 24 px exigés par WCAG 2.5.8 */
  padding: 0 6px;
  display: grid; place-items: center;
  font: inherit; font-size: 14px; line-height: 1;
  color: var(--lz-ink);
  background: var(--lz-surface);
  border: 1px solid var(--lz-rule);
  border-radius: 5px;
  cursor: pointer;
}
.lz-btn-wide { min-width: 52px; font-size: 12px; font-variant-numeric: tabular-nums; }
/* Un bouton qui porte un dessin et non du texte doit être carré, sinon la barre
   se déforme selon le glyphe (même raison que .lz-modes .lz-btn). */
.lz-btn-icon { display: inline-grid; place-items: center; padding: 0; width: 30px; }
.lz-btn:hover { color: var(--lz-accent); border-color: var(--lz-accent); }
.lz-btn:focus-visible { outline: 2px solid var(--lz-accent); outline-offset: 2px; }

/* --- état zoomé --- */
.lz-stage { overflow: hidden; touch-action: pan-y; }
.lz-stage.is-zoomed { cursor: grab; touch-action: none; }
.lz-stage.is-zoomed:active { cursor: grabbing; }
.lz-spread { transform-origin: center center; will-change: transform; }

/* --- plein écran --- */
.lz.is-full { height: 100vh; }
.lz:fullscreen { background: var(--lz-bg); }

/* --- recherche --- */
.lz-find { display: flex; align-items: center; gap: 6px; }
.lz-find-input {
  width: 190px; height: 28px; padding: 0 9px;
  font: inherit; font-size: 13px;
  color: var(--lz-ink);
  background: var(--lz-surface);
  border: 1px solid var(--lz-rule); border-radius: 5px;
}
.lz-find-input::placeholder { color: var(--lz-muted); }
.lz-find-input:focus-visible { outline: 2px solid var(--lz-accent); outline-offset: 1px; }
.lz-find-count {
  font-size: 12px; color: var(--lz-muted);
  min-width: 68px; font-variant-numeric: tabular-nums;
}

.lz-results {
  flex: 0 0 auto; max-height: 34%; overflow-y: auto;
  border-top: 1px solid var(--lz-rule);
  background: var(--lz-surface);
}
.lz-result {
  display: block; width: 100%; text-align: left;
  padding: 8px 14px; min-height: 28px;
  font: inherit; font-size: 13.5px; color: var(--lz-ink);
  background: none; border: 0; border-bottom: 1px solid var(--lz-rule);
  cursor: pointer;
}
.lz-result:hover { background: var(--lz-bg); }
.lz-result:focus-visible { outline: 2px solid var(--lz-accent); outline-offset: -2px; }
.lz-result b { color: var(--lz-accent); margin-right: 8px; font-variant-numeric: tabular-nums; }
.lz-result span { color: var(--lz-muted); }

/* --- surlignage : posé en pourcentages, donc valable à tout niveau et tout zoom --- */
.lz-marks { position: absolute; inset: 0; pointer-events: none; }
.lz-mark {
  position: absolute;
  background: color-mix(in srgb, var(--lz-accent) 32%, transparent);
  outline: 1px solid color-mix(in srgb, var(--lz-accent) 65%, transparent);
  border-radius: 1px;
  mix-blend-mode: multiply;
}
@media (prefers-color-scheme: dark) {
  :root:not([data-theme="light"]) .lz-mark { mix-blend-mode: screen; }
}


/* --- modes d'affichage ---------------------------------------------------
   Trois reglages qui appartiennent au LECTEUR : une page ou deux, miniatures
   en bas, a gauche, ou nulle part. Ils passent par des attributs sur la racine
   (`data-pages`, `data-vignettes`), donc toute l'apparence reste decrite ici.  */

.lz-sep {
  width: 1px; height: 18px; margin: 0 2px;
  background: var(--lz-rule); flex: none;
}
.lz-modes { display: inline-flex; gap: 2px; }
/* Les boutons de mode portent un dessin, pas du texte : ils doivent etre
   carres, sinon la barre se deforme selon la largeur du glyphe. */
.lz-modes .lz-btn { display: inline-grid; place-items: center; padding: 0; width: 30px; }
/* Le mode actif se voit : sans ca, cinq boutons identiques ne disent jamais
   dans quel etat on se trouve. */
/* SEUL ENDROIT OU L'ACCENT EST UN FOND PLEIN, donc le seul qui demande les
   deux autres variables de marque : `--marque-plein` est la couleur telle que
   l'editeur l'a choisie — c'est la qu'il la reconnait — et `--marque-encre`
   l'encre calculee pour tenir 4,5:1 dessus. Du blanc en dur rendrait un bouton
   jaune illisible. */
.lz-modes .lz-btn[aria-pressed="true"] {
  background: var(--marque-plein, var(--lz-accent));
  color: var(--marque-encre, #fff);
  border-color: var(--marque-plein, var(--lz-accent));
}

/* Miniatures a gauche : la colonne defile verticalement et la scene prend ce
   qui reste. On bascule la direction du conteneur plutot que de repositionner
   chaque bloc -- une seule regle, et l'ordre du DOM reste inchange pour le
   clavier et les lecteurs d'ecran. */
.lz[data-vignettes="gauche"] {
  display: grid;
  grid-template-columns: auto 1fr;
  grid-template-rows: auto 1fr auto;
}
.lz[data-vignettes="gauche"] .lz-bar { grid-column: 1 / -1; }
.lz[data-vignettes="gauche"] .lz-results { grid-column: 1 / -1; }
.lz[data-vignettes="gauche"] .lz-strip {
  grid-row: 2 / 3; grid-column: 1;
  flex-direction: column;
  width: 84px; height: auto;
  overflow-x: hidden; overflow-y: auto;
  border-top: 0; border-right: 1px solid var(--lz-rule);
}
.lz[data-vignettes="gauche"] .lz-stage { grid-row: 2 / 3; grid-column: 2; }

@media (max-width: 640px) {
  /* Sur un telephone, une colonne de miniatures mange la moitie de la largeur
     utile : on la repose en bas, quel que soit le reglage. */
  .lz[data-vignettes="gauche"] { display: flex; }
  .lz[data-vignettes="gauche"] .lz-strip {
    flex-direction: row; width: auto;
    border-right: 0; border-top: 1px solid var(--lz-rule);
    overflow-x: auto; overflow-y: hidden;
  }
}


/* --- sommaire ------------------------------------------------------------
   Les signets du PDF, ouverts depuis la barre d'outils.

   IL SE POSE PAR-DESSUS LA SCENE, et c'est le point a ne pas defaire. Les
   miniatures occupent deja le bas ou la gauche selon la preference du lecteur,
   et la scene est exactement la surface qui reste : un panneau qui prendrait
   une colonne ou une rangee de plus obligerait a remesurer la planche a chaque
   ouverture — donc a la faire sauter — et il faudrait en plus arbitrer avec la
   bande laterale. Pose DANS la scene, il ne negocie rien : il est deja a la
   bonne place, deja borne a la bonne hauteur, et il se range sans rien bouger.

   La scene est `position: relative` et `overflow: hidden` depuis le depart : le
   panneau est donc cadre par elle, sans une seule mesure en JavaScript.        */

.lz-toc {
  position: absolute; z-index: 6;
  top: 8px; left: 8px;
  display: flex; flex-direction: column;
  width: min(320px, calc(100% - 16px));
  max-height: calc(100% - 16px);
  background: var(--lz-surface);
  border: 1px solid var(--lz-rule); border-radius: 10px;
  box-shadow: var(--lz-shadow);
  /* La scene entiere est cliquable pour tourner la page ; le panneau, non. */
  cursor: default; text-align: left;
}
/* Sens de lecture de droite a gauche : le panneau change de bord, comme le coin
   corne. */
.lz[data-rtl] .lz-toc { left: auto; right: 8px; }
/* Il recoit le focus quand on l'ouvre, et un clic sur son propre fond le
   designe lui-meme — c'est ce qui l'empeche de se refermer sous le doigt. */
.lz-toc:focus-visible { outline: 2px solid var(--lz-accent); outline-offset: -3px; }

.lz-toc-bar {
  display: flex; align-items: center; justify-content: space-between; gap: 8px;
  flex: 0 0 auto;
  padding: 7px 7px 7px 12px;
  border-bottom: 1px solid var(--lz-rule);
}
.lz-toc-h { font-size: 13px; font-weight: 600; }

/* UN SOMMAIRE PEUT ETRE ENORME : 300 entrees sur un catalogue, et c'est normal.
   Il defile dans le panneau, et son defilement ne se propage pas a la page qui
   l'entoure -- le lecteur est embarque en iframe, et une roulette qui traverse
   fait bouger le site du client. */
.lz-toc-body {
  flex: 1 1 auto; min-height: 0;
  overflow-y: auto; overscroll-behavior: contain;
  padding: 5px 0 7px;
  scrollbar-width: thin;
}
.lz-toc-list { margin: 0; padding: 0; list-style: none; }

.lz-toc-entry {
  display: flex; align-items: baseline; gap: 10px;
  width: 100%; min-height: 30px;          /* > 24 px exigés par WCAG 2.5.8 */
  /* LE RETRAIT EST CALCULE A PARTIR D'UN SEUL NOMBRE, pose par le JavaScript
     sur chaque entree (`--lz-niv`, borne a SOMMAIRE_NIVEAUX). Une regle couvre
     donc toutes les profondeurs, au lieu d'un selecteur par niveau. */
  padding: 6px 12px 6px calc(12px + var(--lz-niv, 0) * 14px);
  font: inherit; font-size: 13.5px; text-align: left;
  color: var(--lz-ink); background: none; border: 0;
  cursor: pointer;
}
.lz-toc-entry:hover { background: var(--lz-bg); }
.lz-toc-entry:focus-visible { outline: 2px solid var(--lz-accent); outline-offset: -2px; }
/* Un titre de signet est une information : il passe a la ligne, il ne se
   tronque pas. `anywhere` couvre le cas du mot interminable d'un PDF technique,
   qui sinon elargirait le panneau. */
.lz-toc-label { flex: 1 1 auto; overflow-wrap: anywhere; }
.lz-toc-page {
  flex: 0 0 auto; color: var(--lz-muted);
  font-size: 12px; font-variant-numeric: tabular-nums;
}

@media (max-width: 640px) {
  /* Sur un telephone, 320 px de panneau sur 360 px d'ecran : autant prendre la
     largeur utile franchement, et laisser voir qu'il y a une page derriere. */
  .lz-toc { width: calc(100% - 12px); top: 6px; left: 6px; max-height: calc(100% - 12px); }
  .lz[data-rtl] .lz-toc { left: auto; right: 6px; }
}


/* ==========================================================================
   EFFET DE PASSAGE D'UNE PLANCHE A L'AUTRE
   ==========================================================================

   D'ou ca vient : VEKA a compare Lizio a un concurrent et prefere le
   concurrent « pour les effets de lecture » (26/10/2026). Le constat etait
   juste — changer de planche REMPLACAIT le contenu, sans rien entre les deux.
   Chez le concurrent, le document a une epaisseur, un coin corne, et la page se
   tourne.

   PREMIERE REPONSE, PREMIER REFUS. La version precedente faisait pivoter un
   PLAN RIGIDE autour d'une charniere, en une seule `rotateY`. Verdict du
   proprietaire du produit : « c'est tres, tres moyen, c'est pas ce que
   j'appelle feuillete ». Il avait raison — un plan rigide qui bascule est un
   carton, et une feuille de papier n'est jamais plate pendant qu'on la tourne.
   D'ou le moteur a bandes de `feuilletage.js`, et d'ou le partage ci-dessous.

   SIX REGLAGES, portes par `data-effect` sur la racine, que l'editeur choisit
   par publication (`publications.reader_effect`) :

     flip      magazine : papier souple, se bombe beaucoup, rapide — le defaut
     book      livre relie : feuille plus raide, plus lente, fond de cahier
     album     album : pages rigides et epaisses, bascule lente et lourde
     notebook  carnet : on tourne PAR LE HAUT
     slide     la planche glisse — ce n'est pas un feuilletage
     none      le comportement d'avant : remplacement sec

   Les quatre premiers portent en plus `data-turn="on"` sur la racine. C'est lui
   que lisent l'epaisseur du bloc, le coin corne et la perspective : sans lui,
   chaque selecteur devrait recopier la liste des modes, et en ajouter un
   obligerait a tous les retrouver.

   CE QUI EST ICI ET CE QUI N'Y EST PAS. L'APPARENCE est ici — fond, degrades,
   ombres, tranches, charnieres, empilement. Le MOUVEMENT d'un feuilletage ne
   peut pas y etre : il fait varier EN MEME TEMPS la rotation de la charniere,
   la courbure de la feuille, l'eclairement de chaque bande et la projection de
   l'ombre portee, et aucune courbe de Bezier ne sait faire ca. Ces valeurs-la
   vivent dans la table des modes de `feuilletage.js`, qui ecrit les `transform`
   image par image. `slide`, lui, est un deplacement rigide : son animation est
   decrite ici et jouee par le seul compositeur.

   Ce qu'on ne fait toujours PAS : aucune bibliotheque, aucune toile, aucun
   WebGL. Ce paquet est embarque chez des tiers pour des annees et chaque
   kilo-octet est paye par chaque lecteur de chaque publication — la 3D de CSS
   suffit, et c'est le compositeur qui fait la projection, l'interpolation et le
   texte net, gratuitement. */

/* Le glissement est le SEUL effet dont la duree vive ici : c'est un
   deplacement rigide, qu'une courbe de Bezier decrit entierement. Les durees
   des feuilletages sont dans la table des modes de `feuilletage.js`, avec la
   courbure et la raideur du decollement — elles ne se reglent pas separement. */
.lz {
  --lz-slide:      360ms;
  --lz-slide-ease: cubic-bezier(.3, .8, .3, 1);
}

/* Les tranches, le coin corne et la feuille qui tourne se posent DANS la
   planche. Elle devient donc leur reference, ce qui ne deplace rien : la
   planche est deja mesuree au pixel par le rendu. */
.lz-spread { position: relative; }

/* La perspective est sur la planche, pas sur la scene : elle doit suivre le
   zoom, qui transforme precisement la planche. Posee sur la scene, un document
   agrandi 2,5 fois se tournerait avec le recul d'un document a 100 %. */
.lz[data-turn="on"] .lz-spread {
  perspective: var(--lz-persp, 1800px);
  perspective-origin: 50% 50%;
}


/* --- L'EPAISSEUR DU BLOC DE PAGES ---------------------------------------
   Permanente, pas seulement pendant l'animation. C'est elle qui donne au
   document l'air d'un objet, et elle dit ou on en est sans un chiffre : le cote
   deja lu epaissit, le cote qui reste s'amincit.

   Des TRAITS, pas un bloc gris : une tranche de livre, c'est des bords de
   feuilles. D'ou le degrade repete, cale sur 2,5 px pour qu'on distingue les
   traits a tous les rapports de pixels. */
.lz[data-turn="on"] .lz-spread::before,
.lz[data-turn="on"] .lz-spread::after {
  content: "";
  position: absolute;
  top: 1.2%; bottom: 1.2%;
  pointer-events: none;
  background-color: var(--lz-surface);
  background-image: repeating-linear-gradient(to right,
      color-mix(in srgb, var(--lz-ink) 30%, transparent) 0 1px,
      color-mix(in srgb, var(--lz-ink) 5%, transparent) 1px 2.5px);
  /* Le passage d'une planche a l'autre fait varier la tranche de un ou deux
     pixels : qu'ils glissent plutot que de sauter. */
  transition: width .32s ease-out;
}
/* Ce qui est deja lu. Largeur nulle sur la premiere planche : un livre qu'on
   vient d'ouvrir n'a rien a gauche, et le dire est plus honnete que de poser
   une tranche de principe. */
.lz[data-turn="on"] .lz-spread::before {
  right: 100%; width: var(--lz-edge-l, 0px);
  border-radius: 3px 0 0 3px;
  box-shadow: -1px 1px 3px rgba(12, 9, 18, .22);
}
/* Ce qui reste a lire. */
.lz[data-turn="on"] .lz-spread::after {
  left: 100%; width: var(--lz-edge-r, 0px);
  border-radius: 0 3px 3px 0;
  box-shadow: 1px 1px 3px rgba(12, 9, 18, .22);
}

/* L'EPAISSEUR, ETEINTE PAR L'EDITEUR.

   Un catalogue de mode veut la page qui se tourne et pas la tranche d'un
   annuaire : c'est un reglage par publication (`publications.reader_edges`),
   que `reader.js` traduit en attribut.

   `content: none` et pas une largeur nulle : les deux tranches portent une
   ombre portee, qui reste parfaitement visible sur un element large de zero
   pixel -- on voyait alors deux traits gris flotter de chaque cote de la page.
   Pas `display: none` non plus : sur un pseudo-element, retirer le `content`
   est ce qui l'empeche d'exister. */
.lz[data-edges="off"][data-turn="on"] .lz-spread::before,
.lz[data-edges="off"][data-turn="on"] .lz-spread::after { content: none; }


/* --- LA FEUILLE QUI TOURNE, ET SES BANDES -------------------------------
   C'est la planche QUI S'EN VA. La planche qui ARRIVE, elle, est deja en place,
   a plat, dessous — donc le zoom, le surlignage, les zones cliquables et le
   prechargement travaillent sur des pages ordinaires, jamais sur un element
   anime. C'est la raison de ce choix, et elle n'a pas bouge : l'animation ne
   touche a rien de ce qui marche.

   DEUX FORMES DE FEUILLE, selon l'effet :

   — un FEUILLETAGE la decoupe en BANDES (`data-axe` est pose). La feuille
     elle-meme ne peint alors plus rien : elle n'est qu'un repere 3D. Ce sont
     les bandes qui portent l'image, chacune avec son propre angle — et c'est
     exactement ca, courber une page.
   — un GLISSEMENT garde la planche entiere (`data-axe` absent) : elle porte ses
     pages, son fond et son ombre, et une animation CSS la deplace. */
.lz-sheet {
  position: absolute;
  top: 50%;                 /* recentre par marginTop, pose par le rendu :
                               `transform` est deja pris par la rotation */
  z-index: 3;
}
/* La feuille d'un GLISSEMENT : elle porte ses pages, donc elle se peint. */
.lz-sheet:not([data-axe]) {
  display: flex;
  background: var(--lz-surface);
  backface-visibility: hidden;
  box-shadow: var(--lz-shadow);
}
/* La feuille d'un FEUILLETAGE : un repere, et rien d'autre.

   `preserve-3d` n'est pas un ornement : sans lui, les bandes seraient projetees
   a plat dans le plan de la feuille et la courbure disparaitrait purement et
   simplement — on retomberait trait pour trait sur le carton qu'on cherche a
   quitter. C'est aussi la raison pour laquelle le fondu de fin est pose sur
   chaque bande et jamais sur la feuille : une `opacity` sur un element en
   `preserve-3d` le ramene a plat (voir Tournage.poser). */
.lz-sheet[data-axe]:not([data-rendu="rouleau"]) { transform-style: preserve-3d; }

/* LA FEUILLE PEINTE SUR UNE TOILE — modes souples (magazine, livre).

   Ici il n'y a ni bande ni repere 3D : une seule toile transparente, posee
   par-dessus la planche, ou le moteur dessine la feuille tranche par tranche
   (voir rouleau.js). Donc PAS de `preserve-3d` : il ne servirait a rien et
   couterait un contexte d'empilement de plus.

   LA TOILE DEBORDE DE LA FEUILLE, des deux cotes — une largeur de page vers la
   reliure, un septieme de hauteur en haut et en bas. Ses decalages sont poses
   par le moteur, qui seul connait ces marges. Ce qui sort de la planche est
   coupe par la scene, comme pour les bandes. */
.lz-sheet--toile { transform-style: flat; }
.lz-sheet--toile > canvas {
  position: absolute;
  display: block;
  pointer-events: none;
}

/* LES BANDES.

   Toutes posees SUR LA CHARNIERE, et ecartees par leur seule transformation :
   c'est ce qui rend le calcul identique dans les deux sens de lecture et sur
   les deux axes. Leur origine de transformation est donc le bord de la
   charniere, et leur contenu est decale pour montrer le bon morceau de page
   (voir construireFeuille).

   `backface-visibility: hidden` fait tout le travail du passage a la verticale.
   Au-dela de 90 degres une bande montre son dos et s'efface, pendant que la
   bande de VERSO posee au meme endroit apparait. A 90 degres pile, toutes deux
   sont vues par la tranche, donc larges de zero pixel : l'echange ne se voit
   pas. La page se retourne ainsi bande par bande, du bord libre vers la
   charniere — et on n'a jamais a peindre l'image a l'envers. */
.lz-band {
  position: absolute;
  pointer-events: none;
  backface-visibility: hidden;
  background-repeat: no-repeat;
  will-change: transform;
}
.lz-sheet[data-axe="y"] .lz-band { top: 0; height: 100%; }
.lz-sheet[data-axe="x"] .lz-band { left: 0; width: 100%; }
.lz-sheet[data-axe="y"][data-sens="next"] .lz-band { left: 0;    transform-origin: 0 50%; }
.lz-sheet[data-axe="y"][data-sens="prev"] .lz-band { right: 0;   transform-origin: 100% 50%; }
.lz-sheet[data-axe="x"][data-sens="next"] .lz-band { top: 0;     transform-origin: 50% 0; }
.lz-sheet[data-axe="x"][data-sens="prev"] .lz-band { bottom: 0;  transform-origin: 50% 100%; }

/* LE DOS DE LA PAGE : du papier, et pas l'image retournee.

   Peindre la face a l'envers serait un contresens — le dos d'une page n'est pas
   sa face —, et peindre la page SUIVANTE obligerait a la dupliquer au moment
   precis ou l'animation demarre. Un degrade de papier est juste, et gratuit :
   on ne le voit jamais de face, seulement de biais, le temps que la page passe.
   Il est volontairement INDEPENDANT DU THEME, comme le coin corne : c'est le
   verso de la PAGE, pas un morceau de l'habillage. */
.lz-band--verso {
  background-image: linear-gradient(100deg, #f8f6f3, #ece8e2 52%, #ded9d1);
}

/* L'OMBRAGE ET LE REFLET, poses a chaque image par le moteur.

   Ce sont EUX qui font lire la bosse : de face, un arc et un plan se
   ressemblent beaucoup, et c'est le gradient de lumiere en travers de la page
   qui dit lequel on regarde. L'ombre de pliure n'est donc plus un degrade fixe
   qui s'allume — elle SE DEPLACE avec la courbure, bande par bande.

   Deux pseudo-elements plutot que deux enfants : une bande doit rester UN seul
   element, sinon c'est le double de noeuds a transformer a chaque image. */
.lz-band::before,
.lz-band::after {
  content: "";
  position: absolute; inset: 0;
  pointer-events: none;
}
.lz-band::after  { background: #0a0711; opacity: var(--lz-o, 0); }
.lz-band::before { background: #ffffff; opacity: var(--lz-e, 0); z-index: 1; }

/* L'EPAISSEUR DE LA FEUILLE ELLE-MEME — un album, pas un magazine.

   Un trait sombre sous chaque bande et un trait clair dessus. Peints dans le
   PLAN de la bande, ils tournent avec elle et se lisent comme la tranche d'un
   carton. Seuls les modes qui ont une epaisseur posent l'attribut : les modes
   souples ne paient donc pas une ombre invisible a chaque image. */
.lz-sheet[data-epais] .lz-band {
  box-shadow:
    0 var(--lz-tranche, 0px) 0 rgba(28, 22, 40, .42),
    0 calc(var(--lz-tranche, 0px) / -3) 0 rgba(255, 255, 255, .36);
}

/* L'OMBRE PORTEE sur la page qu'on decouvre.

   Elle vit dans la planche et non dans la feuille : elle appartient a ce qu'on
   devoile, et sa boite est celle de la feuille, posee par le rendu — l'ombre
   tombe la ou la page etait, pas sur toute la planche. Sur un document ou la
   couverture est deux fois moins large que la double page suivante, la
   difference saute aux yeux.

   ELLE SUIT LE BORD DE LA FEUILLE, et c'est tout l'interet. Un degrade fixe
   serait sombre a la charniere, c'est-a-dire sous la feuille, donc invisible —
   alors que l'ombre d'une page qui se leve se tient le long de son bord LIBRE,
   qui balaye la planche a mesure que la page se redresse. On met donc le noir
   au bord libre, et c'est le moteur qui retrecit l'ombre : il connait la
   PROJECTION REELLE de l'arc sur la planche, au lieu de recopier des cosinus
   dans des paliers d'animation.

   Elle n'existe que pour un feuilletage. Un glissement n'a pas de page qui se
   leve, donc rien a projeter : lui en poser une laissait un voile sombre
   immobile par-dessus la planche qui arrive, pendant toute la duree du
   mouvement. */
.lz-cast {
  position: absolute;
  top: 50%;
  z-index: 1;
  pointer-events: none;
}
.lz-cast[data-axe="y"][data-sens="next"] {
  transform-origin: left center;
  background: linear-gradient(to left, rgba(8, 6, 12, .55), rgba(8, 6, 12, 0) 48%);
}
.lz-cast[data-axe="y"][data-sens="prev"] {
  transform-origin: right center;
  background: linear-gradient(to right, rgba(8, 6, 12, .55), rgba(8, 6, 12, 0) 48%);
}
.lz-cast[data-axe="x"][data-sens="next"] {
  transform-origin: center top;
  background: linear-gradient(to top, rgba(8, 6, 12, .55), rgba(8, 6, 12, 0) 48%);
}
.lz-cast[data-axe="x"][data-sens="prev"] {
  transform-origin: center bottom;
  background: linear-gradient(to bottom, rgba(8, 6, 12, .55), rgba(8, 6, 12, 0) 48%);
}

/* LA PAGE D'EN FACE QUI S'EN VA — double page reliee seulement.

   Elle n'est plus dans la planche : le rendu l'a remplacee par la nouvelle des
   la premiere image du mouvement. On la repose donc telle quelle, a sa place,
   SOUS le feuillet qui tourne et AU-DESSUS de la planche d'arrivee, et on la
   retire quand le dos du feuillet est venu la recouvrir. Sans elle, on verrait
   la page de gauche changer AVANT que le feuillet ne se pose dessus — l'exact
   inverse de ce qui se passe dans un livre.

   Elle est au niveau 2 : au-dessus de l'ombre portee (1), sous la feuille (3). */
.lz-rest {
  position: absolute;
  top: 50%;
  z-index: 2;
  pointer-events: none;
  background-repeat: no-repeat;
  background-color: var(--lz-surface);
}


/* L'OMBRE DE PLIURE, ETEINTE PAR L'EDITEUR (`publications.reader_fold`).

   Elle n'a plus de regle ici, et ce n'est pas un oubli : elle n'est plus un
   degrade pose sur la feuille mais l'eclairement de chaque bande, calcule a
   partir de l'angle. Le reglage part donc au moteur (`relief`), qui ramene
   l'ombrage et le reflet a zero. Le tournage, lui, n'est pas touche : la page
   se courbe exactement pareil, sans la lumiere qui la balaye. */


/* --- slide : la planche glisse ------------------------------------------
   La planche sortante s'en va, la planche entrante arrive de l'autre bord. Le
   fondu de la fin n'est pas un effet de plus : la scene est souvent plus large
   que la planche, donc un deplacement de 100 % de sa largeur ne suffit pas
   toujours a la sortir du champ. Sans le fondu, elle disparaitrait d'un coup au
   moment ou on la retire. */
@keyframes lz-slide-out-next {
  0%   { transform: translateX(0);       opacity: 1 }
  72%  {                                 opacity: 1 }
  100% { transform: translateX(-112%);   opacity: 0 }
}
@keyframes lz-slide-out-prev {
  0%   { transform: translateX(0);       opacity: 1 }
  72%  {                                 opacity: 1 }
  100% { transform: translateX(112%);    opacity: 0 }
}
@keyframes lz-slide-in-next {
  0%   { transform: translateX(112%);    opacity: .35 }
  34%  {                                 opacity: 1 }
  100% { transform: translateX(0);       opacity: 1 }
}
@keyframes lz-slide-in-prev {
  0%   { transform: translateX(-112%);   opacity: .35 }
  34%  {                                 opacity: 1 }
  100% { transform: translateX(0);       opacity: 1 }
}
.lz[data-effect="slide"] .lz-sheet[data-sens="next"] {
  animation: lz-slide-out-next var(--lz-slide) var(--lz-slide-ease) both;
}
.lz[data-effect="slide"] .lz-sheet[data-sens="prev"] {
  animation: lz-slide-out-prev var(--lz-slide) var(--lz-slide-ease) both;
}
/* La planche qui arrive glisse elle aussi : le `transform` se pose sur les
   PAGES, jamais sur la planche, qui porte deja celui du zoom.

   ENFANTS DIRECTS, et c'est indispensable : la feuille qui s'en va est elle
   aussi dans la planche, et ses pages sont donc des `.lz-leaf`. Sans le `>`,
   elles prenaient l'animation d'ENTREE par-dessus la sortie de la feuille, et
   la planche sortante partait de travers. */
.lz[data-effect="slide"] .lz-spread[data-anim="next"] > .lz-leaf {
  animation: lz-slide-in-next var(--lz-slide) var(--lz-slide-ease) both;
}
.lz[data-effect="slide"] .lz-spread[data-anim="prev"] > .lz-leaf {
  animation: lz-slide-in-prev var(--lz-slide) var(--lz-slide-ease) both;
}


/* --- LE COIN CORNE ------------------------------------------------------
   Un ornement, et une invitation : chez le concurrent c'est lui qui dit qu'on
   peut tourner la page, avant meme d'avoir cherche un bouton. Il est donc
   cliquable, et il mene exactement la ou mene « Planche suivante ».

   Sa taille est posee par le rendu (`--lz-coin`), en pixels et carree : une
   taille en pourcentage donnerait un pourcentage de la LARGEUR pour `width` et
   un pourcentage de la HAUTEUR pour `height`, donc un coin de travers.

   Le pli est dessine par un degrade coupe net a 50 % : la frontiere d'un degrade
   a 315° est une droite du coin bas-gauche au coin haut-droit, exactement la
   ligne de pli d'un coin bas-droit. `drop-shadow` suit la forme VISIBLE et non
   la boite, donc l'ombre se pose le long du pli et pas autour d'un carre. */
.lz-corner {
  position: absolute;
  right: 0; bottom: 0;
  z-index: 4;
  width: var(--lz-coin, 38px); height: var(--lz-coin, 38px);
  padding: 0; border: 0;
  /* INDEPENDANT DU THEME, et c'est voulu. Le coin corne est le verso de la PAGE,
     pas un morceau de l'habillage : il se pose sur l'image du document, qui est
     la meme en clair et en sombre. Teinte en `--lz-surface`, il devenait un
     triangle fonce sur une page blanche des que le visiteur lisait en sombre.
     Un gris papier tient sur les deux. */
  background:
    linear-gradient(315deg, rgba(255, 255, 255, .55) 0 18%, rgba(255, 255, 255, 0) 18%),
    linear-gradient(315deg,
        rgba(213, 211, 219, .95) 0 47%,
        rgba(126, 122, 136, .95) 47% 50%,
        transparent 50%);
  filter: drop-shadow(-1px -1px 2px rgba(10, 7, 16, .34));
  cursor: pointer;
  transition: width .16s ease-out, height .16s ease-out;
}
.lz-corner:hover {
  width: calc(var(--lz-coin, 38px) * 1.3);
  height: calc(var(--lz-coin, 38px) * 1.3);
}
/* Sens de lecture de droite a gauche : on tourne par l'autre coin. */
.lz[data-rtl] .lz-corner {
  right: auto; left: 0;
  background:
    linear-gradient(45deg, rgba(255, 255, 255, .55) 0 18%, rgba(255, 255, 255, 0) 18%),
    linear-gradient(45deg,
        rgba(213, 211, 219, .95) 0 47%,
        rgba(126, 122, 136, .95) 47% 50%,
        transparent 50%);
  filter: drop-shadow(1px -1px 2px rgba(10, 7, 16, .34));
}
/* Pendant le tour de page, le coin appartient a une planche qu'on ne voit pas
   encore : il s'efface le temps du mouvement plutot que de flotter au-dessus de
   la feuille qui tourne. */
.lz-spread[data-anim] .lz-corner { opacity: 0; }


/* --- mouvement reduit ---------------------------------------------------
   Le reglage de l'editeur ne prime JAMAIS sur la demande du visiteur : le
   JavaScript ne fabrique meme pas de feuille quand `prefers-reduced-motion` est
   pose (voir _preleverPlanche), et la regle generale de ce fichier ramene de
   toute facon toute animation a une duree nulle.

   L'epaisseur et le coin corne, eux, RESTENT : ils ne bougent pas, et personne
   n'a demande moins d'epaisseur. On coupe seulement leurs transitions, ce que la
   regle generale fait deja. */


/* ==========================================================================
   UNE COMMANDE ETEINTE PAR L'EDITEUR DISPARAIT VRAIMENT
   ==========================================================================

   `reader.js` pose `hidden` sur les commandes que l'editeur a retirees de la
   barre (voir _masquerLesCommandes). Or `[hidden]` ne vaut que `display: none`
   dans la feuille du navigateur : `.lz-btn { display: inline-flex }` et
   `.lz-modes .lz-btn { display: inline-grid }` l'emportent toutes les deux, et
   les boutons restaient a l'ecran malgre l'attribut.

   D'ou `!important`, qui est ici le bon outil plutot qu'un defaut : c'est une
   regle d'EXISTENCE, pas de presentation, et aucune autre regle de ce fichier
   ne doit pouvoir la contredire. Elle vaut aussi pour la bande de vignettes,
   deja masquee de cette facon par la preference du visiteur. */
.lz [hidden] { display: none !important; }
