/**
 * NEF HeadSlider — estilos públicos.
 *
 * LA CUADRÍCULA
 *
 * El escenario mide exactamente lo que midiese el diseño original (1280 × 672
 * en el de la portada) y las capas se colocan encima en píxeles. Después se
 * encoge el conjunto entero con un scale(), que el JavaScript calcula según el
 * ancho disponible.
 *
 * Se hace así, y no recalculando cada capa en porcentajes, porque las capas
 * están colocadas con decimales (x = 657.984375). En porcentajes, cualquier
 * redondeo las movería un par de píxeles y el diseño dejaría de ser el mismo.
 *
 * LAS ANIMACIONES
 *
 * Cada capa trae sus propias variables (--nefhs-tr-entra, --nefhs-d-entra…)
 * escritas por PHP en su atributo style. El JavaScript solo pone y quita la
 * clase is-activa; de animar se encarga el navegador, con transiciones y sus
 * retardos. Con treinta capas en pantalla, eso es la diferencia entre ir suave
 * y ir a trompicones.
 */

.nefhs {
    --nefhs-ancho: 1280;
    --nefhs-alto: 672;
    --nefhs-escala: 1;

    position: relative;
    box-sizing: border-box;
    width: 100%;
    /* Ni un píxel de barra horizontal mientras se calcula la escala. */
    overflow: hidden;
    -webkit-user-select: none;
    user-select: none;
}

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

/* -------------------------------------------------------------------------
 * Los botones, a cero
 * ---------------------------------------------------------------------- */

/* Un slider acaba metido en cualquier tema, y los temas tienen manía a los
   botones. El de la tienda (Aurel, a través de kube.css) le pone a TODO
   `button` un `min-height: 40px`, un fondo azul y 8px 20px de relleno. Como
   `min-height` gana a la altura que se ponga después, los puntos de paginación
   salían como huevos: nueve píxeles de ancho y cuarenta de alto.
   De ahí que aquí se ponga a cero todo lo que un tema suele tocar, antes de
   dar a cada botón su forma. */
.nefhs .nefhs-flecha,
.nefhs .nefhs-punto {
    min-width: 0;
    min-height: 0;
    max-width: none;
    max-height: none;
    margin: 0;
    padding: 0;
    border: 0;
    outline: none;
    background: none;
    box-shadow: none;
    font: inherit;
    line-height: 0;
    text-transform: none;
    letter-spacing: normal;
    flex: 0 0 auto;
    -webkit-appearance: none;
    appearance: none;
}

/* -------------------------------------------------------------------------
 * El marco y el escenario
 * ---------------------------------------------------------------------- */

.nefhs-marco {
    position: relative;
    width: 100%;
    overflow: hidden;

    /* La altura se calcula sola a partir de la escala. Antes de que el
       JavaScript arranque, la proporción ya es la correcta gracias a esto, así
       que la página no da el salto típico al terminar de cargar. */
    height: calc(var(--nefhs-alto) * 1px * var(--nefhs-escala));
}

.nefhs-escenario {
    position: relative;
    width: calc(var(--nefhs-ancho) * 1px);
    height: calc(var(--nefhs-alto) * 1px);

    /* Desde la esquina de arriba a la izquierda: así el escenario encogido
       sigue empezando donde empieza el marco. */
    transform: scale(var(--nefhs-escala));
    transform-origin: top left;
}

/* -------------------------------------------------------------------------
 * Diapositivas
 * ---------------------------------------------------------------------- */

.nefhs-diapositiva {
    position: absolute;
    inset: 0;

    /* La transición entre diapositivas es un fundido: es lo que tiene puesto
       el slider de la portada (trView: fade). */
    opacity: 0;
    visibility: hidden;
    transition: opacity var(--nefhs-ms, 600ms) ease, visibility 0s linear var(--nefhs-ms, 600ms);
}

.nefhs-diapositiva.is-activa {
    opacity: 1;
    visibility: visible;
    z-index: 2;
    transition: opacity var(--nefhs-ms, 600ms) ease, visibility 0s;
}

.nefhs-fondo {
    position: absolute;
    inset: 0;
    background-position: center center;
    background-repeat: no-repeat;

    /* fillMode "fill" de MasterSlider: la imagen cubre el escenario entero. */
    background-size: cover;
}

/* Los otros modos de encaje que entiende MasterSlider. */
.nefhs-fondo--fit    { background-size: contain; }
.nefhs-fondo--stretch { background-size: 100% 100%; }
.nefhs-fondo--center { background-size: auto; }
.nefhs-fondo--tile   { background-size: auto; background-repeat: repeat; }

/* -------------------------------------------------------------------------
 * Vídeo de fondo
 * ---------------------------------------------------------------------- */

/* La diapositiva del theremin de la portada no es una imagen quieta: es un
   vídeo en bucle y sin sonido. La imagen de fondo se queda debajo haciendo de
   cartel mientras el vídeo carga, así que si tarda o el navegador se niega a
   reproducirlo, se sigue viendo lo que se veía antes. */
.nefhs-video {
    position: absolute;
    inset: 0;
    width: 100%;
    height: 100%;
    max-width: none;
    border: 0;
    background: transparent;
    pointer-events: none;

    /* Sin esto, el vídeo se deforma: casi nunca tiene la misma proporción que
       el escenario. `cover` recorta, que es lo que hace MasterSlider con su
       fillMode "fill". */
    object-fit: cover;
}

.nefhs-video--fit     { object-fit: contain; }
.nefhs-video--stretch { object-fit: fill; }
.nefhs-video--center  { object-fit: none; }

/* -------------------------------------------------------------------------
 * La mini línea de tiempo del modo scroll
 * ---------------------------------------------------------------------- */

/* En modo scroll la página está retenida y la diapositiva no pasa sola: no
   queda ni una pista de por dónde se va. Esto es esa pista, y solo eso. No
   recibe el ratón, para no quitarle ni un píxel al arrastre ni a los enlaces
   de las capas que tenga debajo.

   Todo lo que se puede configurar llega en variables desde PHP, así que el
   JavaScript solo escribe `--nefhs-mini-p` (de 0 a 1) y de colocar la bolita se
   encarga el navegador. Las medidas van en píxeles de la cuadrícula de diseño:
   el escenario se encoge entero con su scale() y la barra se encoge con él.

   OJO AL NOMBRE: `.nefhs-mini` es esta barrita y nada más. La miniatura de
   cada diapositiva en el editor (admin/editar-ui.php) se llama
   `.nefhs-miniatura` justamente para no chocar con esto, porque su recuadro
   lleva la clase `nefhs` y le llegan estas reglas. */
.nefhs-mini {
    position: absolute;
    left: 50%;
    bottom: var(--nefhs-mini-abajo, 28px);
    width: var(--nefhs-mini-ancho, 320px);
    max-width: 90%;
    transform: translateX(-50%);
    pointer-events: none;

    /* Por encima de las capas, que van sin z-index y se apilan por orden. */
    z-index: 5;
}

.nefhs-mini-linea {
    position: relative;
    width: 100%;
    height: var(--nefhs-mini-grosor, 4px);
    border-radius: 999px;
    background: var(--nefhs-mini-color, rgba(255, 255, 255, 0.3));
}

/* Lo ya recorrido, en el color de la bolita: es lo que hace que de un vistazo
   se vea cuánto queda y no solo dónde se está. */
.nefhs-mini-visto {
    position: absolute;
    left: 0;
    top: 0;
    height: 100%;
    width: calc(var(--nefhs-mini-p, 0) * 100%);
    border-radius: inherit;
    background: var(--nefhs-mini-bola-color, #fff);
}

/* El -50% de la izquierda es lo que hace que la bolita empiece centrada en el
   extremo de la línea y acabe centrada en el otro, en vez de asomar media
   bolita por fuera al llegar al final. */
.nefhs-mini-bola {
    position: absolute;
    top: 50%;
    left: calc(var(--nefhs-mini-p, 0) * 100%);
    width: var(--nefhs-mini-bola, 14px);
    height: var(--nefhs-mini-bola, 14px);
    margin: 0;
    border-radius: 50%;
    transform: translate(-50%, -50%);
    background: var(--nefhs-mini-bola-color, #fff);
}

/* -------------------------------------------------------------------------
 * El aviso que late: «esta diapositiva se recorre»
 * ---------------------------------------------------------------------- */

/* La barrita de arriba dice por dónde se va; esto dice que se puede ir. Sale
   escondido y lo enseña el JavaScript al entrar la diapositiva, porque desde
   aquí no hay forma de saber cuándo entra.

   Dos elementos y no uno, y no es un capricho: el de fuera se centra con un
   translateX(-50%) y el de dentro es el que late. En el mismo elemento, la
   animación pisaría el centrado y el aviso se iría a la derecha en cada
   latido. */
.nefhs-aviso {
    position: absolute;
    left: 50%;
    bottom: var(--nefhs-aviso-abajo, 64px);
    transform: translateX(-50%);
    max-width: 90%;

    /* Un cartel centrado abajo, justo encima de donde se arrastra: si recibiera
       el ratón le quitaría el gesto al arrastre de toda la vida. */
    pointer-events: none;

    /* Por encima de las capas y de la barrita. */
    z-index: 6;

    opacity: 0;
    transition: opacity 0.45s ease;
}

.nefhs-aviso.is-visible {
    opacity: 1;
}

.nefhs-aviso-txt {
    display: inline-block;
    padding: var(--nefhs-aviso-relleno, 10px) calc(var(--nefhs-aviso-relleno, 10px) * 1.8);

    /* Sin familia puesta manda la que herede del tema, que es lo que hace que
       el aviso no desentone sin configurar nada. */
    font-family: var(--nefhs-aviso-fuente, inherit);
    font-size: var(--nefhs-aviso-tam, 16px);
    font-weight: var(--nefhs-aviso-peso, 600);
    line-height: 1.25;
    white-space: nowrap;
    text-align: center;
    color: var(--nefhs-aviso-color, #fff);
    background: transparent;
}

.nefhs-aviso--con-fondo .nefhs-aviso-txt {
    background: var(--nefhs-aviso-fondo, rgba(0, 0, 0, 0.45));
}

/* Las tres formas. Sin fondo, el redondeo no se ve, pero se deja puesto igual:
   así encender el fondo no cambia nada más que el fondo. */
.nefhs-aviso--pildora .nefhs-aviso-txt { border-radius: 999px; }
.nefhs-aviso--caja    .nefhs-aviso-txt { border-radius: 10px; }
.nefhs-aviso--recta   .nefhs-aviso-txt { border-radius: 0; }

/* Los pulsos. Solo laten mientras el aviso se ve: una animación corriendo
   sobre un elemento a opacidad 0 le sigue costando al navegador un repintado
   por fotograma, y aquí al lado hay un vídeo saltando de fotograma en
   fotograma con el que no conviene competir. */
.nefhs-aviso.is-visible.nefhs-aviso--latido .nefhs-aviso-txt {
    animation: nefhs-aviso-latido 1.6s ease-in-out infinite;
}

.nefhs-aviso.is-visible.nefhs-aviso--flecha .nefhs-aviso-txt {
    animation: nefhs-aviso-flecha 1.6s ease-in-out infinite;
}

.nefhs-aviso.is-visible.nefhs-aviso--brillo .nefhs-aviso-txt {
    animation: nefhs-aviso-brillo 1.6s ease-in-out infinite;
}

@keyframes nefhs-aviso-latido {
    0%, 100% { transform: scale(1); }
    50%      { transform: scale(1.08); }
}

@keyframes nefhs-aviso-flecha {
    0%, 100% { transform: translateY(0); }
    50%      { transform: translateY(6px); }
}

@keyframes nefhs-aviso-brillo {
    0%, 100% { opacity: 1; }
    50%      { opacity: 0.45; }
}

/* Quien ha pedido que no se mueva nada no ve latir el aviso, pero SÍ lo ve:
   el texto es la información y el latido solo es la forma de llamar la
   atención. Quitar el cartel entero sería quitarle el aviso a quien más lo
   necesita. */
@media (prefers-reduced-motion: reduce) {
    .nefhs-aviso .nefhs-aviso-txt {
        animation: none;
    }
}

/* -------------------------------------------------------------------------
 * Tinte de color
 * ---------------------------------------------------------------------- */

.nefhs-tinte {
    position: absolute;
    inset: 0;
    pointer-events: none;
}

.nefhs-enlace {
    position: absolute;
    inset: 0;
    display: block;
    text-decoration: none;
}

/* -------------------------------------------------------------------------
 * Capas
 * ---------------------------------------------------------------------- */

.nefhs-capa {
    position: absolute;

    /* Estado de partida: donde la capa está ANTES de entrar. */
    transform: var(--nefhs-tr-entra, none);
    opacity: var(--nefhs-op-entra, 0);

    /* Nada de transición mientras la diapositiva no está activa: si la hubiera,
       las capas se animarían de vuelta a su sitio al salir y se vería el
       movimiento al revés. */
    transition: none;
}

/* Cuando la diapositiva se activa, cada capa se va a su sitio con su propio
   retardo. Los retardos aquí llegan a 8,5 segundos, y por eso conviene que los
   lleve el navegador y no una lista de temporizadores. */
.nefhs-diapositiva.is-activa .nefhs-capa,
.nefhs-fijas .nefhs-capa {
    transform: none;
    opacity: 1;
    /* El fundido lleva su propio reloj: `--nefhs-of-*` es lo que dura la curva
       y `--nefhs-od-*` cuándo empieza. Cuando no vienen puestas, valen las del
       movimiento y el fundido ocupa la animación entera, que es el fundido de
       toda la vida. */
    transition:
        transform var(--nefhs-t-entra, 0.6s) var(--nefhs-e-entra, ease) var(--nefhs-d-entra, 0s),
        opacity   var(--nefhs-of-entra, var(--nefhs-t-entra, 0.6s)) var(--nefhs-e-entra, ease) var(--nefhs-od-entra, var(--nefhs-d-entra, 0s));
}

/* Las capas que tienen salida propia la usan al marcharse. */
.nefhs-diapositiva.is-saliendo .nefhs-capa--con-salida {
    transform: var(--nefhs-tr-sale, none);
    opacity: var(--nefhs-op-sale, 0);
    transition:
        transform var(--nefhs-t-sale, 0.3s) var(--nefhs-e-sale, ease) var(--nefhs-d-sale, 0s),
        opacity   var(--nefhs-of-sale, var(--nefhs-t-sale, 0.3s)) var(--nefhs-e-sale, ease) var(--nefhs-od-sale, var(--nefhs-d-sale, 0s));
}

/* Apagada desde el editor. Se pinta igual pero no se ve. */
.nefhs-capa--oculta {
    display: none;
}

.nefhs-capa img {
    display: block;
    max-width: none;
    height: auto;
}

/* Una capa marcada como "no escalar" se compensa el encogido del conjunto, de
   modo que se queda a su tamaño real. Se usa para textos que no deben
   achicarse en pantallas pequeñas. */
.nefhs-capa--sin-escala {
    transform-origin: top left;
    zoom: calc(1 / var(--nefhs-escala));
}

/* Las capas fijas van por encima de todas las diapositivas y no cambian al
   pasar de una a otra. */
.nefhs-fijas {
    position: absolute;
    inset: 0;
    z-index: 5;
    pointer-events: none;
}

.nefhs-fijas .nefhs-capa {
    pointer-events: auto;
}

/* -------------------------------------------------------------------------
 * Flechas
 * ---------------------------------------------------------------------- */

.nefhs .nefhs-flecha {
    position: absolute;
    top: 50%;
    z-index: 10;
    display: flex;
    align-items: center;
    justify-content: center;
    width: 46px;
    height: 46px;
    margin: 0;
    padding: 0;
    border: 0;
    border-radius: 50%;
    background: transparent;
    color: rgba(255, 255, 255, 0.85);
    cursor: pointer;
    opacity: 0;
    transform: translateY(-50%);
    transition: opacity 220ms ease, transform 220ms ease, color 220ms ease;
    -webkit-appearance: none;
    appearance: none;
}

/* Las flechas aparecen al acercar el ratón, como en el original. En una
   pantalla táctil no hay ratón que acercar, así que se dejan puestas. */
.nefhs:hover .nefhs-flecha,
.nefhs-flecha:focus-visible {
    opacity: 1;
}

@media (hover: none) {
    .nefhs-flecha {
        opacity: 1;
    }
}

.nefhs .nefhs-flecha:hover {
    color: #ffffff;
    transform: translateY(-50%) scale(1.12);
}

.nefhs .nefhs-flecha--prev {
    left: 14px;
}

.nefhs .nefhs-flecha--next {
    right: 14px;
}

.nefhs-flecha:focus-visible {
    outline: 2px solid currentColor;
    outline-offset: 3px;
}

/* -------------------------------------------------------------------------
 * Puntos
 * ---------------------------------------------------------------------- */

.nefhs-puntos {
    position: absolute;
    left: 0;
    right: 0;
    bottom: 14px;
    z-index: 10;
    display: flex;
    align-items: center;
    justify-content: center;
    gap: 8px;
}

.nefhs .nefhs-punto {
    width: 9px;
    height: 9px;
    padding: 0;
    border: 0;
    border-radius: 50%;
    background: rgba(255, 255, 255, 0.35);
    cursor: pointer;
    transition: background-color 200ms ease, transform 200ms ease;
    -webkit-appearance: none;
    appearance: none;
}

.nefhs .nefhs-punto:hover {
    transform: scale(1.25);
}

.nefhs .nefhs-punto.is-activo {
    background: #ffffff;
    transform: scale(1.15);
}

/* La diapositiva de campaña se distingue en el panel y en los puntos, para que
   se vea de un vistazo que hay una de más y de dónde ha salido. */
.nefhs .nefhs-punto.es-campana {
    box-shadow: 0 0 0 2px rgba(255, 255, 255, 0.5);
}

/* -------------------------------------------------------------------------
 * Arrastre
 * ---------------------------------------------------------------------- */

.nefhs--arrastrable .nefhs-marco {
    cursor: grab;
}

.nefhs--arrastrando .nefhs-marco {
    cursor: grabbing;
}

.nefhs--arrastrando a {
    pointer-events: none;
}

/* -------------------------------------------------------------------------
 * Aviso para quien edita
 * ---------------------------------------------------------------------- */

.nefhs-aviso {
    padding: 14px 16px;
    border: 1px dashed rgba(127, 127, 127, 0.6);
    border-radius: 4px;
    background: rgba(127, 127, 127, 0.08);
    font-size: 13px;
    line-height: 1.5;
}

/* -------------------------------------------------------------------------
 * Accesibilidad
 * ---------------------------------------------------------------------- */

/* Quien ha pedido menos movimiento no quiere treinta capas volando. Se dejan
   todas puestas en su sitio y el slider se limita a cambiar de diapositiva. */
@media (prefers-reduced-motion: reduce) {
    .nefhs-capa,
    .nefhs-diapositiva.is-activa .nefhs-capa,
    .nefhs-diapositiva.is-saliendo .nefhs-capa--con-salida {
        transform: none !important;
        opacity: 1 !important;
        transition: none !important;
    }
}

/* =========================================================================
 * EL OVERLAY DE UNA CAPA
 *
 * Lo que hace una capa cuando YA ESTÁ QUIETA, que no es lo mismo que su
 * entrada y su salida. Aquellas ocurren una vez, atadas a la línea de tiempo;
 * esto ocurre después, al pasar el ratón por encima o en bucle.
 *
 * Va sobre un envoltorio dentro de la capa y no sobre la capa misma, porque el
 * `transform` de la capa lo ocupan la entrada y la salida. Si la magnificación
 * se pusiera ahí, se pelearía con ellas y la capa saldría volando a mitad de
 * la entrada.
 * ====================================================================== */

.nefhs-ov {
    display: block;
}

/* El enlace propio de una capa. Ocupa todo el contenido para que se pueda
   pinchar donde se ve, y no pinta nada suyo: el aspecto lo sigue poniendo la
   imagen o el texto que lleva dentro, no el enlace. */
.nefhs-capa-enlace {
    display: block;
    color: inherit;
    text-decoration: none;
}

/* MAGNIFICACIÓN. Con transición y no con fotogramas clave: así vuelve a su
   sitio igual de suave cuando el ratón se va, cosa que una animación no hace. */
.nefhs-capa--ov.nefhs-ov--magnificar .nefhs-ov,
.nefhs-capa--ov.nefhs-ov--magnificar_latido .nefhs-ov {
    transition: transform var(--nefhs-ov-t, 0.35s) cubic-bezier(0.23, 1, 0.32, 1);
}

.nefhs-ov-cuando--hover.nefhs-ov--magnificar:hover .nefhs-ov,
.nefhs-ov-cuando--siempre.nefhs-ov--magnificar .nefhs-ov {
    transform: scale(var(--nefhs-ov-fuerza, 1.08));
}

/* LATIDO, DESTELLO, BRILLO y TEMBLOR van con fotogramas clave, porque son
   ciclos: mientras el ratón está encima (o siempre) se repiten. */
@keyframes nefhs-ov-latido {
    0%, 100% { transform: scale(1); }
    50%      { transform: scale(var(--nefhs-ov-fuerza, 1.08)); }
}

@keyframes nefhs-ov-flash {
    0%, 100% { filter: brightness(1); }
    45%      { filter: brightness(calc(1 + (var(--nefhs-ov-fuerza, 1.08) - 1) * 6)); }
}

@keyframes nefhs-ov-brillo {
    0%, 100% { filter: drop-shadow(0 0 0 rgba(255, 255, 255, 0)); }
    50%      { filter: drop-shadow(0 0 calc((var(--nefhs-ov-fuerza, 1.08) - 1) * 120px) rgba(255, 255, 255, 0.9)); }
}

@keyframes nefhs-ov-temblor {
    0%, 100% { transform: translateX(0); }
    20%      { transform: translateX(calc((var(--nefhs-ov-fuerza, 1.08) - 1) * -40px)); }
    40%      { transform: translateX(calc((var(--nefhs-ov-fuerza, 1.08) - 1) * 40px)); }
    60%      { transform: translateX(calc((var(--nefhs-ov-fuerza, 1.08) - 1) * -24px)); }
    80%      { transform: translateX(calc((var(--nefhs-ov-fuerza, 1.08) - 1) * 24px)); }
}

.nefhs-ov-cuando--hover.nefhs-ov--latido:hover .nefhs-ov,
.nefhs-ov-cuando--siempre.nefhs-ov--latido .nefhs-ov {
    animation: nefhs-ov-latido var(--nefhs-ov-t, 0.35s) ease-in-out;
    animation-iteration-count: var(--nefhs-ov-veces, infinite);
    animation-fill-mode: forwards;
}

.nefhs-ov-cuando--hover.nefhs-ov--flash:hover .nefhs-ov,
.nefhs-ov-cuando--siempre.nefhs-ov--flash .nefhs-ov {
    animation: nefhs-ov-flash var(--nefhs-ov-t, 0.35s) ease-in-out;
    animation-iteration-count: var(--nefhs-ov-veces, infinite);
    animation-fill-mode: forwards;
}

.nefhs-ov-cuando--hover.nefhs-ov--brillo:hover .nefhs-ov,
.nefhs-ov-cuando--siempre.nefhs-ov--brillo .nefhs-ov {
    animation: nefhs-ov-brillo var(--nefhs-ov-t, 0.35s) ease-in-out;
    animation-iteration-count: var(--nefhs-ov-veces, infinite);
    animation-fill-mode: forwards;
}

.nefhs-ov-cuando--hover.nefhs-ov--temblor:hover .nefhs-ov,
.nefhs-ov-cuando--siempre.nefhs-ov--temblor .nefhs-ov {
    animation: nefhs-ov-temblor var(--nefhs-ov-t, 0.35s) ease-in-out;
    animation-iteration-count: var(--nefhs-ov-veces, infinite);
    animation-fill-mode: forwards;
}

/* MAGNIFICACIÓN CON LATIDO. Las dos cosas son `transform`, así que no se pueden
   poner una encima de otra: van juntas en los mismos fotogramas, latiendo
   alrededor del tamaño magnificado. La transición de arriba sigue valiendo para
   la vuelta, cuando el ratón se va y la animación se para. */
@keyframes nefhs-ov-mag-latido {
    0%, 100% { transform: scale(var(--nefhs-ov-fuerza, 1.08)); }
    50%      { transform: scale(calc(var(--nefhs-ov-fuerza, 1.08) * 1.06)); }
}

.nefhs-ov-cuando--hover.nefhs-ov--magnificar_latido:hover .nefhs-ov,
.nefhs-ov-cuando--siempre.nefhs-ov--magnificar_latido .nefhs-ov {
    animation: nefhs-ov-mag-latido var(--nefhs-ov-t, 0.35s) ease-in-out;
    animation-iteration-count: var(--nefhs-ov-veces, infinite);

    /* Al acabar los latidos se queda en el ultimo fotograma, que es el tamano
       magnificado: si volviera a su tamano normal con el raton todavia encima,
       pareceria que el efecto se ha caido. */
    animation-fill-mode: forwards;
}

/* MAGNIFICACIÓN CON LATIDO Y DESTELLO. Las tres cosas a la vez: el tamaño y el
   latido se pelean por el `transform`, así que van juntos en los mismos
   fotogramas —igual que arriba—, y el destello va por `filter`, que es una
   propiedad distinta y puede animarse en los mismos fotogramas sin estorbar.

   El brillo sube y baja antes que el latido (pico en el 45 %, apagado en el
   70 %) para que se lea como un chispazo dentro de un latido suave y no como
   una segunda pulsación más. Cada propiedad interpola entre los fotogramas en
   los que aparece, así que el `transform` sigue haciendo su ciclo entero. */
@keyframes nefhs-ov-mag-latido-flash {
    0%   { transform: scale(var(--nefhs-ov-fuerza, 1.08)); filter: brightness(1); }
    45%  { filter: brightness(calc(1 + (var(--nefhs-ov-fuerza, 1.08) - 1) * 6)); }
    50%  { transform: scale(calc(var(--nefhs-ov-fuerza, 1.08) * 1.06)); }
    70%  { filter: brightness(1); }
    100% { transform: scale(var(--nefhs-ov-fuerza, 1.08)); filter: brightness(1); }
}

/* La vuelta, cuando el ratón se va y la animación se para: el tamaño se
   deshincha con la misma suavidad que la magnificación sola, y el brillo la
   acompaña por si el ratón sale a mitad de un destello. */
.nefhs-capa--ov.nefhs-ov--magnificar_latido_flash .nefhs-ov {
    transition: transform var(--nefhs-ov-t, 0.35s) cubic-bezier(0.23, 1, 0.32, 1),
                filter var(--nefhs-ov-t, 0.35s) ease-out;
}

.nefhs-ov-cuando--hover.nefhs-ov--magnificar_latido_flash:hover .nefhs-ov,
.nefhs-ov-cuando--siempre.nefhs-ov--magnificar_latido_flash .nefhs-ov {
    animation: nefhs-ov-mag-latido-flash var(--nefhs-ov-t, 0.35s) ease-in-out;
    animation-iteration-count: var(--nefhs-ov-veces, infinite);

    /* Se queda en el último fotograma, que es el tamaño magnificado y el brillo
       normal, por lo mismo que el efecto de arriba. */
    animation-fill-mode: forwards;
}

/* NUBE. Un vaivén suave y sin final: la capa se va y vuelve por un recorrido
   cerrado —empieza y acaba en el mismo sitio, así que el bucle no da tirones—
   ladeándose un poco y respirando de tamaño por el camino.

   No es un ciclo de ida y vuelta como el latido, sino cinco sitios por los que
   pasa, y por eso se nota como un baile y no como una pulsación. El `ease-in-out`
   vale entre cada dos fotogramas, no solo en los extremos: eso es lo que le
   quita la línea recta al recorrido y lo que lo hace parecer flotar.

   Las medidas salen de la fuerza, como en el resto: con 1,08 son diez píxeles
   y un grado y medio, que es lo que hace falta para que se lea como una nube
   y no como un temblor. El desplazamiento se guarda en dos variables propias
   para no repetir la misma cuenta doce veces. */
@keyframes nefhs-ov-nube {
    0%   { transform: translate(0, 0) rotate(0deg) scale(1); }

    20%  { transform: translate(calc(var(--nefhs-ov-nube-d) * 0.55), calc(var(--nefhs-ov-nube-d) * -0.42))
                      rotate(calc(var(--nefhs-ov-nube-g) * 0.35)) scale(var(--nefhs-ov-nube-s)); }

    40%  { transform: translate(var(--nefhs-ov-nube-d), calc(var(--nefhs-ov-nube-d) * 0.18))
                      rotate(calc(var(--nefhs-ov-nube-g) * -0.22)) scale(1); }

    60%  { transform: translate(calc(var(--nefhs-ov-nube-d) * 0.2), calc(var(--nefhs-ov-nube-d) * 0.68))
                      rotate(calc(var(--nefhs-ov-nube-g) * -0.5)) scale(var(--nefhs-ov-nube-s)); }

    80%  { transform: translate(calc(var(--nefhs-ov-nube-d) * -0.5), calc(var(--nefhs-ov-nube-d) * 0.22))
                      rotate(calc(var(--nefhs-ov-nube-g) * 0.32)) scale(1); }

    100% { transform: translate(0, 0) rotate(0deg) scale(1); }
}

.nefhs-ov-cuando--hover.nefhs-ov--nube:hover .nefhs-ov,
.nefhs-ov-cuando--siempre.nefhs-ov--nube .nefhs-ov {
    --nefhs-ov-nube-d: calc((var(--nefhs-ov-fuerza, 1.08) - 1) * 120px);
    --nefhs-ov-nube-g: calc((var(--nefhs-ov-fuerza, 1.08) - 1) * 18deg);
    --nefhs-ov-nube-s: calc(1 + (var(--nefhs-ov-fuerza, 1.08) - 1) * 0.25);

    animation: nefhs-ov-nube var(--nefhs-ov-t, 0.35s) ease-in-out;
    animation-iteration-count: var(--nefhs-ov-veces, infinite);

    /* El último fotograma es el sitio de siempre, así que al acabar las vueltas
       la capa se queda donde estaba: no hace falta transición de vuelta como en
       la magnificación, porque no se queda desplazada en ningún momento. */
    animation-fill-mode: forwards;
}

/* Quien no quiere movimiento no lo tiene. Es la misma regla que ya respeta el
   resto del slider. */
@media (prefers-reduced-motion: reduce) {
    .nefhs-capa--ov .nefhs-ov {
        animation: none !important;
        transition: none !important;
        transform: none !important;
    }
}

/* =========================================================================
 * LOS BOTONES DE UNA CAPA
 *
 * El color, el radio, el tamaño y las medidas los escribe PHP en el atributo
 * `style` a partir de los campos del editor. Aquí solo va lo que es igual para
 * todos, y sobre todo el reseteo: un botón de un slider acaba en cualquier
 * tema, y los temas maltratan los botones. El de la tienda, por `kube.css`, le
 * pone a todo un `min-height: 40px` que gana a cualquier altura puesta
 * después; es la misma trampa que dejó los puntos de paginación como huevos.
 * ====================================================================== */

.nefhs .nefhs-boton {
    display: inline-block;
    box-sizing: border-box;
    margin: 0;
    padding: 12px 26px;
    border: 0;
    min-height: 0;
    min-width: 0;
    max-width: none;
    text-align: center;
    text-decoration: none;
    line-height: 1.2;
    font-family: inherit;
    letter-spacing: normal;
    text-transform: none;
    cursor: pointer;
    transition: filter 200ms ease, transform 200ms ease;
    -webkit-appearance: none;
    appearance: none;
}

.nefhs .nefhs-boton:hover,
.nefhs .nefhs-boton:focus {
    filter: brightness(1.12);
    text-decoration: none;
}

.nefhs .nefhs-boton:active {
    transform: translateY(1px);
}

/* El bloque de donación lo pinta NEF Donations con su propio marcado; aquí solo
   se le da la caja y el color de fondo que se hayan elegido. */
.nefhs .nefhs-boton-donacion {
    display: inline-block;
    padding: 10px 14px;
}

@media (prefers-reduced-motion: reduce) {
    .nefhs .nefhs-boton {
        transition: none;
    }
}

/* Una capa marcada como inerte no recibe el ratón: no tiene overlay, ni enlace,
   ni es un botón. Así deja de tapar a las que tiene debajo, que en este slider
   son casi todas PNG con transparencia solapados. La marca la pone PHP en
   `nefhs_render_capa()`, donde está explicado por qué. */
.nefhs .nefhs-capa--inerte {
    pointer-events: none;
}

/* ---------------------------------------------------------------------------
   EL ALTAVOZ PARA DAR PERMISO AL SONIDO

   Solo aparece si el slider tiene algún sonido y la persona todavía no ha
   tocado la página. Un click y se va. Va discreto a propósito: no es un
   reclamo, es un permiso.
   ------------------------------------------------------------------------ */

.nefhs .nefhs-altavoz {
    position: absolute;
    right: 16px;
    bottom: 16px;
    z-index: 20;

    display: inline-flex;
    align-items: center;
    gap: 7px;

    margin: 0;
    padding: 8px 13px 8px 10px;

    font: 500 12px/1 -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
    letter-spacing: 0.02em;
    color: #fff;

    background: rgba(20, 20, 22, 0.55);
    border: 1px solid rgba(255, 255, 255, 0.28);
    border-radius: 999px;
    box-shadow: 0 2px 14px rgba(0, 0, 0, 0.3);

    -webkit-backdrop-filter: blur(6px);
    backdrop-filter: blur(6px);

    cursor: pointer;
    opacity: 0.72;
    transition: opacity 220ms ease, background-color 220ms ease, transform 220ms ease;
}

.nefhs .nefhs-altavoz:hover,
.nefhs .nefhs-altavoz:focus-visible {
    opacity: 1;
    background: rgba(20, 20, 22, 0.78);
    transform: translateY(-1px);
}

.nefhs .nefhs-altavoz svg {
    width: 16px;
    height: 16px;
    fill: currentColor;
    stroke: currentColor;
}

.nefhs .nefhs-altavoz.is-yendose {
    opacity: 0;
    transform: translateY(6px);
    pointer-events: none;
}

/* En pantallas pequeñas, solo el dibujo: el texto se come el sitio. */
@media (max-width: 600px) {
    .nefhs .nefhs-altavoz span {
        display: none;
    }

    .nefhs .nefhs-altavoz {
        padding: 9px;
    }
}

@media (prefers-reduced-motion: reduce) {
    .nefhs .nefhs-altavoz {
        transition: none;
    }
}

/* -------------------------------------------------------------------------
 * LA DIAPOSITIVA MOVIDA POR EL SCROLL
 *
 * Mientras está anclada, sus capas NO se animan solas: las coloca el
 * JavaScript en el punto exacto que diga la rueda, y una transición encima
 * haría que cada golpe de rueda llegara con medio segundo de retraso y que
 * moverse hacia atrás se viera como un rebote. Aquí se apagan, que es lo mismo
 * que hace el editor de la línea de tiempo para poder pararse en un instante
 * concreto.
 *
 * La clase la pone y la quita el motor: `--scroll` es cómo está configurada la
 * diapositiva, y `is-scroll` es que ahora mismo la lleva la rueda.
 * ---------------------------------------------------------------------- */

.nefhs-diapositiva.is-scroll.is-activa .nefhs-capa,
.nefhs-diapositiva.is-scroll .nefhs-capa {
    transition: none;
}

/* El vídeo tampoco se reproduce: se rebobina. Se le quita el suavizado de
   cambio de tamaño del navegador porque saltando de fotograma en fotograma no
   aporta nada y sí cuesta. */
.nefhs-video--scroll {
    will-change: contents;
}

/* Con prefers-reduced-motion no se ancla nada —el motor ni siquiera entra en
   modo scroll—, así que la diapositiva se comporta como cualquier otra y no
   hace falta ninguna regla aquí: las de arriba solo se aplican cuando el
   JavaScript ha puesto `is-scroll`, y en ese caso nunca lo hace. */
