/* ==========================================================================
   Responsive-Fundament (Etappe 0 der Mobil-Umstellung)

   Diese Datei enthaelt ausschliesslich das, was auf JEDER Seite gilt:
   Kopfzeile/Navigation, Seitenpolsterung, Formularfelder, Modals,
   Beruehrungsflaechen und die beiden wiederverwendbaren Tabellenmuster.
   Seitenspezifische Anpassungen gehoeren in die jeweilige Seiten-CSS
   (bookings.css, settings.css, ...), NICHT hierher - sonst waechst diese
   Datei zu einer zweiten, parallelen Stylesheet-Sammlung heran.

   Ladereihenfolge: MUSS als letzte CSS-Datei eingebunden werden (siehe
   layout.php, operator/layout.php, auth/*.php). Die Regeln hier haben
   bewusst dieselbe oder eine niedrigere Spezifitaet wie die Basisregeln,
   die sie ueberschreiben - sie gewinnen ueber die Reihenfolge, nicht ueber
   !important. Zwei Ausnahmen: die beiden u-hide-*-Hilfsklassen ganz unten.

   BREAKPOINTS - verbindliche Konvention fuer die gesamte App. Neue Media
   Queries verwenden ausschliesslich diese drei Werte, damit nicht in jeder
   Datei ein eigener Umbruchpunkt entsteht (CSS kennt keine Variablen in
   Media Queries, die Werte muessen also per Konvention zusammengehalten
   werden):

     max-width: 1024px   Tablet quer / schmaler Laptop - Seitenlayouts
                         entzerren, noch keine Umstellung auf "mobil"
     max-width:  720px   HAUPTUMBRUCH: ab hier gilt "mobil". Navigation im
                         Burger-Menue, Tabellen als Karten, Spalten
                         gestapelt. Entspricht den bereits vorhandenen
                         Media Queries in settings.css/statistics.css/
                         operator.css/public-site.css.
     max-width:  480px   schmales Telefon - nur fuer Faelle, die bei 720px
                         noch passen und erst hier wirklich zu eng werden.

   Der Gegenpart fuer "nur Desktop" ist min-width: 721px (bzw. 1025px),
   damit sich die Bereiche nicht ueberlappen.
   ========================================================================== */


/* --------------------------------------------------------------------------
   Kopfzeile: Navigation im Burger-Menue
   --------------------------------------------------------------------------
   Die acht Navigationspunkte passen in einer Zeile nur auf breiten
   Bildschirmen. Bis 1024px wandern sie in ein aufklappbares Panel direkt
   unter der Kopfzeile; der Umschalter sitzt links vor dem Logo. Bis
   2026-11-02 lag die Grenze bei 720px - zwischen 721 und ~1280px reichte
   der Platz aber nicht, das Logo schrumpfte auf 0 und rechts wurde
   abgeschnitten. Oberhalb von 1024px rueckt die Kopfzeile stattdessen
   fliessend zusammen (base.css, clamp()-Werte an .app-header/.app-nav, volle
   Groesse ab 1600px).
   Die groesseren Beruehrungsflaechen (40px) bleiben beim 720px-Umbruch.

   Auf/Zu laeuft ueber die Klasse .is-open (nicht ueber das hidden-Attribut
   wie bei Glocke und Profilmenue): Wird das Menue mobil geschlossen und das
   Fenster danach verbreitert, muss die Navigation auf dem Desktop wieder
   sichtbar sein - ein gesetztes hidden-Attribut wuerde das verhindern und
   die Navigation dauerhaft verschwinden lassen. Mit der Klasse ist der
   Desktop-Zustand unberuehrt, weil ihn dort ohnehin keine Regel auswertet.
   -------------------------------------------------------------------------- */

/* Ausserhalb jeder Media Query, damit der Knopf auf dem Desktop garantiert
   verschwindet - auch auf Seiten, die responsive.css laden, aber nie in den
   mobilen Zweig kommen. */
.app-nav-toggle {
    display: none;
}

@media (max-width: 1024px) {
    .app-nav-toggle {
        display: flex;
        align-items: center;
        justify-content: center;
        flex-shrink: 0;
        width: var(--header-control);
        height: var(--header-control);
        margin-top: 0; /* globale button-Regel aus shared.css zuruecknehmen */
        padding: 0;
        background: none;
        border: none;
        border-radius: 50%;
        color: var(--color-text-muted);
        cursor: pointer;
    }

    .app-nav-toggle:hover {
        background: var(--color-bg);
        color: var(--color-text);
    }

    .app-header__brand {
        flex: 1;
        min-width: 0;
    }

    /* z-index 45: ueber dem Seiteninhalt (Kalender-Sticky-Zeilen liegen bei
       30), aber unter dem Modal-Overlay (50) und den beiden Kopf-Dropdowns
       (100) - ein geoeffnetes Profil-/Glockenmenue soll das Nav-Panel
       ueberdecken, nicht umgekehrt.
       Kein eigenes "position" an der Kopfzeile: base.css setzt sie auf
       sticky, und als Bezugspunkt fuer das absolut platzierte Panel taugt
       sticky genauso - jeder Wert ausser static bildet einen Containing
       Block. */
    .app-nav {
        display: none;
        position: absolute;
        top: 100%;
        left: 0;
        right: 0;
        z-index: 45;
        flex-direction: column;
        gap: 0;
        padding: 0.4rem;
        background: var(--color-surface);
        border-bottom: 1px solid var(--color-border);
        box-shadow: 0 6px 14px rgba(0, 0, 0, 0.12);
    }

    .app-nav.is-open {
        display: flex;
    }

    .app-nav__link {
        padding: 0.75rem 0.8rem;
        font-size: 1rem;
    }
}

/* Auf dem Tablet kein Panel ueber die volle Breite, sondern ein schmales
   Dropdown unter dem Umschalter - eine 1000px breite Liste mit acht kurzen
   Eintraegen wirkte verloren. */
@media (min-width: 721px) and (max-width: 1024px) {
    .app-nav {
        right: auto;
        width: 280px;
        border-right: 1px solid var(--color-border);
        border-bottom-right-radius: var(--radius);
    }
}

@media (max-width: 720px) {
    /* 40px statt 36px: naeher an den ueblichen 44px Mindestgroesse fuer
       Fingertipps, ohne die Kopfzeile aufzublaehen. Ein Wert genuegt - Logo,
       Navigationslinks, Menue-, Hilfe- und Glockenknopf sowie der Profil-
       Avatar haengen alle an --header-control (base.css). */
    .app-header {
        --header-control: 40px;
        gap: 0.5rem;
        padding: 0.6rem 0.75rem;
    }

    .app-header__user {
        gap: 0.15rem;
    }

    /* Kein Platz neben Menue, Logo und vier Knoepfen - der Hinweis zur
       Testphase steht auf schmalen Geraeten nur im Profil-Dropdown. */
    .app-header__trial {
        display: none;
    }

    /* Die Dropdowns duerfen auf schmalen Geraeten nicht ueber den rechten
       Rand hinauslaufen: min-width (260px bzw. 200px) bleibt als Wunsch
       bestehen, max-width deckelt sie auf die Bildschirmbreite. */
    .notification-menu__dropdown,
    .profile-menu__dropdown {
        max-width: calc(100vw - 1.5rem);
    }
}


/* --------------------------------------------------------------------------
   Seiteninhalt
   -------------------------------------------------------------------------- */

@media (max-width: 720px) {
    .app-content {
        padding: 1rem 0.75rem;
    }

    /* Karten sind auf dem Telefon der Hauptinhalt und muessen nicht noch
       einmal 1.25rem Innenabstand von der ohnehin knappen Breite abziehen. */
    .card {
        padding: 1rem 0.85rem;
        margin-bottom: 1rem;
    }
}


/* --------------------------------------------------------------------------
   Formulare und Beruehrungsflaechen
   -------------------------------------------------------------------------- */

@media (max-width: 720px) {
    /* 16px ist kein Geschmacks-, sondern ein Verhaltenswert: iOS Safari
       zoomt beim Hineintippen automatisch in jedes Feld, dessen Schrift
       kleiner als 16px ist, und laesst die Seite danach verschoben stehen.
       Die Felder erben ueber "font: inherit" (shared.css) die Schriftgroesse
       ihres Umfelds - in Tabellen und Panels also oft 0.85-0.92rem. Hier
       einmal zentral festgenagelt. */
    input,
    select,
    textarea {
        font-size: 16px;
        padding: 0.65rem 0.7rem;
    }

    /* Bewusst KEIN globales "button { min-height: 44px }": ein gutes Dutzend
       Knoepfe in dieser Codebase sind runde Icon-Flaechen mit fester height
       (Glocke, Profil, Wegklick-Kreuz, Kalender-Steuerung). min-height
       gewinnt gegen height und wuerde sie alle zu Ovalen ziehen. Deshalb
       gezielt die klassenlosen Formular-Knoepfe (praktisch immer Absenden-
       Buttons) und die eine generische Sekundaerklasse. */
    button:not([class]),
    .btn-secondary {
        min-height: 44px;
    }

    /* Zwei Felder pro Zeile, dreier-Reihen brechen nach dem zweiten um.
       Die Breite ist bewusst RELATIV zur Zeile und nicht als rem-Schwelle
       formuliert: 50% minus dem halben Spaltenabstand ergibt fuer zwei
       Felder exakt 100%, fuer drei zwangslaeufig mehr - der Umbruch folgt
       also aus der Anzahl der Felder statt aus einer Pixelrechnung.

       Eine feste Schwelle (zuvor 9rem) haengt dagegen an der Schriftgroesse
       UND an der Bildschirmbreite und kippt an beiden: auf einem 360px-Geraet
       blieben davon 9px Reserve, sodass bereits eine auf 17px hochgestellte
       Systemschrift - unter Android eine gewoehnliche Einstellung - jedes
       Feld einzeln untereinander stellte. Und schon bei Standardschrift
       stapelte sich ausgerechnet die Zeile mit dem breiter bauenden
       Datumsfeld als einzige, was wie ein Fehler aussieht.

       row-gap: 0 haelt die vertikalen Abstaende gleich. Der Abstand zwischen
       zwei Feldern kommt ueberall aus dem margin-top des Labels (0.75rem,
       shared.css); ein zusaetzlicher Zeilenabstand aus dem gap traefe nur
       umgebrochene Zeilen und machte deren Abstand groesser als den zwischen
       zwei .form-row-Bloecken (gemessen 47px statt 35px). */
    .form-row {
        --field-gap: 0.75rem;
        flex-wrap: wrap;
        column-gap: var(--field-gap);
        row-gap: 0;
    }

    .form-row > div {
        flex: 1 1 calc(50% - var(--field-gap) / 2);
        min-width: 0;
    }

    /* Gegenstueck zu field-wide: eine Reihe aus schmalen, zusammengehoerigen
       Feldern, die auch auf dem Telefon nebeneinander bleiben soll (etwa die
       drei Zaehler Erwachsene/Kinder/Hunde im Buchungsmodal). Ohne die
       Variante zerlegte die Zwei-pro-Zeile-Regel sie in "2 + 1", was drei
       gleichrangige Werte optisch auseinanderreisst.

       flex-basis: 0 statt 50% - die Felder teilen sich die Zeile zu gleichen
       Teilen, egal wie viele es sind. Nur fuer Inhalte einsetzen, die in
       einem Drittel Zeilenbreite noch bedienbar sind. */
    .form-row--compact > div {
        flex: 1 1 0;
    }

    /* In einem Drittel Zeilenbreite (rund 94px) braucht die Beschriftung
       weniger Platz, sonst bricht "Erwachsene" neben seinem Symbol um. */
    .form-row--compact label {
        font-size: 0.75rem;
    }

    /* Felder, denen die halbe Zeile inhaltlich nicht reicht - im Markup mit
       class="field-wide" ausgezeichnet, so wie breite Tabellenspalten mit
       data-card="wide". Zwei Faelle gibt es dafuer:

       - Ein natives Datumsfeld hat eine feste Mindestbreite, die es sich
         nicht nehmen laesst: "TT.MM.JJJJ" plus Kalendersymbol. Ist das Feld
         schmaler, schneidet der Browser den Text ab - unter Android sichtbar
         an der letzten Ziffer der Jahreszahl. Wie breit genau, rendert jede
         Plattform anders; in der Desktop-Emulation sieht es unauffaellig
         aus, auf dem Geraet nicht.
       - Eine E-Mail-Adresse in 148px zeigt drei bis vier Zeichen. Das Feld
         funktioniert, ist aber nicht kontrollierbar.

       Statt fester Vollbreite eine Mindestbreite: auf dem Telefon reicht
       sie nicht, das Feld nimmt die ganze Zeile - auf einem Tablet passen
       zwei solcher Felder weiterhin nebeneinander. */
    .form-row > .field-wide {
        min-width: min(100%, 14rem);
    }
}


/* --------------------------------------------------------------------------
   Modals
   --------------------------------------------------------------------------
   Die Modals sind mit "width: 100%; max-width: <n>px" bereits fluid; auf dem
   Telefon stoert nur die grosszuegige Polsterung des Overlays (3rem oben)
   und die Deckelung der breiten Varianten (.modal--x mit eigener
   max-width, die hier ohnehin nie erreicht wird).
   -------------------------------------------------------------------------- */

@media (max-width: 720px) {
    .modal-backdrop {
        align-items: flex-start;
        padding: 1rem 0.6rem 2rem;
    }

    /* Spezifitaet 0,2,0 - schlaegt die .modal--x-Varianten (0,1,0), ohne
       dass hier jede einzelne aufgezaehlt werden muss. */
    .modal-backdrop .modal {
        max-width: none;
        padding: 1.1rem;
    }

    /* Fusszeile jedes Modals der App (Einstellungen, Reinigung, Kommunikation,
       Website-Baukasten ...) und auch mancher Formularseite wie "Gast
       bearbeiten". Aufbau ueberall gleich: links optional eine destruktive
       Aktion, rechts .modal-actions__right mit Abbrechen und der Hauptaktion.

       Gestapelt ueber die volle Breite, in der Reihenfolge Hauptaktion -
       Abbrechen - Loeschen. Zweimal column-reverse dreht dafuer die
       Markup-Reihenfolge um; ein blosses Umbrechen wuerde sich nach dem
       Markup richten und die Loeschen-Aktion nach OBEN setzen, also die
       gefaehrlichste Schaltflaeche an die prominenteste Stelle. Dieselbe
       Behandlung wie .bm-footer im Buchungsmodal (bookings.css) - die beiden
       Fusszeilen sollen sich auf dem Telefon nicht unterschiedlich
       verhalten. */
    .modal-actions {
        flex-direction: column-reverse;
        align-items: stretch;
        gap: 0.6rem;
    }

    /* margin-left: auto haelt die Gruppe auf dem Desktop rechts. In der
       gestapelten Spalte macht dasselbe auto-Margin das Gegenteil von dem,
       was hier gebraucht wird: Es hebt das Strecken durch align-items:
       stretch auf, die Gruppe schrumpft auf ihre Inhaltsbreite und die
       Knoepfe darin bleiben schmal - waehrend die Loeschen-Aktion daneben
       ueber die volle Breite geht. */
    .modal-actions__right {
        display: flex;
        flex-direction: column-reverse;
        gap: 0.6rem;
        margin-left: 0;
    }

    .modal-actions button {
        width: 100%;
        min-height: 44px;
        justify-content: center;
    }

    /* Die Textlink-Variante der Loeschen-Aktion ("Gast loeschen") ist nur so
       hoch wie ihre Schrift, also rund 22px - als Ziel fuer einen Fingertipp
       zu klein, ausgerechnet bei der destruktiven Aktion. Bewusst nur hier
       und nicht fuer jeden .link-button: in Fliesstext ist ein 44px hoher
       Textlink fehl am Platz. */
    .modal-actions .link-button {
        min-height: 44px;
        justify-content: center;
    }
}


/* --------------------------------------------------------------------------
   Tabellenmuster
   --------------------------------------------------------------------------
   Fuer die 15 Views mit <table> gibt es genau zwei zugelassene Antworten -
   die Entscheidung faellt pro Tabelle, aber die Umsetzung ist beide Male
   dieselbe:

   1. .table-scroll  Wrapper-<div> um die Tabelle. Die Tabelle behaelt ihre
                     Spalten und wird horizontal scrollbar. Richtig fuer
                     Tabellen, die man vergleichend liest (Einstellungs-
                     Panels, Kanaluebersicht).

   2. .table-cards   Klasse auf dem <table>. Unter 720px wird jede Zeile zu
                     einer Karte mit "Spaltenname: Wert" untereinander.
                     Richtig fuer Listen, die man Zeile fuer Zeile abarbeitet
                     (Buchungen, Gaeste, Zahlungen).

   Die Beschriftungen fuer Variante 2 stehen NICHT im Markup: table-cards.js
   traegt sie als data-label aus dem <thead> nach - auch fuer Zeilen, die
   erst spaeter per JavaScript entstehen (bookings.js, guests.js, ...).
   -------------------------------------------------------------------------- */

.table-scroll {
    overflow-x: auto;
    -webkit-overflow-scrolling: touch;
}

@media (max-width: 720px) {
    /* display:block loest den Tabellen-Layoutalgorithmus auf; ohne das
       bleiben die Spaltenbreiten aneinander gekoppelt und die Karten haetten
       weiterhin eine gemeinsame, viel zu breite Spaltenaufteilung. */
    .table-cards,
    .table-cards tbody,
    .table-cards tr,
    .table-cards td {
        display: block;
        width: 100%;
    }

    /* Die Regel darueber wuerde sonst das hidden-Attribut aushebeln: das
       "display: none" dafuer stammt aus dem Browser-Standardstylesheet und
       verliert gegen JEDE Autorenregel, unabhaengig von der Spezifitaet.
       Die Listenfilter blenden Zeilen genau so aus (guests.js: row.hidden =
       !matches, ebenso bookings.js) - ohne diese Zeile bliebe auf dem
       Telefon jede weggefilterte Zeile stehen.

       Die Tabelle SELBST gehoert mit in die Aufzaehlung: mehrere Views
       blenden ihre Tabelle aus, solange sie leer ist, und zeigen stattdessen
       einen Hinweistext (Vorlagenliste der Kommunikation, ...) - ohne diese
       Zeile staende darunter mobil zusaetzlich eine leere Tabelle. */
    .table-cards[hidden],
    .table-cards tr[hidden],
    .table-cards td[hidden] {
        display: none;
    }

    /* Die Kopfzeile wird durch die data-label-Vorspalte ersetzt. Nicht
       display:none auf <thead> allein - sortierbare <th> sollen mobil auch
       nicht mehr anklickbar sein. */
    .table-cards thead {
        display: none;
    }

    .table-cards tr {
        margin-bottom: 0.7rem;
        padding: 0.35rem 0.8rem;
        background: var(--color-surface);
        border: 1px solid var(--color-border);
        border-radius: var(--radius);
    }

    .table-cards td {
        display: flex;
        align-items: baseline;
        justify-content: space-between;
        gap: 1rem;
        padding: 0.4rem 0;
        text-align: right;
        /* Trennlinie oben statt unten: Die letzte Spalte ist haeufig die
           namenlose Aktionsspalte und damit oft leer - sie wird dann
           ausgeblendet (data-card-empty weiter unten) und ein
           "td:last-child { border-bottom: none }" haette die falsche Zelle
           erwischt, naemlich eine unsichtbare. Die erste Spalte traegt
           dagegen praktisch immer den Hauptwert der Zeile und ist nie leer.

           Das border-bottom MUSS dabei explizit weg: es kommt aus der
           globalen "th, td"-Regel in base.css und bliebe sonst zusaetzlich
           stehen. Zwischen zwei Zellen faellt es mit der Oberlinie der
           naechsten zusammen und faellt nicht auf - unter der letzten
           sichtbaren Zelle bleibt es als ueberzaehlige Linie stehen. */
        border-top: 1px solid var(--color-border);
        border-bottom: none;
        /* Der Zellinhalt ist ein anonymes Flex-Element und damit von aussen
           nicht ansprechbar - es behaelt min-width: auto und kann unter seine
           Inhaltsbreite nicht schrumpfen. Eine lange E-Mail-Adresse (ein
           einziges "Wort" ohne Trennmoeglichkeit) waechst deshalb aus der
           Karte heraus. overflow-wrap wird vererbt, wirkt also auch auf das
           anonyme Element, und "anywhere" senkt zusaetzlich dessen
           min-content-Breite - genau das, was das Flex-Layout braucht.
           Gebrochen wird nur, wenn es sonst ueberlaufen wuerde. */
        overflow-wrap: anywhere;
    }

    .table-cards tr td:first-child {
        border-top: none;
    }

    .table-cards td::before {
        content: attr(data-label);
        flex-shrink: 0;
        color: var(--color-text-muted);
        font-weight: 600;
        text-align: left;
    }

    /* Breite Spalten: Wert unter die Beschriftung statt daneben.
       Nebeneinander bleibt fuer den Wert nur die halbe Kartenbreite - ein
       Datumszeitraum bricht dort mitten im "01.01.2026 – 08.01.2026" um und
       die beiden Daten stehen danach unterschiedlich weit links (der
       Trennstrich haengt am Ende der ersten Zeile). Untereinander hat der
       Wert die volle Breite, passt in eine Zeile und bleibt buendig.

       Gesetzt wird das pro SPALTE am <th data-card="wide">; table-cards.js
       traegt es auf die Zellen nach - eine Angabe pro Tabelle statt eine pro
       Zelle, und sie gilt automatisch auch fuer nachtraeglich gerenderte
       Zeilen. */
    .table-cards td[data-card="wide"] {
        display: block;
        text-align: left;
    }

    .table-cards td[data-card="wide"]::before {
        display: block;
        margin-bottom: 0.1rem;
        font-size: 0.78rem;
    }

    /* Zellen ohne Beschriftung - die namenlose Aktionsspalte am Zeilenende
       und aufgespannte "Keine Eintraege"-Zellen (colspan). table-cards.js
       setzt dort bewusst kein data-label; die Zelle nimmt dann die volle
       Kartenbreite ein, statt rechtsbuendig neben einer leeren Vorspalte zu
       kleben. */
    .table-cards td:not([data-label]) {
        display: block;
        text-align: left;
    }

    .table-cards td:not([data-label])::before {
        content: none;
    }

    /* Leere Zellen ganz weglassen. In der Tabellenansicht faellt eine leere
       Zelle nicht auf, in der Karte ist sie eine eigene Zeile, die nur aus
       einer Beschriftung besteht ("Telefon" und dahinter nichts). Welche
       Zelle als leer gilt, entscheidet table-cards.js - dort steht auch,
       warum ein Loeschknopf ohne Textinhalt nicht dazugehoert.

       Bewusst die LETZTE Regel des Blocks: alle Regeln darueber haben
       dieselbe Spezifitaet (0,2,1) und setzen ein display - eine leere
       Zelle kann gleichzeitig breit (data-card="wide") oder unbeschriftet
       sein und wuerde von der jeweils spaeteren Regel wieder sichtbar
       gemacht. */
    .table-cards td[data-card-empty] {
        display: none;
    }

    /* ---- Aufklappbare Karten (data-card-collapse am <table>) ----
       Zugeklappt ist die Karte eine einzige Zeile aus den Spalten mit
       data-card-summary (Hauptwert fett links, weitere Werte klein daneben,
       Aktionsknoepfe und Pfeil rechts); aufgeklappt folgen darunter die
       uebrigen Werte im normalen "Spaltenname: Wert"-Muster. Zustand und
       Tippen: table-cards.js.

       Die Zeile wird dafuer zum umbrechenden Flex-Container: Kopfzellen und
       Pfeil (::after) teilen sich die erste Zeile, jede Detailzelle nimmt mit
       flex-basis 100% eine eigene darunter ein (order 2).

       :not([hidden]) ist Pflicht - die Regel ist spezifischer als
       ".table-cards tr[hidden]" oben und wuerde weggefilterte Zeilen sonst
       wieder einblenden. */
    .table-cards tr[data-card-collapsible]:not([hidden]) {
        display: flex;
        flex-wrap: wrap;
        align-items: center;
        column-gap: 0.6rem;
        margin-bottom: 0.4rem;
        padding: 0 0.8rem;
        cursor: pointer;
        -webkit-tap-highlight-color: transparent;
    }

    .table-cards tr[data-card-collapsible]:not([hidden])::after {
        content: '';
        order: 1;
        flex: 0 0 auto;
        width: 0.45rem;
        height: 0.45rem;
        margin: 0 0.15rem 0.2rem 0;
        border-right: 2px solid var(--color-text-muted);
        border-bottom: 2px solid var(--color-text-muted);
        transform: rotate(45deg);
        transition: transform 0.15s ease;
    }

    .table-cards tr[data-card-open]:not([hidden])::after {
        margin: 0.2rem 0.15rem 0 0;
        transform: rotate(-135deg);
    }

    /* width: auto nimmt das "width: 100%" der Grundregel zurueck - ueber
       flex-basis: auto wuerde sonst jede Kopfzelle eine eigene Zeile
       fuellen. */
    .table-cards tr[data-card-collapsible] td[data-card-summary] {
        display: block;
        width: auto;
        flex: 0 1 auto;
        min-width: 0;
        padding: 0.6rem 0;
        border-top: none;
        text-align: left;
        white-space: nowrap;
        overflow: hidden;
        text-overflow: ellipsis;
        color: var(--color-text-muted);
        font-size: 0.85rem;
    }

    .table-cards tr[data-card-collapsible] td[data-card-summary]::before {
        content: none;
    }

    /* Grundbreite 0 statt auto: in einem umbrechenden Flex-Container wird
       erst nach der Grundbreite umbrochen und danach geschrumpft - ein langer
       Name schob den Pfeil sonst in eine zweite Zeile, statt mit "..."
       gekuerzt zu werden. Die Nebenwerte sind aus demselben Grund gedeckelt. */
    .table-cards tr[data-card-collapsible] td[data-card-summary]:not([data-card-summary="main"]) {
        max-width: 45%;
    }

    .table-cards tr[data-card-collapsible] td[data-card-summary="main"] {
        flex: 1 1 0;
        color: var(--color-text);
        font-size: 0.95rem;
        font-weight: 600;
    }

    /* Aufgeklappt darf der Hauptwert umbrechen - sonst bliebe ein langer
       Name auch in der offenen Karte abgeschnitten. */
    .table-cards tr[data-card-open] td[data-card-summary] {
        white-space: normal;
    }

    /* Aktionszellen in der Kopfzeile (ohne Spaltenname: "Details",
       Bearbeiten-Symbol ...) behalten ihre volle Breite und werden nicht
       abgeschnitten. Als Flex-Container, damit der Knopf mittig sitzt:
       inline in der Zelle stuende er auf der Grundlinie und rutschte
       sichtbar unter die Nachbarwerte ("Details" in der Buchungsliste). */
    .table-cards tr[data-card-collapsible] td[data-card-summary]:not([data-label]) {
        display: flex;
        align-items: center;
        flex: 0 0 auto;
        overflow: visible;
        color: inherit;
    }

    .table-cards tr[data-card-collapsible] td:not([data-card-summary]) {
        flex: 0 0 100%;
        order: 2;
    }

    .table-cards tr[data-card-collapsible]:not([data-card-open]) td:not([data-card-summary]) {
        display: none;
    }

    /* Aufgeklappt wandern die Nebenwerte der Kopfzeile (Anreise, Einheit,
       Vorlage ...) als normale "Spaltenname: Wert"-Zeilen in die Liste
       darunter - in der Spaltenreihenfolge, also z. B. "Anreise" direkt vor
       "Abreise". Blieben sie unbeschriftet oben stehen, fehlte in der Liste
       scheinbar ein Wert (Nutzerfeedback 2026-11-16: Abreise ohne Anreise).
       Oben bleiben nur Hauptwert, Knoepfe und Pfeil. */
    .table-cards tr[data-card-open] td[data-card-summary=""][data-label] {
        display: flex;
        flex: 0 0 100%;
        order: 2;
        max-width: none;
        padding: 0.4rem 0;
        border-top: 1px solid var(--color-border);
        text-align: right;
        white-space: normal;
        overflow: visible;
        color: inherit;
        font-size: inherit;
    }

    .table-cards tr[data-card-open] td[data-card-summary=""][data-label]::before {
        content: attr(data-label);
    }

    /* Der Hauptwert bleibt oben, bekommt aufgeklappt aber seine Beschriftung
       klein darueber - sonst stuende in den Aufenthalten oben ein Datum ohne
       Namen und darunter "Abreise", die Anreise waere nicht erkennbar. */
    .table-cards tr[data-card-open] td[data-card-summary="main"][data-label]::before {
        content: attr(data-label);
        display: block;
        margin-bottom: 0.1rem;
        color: var(--color-text-muted);
        font-size: 0.72rem;
        font-weight: 600;
    }

    .table-cards tr[data-card-open] td[data-card-summary=""][data-label][data-card="wide"] {
        display: block;
        text-align: left;
    }

    /* Wie oben "td[data-card-empty]" als letzte Regel - die Kopfzellen-Regeln
       sind spezifischer und wuerden eine leere Kopfzelle sonst einblenden. */
    .table-cards tr[data-card-collapsible] td[data-card-empty],
    .table-cards tr[data-card-collapsible] td[data-card-empty][data-card-summary]:not([data-label]),
    .table-cards tr[data-card-open] td[data-card-empty][data-card-summary=""][data-label] {
        display: none;
    }
}


/* --------------------------------------------------------------------------
   Einfuehrungstour (intro.js)
   --------------------------------------------------------------------------
   Welche Schritte eine Tour mobil ueberhaupt zeigt, entscheidet tour.js
   (Sichtbarkeitspruefung plus optionales viewport-Feld). Hier steht nur die
   Darstellung: die Standardbreite von intro.js (300px zzgl. Rahmen) ragt auf
   einem 320px-Geraet ueber den Rand hinaus.
   -------------------------------------------------------------------------- */

@media (max-width: 720px) {
    .introjs-tooltip {
        max-width: calc(100vw - 1.5rem);
    }
}


/* --------------------------------------------------------------------------
   Hilfsklassen
   --------------------------------------------------------------------------
   Fuer Inhalte, die auf einer Seite nur in einer der beiden Welten Sinn
   ergeben (z.B. eine erklaerende Nebenspalte, die mobil entfaellt).
   !important ist hier gewollt: eine Hilfsklasse, die von der naechstbesten
   Seitenregel ueberstimmt wird, ist keine Hilfsklasse. Sparsam einsetzen -
   doppelt gepflegte Varianten desselben Inhalts sind fast immer der
   schlechtere Weg gegenueber einem Layout, das beides kann.
   -------------------------------------------------------------------------- */

@media (max-width: 720px) {
    .u-hide-mobile {
        display: none !important;
    }
}

@media (min-width: 721px) {
    .u-hide-desktop {
        display: none !important;
    }
}
