/* =====================================================================
   lumos-native.css - the no-JS, native-first interaction layer for the
   Lumos starter. Loaded AFTER lumos.css (canonical/verbatim), BEFORE the
   tenant styles.css. Brand-agnostic.

   It ONLY adds what the native mechanism needs on top of the faithful Lumos
   markup + classes (which lumos.css already styles): show/hide bound to the
   native <details> [open] state, the native <dialog> shell reset, CSS
   scroll-snap for the slider, and CSS reveal/marquee. It must NOT re-style the
   Lumos components - lumos.css owns their look. scripts.js adds optional polish
   (dialog wiring, nav/dropdown close affordances, slider controls, ARIA tabs).

   Convention: html.js = JS present (inline <head> flag, before first paint).
   All motion respects prefers-reduced-motion.
   ===================================================================== */

/* ---- Scroll reveal: CSS-only, self-completing on load (content ends visible) ---- */
@keyframes u-reveal-in { from { opacity: 0; transform: translateY(1.25rem); } to { opacity: 1; transform: none; } }
.u-reveal { animation: u-reveal-in 0.6s both; }
.u-reveal-2 { animation-delay: 0.1s; }
.u-reveal-3 { animation-delay: 0.2s; }
.u-reveal-4 { animation-delay: 0.3s; }
@media (prefers-reduced-motion: reduce) { .u-reveal, .u-reveal-2, .u-reveal-3, .u-reveal-4 { animation: none; } }

/* ---- Marquee: CSS @keyframes, configurable via data-* on .u-marquee:
   - data-marquee-speed   seconds for one full cycle (read by scripts.js wireMarquee
                          into --marquee-duration; CSS can't read a numeric attr into
                          a time). Default 30s.
   - data-marquee-loop    "false" = static (no scroll); default loops forever.
   - data-marquee-pause-on-hover  "false" = keep scrolling on hover; default pauses.
   Loop + pause-on-hover are pure-CSS attribute toggles, so they work with NO JS; only
   speed needs the JS hook. The track must hold TWO identical sets of items so the
   -50% shift lands exactly one set over (seamless). Respects reduced-motion. ---- */
.u-marquee { overflow: hidden; }
.u-marquee_track { display: flex; width: max-content; gap: var(--_spacing---space--5, 2rem); animation: u-marquee-x var(--marquee-duration, 30s) linear infinite; }
@keyframes u-marquee-x { from { transform: translateX(0); } to { transform: translateX(-50%); } }
.u-marquee:not([data-marquee-pause-on-hover="false"]):hover .u-marquee_track { animation-play-state: paused; }
.u-marquee[data-marquee-loop="false"] .u-marquee_track { animation: none; }
@media (prefers-reduced-motion: reduce) { .u-marquee_track { animation: none; } }

/* ---- <summary> marker removal for the Lumos toggles we turn into summaries ---- */
.accordion_toggle_button::-webkit-details-marker,
.dropdown_toggle_wrap::-webkit-details-marker,
.nav_menu_summary::-webkit-details-marker { display: none; }
summary.accordion_toggle_button, summary.dropdown_toggle_wrap, summary.nav_menu_summary { list-style: none; cursor: pointer; }

/* ---- Accordion: native <details name> (single-open, no JS). The <details> is
   the .accordion_component (the element whose direct children are the summary +
   the content_wrap); its summary is the .accordion_toggle_button. lumos.css
   styles .accordion_toggle_button / _content_wrap (the latter display:none, was
   JS-driven); we only bind show + icon rotation to the native [open] state. ---- */
details[open].accordion_component .accordion_content_wrap { display: block; }
/* Icon state indicator: Lumos rotated the chevron via its [data-state] var
   (transform: rotate(-180deg * --_state---false)); that JS is stripped and the
   var is inert, so we rebind both rotations to the native [open] state, pinned
   deterministically (not relying on the dead var). Closed = the base downward
   chevron; open = 180deg (upward) - the conventional affordance, same swing
   magnitude Lumos used. */
.accordion_toggle_icon { transition: transform 0.3s ease; }
.accordion_component:not([open]) .accordion_toggle_icon { transform: rotate(0deg); }
details[open].accordion_component .accordion_toggle_icon { transform: rotate(180deg); }
/* The <h3> heading is kept INSIDE the <summary> (for screen-reader heading nav),
   but the flex layout (space-between: text | icon) lives on .accordion_toggle_button
   = the summary. Make the heading wrapper layout-transparent so the text + icon
   spans are the summary's flex items again, exactly as they were direct children
   of the original <button>. lumos.css only zeroes the heading's margins, so this
   drops nothing visible. */
summary.accordion_toggle_button > .accordion_toggle_heading { display: contents; }
@media (prefers-reduced-motion: reduce) { .accordion_toggle_icon { transition: none; } }

/* ---- Dropdown: native <details> (summary = .dropdown_toggle_wrap). lumos.css
   styles dropdown_wrap/_toggle_wrap/_content; we only bind content show + arrow
   to [open]. ---- */
details[open] .dropdown_content { display: block; }
details:not([open]) > .dropdown_content { display: none; }
/* arrow: same dead [data-state] var as the accordion icon (rotate(-180deg *
   --_state---false)); rebind both states to native [open] - closed = base
   (down), open = 180deg (up). */
.dropdown_toggle_arrow { transition: transform 0.3s ease; }
details:not([open]) > .dropdown_toggle_wrap .dropdown_toggle_arrow { transform: rotate(0deg); }
details[open] > .dropdown_toggle_wrap .dropdown_toggle_arrow { transform: rotate(180deg); }
@media (prefers-reduced-motion: reduce) { .dropdown_toggle_arrow { transition: none; } }

/* ---- Slider: CSS scroll-snap (Swiper removed). The SCROLL CONTAINER is .slider_element (the
   Swiper viewport), NOT .slider_list (the flex track). Putting overflow-x:auto on the flex track
   left it a dead box - content overflowed but no scroll method (scrollLeft / scrollBy / wheel /
   scrollIntoView) ever engaged; the element is the correct scroll container. The list stays a plain
   flex track (overflow visible) whose slides each get width:calc(100%/--slide-count) (--slide-count
   from data-slider-* via the global table). scripts.js wires the data-slider="next"/"previous" arrows
   + an optional drag + a grid-width scrollbar (no per-slide dots); the track is swipe/wheel-scrollable no-JS. ---- */
.slider_element.swiper {
  overflow-x: auto; overflow-y: hidden; scroll-snap-type: x proximity; scroll-behavior: smooth;
  -webkit-overflow-scrolling: touch; overscroll-behavior-x: contain; scrollbar-width: none;
}
.slider_element.swiper::-webkit-scrollbar { display: none; }
.slider_element.swiper .slider_list { overflow: visible; }   /* the flex track; scroll lives on the element */
/* Full-width crop-left slider (Swiper-equivalent, matches the live G&A .cond_track): while scrolling,
   off-screen cards peek into the RIGHT gutter (the track bleeds to the viewport edge); at scroll-END the
   LAST card rests flush with the content-grid right edge (a "normalised" stop, inline with the section
   content), NOT the viewport edge. How:
   (1) margin-right:-gutter extends the scroll viewport into the gutter so the overflow CLIP happens at the
       viewport edge — that's what makes the right-side peek visible (overflow:auto clips at the box, so the
       box must reach the viewport; clip-path alone can't un-clip it).
   (2) The end-space that lands the last card at the grid edge is a REAL flex item: a ::after pseudo on the
       flex track, gutter-wide. Measured the hard way — neither the scroll container's padding-right NOR a
       flex-item margin-right is counted in scrollWidth here (slides overflow .slider_list via
       overflow:visible, so Chrome ignores the wrapper's end padding/margin); only a real box with a
       definite width is. The ::after adds exactly `gutter` of scrollable content after the last card, so at
       max-scroll the last card's right = element-right(viewport) - gutter = grid edge. Verified -0.2px.
   (3) proximity (not mandatory) scroll-snap + scroll-snap-align:start on the slides: cards snap their
       LEFT edge to the container on rest (left-aligned), while proximity still lets the very END rest
       free (flush) instead of snapping back. This is the G&A native pattern - NO per-slide dots (they
       fight snap on a fractional peek slider). A grid-width custom scroll bar (scripts.js) + arrows +
       native swipe drive it; the track still scrolls without JS.
   gutter is a LENGTH (not %, which would resolve against the bled track). Opt-in via .u-bleed-right on
   .slider_offset; pair with v-slider-crop-left + body/.page_main overflow-x: clip. */
.slider_offset.u-bleed-right {
  --slider-gutter: max(var(--site--margin), calc((100vw - var(--max-width--main)) / 2));
  margin-right: calc(-1 * var(--slider-gutter));
}
.slider_offset.u-bleed-right .slider_list::after { content: ""; flex: 0 0 var(--slider-gutter); align-self: stretch; }

/* Grid-width custom scroll bar. The NATIVE scrollbar can't be used here: the track bleeds to the
   viewport for the right-gutter peek, so its scrollbar bleeds with it. scripts.js injects
   .slider_scrollbar as a grid-width sibling AFTER the bled track and syncs the thumb to scrollLeft;
   the native bar stays hidden (base rule). JS-injected, so no-JS simply has no bar (the track still
   scrolls by swipe/trackpad). */
.slider_scrollbar { position: relative; height: 0.3rem; margin-top: 1.25rem; border-radius: 999px;
  background: color-mix(in srgb, var(--_theme---text) 14%, transparent); touch-action: none; }
.slider_scrollbar_thumb { position: absolute; inset-block: 0; left: 0; min-width: 2rem; border-radius: 999px;
  background: var(--_theme---button-primary--background); cursor: grab; }
.slider_scrollbar_thumb.is-dragging { cursor: grabbing; }
html .slider_list > :not(.u-display-contents, .w-dyn-list),
.slider_list > .u-display-contents > *,
.slider_list > .u-display-contents > .u-display-contents > * { scroll-snap-align: start; }

/* ---- Range slider: native knob baseline (no JS dependency). lumos.css owns the
   track (.form_range_element) and declares `--thumb-color: currentColor`; the export's
   inline <style> overrides it to `transparent` for the JS-present path, which overlays
   Lumos's custom thumb/fill (.form_range_thumb_wrap / .form_range_fill - display:none
   in lumos.css, awaiting Lumos's runtime to un-hide + position via --progress). We
   don't ship that runtime, so under html.js re-assert the visible native knob -
   mirroring the export's own <noscript> (JS-absent) fallback. The thumb's size/shape
   (::-webkit-slider-thumb / ::-moz-range-thumb) is already styled by the export's
   inline <style>; we only restore its colour so it's visible + grabbable.
   scripts.js wireRanges() optionally upgrades to Lumos's custom thumb + progress fill
   (it sets --thumb-color:transparent inline to re-hide this native knob, so the two
   never both show). ---- */
html.js .form_range_wrap { --thumb-color: currentColor; }
/* Give the native thumb an explicit track box (the runnable-track is otherwise
   unstyled - lumos.css styles the .form_range_element wrapper, not the input's own
   track) so the 2rem knob's vertical centring is deterministic while dragging.
   Transparent + zero border so the Lumos track (.form_range_element bg) stays the
   only visible bar. */
.form_range_input::-webkit-slider-runnable-track { height: 0.7rem; background: transparent; border: 0; }
.form_range_input::-moz-range-track { height: 0.7rem; background: transparent; border: 0; }
/* No-JS swaps the slider for a real number field (0-100) - the honest no-JS control,
   since a range can't show its live value without JS (above). The number input
   carries name="Label" and is the canonical SUBMITTED field in BOTH modes: JS-on it's
   hidden but scripts.js wireRanges() writes the dragged value into it; JS-off it's the
   visible control the user reads + types. So exactly one "Label" submits either way.
   (The range loses its name in swap-range-number.py, becoming a JS-only visual driver.) */
.form_range_number_wrap { display: flex; align-items: baseline; gap: 0.6rem; }
.form_range_number { max-width: 7rem; }
.form_range_number_suffix { opacity: 0.7; }
html.js .form_range_number_wrap { display: none; }      /* JS present: show the slider, hide the number field */
html:not(.js) .form_range_element { display: none; }     /* no JS: show the number field, hide the slider */
html:not(.js) .form_range_output_wrap { display: none; } /* no JS: the "%" readout can't track - hide it */

/* ---- Modal: native <dialog> on Lumos's real structure (modal_dialog > modal_inner
   > modal_backdrop + modal_content > modal_scroll), which lumos.css fully styles.
   We ONLY reset the native <dialog> to a full-viewport transparent shell (Lumos's
   modal_dialog was a Webflow div, not a UA-centered native dialog) so modal_inner
   centers the card; keep the native ::backdrop invisible (the .modal_backdrop div
   is the dim); add the no-JS :target reveal. The light panel is Lumos-intentional. ---- */
dialog.modal_dialog {
  position: fixed; inset: 0; width: 100%; max-width: 100%; height: 100dvh; max-height: 100dvh;
  margin: 0; padding: 0; border: 0; background: transparent;
}
.modal_close { cursor: pointer; }
html:not(.js) dialog.modal_dialog:target { display: block; }

/* ---- Tabs: progressive enhancement (no markup swap - Lumos already ships
   .tab_button_list[role=tablist] + .tab_button_item buttons + .tab_content_list
   panels; scripts.js wires the ARIA tablist + switching onto it).
   No-JS baseline (§7): data-preview="true" keeps every panel stacked + reachable.
   JS present: collapse to the active (first) panel BEFORE enhanceTabs runs so
   there's no flash of the stacked baseline; enhanceTabs then sets inline display
   to switch. Lumos renders the active panel as display:block (its :first-child
   rule), which enhanceTabs mirrors. ---- */
html.js .tab_content_list > :not(:first-child):not(.u-display-contents):not(.w-dyn-list) { display: none; }
/* Auto-rotate "Hover to pause" hint - our addition (not a Lumos element). Created
   by scripts.js next to the prev/next arrows only when autoplay + pause-on-hover
   are on, shown only while playing. Inherits the theme text colour, kept muted. */
.tab_autoplay_hint { align-self: center; font-size: 0.8rem; line-height: 1; opacity: 0.55; white-space: nowrap; -webkit-user-select: none; user-select: none; }
.tab_autoplay_hint[hidden] { display: none; }

/* ---- Nav dropdowns: native <details name> (click to open, exclusive per
   breakpoint; scripts.js adds optional hover for data-hover="true"). Lumos's open
   animation lives in the per-page nav embed, keyed to the Webflow
   [aria-expanded]/.w--open states; we rebind it to the native [open]. The
   collapsed state + grid-rows transition in the embed are REUSED - we only add the
   open trigger. The .nav_component prefix wins specificity over the embed rule. ---- */
summary.w-dropdown-toggle { list-style: none; cursor: pointer; }
summary.w-dropdown-toggle::-webkit-details-marker { display: none; }
.nav_component details.nav_dropdown_component[open] > .w-dropdown-list { grid-template-rows: 1fr; visibility: visible; opacity: 1; }
.nav_component details.nav_dropdown_component[open] > summary.w-dropdown-toggle { --_state---true: 0; --_state---false: 1; }  /* expanded toggle (arrow rotation) */
.nav_component:has(details.nav_dropdown_component[open]) .nav_dropdown_backdrop { opacity: 1; }

/* ---- Mobile drawer: hamburger -> <summary>, menu -> content, in
   <details data-nav-drawer>. Lumos keyed the open state to .w-nav-button.w--open;
   rebind the menu clip-path animation + backdrop + scroll-lock + hamburger X to the
   native [open]. The menu is shown/hidden by the native <details>; the clip-path
   reveal animates it open. ---- */
summary.nav_button_wrap { list-style: none; cursor: pointer; }
summary.nav_button_wrap::-webkit-details-marker { display: none; }
/* the drawer toggle is a full-height flex item in the bar (align-items:normal);
   centre the hamburger/X lines vertically within it. */
details[data-nav-drawer] { display: flex; align-items: center; }
/* override Webflow's data-collapse="all" display:none AND supply the overlay
   positioning webflow.js used to add (.w-nav-overlay): position:absolute so the
   menu's own inset/width/margin:auto form the drop-down drawer card from the top. */
.nav_component:has(details[data-nav-drawer][open]) .w-nav-menu {
  display: block; position: absolute; float: none; z-index: 1;
  width: auto; margin: 0;  /* full width of the nav bar - drop Lumos's calc(100% - margins) + margin:auto; the menu's inset:0 0 auto stretches it edge to edge */
  animation: menuOpen var(--nav--menu-open-duration) ease-in-out forwards;
}
.nav_component:has(details[data-nav-drawer]:not([open])) .w-nav-menu { animation: menuClose var(--nav--menu-close-duration) ease-in-out forwards; }
.nav_component:has(details[data-nav-drawer][open]) .nav_menu_backdrop { opacity: 1; }  /* backdrop stays pointer-events:none (clicks pass through); scripts.js wireNav closes on any pointerdown outside the drawer */
body:has(.nav_component details[data-nav-drawer][open]) { overflow: hidden; }
details[data-nav-drawer][open] > summary { --_state---true: 0; --_state---false: 1; }  /* hamburger lines -> X */

/* ---- Slider slides-per-breakpoint: GLOBAL value table (starter) ---------------
   Mirrors Lumos's own [data-number] pattern: one global attribute->var table so a
   slider sets its count purely by attribute, with NO inline <style>. Lives here in
   lumos-native.css (loaded AFTER lumos.css) so it beats the baked-in
   .slider_offset{--lg:3} default (lumos.css:8322) at equal specificity. Covers
   integer counts 0-12 (realistic) + the fractional peek values the starter uses;
   mirrors data-number's 0-99 idea - add a line for any value beyond this set. ---- */
[data-slider-large="0"]{--lg:0}[data-slider-large="1"]{--lg:1}[data-slider-large="2"]{--lg:2}[data-slider-large="3"]{--lg:3}[data-slider-large="4"]{--lg:4}[data-slider-large="5"]{--lg:5}[data-slider-large="6"]{--lg:6}[data-slider-large="7"]{--lg:7}[data-slider-large="8"]{--lg:8}[data-slider-large="9"]{--lg:9}[data-slider-large="10"]{--lg:10}[data-slider-large="11"]{--lg:11}[data-slider-large="12"]{--lg:12}[data-slider-large="1.1"]{--lg:1.1}[data-slider-large="1.5"]{--lg:1.5}[data-slider-large="1.7"]{--lg:1.7}[data-slider-large="2.4"]{--lg:2.4}[data-slider-large="3.27"]{--lg:3.27}[data-slider-large="1.2"]{--lg:1.2}[data-slider-large="1.3"]{--lg:1.3}[data-slider-large="1.8"]{--lg:1.8}[data-slider-large="2.2"]{--lg:2.2}[data-slider-large="2.5"]{--lg:2.5}[data-slider-large="2.7"]{--lg:2.7}[data-slider-large="3.5"]{--lg:3.5}[data-slider-large="4.5"]{--lg:4.5}
[data-slider-medium="0"]{--md:0}[data-slider-medium="1"]{--md:1}[data-slider-medium="2"]{--md:2}[data-slider-medium="3"]{--md:3}[data-slider-medium="4"]{--md:4}[data-slider-medium="5"]{--md:5}[data-slider-medium="6"]{--md:6}[data-slider-medium="7"]{--md:7}[data-slider-medium="8"]{--md:8}[data-slider-medium="9"]{--md:9}[data-slider-medium="10"]{--md:10}[data-slider-medium="11"]{--md:11}[data-slider-medium="12"]{--md:12}[data-slider-medium="1.1"]{--md:1.1}[data-slider-medium="1.5"]{--md:1.5}[data-slider-medium="1.7"]{--md:1.7}[data-slider-medium="2.4"]{--md:2.4}[data-slider-medium="3.27"]{--md:3.27}[data-slider-medium="1.2"]{--md:1.2}[data-slider-medium="1.3"]{--md:1.3}[data-slider-medium="1.8"]{--md:1.8}[data-slider-medium="2.2"]{--md:2.2}[data-slider-medium="2.5"]{--md:2.5}[data-slider-medium="2.7"]{--md:2.7}[data-slider-medium="3.5"]{--md:3.5}[data-slider-medium="4.5"]{--md:4.5}
[data-slider-small="0"]{--sm:0}[data-slider-small="1"]{--sm:1}[data-slider-small="2"]{--sm:2}[data-slider-small="3"]{--sm:3}[data-slider-small="4"]{--sm:4}[data-slider-small="5"]{--sm:5}[data-slider-small="6"]{--sm:6}[data-slider-small="7"]{--sm:7}[data-slider-small="8"]{--sm:8}[data-slider-small="9"]{--sm:9}[data-slider-small="10"]{--sm:10}[data-slider-small="11"]{--sm:11}[data-slider-small="12"]{--sm:12}[data-slider-small="1.1"]{--sm:1.1}[data-slider-small="1.5"]{--sm:1.5}[data-slider-small="1.7"]{--sm:1.7}[data-slider-small="2.4"]{--sm:2.4}[data-slider-small="3.27"]{--sm:3.27}[data-slider-small="1.2"]{--sm:1.2}[data-slider-small="1.3"]{--sm:1.3}[data-slider-small="1.8"]{--sm:1.8}[data-slider-small="2.2"]{--sm:2.2}[data-slider-small="2.5"]{--sm:2.5}[data-slider-small="2.7"]{--sm:2.7}[data-slider-small="3.5"]{--sm:3.5}[data-slider-small="4.5"]{--sm:4.5}
[data-slider-xsmall="0"]{--xs:0}[data-slider-xsmall="1"]{--xs:1}[data-slider-xsmall="2"]{--xs:2}[data-slider-xsmall="3"]{--xs:3}[data-slider-xsmall="4"]{--xs:4}[data-slider-xsmall="5"]{--xs:5}[data-slider-xsmall="6"]{--xs:6}[data-slider-xsmall="7"]{--xs:7}[data-slider-xsmall="8"]{--xs:8}[data-slider-xsmall="9"]{--xs:9}[data-slider-xsmall="10"]{--xs:10}[data-slider-xsmall="11"]{--xs:11}[data-slider-xsmall="12"]{--xs:12}[data-slider-xsmall="1.1"]{--xs:1.1}[data-slider-xsmall="1.5"]{--xs:1.5}[data-slider-xsmall="1.7"]{--xs:1.7}[data-slider-xsmall="2.4"]{--xs:2.4}[data-slider-xsmall="3.27"]{--xs:3.27}[data-slider-xsmall="1.2"]{--xs:1.2}[data-slider-xsmall="1.3"]{--xs:1.3}[data-slider-xsmall="1.8"]{--xs:1.8}[data-slider-xsmall="2.2"]{--xs:2.2}[data-slider-xsmall="2.5"]{--xs:2.5}[data-slider-xsmall="2.7"]{--xs:2.7}[data-slider-xsmall="3.5"]{--xs:3.5}[data-slider-xsmall="4.5"]{--xs:4.5}

/* ===== CUSTOM OVERRIDE [CO-1]: theme-driven media-overlay (folded from Kyoom, 2026-06-25) =====
   Stock Lumos 2.2.3 (lumos.css) paints overlays as a HARDCODED-black scrim and ships only the
   base + linear `gradient` variant. Kyoom (on an older Lumos) custom-added theme-driven overlays
   + a `radial` variant. We fold that in as the starter STANDARD: overlays now derive from a theme
   role token `--_theme---overlay--background`, so they respond to the active theme/brand instead of
   being locked to black. base = scrim, `gradient` = linear (transparent->scrim), `radial` = radial
   vignette; opacity via data-number throughout. A tenant can re-point --_theme---overlay--background
   in styles.css for a brand-tinted scrim.
   Tracked in `_inventory/custom-overrides.md` (CO-1). lumos.css stays byte-identical for re-sync;
   these rules load after it and win. RE-SYNC CHECK: if a future Lumos ships theme-driven overlays
   natively, reconcile/retire this block (see the registry). ===== */
.u-theme-dark, .u-theme-light { --_theme---overlay--background: black; }
.u-theme-brand                { --_theme---overlay--background: var(--swatch--brand-800); }
.u-overlay {
  --_theme---overlay--gradient-linear: linear-gradient(0deg, color-mix(in srgb, var(--_theme---overlay--background, black) calc(var(--number, 50) / 100 * 80%), transparent) 0%, transparent 100%);
  --_theme---overlay--gradient-radial: radial-gradient(transparent 0%, color-mix(in srgb, var(--_theme---overlay--background, black) calc(var(--number, 50) / 100 * 80%), transparent) 100%);
  background-color: color-mix(in srgb, var(--_theme---overlay--background, black) calc(var(--number) / 100 * 80%), transparent);
}
/* `gradient` variant -> linear scrim (overrides lumos.css's hardcoded #0000009e gradient) */
.u-overlay:where(.w-variant-9653c0cc-21fc-fb82-1373-c98b1644e5a8) {
  background-color: transparent;
  background-image: var(--_theme---overlay--gradient-linear);
}
/* `radial` variant -> BRAND radial vignette. The Kyoom export's radial variant re-themes the overlay
   to the brand (brand-800), so the radial scrim is a warm brand tint on ANY theme (not the section's
   theme colour like the base/linear). A tenant re-points --swatch--brand-800 (or this rule) to change it. */
.u-overlay:where(.v-media-overlay-radial) {
  --_theme---overlay--background: var(--swatch--brand-800);
  background-color: transparent;
  background-image: var(--_theme---overlay--gradient-radial);
}

/* ===== CUSTOM OVERRIDE [CO-6]: themed nav logo (folded from Kyoom, 2026-06-25) =====
   The 4th token in Kyoom's overlay-era theme set. Stock Lumos 2.2.3 leaves the nav logo on the
   inherited text colour; Kyoom defines a dedicated --_theme---nav--logo role (but never wired it).
   We define it per theme context AND wire it: the logo SVG is `currentColor`, so setting `color`
   on the logo element drives it. So the logo now follows the theme/brand (brand-500 on dark/light,
   light-100 on brand) instead of the text colour; a tenant re-points it in styles.css.
   Tracked in `_inventory/custom-overrides.md` (CO-6). RE-SYNC: if new Lumos wires nav--logo itself,
   reconcile. ===== */
.u-theme-dark, .u-theme-light { --_theme---nav--logo: var(--swatch--brand-500); }
.u-theme-brand                { --_theme---nav--logo: var(--swatch--light-100); }
.nav_desktop_logo, .nav_mobile_logo { color: var(--_theme---nav--logo, currentColor); }

/* ===== CUSTOM OVERRIDE [CO-8]: Secondary typography MODE (divergence from stock Lumos) =====
   Stock Lumos ships ONE font: the `primary` family + its line-box trim, consumed by every
   text-style via --_typography---font--primary-*. Kris's Lumos DIVERGES from stock: the
   Typography variable COLLECTION gains a second MODE ("Secondary"), and the font/trim token names
   drop the `primary` qualifier so the ACTIVE MODE supplies them (base mode = body font, secondary
   mode = usually the heading font). A Webflow variable-collection mode compiles to a selector that
   re-emits the whole collection; we fold the same capability into the starter so dual-font tenants
   are first-class:
     - define a SECONDARY set (family + trim) that DEFAULTS to the primary values => a no-op for
       single-font tenants (the starter still renders in one font);
     - applying the mode (the .u-typography-secondary class, or a tenant mapping it onto headings
       in styles.css) re-points the primary-* tokens the text-styles read => that scope renders in
       the secondary font WITH its matching trim. Font + trim MUST travel together: each font's
       cap-height/baseline sit differently in the line box, so a mismatched trim clips the glyphs.
   A tenant sets the secondary font in styles.css and maps it where wanted. Tracked in
   `_inventory/custom-overrides.md` (CO-8) + the divergence map. RE-SYNC: stock Lumos has no
   secondary mode, so this stays a DIVERGENCE — unless the re-sync SOURCE is Kris's own Lumos
   (which has the mode + the primary-stripped names natively) => then retire + reconcile (map
   --_typography---font--primary-* <-> the mode-driven --_typography---font--*). ===== */
:root {
  --_typography---font--secondary-family:      var(--_typography---font--primary-family);
  --_typography---font--secondary-trim-top:    var(--_typography---font--primary-trim-top);
  --_typography---font--secondary-trim-bottom: var(--_typography---font--primary-trim-bottom);
}
.u-typography-secondary {
  --_typography---font--primary-family:      var(--_typography---font--secondary-family);
  --_typography---font--primary-trim-top:    var(--_typography---font--secondary-trim-top);
  --_typography---font--primary-trim-bottom: var(--_typography---font--secondary-trim-bottom);
}

/* ===== CUSTOM OVERRIDE [CO-18]: emphasis-in-heading span (H5; wires off CO-8) =====
   A heading runs in one weight; a single inline span carries a CONTRASTING treatment - the
   "emphasis" word(s). This is the explicit hook for it (D4): mixed-weight / mixed-font headings
   WITHOUT overloading <em> (reserved for true italics). It mirrors CO-8's secondary re-point - so
   a dual-font tenant can give the accent the secondary FAMILY - AND flips the weight to a dedicated
   --emphasis-weight token. The common case is a heavy heading + a light accent (Kyoom: Inter-700
   heading / Inter-200 upright accent). Either split order works: apply the class to whichever part
   is the accent (#7 accent = the lighter tail; #8 accent = the lighter head).
   Set font-family/weight DIRECTLY (not only via the token re-point) because an inline <span> inherits
   its parent's COMPUTED font + weight, so the span needs its own declarations to change. The token
   re-points are kept too, for the case where the class is applied to a whole heading block.
   Single-font starter: --secondary-family defaults to primary (no font change), so only the weight
   contrast shows - which is exactly the gallery demo. RE-SYNC: stock Lumos has no emphasis hook; keep.
   Tracked CO-18 + the divergence map. ===== */
:root { --_typography---font--emphasis-weight: 300; }   /* the accent weight; a tenant sets it (Kyoom = 200) */
.u-heading-emphasis {
  font-family: var(--_typography---font--secondary-family);
  font-weight: var(--_typography---font--emphasis-weight);
  --_typography---font--primary-family:      var(--_typography---font--secondary-family);
  --_typography---font--primary-trim-top:    var(--_typography---font--secondary-trim-top);
  --_typography---font--primary-trim-bottom: var(--_typography---font--secondary-trim-bottom);
}

/* Eyebrow heading reset — the eyebrow analog of the `.u-text h1..h6` reset in lumos.css. An eyebrow
   may carry a SEMANTIC heading tag (e.g. the page <h1> styled as a small eyebrow label — the About
   hero: h1 "About Kyoom" reads as an eyebrow, the big statement below is a <p>). A raw <h1> keeps its
   display font-size and blows the eyebrow up, so inherit the eyebrow's own text style instead.
   RE-SYNC: stock Lumos eyebrows never hold a heading; keep. (Registry candidate — see custom-overrides.md.) */
.u-eyebrow-text :is(h1,h2,h3,h4,h5,h6) {
  font-family: inherit; font-size: inherit; font-weight: inherit; line-height: inherit;
  letter-spacing: inherit; text-transform: inherit; text-wrap: inherit; margin: 0;
}

/* NOTE: the former subset-gap overrides CO-9..CO-16 (background-slot z-index, u-hide-if-empty,
   default-collection tokens, u-shadow-primary, nav overlap/sizing/radius, primary-small variant)
   are now folded into the canonical lumos.css via build-lumos.sh block 7. See _inventory/custom-overrides.md. */

/* ===== CUSTOM OVERRIDE [CO-17]: Nav layout variants (ADDITION) =====
   The nav bar (.nav_desktop_contain) is a floating, rounded, theme-glassy strip. Block 7 (lumos.css)
   ships ONE layout - a content-width pill, centred (width:max-content + margin:auto). This lifts that
   into an opt-in choice via a `data-nav-layout` attribute on .nav_component (mirrors the data-card-*
   variant pattern), so a tenant PICKS a layout instead of forking the nav. CENTERED is the default
   (no attribute => block 7 stays in force), so existing markup + computed-style parity are unchanged.
   Five layouts:
     centered - content-width pill, centred + floating         (default)
     full     - floating rounded bar, spans the content column
     content  - content-width pill, left-aligned to the column
     bar      - flush full-bleed 100vw top bar (classic header): no float gap, no radius, edge-to-edge
                background; inner content stays column-constrained via .nav_desktop_layout (already
                max-width-inner + margin:auto). Pairs well with a solid (non-glassy) --_theme---nav--background.
     vertical - full-height sidebar down ONE side. SECOND attribute data-nav-align="left" (default) |
                "right" picks the side. The horizontal row (.nav_desktop_layout) flips to a column, the
                link list stacks, and the sibling .page_main is padded by --nav--vertical-width so content
                clears the fixed sidebar. (Dropdowns still open as the horizontal mega-menu - a vertical
                fly-out treatment is a follow-up.)
   Variant rules out-specify block 7's bare `.nav_desktop_contain` (attr+class = 0,2,0 > 0,1,0).
   Set the attribute on the nav root:  <div class="nav_component" data-nav-layout="vertical" data-nav-align="right">  ===== */
:root { --nav--vertical-width: 16rem; --nav--vertical-collapsed: 4.25rem; }   /* sidebar footprint (expanded / collapsed rail) for data-nav-layout="vertical" */
[data-nav-layout="centered"] .nav_desktop_contain {   /* = default (block 7); listed for round-tripping */
  width: max-content; margin-left: auto; margin-right: auto;
}
[data-nav-layout="full"] .nav_desktop_contain {        /* floating bar: spans the content column */
  width: calc(100% - var(--nav--spacing-outer-horizontal) * 2); margin-left: auto; margin-right: auto;
}
[data-nav-layout="content"] .nav_desktop_contain {     /* content-width pill, left-aligned to the content column edge */
  width: max-content;
  margin-left: max(var(--nav--spacing-outer-horizontal), calc((100% - var(--nav--max-width-outer)) / 2));
  margin-right: auto;
}
[data-nav-layout="bar"] .nav_desktop_wrap { margin-top: 0; }   /* flush to the very top - no float gap */
[data-nav-layout="bar"] .nav_desktop_contain {                 /* full-bleed 100vw, square; content column-constrained by .nav_desktop_layout */
  width: 100%; max-width: none; border-radius: 0; margin-left: 0; margin-right: 0;
}

/* --- vertical sidebar (data-nav-layout="vertical"; data-nav-align left|right, default left) ---
   Everything stacks + LEFT-aligns and is clamped to the rail width (no horizontal overflow), both
   sides. A chevron toggle (.nav_collapse_btn, injected into the nav markup) flips data-nav-collapsed
   on .nav_component to shrink the rail to --nav--vertical-collapsed and hide labels. */
[data-nav-layout="vertical"] .nav_desktop_wrap { margin-top: 0; height: 100%; }
[data-nav-layout="vertical"] .nav_component { inset: 0 auto 0 0; width: var(--nav--vertical-width); transition: width .25s ease; }   /* LEFT (default) */
[data-nav-layout="vertical"][data-nav-align="right"] .nav_component { inset: 0 0 0 auto; }                                          /* RIGHT */
[data-nav-layout="vertical"] .nav_desktop_contain {
  position: relative;                                  /* anchors the collapse toggle */
  width: var(--nav--vertical-width); max-width: none; height: 100vh; min-height: 100%;
  margin: 0; border-radius: 0; overflow-x: hidden; overflow-y: auto;
}
/* The LAYOUT stays flex (column) so .nav_actions_wrap pins to the bottom (margin-top:auto) and
   align-items:stretch fills its direct children to the rail. Everything INSIDE resets to BLOCK so
   width:100% fills predictably and items stack in normal flow (the Webflow nav's nested horizontal
   flex bases - flex:1 1 0% / 0 0 auto + auto margins - were collapsing/shifting widths). The dropdown
   panel is kept as a GRID (its open/close animation) but made static + full-width so it expands
   IN-FLOW, pushing the items below it down. */
[data-nav-layout="vertical"] .nav_desktop_layout {
  display: flex; flex-direction: column; align-items: stretch; justify-content: flex-start;
  height: 100%; max-width: none; row-gap: var(--_spacing---space--4);
}
[data-nav-layout="vertical"] .nav_links_component,
[data-nav-layout="vertical"] .nav_links_wrap,
[data-nav-layout="vertical"] .nav_links_item,
[data-nav-layout="vertical"] .nav_dropdown_component,
[data-nav-layout="vertical"] .nav_actions_wrap,
[data-nav-layout="vertical"] .nav_actions_wrap > * {
  display: block; width: 100%; max-width: 100%; margin-left: 0; margin-right: 0; float: none;
}
/* bottom-pin: only the links block grows (the layout's other direct children - logo + actions - are
   fixed), so the actions are pushed to the bottom of the rail. */
[data-nav-layout="vertical"] .nav_desktop_layout > * { flex: 0 0 auto; }
[data-nav-layout="vertical"] .nav_desktop_layout > .nav_links_wrap { flex: 1 1 auto; }
[data-nav-layout="vertical"] .nav_links_wrap > * + * { margin-top: var(--_spacing---space--1); }    /* link spacing (block, no flex gap) */
[data-nav-layout="vertical"] .nav_actions_wrap > * + * { margin-top: var(--_spacing---space--3); }  /* actions spacing */
/* the link row keeps flex: label LEFT, dropdown chevron RIGHT; flush to the rail's left edge */
[data-nav-layout="vertical"] .nav_links_link { display: flex; justify-content: space-between; align-items: center; width: 100%; padding-left: 0; }
[data-nav-layout="vertical"] .button_main_wrap,
[data-nav-layout="vertical"] .button_main_element { width: 100%; max-width: 100%; }
/* logo + links share the rail's left edge */
[data-nav-layout="vertical"] .nav_desktop_logo,
[data-nav-layout="vertical"] .nav_links_component { padding-left: 0; margin-left: 0; }
/* dropdown panel: keep the grid (open/close animation) but fill the rail + flow in-column; labels wrap */
[data-nav-layout="vertical"] .nav_dropdown_main_wrap,
[data-nav-layout="vertical"] .nav_dropdown_mega_wrap { position: static; width: 100%; max-width: none; }
[data-nav-layout="vertical"] .nav_dropdown_text { white-space: normal; }

/* collapse toggle (chevron). The button is injected into .nav_desktop_contain; scaleX flips the
   glyph by side + state so it always points the way it will move. */
[data-nav-layout="vertical"] .nav_collapse_btn {
  position: absolute; top: var(--_spacing---space--3); right: var(--_spacing---space--3);
  width: 1.9rem; height: 1.9rem; padding: 0; display: grid; place-items: center; cursor: pointer;
  border-radius: 99px; background: var(--_theme---background-2); color: var(--_theme---text);
  border: 1px solid var(--_theme---border); z-index: 5; pointer-events: auto;   /* .nav_component is pointer-events:none; re-enable on the toggle */
}
[data-nav-layout="vertical"][data-nav-align="right"] .nav_collapse_btn { right: auto; left: var(--_spacing---space--3); }
[data-nav-layout="vertical"] .nav_collapse_btn svg { width: 1rem; height: 1rem; transition: transform .2s ease; }
[data-nav-layout="vertical"][data-nav-align="right"] .nav_collapse_btn svg,
[data-nav-layout="vertical"][data-nav-collapsed="true"] .nav_collapse_btn svg { transform: scaleX(-1); }
[data-nav-layout="vertical"][data-nav-align="right"][data-nav-collapsed="true"] .nav_collapse_btn svg { transform: none; }

/* collapsed rail: shrink + hide labels (toggle + dropdown chevrons stay) */
[data-nav-layout="vertical"][data-nav-collapsed="true"] { --nav--vertical-width: var(--nav--vertical-collapsed); }
[data-nav-layout="vertical"][data-nav-collapsed="true"] .nav_links_text,
[data-nav-layout="vertical"][data-nav-collapsed="true"] .nav_links_svg,
[data-nav-layout="vertical"][data-nav-collapsed="true"] .nav_actions_wrap,
[data-nav-layout="vertical"][data-nav-collapsed="true"] .nav_desktop_logo { display: none; }
/* NB: the starter nav links are text-only, so the collapsed rail has no per-link glyphs yet - it
   shrinks + hides labels but shows no icon rail. A USEFUL collapsed rail needs an icon slot added to
   each nav link (+ a logo MARK that fits the rail); that icon set is the follow-up to this mechanism. */

/* page content clears the fixed rail (expanded + collapsed, left + right) */
.nav_component[data-nav-layout="vertical"] ~ .page_main { padding-left: var(--nav--vertical-width); transition: padding .25s ease; }
.nav_component[data-nav-layout="vertical"][data-nav-align="right"] ~ .page_main { padding-left: 0; padding-right: var(--nav--vertical-width); }
.nav_component[data-nav-layout="vertical"][data-nav-collapsed="true"] ~ .page_main { padding-left: var(--nav--vertical-collapsed); }
.nav_component[data-nav-layout="vertical"][data-nav-align="right"][data-nav-collapsed="true"] ~ .page_main { padding-left: 0; padding-right: var(--nav--vertical-collapsed); }
.nav_component[data-nav-layout="vertical"] ~ .page_main { padding-left: var(--nav--vertical-width); }       /* clear the fixed sidebar */
.nav_component[data-nav-layout="vertical"][data-nav-align="right"] ~ .page_main { padding-left: 0; padding-right: var(--nav--vertical-width); }

/* ===== CUSTOM OVERRIDE [CO-19]: nav blur-on-scroll (H2; opt-in) =====
   The desktop nav bar (.nav_desktop_contain) is an opaque light-100 pill at the top of the page
   (the nav theme's --_theme---nav--background). This adds the one missing state: once the page
   scrolls, the bar goes TRANSLUCENT + backdrop-blurred so content reads through it - the floating
   "frosted pill" treatment. Opt-in per tenant via data-nav-blur="true" on .nav_component (mirrors
   CO-17's data-nav-layout attribute pattern), so navs that don't want it are byte-for-byte unchanged.
   scripts.js (wireNavScroll) owns ONLY the .is-scrolled class toggle; the look is entirely here.
   No-JS: the class never lands, so the bar stays opaque - a perfectly good baseline. RE-SYNC: pure
   addition; keep. Tracked CO-19 + the divergence map. ===== */
[data-nav-blur="true"] .nav_desktop_contain {
  transition: background-color .25s ease, -webkit-backdrop-filter .25s ease, backdrop-filter .25s ease;
}
[data-nav-blur="true"].nav_component.is-scrolled .nav_desktop_contain {
  background-color: color-mix(in srgb, var(--_theme---nav--background) 72%, transparent);
  -webkit-backdrop-filter: blur(14px) saturate(1.4);
  backdrop-filter: blur(14px) saturate(1.4);
}

/* ===== CUSTOM OVERRIDE [CO-21]: layout columns must NOT impose an aspect-ratio =====
   Stock Webflow-Lumos sizes a column's image by the COLUMN, not the image: (a) .u-layout-column-2
   carries `aspect-ratio:16/9` + `height:100%`, and (b) when a column's only child is an image/video/
   overlay, Lumos forces that wrapper to `position:absolute; height:100%` so it FILLS the column's
   aspect box. So a v-visual-image-square-1-1 wrapper (its own aspect-ratio:1) renders 16/9 — the
   column wins. Kris's rule: the column never forces a ratio; its CONTENT defines its own. So clear the
   column aspect + height, and put the sole image wrapper back IN FLOW (position:relative; height:auto)
   so its own aspect-ratio drives the box (in-flow + a definite column width → the wrapper sizes itself,
   so the grid row no longer collapses to the text column). RE-SYNC: re-apply after a Lumos re-sync.
   Tracked CO-21. ===== */
.u-layout-column-1, .u-layout-column-2 { aspect-ratio: auto; height: auto; }
.u-layout-column-1:not(.v-layout-card):not(.v-layout-contain-4-8-reversed):not(:has(> :not(.u-image-wrapper,.u-video,.u-overlay))) :is(.u-image-wrapper,.u-video),
.u-layout-column-2:not(.v-layout-card):not(.v-layout-contain-4-8-reversed):not(:has(> :not(.u-image-wrapper,.u-video,.u-overlay))) :is(.u-image-wrapper,.u-video) {
  position: relative; height: auto;   /* in-flow → the wrapper's own aspect-ratio sizes it. EXCLUDES v-layout-card columns (:not(.v-layout-card), see CO-23) + v-layout-contain-4-8-reversed (the Meet Grant square image FILLS its taller text-column box — no grey gap below it, matching stock Lumos/the Webflow export) + keeps .u-overlay out of the target so it stays position:absolute and covers the media. */
}

/* ===== CUSTOM OVERRIDE [CO-23]: v-layout-card media FILLS the card (folded from the Kyoom CTA) =====
   In a v-layout-card the column IS the box: column-2 is position:absolute inset:0 over the card, and the
   media should COVER it (object-fit:cover, centred). CO-21 (above) re-flows a column's sole image to its
   OWN aspect-ratio — right for 2-col text+image rows, WRONG for a card (a 16:9 wrapper overflows a shorter
   card and TOP-CROPS — clock instead of the people). So CO-21 now EXCLUDES v-layout-card columns
   (:not(.v-layout-card)); the card's image/video/overlay fall back to STOCK Lumos
   (.u-layout-column-2:not(:has(...)) :is(...) { position:absolute; height:100% } + width:100% base = FILL).
   Result: media covers the card (object-position centres the crop) and the overlay genuinely covers it.
   The image's faded look (stock opacity .5) is a per-tenant BRAND choice — tune in styles.css, not here.
   No standalone rule needed: the fix is the :not(.v-layout-card) exclusion above. Tracked CO-23 + the
   divergence map. RE-SYNC: re-apply after a Lumos re-sync. ===== */

/* ===== CUSTOM OVERRIDE [CO-24]: grid row-spans collapse below the large breakpoint =====
   A grid's column count is responsive (data-large/medium/small-columns), but the masonry row-span
   utilities (u-row-span-N) are GLOBAL — so a 2-row span that reads as masonry on the wide (large)
   grid leaves big empty GAPS once the grid drops to 2 or 1 columns (the spanned card stays tall while
   its neighbour is short — the Kyoom stats grid on tablet). Below the large breakpoint, collapse
   row-spans so the cards flow as clean rows. Column-spans (full-width cards, e.g. a wide stat) are
   KEPT — a full-width card reads fine at any width. Tracked CO-24. RE-SYNC: re-apply. ===== */
@media screen and (max-width: 991px) {
  .u-grid [class*="u-row-span-"] { grid-row-end: auto; }
}

/* ===== CUSTOM OVERRIDE [CO-22]: slider click-and-drag affordance (opt-in) =====
   Swiper's grabCursor/followFinger replaced by a native pointer-drag in scripts.js wireSliders
   (mouse drags scrollLeft on .slider_element). This is purely the cursor + selection affordance;
   opt-in via data-slider-drag="true" on the .slider_offset (the same element that carries the
   data-slider-* counts). Trackpad/touch/wheel scrolling is unaffected (native). RE-SYNC: re-apply
   after a Lumos re-sync. Tracked CO-22. ===== */
.slider_offset[data-slider-drag="true"] .slider_element.swiper { cursor: grab; }
.slider_offset[data-slider-drag="true"] .slider_element.swiper.is-dragging { cursor: grabbing; user-select: none; }
.slider_offset[data-slider-drag="true"] .slider_element.swiper :is(img, picture, a) { -webkit-user-drag: none; user-drag: none; }

/* ===== CUSTOM OVERRIDE [CO-25]: mobile nav drawer layout =====
   The centred-pill nav reuses the desktop nav markup (v-menu-desktop on the links,
   dropdown lists + dropdown links) inside the mobile drawer, so on mobile the dropdown
   list inherits position:absolute; width:10rem — it floats over and OVERLAPS the links
   below it (the Blog/About/CTA overlap in the drawer) — and the links are max-content with
   small centred text. Restyle the DRAWER only (.nav_mobile_wrap, <=991px): full-width
   stacked rows, text LEFT + chevron RIGHT, larger link/dropdown text, and IN-FLOW dropdown
   lists (position:static, full width) so an open dropdown PUSHES the siblings below it down.
   The grid-rows 0fr->1fr collapse (lumos.css:8436 closed / this file's line ~206 open) makes
   the height in-flow. Scoped to the SAME container query the nav uses for its desktop/
   mobile swap (@container (min-width: 65em) shows desktop; below it the drawer is live) —
   .nav_component is container-type:inline-size, and .nav_mobile_wrap is inside it — so a
   plain @media would miss the ~992-1040px band where the drawer is active. RE-SYNC:
   re-apply after a Lumos re-sync. Should propagate to the starter. Tracked CO-25. ===== */
@container (max-width: 65em) {
  .nav_mobile_wrap .nav_links_component { gap: var(--_spacing---space--3); }
  .nav_mobile_wrap .nav_links_wrap { display: flex; flex-direction: column; align-items: stretch; gap: var(--_spacing---space--2); }
  .nav_mobile_wrap .nav_links_item { width: 100%; }
  .nav_mobile_wrap .nav_links_link {
    width: 100%; max-width: none; height: auto;
    display: flex; justify-content: space-between; align-items: center;
    padding: var(--_spacing---space--2) 0;
  }
  .nav_mobile_wrap .nav_links_text { font-size: 1.25rem; }
  .nav_mobile_wrap .nav_links_svg { width: 1rem; margin-left: auto; }
  /* dropdown list IN-FLOW + full width so it pushes siblings; drop the floating-card chrome */
  .nav_mobile_wrap .nav_dropdown_main_wrap { position: static; width: 100%; max-width: none; padding-top: 0; }
  .nav_mobile_wrap .nav_dropdown_main_scroll { background-color: transparent; max-height: none; border-radius: 0; }
  .nav_mobile_wrap .nav_dropdown_link { padding-left: 0; padding-right: 0; border-bottom: 0; }
  .nav_mobile_wrap .nav_dropdown_text { font-size: 1rem; white-space: normal; }
  .nav_mobile_wrap .nav_actions_wrap { width: 100%; }
}
