/* ==========================================================================
   ERZEUGT — nicht von Hand ändern.
   Quelle: website/css/layout.css
   Neu erzeugen mit: node build/theme.mjs
   ========================================================================== */

/* ==========================================================================
   Layout — Container, Sections, Raster
   Diese Klassen bilden das Gerüst, das in WordPress später von
   Group-/Row-/Grid-Blöcken übernommen werden kann (align-wide / align-full).
   ========================================================================== */

/* --- Seitenskelett ------------------------------------------------------- */

.site {
  display: flex;
  flex-direction: column;
  min-height: 100vh;
}

.site-main { flex: 1 0 auto; }

/* --- Container ----------------------------------------------------------- */

.container {
  width: 100%;
  max-width: var(--sv-container-default);
  margin-inline: auto;
  padding-inline: var(--sv-container-padding);
}

.container--wide   { max-width: var(--sv-container-wide); }
.container--narrow { max-width: var(--sv-container-narrow); }

/* --- Sections ------------------------------------------------------------ */

.section {
  padding-block: var(--sv-space-section);
}

.section--tight { padding-block: var(--sv-space-section-tight); }

.section--alt {
  background-color: var(--sv-color-surface-light);
}

.section--dark {
  background-color: var(--sv-color-surface-dark);
  color: var(--sv-color-text-inverse);
}

.section--dark h1,
.section--dark h2,
.section--dark h3,
.section--dark h4 { color: var(--sv-color-text-inverse); }

/* Trennlinie zwischen zwei Sections gleicher Farbe */
.section--divider { border-top: 1px solid var(--sv-color-border); }

/* --- Vertikaler Abstandsstapel ------------------------------------------- */

/* Der Stapel regelt seinen Abstand über Außenabstände — und zwar allein.
   `gap: 0` sagt das ausdrücklich: Ist der Stapel zufällig ein Flex- oder
   Rasterkasten, soll dessen eigener Abstand nicht dazukommen.

   Ohne diese Zeile addieren sich beide. Am 05.09.2026 auf der Pilotseite
   gemessen: 36 px zwischen den Absätzen statt 16 — 20 px vom Kasten, 16 vom
   Stapel. Auf einer gewöhnlichen Blockebene ändert `gap` nichts, die Zeile ist
   dort also wirkungslos. */
.stack, .stack-lg, .stack-sm { gap: 0; }

.stack > * + * { margin-top: var(--sv-space-16); }
.stack-lg > * + * { margin-top: var(--sv-space-32); }
.stack-sm > * + * { margin-top: var(--sv-space-8); }

/* --- Raster -------------------------------------------------------------- */

.grid {
  display: grid;
  gap: var(--sv-space-24);
  grid-template-columns: 1fr;
}

@media (min-width: 40rem) {
  .grid--2, .grid--3, .grid--4 { grid-template-columns: repeat(2, minmax(0, 1fr)); }
}

@media (min-width: 60rem) {
  .grid--3 { grid-template-columns: repeat(3, minmax(0, 1fr)); }
  .grid--4 { grid-template-columns: repeat(4, minmax(0, 1fr)); }
}

/* --- Kartenraster ---------------------------------------------------------
   Karten teilen sich die Breite ihrer Reihe gleichmäßig. Die Verteilung
   ergibt sich aus der ANZAHL der Karten, nicht aus einer Klasse: Redaktion
   fügt eine Karte hinzu oder entfernt eine — mehr nicht.

   ZWÖLF innere Spalten, weil 12 sich glatt in 1, 2, 3 und 4 teilt:
     volle Breite = span 12 · Hälfte = span 6 · Drittel = span 4 · Viertel = span 3

   Verteilung ab 60rem (Desktop):
      1 → 1          6 → 3+3
      2 → 2          7 → 3+2+2
      3 → 3          8 → 3+3+2
      4 → 2+2        9 → 3+3+3
      5 → 3+2       10 → 3+3+2+2

   Die Regel dahinter ist die Restklasse von n modulo 3:
     n ≡ 0  alle Reihen zu dritt
     n ≡ 2  die letzten ZWEI teilen sich eine Reihe zur Hälfte
     n ≡ 1  die letzten VIER bilden 2+2   (n = 1 ausgenommen: volle Breite)
   Dadurch steht nie eine Karte allein in der letzten Reihe.

   EINZIGE AUSNAHME: `--kompakt` stellt GENAU VIER Karten nebeneinander
   (25 % je Karte). Das ist eine bewusste Darstellungsvariante des Rasters,
   keine redaktionelle Einstellung und keine Messung am Textinhalt. Bei jeder
   anderen Anzahl verhält sich ein kompaktes Raster wie jedes andere.

   Zu den strukturellen Selektoren: Sie lesen ausschließlich die ANZAHL der
   Geschwister und setzen daraus eine Spannweite. Sie koppeln keine Bedeutung,
   keine Fläche und keine Position an Platz 1, 2 oder 3 — genau das bleibt
   weiterhin verboten und wird von check-designsystem.mjs geprüft. */

:is(.card-grid, .stats, .event-list, .quick-links) {
  display: grid;
  gap: var(--sv-space-24);
  /* Mobil eine Spalte. Die Spaltenzahl wächst mit der Stufe mit und ist nie
     größer als nötig: Zwölf Spalten bedeuten elf Abstände, und die zählen
     auch dann zur Mindestbreite des Rasters, wenn jede Karte über alle
     zwölf läuft. Bei 32 px Abstand wären das allein 352 px — mehr, als ein
     320-px-Fenster hergibt. */
  grid-template-columns: minmax(0, 1fr);
  margin: 0;
  padding: 0;
  list-style: none;
}

:is(.card-grid, .stats, .event-list, .quick-links) > * { min-width: 0; }

/* Tablet: zwei je Reihe. Vier Karten stehen hier bewusst 2 + 2, auch im
   kompakten Raster — in vier Spalten wären sie zu schmal. */
@media (min-width: 40rem) {
  :is(.card-grid, .stats, .event-list, .quick-links) {
    grid-template-columns: repeat(2, minmax(0, 1fr));
  }
}

/* Bei ungerader Anzahl nimmt die letzte Karte die volle Breite, statt allein
   und halb breit stehen zu bleiben. Nach oben begrenzt, damit die Regel nicht
   in die Desktopstufe hineinreicht. */
@media (min-width: 40rem) and (max-width: 59.999rem) {
  :is(.card-grid, .stats, .event-list, .quick-links):has(> :nth-child(odd):last-child) > :last-child {
    grid-column: span 2;
  }

  .card-grid:has(.person-card):has(> :nth-child(odd):last-child) > :last-child {
    grid-column: span 1;
  }
}

/* Desktop: zwölf Spalten, drei Karten je Reihe, letzte Reihe ausgeglichen */
@media (min-width: 60rem) {
  :is(.card-grid, .stats, .event-list, .quick-links) {
    grid-template-columns: repeat(12, minmax(0, 1fr));
  }

  :is(.card-grid, .stats, .event-list, .quick-links) > * { grid-column: span 4; }

  /* n ≡ 2 (mod 3): die letzten zwei teilen sich eine Reihe */
  :is(.card-grid, .stats, .event-list, .quick-links):has(> :nth-child(3n+2):last-child) > :nth-last-child(-n+2) {
    grid-column: span 6;
  }

  /* n ≡ 1 (mod 3): die letzten vier werden 2+2 — nicht 3+1 */
  :is(.card-grid, .stats, .event-list, .quick-links):has(> :nth-child(3n+1):last-child) > :nth-last-child(-n+4):not(:only-child) {
    grid-column: span 6;
  }

  /* Eine einzelne Karte füllt die Reihe */
  :is(.card-grid, .stats, .event-list, .quick-links) > :only-child { grid-column: span 12; }

  /* … außer bei Porträts: siehe die Begründung beim Loop-Raster oben. */
  .card-grid:has(.person-card):has(> :nth-child(3n+2):last-child) > :nth-last-child(-n+2),
  .card-grid:has(.person-card):has(> :nth-child(3n+1):last-child) > :nth-last-child(-n+4):not(:only-child),
  .card-grid:has(.person-card) > :only-child {
    grid-column: span 4;
  }

  /* Kompakte Variante bei GENAU vier Karten: 25 % je Karte.
     Steht bewusst zuletzt und trägt dieselbe Spezifität wie die 2+2-Regel
     darüber — die spätere Regel gewinnt. Bei jeder anderen Anzahl greift
     sie nicht und das Raster verhält sich wie jedes andere. */
  :is(.card-grid, .stats, .quick-links).card-grid--kompakt:has(> :nth-child(4):last-child) > :nth-child(-n+4):not(:only-child) {
    grid-column: span 3;
  }
}

/* Folgt auf ein Raster eine Überschrift, beginnt dort ein neuer Abschnitt.
   Ohne diese Regel stehen beide auf 0 px Abstand und kleben aneinander —
   aufgefallen bei den drei Vorstandsgruppen auf /verein/vorstand/. */
/* --- Raster, das der Seitenbaukasten selbst aufbaut ----------------------
   In WordPress erzeugt Elementor die Listen von Vorstand, Partner, Downloads
   und Ergebnissen. Es legt sein Raster dabei selbst an — mit eigener
   Spaltenzahl und eigenem Abstand — und schiebt zwischen Raster und Karte zwei
   Hüllen. Die Regeln oben sprechen direkte Kinder an und greifen dort nicht.

   Die Arbeit ist deshalb geteilt: Der Baukasten baut das Raster, und in seinem
   Widget stehen dafür die Zahlen des Designsystems — zwölf Spalten am
   Schreibtisch, zwei am Tablet, eine am Telefon. Von hier kommen der Abstand
   und die Spannweiten der Karten.

   Die Spaltenzahl hier noch einmal zu setzen, hieße gegen die eigene Regel des
   Baukastens anzuschreiben, und die ist spezifischer. Am 05.09.2026 gemessen:
   Alle Karten füllten die ganze Breite, weil `span 4` auf ein Raster mit drei
   Spalten traf. */
.card-grid--loop { --grid-column-gap: var(--sv-space-24); }

/* Dasselbe Raster wie oben, für den Aufbau des Baukastens gespiegelt.

   Warum gespiegelt und nicht in die Listen oben aufgenommen: Elementor legt in
   den Rastercontainer ein `<style>`-Element — aber nicht in jeden. Auf der
   Vorstandsseite steht es im ersten der vier und in den übrigen nicht. Die
   Regeln oben zählen Geschwisterkinder; ein zusätzliches erstes Kind
   verschiebt jede Zählung. Das Ergebnis wäre bei einem Raster richtig und
   beim nächsten falsch — ein Fehler, nach dem niemand sucht.

   `of :not(style)` zählt nur die Karten. Kennt ein Browser das nicht, fällt
   die Regel weg und alle Karten bleiben bei `span 4` — die vernünftige
   Vorgabe, keine kaputte Seite.

   Die zwei Ebenen zwischen Widget und Raster sind der Preis dafür, dass der
   Baukasten das Raster selbst aufbaut. Sie stehen hier an einer Stelle,
   benannt und begründet, statt verstreut in den allgemeinen Regeln. */
@media (min-width: 40rem) and (max-width: 59.999rem) {
  .card-grid--loop > * > *:has(> :nth-child(odd of :not(style)):last-child) > :last-child {
    grid-column: span 2;
  }
}

@media (min-width: 60rem) {
  .card-grid--loop > * > * > :not(style) { grid-column: span 4; }

  .card-grid--loop > * > *:has(> :nth-child(3n+2 of :not(style)):last-child) > :nth-last-child(-n+2) {
    grid-column: span 6;
  }

  .card-grid--loop > * > *:has(> :nth-child(3n+1 of :not(style)):last-child) > :nth-last-child(-n+4):not(:nth-child(1 of :not(style))) {
    grid-column: span 6;
  }

  .card-grid--loop > * > * > :nth-child(1 of :not(style)):last-child { grid-column: span 12; }
}

/* PERSONENKARTEN BLEIBEN GLEICH BREIT — eine Ausnahme von den Regeln oben.

   Jene Regeln gleichen die letzte Reihe aus: Bleiben zwei Karten übrig, werden
   sie breiter; bleibt eine übrig, füllt sie die Reihe. Für Textkarten ist das
   richtig — eine halb leere Reihe sieht nach Versehen aus.

   Für Porträts ist es falsch. Am 08.09.2026 gemessen: Im erweiterten Vorstand
   (sieben Karten) wurden die letzten vier doppelt so breit, und der
   Ehrenvorsitzende stand als einziger seiner Gruppe über die volle Breite —
   sein Bild war dreimal so groß wie das von Ramona Dreikorn daneben. Ein
   Gesicht doppelt so groß wie das nächste liest sich als Rangordnung, und die
   gibt es hier nicht.

   Jede dieser Regeln wird einzeln zurückgenommen, mit derselben Struktur plus
   :has(.person-card) davor. Das ist die einzige Art, die es sicher schlägt: Gegen
   Spezifität hilft Ladereihenfolge nie.

   Dasselbe gilt für das statische Raster weiter unten. */
@media (min-width: 60rem) {
  .card-grid--loop:has(.person-card) > * > *:has(> :nth-child(3n+2 of :not(style)):last-child) > :nth-last-child(-n+2),
  .card-grid--loop:has(.person-card) > * > *:has(> :nth-child(3n+1 of :not(style)):last-child) > :nth-last-child(-n+4):not(:nth-child(1 of :not(style))),
  .card-grid--loop:has(.person-card) > * > * > :nth-child(1 of :not(style)):last-child {
    grid-column: span 4;
  }
}

@media (min-width: 40rem) and (max-width: 59.999rem) {
  .card-grid--loop:has(.person-card) > * > *:has(> :nth-child(odd of :not(style)):last-child) > :last-child {
    grid-column: span 1;
  }
}

/* Die Karte füllt ihren Platz — Breite wie Höhe.

   Der Baukasten legt um jede Karte einen eigenen Kasten mit 10 px
   Innenabstand. Am 05.09.2026 gemessen: Die Karte war dadurch 336 px breit
   statt 356 wie im statischen Raster daneben, und sie endete 28 px über dem
   unteren Rand ihrer Reihe. Nebeneinander sah das aus wie zwei verschiedene
   Rastergrößen.

   Die vier Stufen sind der Weg vom Rasterkind bis zur Karte: Kasten, Widget,
   Hülle des Widgets, Karte. Sie stehen hier ausgeschrieben, damit keine
   Elementor-Klasse ins Designsystem wandert — die Regel beschreibt eine
   Verschachtelung, kein fremdes System. */
/* Der Weg vom Rasterkind bis zur Karte — am 05.09.2026 im Browser abgelesen,
   nicht geschätzt:

     Rasterkind   der Eintrag des Loop Grids
       Kasten     legt 10 px Innenabstand um die Karte
         Widget
           Hülle
             .person-card

   Der Innenabstand faellt weg, und jede Zwischenebene reicht Breite und Höhe
   weiter. Sonst steht neben einem statischen Raster eine Karte, die 20 px
   schmaler ist und ihre Reihe unten nicht ausfüllt. */
.card-grid--loop > * > * > :not(style) > * { padding: 0; }

.card-grid--loop > * > * > :not(style),
.card-grid--loop > * > * > :not(style) > *,
.card-grid--loop > * > * > :not(style) > * > *,
.card-grid--loop > * > * > :not(style) > * > * > *,
.card-grid--loop > * > * > :not(style) > * > * > * > * {
  display: flex;
  flex: 1 1 auto;
  min-width: 0;
}

:is(.card-grid, .stats, .event-list, .quick-links, .media-grid) + :is(h2, h3, h4) {
  margin-top: var(--sv-space-48);
}

/* --- Medienraster --------------------------------------------------------
   Gemeinsame technische Grundlage aller Bildraster. Die Aufgaben bleiben
   getrennt — eine Lightbox-Galerie, ein Sponsorenraster und ein dekoratives
   Kopfmosaik behandeln ihre Bilder unterschiedlich —, aber sie teilen sich
   dieselbe Rasterlogik:

     auto-fill statt auto-fit, damit ein einzelnes Bild nicht auf die volle
     Containerbreite wächst (siehe .grid--auto);
     minmax(min(…, 100%), 1fr), damit das Raster auch bei sehr schmalen
     Containern nicht überläuft.

   Die Mindestbreite steuert jede Variante über --medien-min. */

.media-grid {
  display: grid;
  gap: var(--sv-media-gap, var(--sv-space-16));
  grid-template-columns: repeat(auto-fill, minmax(min(var(--sv-media-min, 14rem), 100%), 1fr));
  margin: 0;
  padding: 0;
  list-style: none;
}

.media-grid > li { margin: 0; min-width: 0; }

/* Automatisches Raster für Karten mit Mindestbreite */
.grid--auto {
  grid-template-columns: repeat(auto-fill, minmax(min(17rem, 100%), 1fr));
}

.grid--auto-wide {
  grid-template-columns: repeat(auto-fill, minmax(min(22rem, 100%), 1fr));
}

/* Mosaik für die Disziplinkacheln: zwei hohe Kacheln außen, zwei flachere
   in der Mitte. Unterhalb von 62rem bleibt es ein normales Raster.
   --sv-tile-row ist die gemeinsame Reihenhöhe: Die hohen Disziplinkacheln
   und die Spartenkacheln rechnen beide damit und werden dadurch gleich hoch. */
.grid--mosaik,
.grid--sparten { --sv-tile-row: clamp(13rem, 17vw, 16.5rem); }

.grid--mosaik { gap: var(--sv-space-24); }

@media (min-width: 40rem) {
  .grid--mosaik { grid-template-columns: repeat(2, minmax(0, 1fr)); }
}

/* Ohne Mosaik begrenzt die Höhe das Hochformat, damit einspaltige Kacheln
   auf breiten Handys nicht die halbe Seite füllen. */
@media (max-width: 61.999rem) {
  .grid--mosaik .sport-tile__image { max-height: 26rem; }
}

@media (min-width: 62rem) {
  .grid--mosaik {
    grid-template-columns: repeat(3, minmax(0, 1fr));
    grid-template-rows: repeat(2, var(--sv-tile-row));
  }

  /* Feste Plätze, damit die hohen Kacheln außen stehen und die beiden
     flachen dazwischen übereinander liegen. Die Position kommt aus einer
     eigenen Klasse, nicht aus :first-child/:last-child — so bleibt das
     Mosaik richtig, wenn Kacheln ergänzt, entfernt oder umsortiert werden. */
  .grid--mosaik > .grid__hoch             { grid-row: 1 / span 2; }
  .grid--mosaik > .grid__hoch--links      { grid-column: 1; }
  .grid--mosaik > .grid__hoch--rechts     { grid-column: 3; }
  .grid--mosaik > :not(.grid__hoch)       { grid-column: 2; }

  /* Kachelhöhe kommt aus dem Raster, nicht mehr aus dem Seitenverhältnis */
  .grid--mosaik .sport-tile { height: 100%; }
}

/* Sparten: ab 62rem zwei große Kacheln nebeneinander. Auf Tablets stehen sie
   als breite Bannerkacheln untereinander — dadurch bleiben sie auch dort
   deutlich präsenter als die Disziplinkacheln. */
.grid--sparten { grid-template-columns: 1fr; }

@media (min-width: 62rem) {
  .grid--sparten {
    grid-template-columns: repeat(2, minmax(0, 1fr));
    /* Genau so hoch wie eine über zwei Reihen laufende Disziplinkachel */
    grid-auto-rows: calc(2 * var(--sv-tile-row) + var(--sv-space-24));
  }

  .grid--sparten .sport-tile { height: 100%; }
}

/* --- Zweispaltiges Layout: Inhalt + Seitenspalte ------------------------- */

.layout-sidebar {
  display: grid;
  gap: var(--sv-space-40);
  grid-template-columns: 1fr;
  align-items: start;
}

@media (min-width: 60rem) {
  .layout-sidebar {
    grid-template-columns: minmax(0, 1fr) 20rem;
    gap: var(--sv-space-48);
  }
  .layout-sidebar--left { grid-template-columns: 20rem minmax(0, 1fr); }
}

/* Ein Block, der unter einem zweispaltigen Layout steht — etwa die
   Terminliste unter Inhalt und Randspalte. */
.layout-sidebar + * { margin-top: var(--sv-space-40); }

/* Ein Raster, das auf eine Kennzahlenreihe folgt, hält Abstand */
.stats + .grid { margin-top: var(--sv-space-32); }

/* --- Randspalte ----------------------------------------------------------
   Inhalte in der Randspalte sind Begleitinformation. Überschriften und Texte
   stehen dort eine Stufe kleiner als im Hauptbereich — das war bisher auf
   jeder Seite einzeln inline gesetzt. */

.sidebar > h2,
.sidebar .info-box > h2 { font-size: var(--sv-text-xl); }

.sidebar .info-box p { font-size: var(--sv-text-sm); }

/* --- Bild + Text nebeneinander ------------------------------------------ */

.split {
  display: grid;
  gap: var(--sv-space-32);
  align-items: center;
  /* minmax(0, 1fr) statt 1fr — gemessen am 12.09.2026 bei 320 Pixeln Breite.

     Eine 1fr-Spur wird nie schmaler als der Inhalt, den sie mindestens
     braucht (min-content). Auf verein/sponsoren.html steckt in der Info-Box
     die Überschrift „Spendenquittungen (Zuwendungsbestätigungen)". Das
     längste Wort darin misst 248 Pixel, mit dem Innenabstand der Box 314 —
     die Spur wuchs auf 314 Pixel, der Container hatte 288, und die Seite
     bekam einen Querbalken. Als einzige von 28.

     Die Überschriftenregel in base.css bricht lange Wörter zwar (`hyphens:
     auto` plus `overflow-wrap: break-word`), aber `break-word` senkt
     absichtlich die Mindestbreite nicht — sonst schrumpfen Rasterspalten
     unkontrolliert. Beides zusammen ergibt sonst genau diesen Fall: Die
     Spur wächst, statt dass das Wort bricht. Mit minmax(0, …) darf die Spur
     schrumpfen, und dann greift der Umbruch.

     WCAG 1.4.10 verlangt, dass eine Seite bei 320 Pixeln ohne waagerechtes
     Scrollen lesbar bleibt — das entspricht 1280 Pixeln bei 400 % Zoom. */
  grid-template-columns: minmax(0, 1fr);
}

@media (min-width: 55rem) {
  .split { grid-template-columns: repeat(2, minmax(0, 1fr)); gap: var(--sv-space-48); }
  .split--media-right .split__media { order: 2; }
}

/* `display: block` steht schon im Reset (base.css) — hier noch einmal, weil es
   dort nur am Element hängt und damit die schwächste aller Regeln ist. Ein
   Baukasten, der `.irgendein-widget img { display: inline-block }` schreibt,
   überstimmt sie mühelos; am 05.09.2026 auf der Pilotseite genau so vorgefunden.
   Ein Bild auf der Textgrundlinie lässt darunter den Platz für die Unterlängen
   stehen — ein paar Pixel, die kein Mensch sucht.

   Die Aussage ist eine des Bausteins selbst: Ein Bild in dieser Komponente ist
   ein Block, kein Wort in einer Zeile.

   Nicht zu verwechseln mit dem, was an jenem Tag zuerst auffiel: Dort waren
   45 px unter dem Bild eine eingeblendete Bildunterschrift, weil der Alt-Text
   versehentlich als Unterschrift eingetragen war. Das ist eine Eingabe, keine
   Regel — und im Stylesheet nicht zu beheben. */
.split__media img { border-radius: var(--sv-radius-lg); width: 100%; display: block; }

/* --- Flex-Hilfen --------------------------------------------------------- */

/* `.cluster` reiht Dinge NEBENEINANDER — daher der Name. Die Richtung steht
   ausdrücklich da, obwohl `row` die Vorgabe des Browsers ist: Elementor baut
   aus so einem Kasten einen Container, und Container stehen dort auf
   `flex-direction: column`.

   Gemessen am 12.09.2026 auf der Aktuelles-Seite: Filterknöpfe und der Verweis
   auf die Wettkampfergebnisse standen untereinander statt nebeneinander, und
   `cluster--between` schob nichts mehr auseinander, weil es in einer Spalte
   nichts zu verteilen gibt. Dieselbe Ursache wie bei `.section-header`. */
.cluster {
  display: flex;
  flex-direction: row;
  flex-wrap: wrap;
  gap: var(--sv-space-16);
  align-items: center;
}

.cluster--between { justify-content: space-between; }
.cluster--end { justify-content: flex-end; }

.flow-center { text-align: center; }
.flow-center p { margin-inline: auto; }
