/**
 * Front-end styles for the Next FAQ module.
 * Collapse/expand, search, category tabs and deep-linking are driven by
 * assets/js/main.js via the `dnxte-active` class and data attributes.
 */

.dnxte-next-faq-list {
  --dnxte-faq-columns: 3;
  --dnxte-faq-column-gap: 20px;
  --dnxte-faq-row-gap: 20px;
  --dnxte-faq-anim-duration: 300ms;
  --dnxte-faq-anim-easing: ease;
  --dnxte-faq-transition-duration: 300ms;
  --dnxte-faq-transition-easing: ease;
  --dnxte-faq-icon-duration: 300ms;
  --dnxte-faq-header-duration: 300ms;
  display: flex;
  flex-direction: column;
  counter-reset: dnxte-faq;
}

/* ---------------------------------------------------------------------------
 * Layouts
 * ------------------------------------------------------------------------- */

.dnxte-faq-layout-grid {
  display: grid;
  grid-template-columns: repeat(var(--dnxte-faq-columns, 3), minmax(0, 1fr));
  column-gap: var(--dnxte-faq-column-gap, 20px);
  row-gap: var(--dnxte-faq-row-gap, 20px);
  align-items: start;
}

.dnxte-faq-layout-masonry {
  display: block;
  column-count: var(--dnxte-faq-columns, 3);
  column-gap: var(--dnxte-faq-column-gap, 20px);
}

.dnxte-faq-layout-masonry > * {
  break-inside: avoid;
  margin-bottom: var(--dnxte-faq-row-gap, 20px);
}

@media (max-width: 767px) {
  .dnxte-faq-layout-grid {
    grid-template-columns: 1fr;
  }

  .dnxte-faq-layout-masonry {
    column-count: 1;
  }
}

.dnxte-faq-layout-plainText .next_faq__header {
  cursor: default;
}

/* Items hidden by the search/category filter. */
.dnxte-next-faq-list [data-dnxte-faq-hidden] {
  display: none !important;
}

/* ---------------------------------------------------------------------------
 * Item header
 * ------------------------------------------------------------------------- */

:where(.dnxte-next-faq-list) .next_faq__item {
  padding: 16px 20px;
}

:where(.dnxte-next-faq-list) .next_faq__header {
  display: flex;
  align-items: center;
  justify-content: space-between;
  gap: 12px;
  cursor: pointer;
  user-select: none;
}

:where(.dnxte-next-faq-list) .next_faq__header:focus-visible {
  outline: 2px solid currentColor;
  outline-offset: 2px;
}

:where(.dnxte-next-faq-list) .next_faq__question {
  margin: 0;
  flex: 1 1 auto;
}

/* Optional sequential numbering (CSS counter, so filtered-out items are
 * skipped automatically). */
:where(.dnxte-next-faq-list) .next_faq__number {
  display: none;
}

:where(.dnxte-next-faq-list[data-numbering="on"]) .next_faq__item {
  counter-increment: dnxte-faq;
}

.dnxte-next-faq-list[data-numbering="on"] .next_faq__number {
  display: inline-flex;
  align-items: center;
  justify-content: center;
  flex: 0 0 auto;
  min-width: 1.7em;
  height: 1.7em;
  line-height: 1;
}

/* Border-radius isolated in :where() so the FAQ Numbering design controller
   can override it. */
:where(.dnxte-next-faq-list[data-numbering="on"]) .next_faq__number {
  border-radius: 50%;
}

:where(.dnxte-next-faq-list[data-numbering="on"]) .next_faq__number::before {
  content: counter(dnxte-faq);
}

/* Optional decorative icon shown before the question text. In :where() so it
   stays overridable by the per-item icon color/size settings. */
:where(.dnxte-next-faq-list) .next_faq__question-icon {
  flex: 0 0 auto;
  display: inline-flex;
  align-items: center;
  justify-content: center;
  line-height: 1;
}

:where(.dnxte-next-faq-list) .next_faq__question-icon--custom {
  font-family: "ETmodules";
  font-style: normal;
  font-weight: normal;
}

/* ---------------------------------------------------------------------------
 * Toggle icon
 * ------------------------------------------------------------------------- */

/* The list wrapper is in :where() so it adds 0 specificity, keeping these as
   overridable defaults — the icon settings (scoped by the module order class)
   take priority for font-size, color, etc. */
:where(.dnxte-next-faq-list) .next_faq__icon {
  flex: 0 0 auto;
  display: inline-flex;
  align-items: center;
  justify-content: center;
  min-width: 1em;
  min-height: 1em;
  font-size: 16px;
  line-height: 1;
  color: currentColor;
  transition: transform var(--dnxte-faq-icon-duration, 300ms) ease,
    opacity var(--dnxte-faq-icon-duration, 300ms) ease;
}

/* Default chevron when no custom icon is selected. */
:where(.dnxte-next-faq-list) .next_faq__icon::before {
  content: "";
  display: block;
  width: 0.5em;
  height: 0.5em;
  margin-top: -0.18em;
  border-right: 2px solid currentColor;
  border-bottom: 2px solid currentColor;
  transform: rotate(45deg);
}

:where(.dnxte-next-faq-list) .next_faq__icon--custom {
  font-family: "ETmodules";
  font-style: normal;
  font-weight: normal;
}

:where(.dnxte-next-faq-list) .next_faq__icon--custom::before {
  display: none;
}

:where(.dnxte-next-faq-list) .next_faq__icon--custom .next_faq__icon-open {
  display: none;
}

:where(.dnxte-next-faq-list) .next_faq__item.dnxte-active .next_faq__icon--custom .next_faq__icon-closed {
  display: none;
}

:where(.dnxte-next-faq-list) .next_faq__item.dnxte-active .next_faq__icon--custom .next_faq__icon-open {
  display: inline;
}

/* Image used as the toggle icon (sized via the icon font-size). */
:where(.dnxte-next-faq-list) .next_faq__icon--image::before {
  display: none;
}

:where(.dnxte-next-faq-list) .next_faq__icon--image .next_faq__icon-img {
  display: block;
  width: 1em;
  height: 1em;
  object-fit: contain;
}

/* Toggle icon placement (left/right of the question). */
:where(.dnxte-next-faq-list) .next_faq__header--icon-left .next_faq__icon {
  order: -1;
}

/* Both-sides placement: one icon at each edge of the question. */
:where(.dnxte-next-faq-list) .next_faq__header--icon-both .next_faq__icon--side-left {
  order: -1;
}

:where(.dnxte-next-faq-list) .next_faq__header--icon-both .next_faq__icon--side-right {
  order: 1;
}

/* Icon state-change animations. */
:where(.dnxte-next-faq-list[data-icon-animation="rotate"]) .next_faq__item.dnxte-active .next_faq__icon {
  transform: rotate(180deg);
}

:where(.dnxte-next-faq-list[data-icon-animation="fade"]) .next_faq__item.dnxte-active .next_faq__icon {
  animation: dnxteFaqIconFade var(--dnxte-faq-icon-duration, 300ms) ease both;
}

:where(.dnxte-next-faq-list[data-icon-animation="scale"]) .next_faq__item.dnxte-active .next_faq__icon {
  animation: dnxteFaqIconScale var(--dnxte-faq-icon-duration, 300ms) ease both;
}

:where(.dnxte-next-faq-list[data-icon-animation="flipX"]) .next_faq__item.dnxte-active .next_faq__icon {
  transform: rotateY(180deg);
}

:where(.dnxte-next-faq-list[data-icon-animation="flipY"]) .next_faq__item.dnxte-active .next_faq__icon {
  transform: rotateX(180deg);
}

@keyframes dnxteFaqIconFade {
  from {
    opacity: 0;
  }
  to {
    opacity: 1;
  }
}

@keyframes dnxteFaqIconScale {
  from {
    transform: scale(0.4);
  }
  to {
    transform: scale(1);
  }
}

/* ---------------------------------------------------------------------------
 * Body collapse/expand + answer reveal animations
 * ------------------------------------------------------------------------- */

/* Expand/collapse uses grid-template-rows 0fr -> 1fr so the animation runs to
 * the answer's ACTUAL height. This makes the transition duration honoured
 * exactly (unlike a max-height keyframe, which reaches the content height in a
 * fraction of the set time). The direct child .next_faq__body-inner must clip
 * its overflow and allow shrinking below its content height. */
:where(.dnxte-next-faq-list) .next_faq__body {
  display: grid;
  grid-template-rows: 0fr;
  transition: grid-template-rows
    var(--dnxte-faq-transition-duration, var(--dnxte-faq-anim-duration, 300ms))
    var(--dnxte-faq-transition-easing, var(--dnxte-faq-anim-easing, ease));
}

:where(.dnxte-next-faq-list) .next_faq__body-inner {
  overflow: hidden;
  min-height: 0;
}

:where(.dnxte-next-faq-list) .next_faq__item.dnxte-active .next_faq__body {
  grid-template-rows: 1fr;
}

.dnxte-faq-layout-plainText .next_faq__item .next_faq__body,
.dnxte-faq-layout-plainText .next_faq__item.dnxte-active .next_faq__body {
  grid-template-rows: 1fr;
}

:where(.dnxte-next-faq-list) .next_faq__answer-wrap {
  display: flex;
  flex-direction: column;
  gap: 16px;
  padding-top: 16px;
}

:where(.dnxte-next-faq-list) .next_faq__answer {
  flex: 1 1 auto;
  min-width: 0;
}

:where(.dnxte-next-faq-list) .next_faq__answer > p:last-child {
  margin-bottom: 0;
}

/* Header reveal animations (run on the full header — number, question and icon —
   when an item is opened). Reuse the shared reveal keyframes with a dedicated
   duration variable. */
:where(.dnxte-next-faq-list[data-header-animation="slideDown"]) .next_faq__item.dnxte-active .next_faq__header {
  animation: dnxteFaqSlideDown var(--dnxte-faq-header-duration, 300ms)
    var(--dnxte-faq-anim-easing, ease) both;
}

:where(.dnxte-next-faq-list[data-header-animation="fade"]) .next_faq__item.dnxte-active .next_faq__header {
  animation: dnxteFaqFade var(--dnxte-faq-header-duration, 300ms)
    var(--dnxte-faq-anim-easing, ease) both;
}

:where(.dnxte-next-faq-list[data-header-animation="slideLeft"]) .next_faq__item.dnxte-active .next_faq__header {
  animation: dnxteFaqSlideLeft var(--dnxte-faq-header-duration, 300ms)
    var(--dnxte-faq-anim-easing, ease) both;
}

:where(.dnxte-next-faq-list[data-header-animation="slideRight"]) .next_faq__item.dnxte-active .next_faq__header {
  animation: dnxteFaqSlideRight var(--dnxte-faq-header-duration, 300ms)
    var(--dnxte-faq-anim-easing, ease) both;
}

:where(.dnxte-next-faq-list[data-header-animation="zoomIn"]) .next_faq__item.dnxte-active .next_faq__header {
  animation: dnxteFaqZoomIn var(--dnxte-faq-header-duration, 300ms)
    var(--dnxte-faq-anim-easing, ease) both;
}

:where(.dnxte-next-faq-list[data-header-animation="flip"]) .next_faq__item.dnxte-active .next_faq__header {
  animation: dnxteFaqFlip var(--dnxte-faq-header-duration, 300ms)
    var(--dnxte-faq-anim-easing, ease) both;
}

:where(.dnxte-next-faq-list[data-header-animation="bounce"]) .next_faq__item.dnxte-active .next_faq__header {
  animation: dnxteFaqBounce var(--dnxte-faq-header-duration, 300ms) linear both;
}

:where(.dnxte-next-faq-list[data-header-animation="scaleUp"]) .next_faq__item.dnxte-active .next_faq__header {
  animation: dnxteFaqScaleUp var(--dnxte-faq-header-duration, 300ms)
    var(--dnxte-faq-anim-easing, ease) both;
}

:where(.dnxte-next-faq-list[data-header-animation="rotateIn"]) .next_faq__item.dnxte-active .next_faq__header {
  animation: dnxteFaqRotateIn var(--dnxte-faq-header-duration, 300ms)
    var(--dnxte-faq-anim-easing, ease) both;
}

/* Answer reveal animations (run when an item is opened). */
:where(.dnxte-next-faq-list[data-animation="slideDown"]) .next_faq__item.dnxte-active .next_faq__answer-wrap {
  animation: dnxteFaqSlideDown var(--dnxte-faq-anim-duration, 300ms)
    var(--dnxte-faq-anim-easing, ease) both;
}

:where(.dnxte-next-faq-list[data-animation="fade"]) .next_faq__item.dnxte-active .next_faq__answer-wrap {
  animation: dnxteFaqFade var(--dnxte-faq-anim-duration, 300ms)
    var(--dnxte-faq-anim-easing, ease) both;
}

:where(.dnxte-next-faq-list[data-animation="slideLeft"]) .next_faq__item.dnxte-active .next_faq__answer-wrap {
  animation: dnxteFaqSlideLeft var(--dnxte-faq-anim-duration, 300ms)
    var(--dnxte-faq-anim-easing, ease) both;
}

:where(.dnxte-next-faq-list[data-animation="slideRight"]) .next_faq__item.dnxte-active .next_faq__answer-wrap {
  animation: dnxteFaqSlideRight var(--dnxte-faq-anim-duration, 300ms)
    var(--dnxte-faq-anim-easing, ease) both;
}

:where(.dnxte-next-faq-list[data-animation="zoomIn"]) .next_faq__item.dnxte-active .next_faq__answer-wrap {
  animation: dnxteFaqZoomIn var(--dnxte-faq-anim-duration, 300ms)
    var(--dnxte-faq-anim-easing, ease) both;
}

:where(.dnxte-next-faq-list[data-animation="flip"]) .next_faq__item.dnxte-active .next_faq__answer-wrap {
  animation: dnxteFaqFlip var(--dnxte-faq-anim-duration, 300ms)
    var(--dnxte-faq-anim-easing, ease) both;
  transform-origin: top center;
}

:where(.dnxte-next-faq-list[data-animation="bounce"]) .next_faq__item.dnxte-active .next_faq__answer-wrap {
  animation: dnxteFaqBounce var(--dnxte-faq-anim-duration, 300ms) linear both;
}

:where(.dnxte-next-faq-list[data-animation="scaleUp"]) .next_faq__item.dnxte-active .next_faq__answer-wrap {
  animation: dnxteFaqScaleUp var(--dnxte-faq-anim-duration, 300ms)
    var(--dnxte-faq-anim-easing, ease) both;
  transform-origin: top center;
}

:where(.dnxte-next-faq-list[data-animation="rotateIn"]) .next_faq__item.dnxte-active .next_faq__answer-wrap {
  animation: dnxteFaqRotateIn var(--dnxte-faq-anim-duration, 300ms)
    var(--dnxte-faq-anim-easing, ease) both;
  transform-origin: top left;
}

/* Close (collapse) animations.
 * When "Animate Close" is on, assets/js/main.js keeps the `.dnxte-active`
 * class and adds `.dnxte-closing` for the duration of the collapse, then
 * removes both. The body collapses alongside the reveal animation played in
 * reverse, mirroring the open transition. These rules are declared after the
 * open rules so they win the (0,3,0) specificity tie while both apply. */
:where(.dnxte-next-faq-list[data-animate-close="on"]) .next_faq__item.dnxte-closing .next_faq__body {
  grid-template-rows: 0fr;
}

:where(.dnxte-next-faq-list[data-animate-close="on"][data-animation="slideDown"]) .next_faq__item.dnxte-closing .next_faq__answer-wrap {
  animation: dnxteFaqSlideDown var(--dnxte-faq-anim-duration, 300ms)
    var(--dnxte-faq-anim-easing, ease) reverse both;
}

:where(.dnxte-next-faq-list[data-animate-close="on"][data-animation="fade"]) .next_faq__item.dnxte-closing .next_faq__answer-wrap {
  animation: dnxteFaqFade var(--dnxte-faq-anim-duration, 300ms)
    var(--dnxte-faq-anim-easing, ease) reverse both;
}

:where(.dnxte-next-faq-list[data-animate-close="on"][data-animation="slideLeft"]) .next_faq__item.dnxte-closing .next_faq__answer-wrap {
  animation: dnxteFaqSlideLeft var(--dnxte-faq-anim-duration, 300ms)
    var(--dnxte-faq-anim-easing, ease) reverse both;
}

:where(.dnxte-next-faq-list[data-animate-close="on"][data-animation="slideRight"]) .next_faq__item.dnxte-closing .next_faq__answer-wrap {
  animation: dnxteFaqSlideRight var(--dnxte-faq-anim-duration, 300ms)
    var(--dnxte-faq-anim-easing, ease) reverse both;
}

:where(.dnxte-next-faq-list[data-animate-close="on"][data-animation="zoomIn"]) .next_faq__item.dnxte-closing .next_faq__answer-wrap {
  animation: dnxteFaqZoomIn var(--dnxte-faq-anim-duration, 300ms)
    var(--dnxte-faq-anim-easing, ease) reverse both;
}

:where(.dnxte-next-faq-list[data-animate-close="on"][data-animation="flip"]) .next_faq__item.dnxte-closing .next_faq__answer-wrap {
  animation: dnxteFaqFlip var(--dnxte-faq-anim-duration, 300ms)
    var(--dnxte-faq-anim-easing, ease) reverse both;
  transform-origin: top center;
}

:where(.dnxte-next-faq-list[data-animate-close="on"][data-animation="bounce"]) .next_faq__item.dnxte-closing .next_faq__answer-wrap {
  animation: dnxteFaqBounce var(--dnxte-faq-anim-duration, 300ms) linear reverse both;
}

:where(.dnxte-next-faq-list[data-animate-close="on"][data-animation="scaleUp"]) .next_faq__item.dnxte-closing .next_faq__answer-wrap {
  animation: dnxteFaqScaleUp var(--dnxte-faq-anim-duration, 300ms)
    var(--dnxte-faq-anim-easing, ease) reverse both;
  transform-origin: top center;
}

:where(.dnxte-next-faq-list[data-animate-close="on"][data-animation="rotateIn"]) .next_faq__item.dnxte-closing .next_faq__answer-wrap {
  animation: dnxteFaqRotateIn var(--dnxte-faq-anim-duration, 300ms)
    var(--dnxte-faq-anim-easing, ease) reverse both;
  transform-origin: top left;
}

@keyframes dnxteFaqSlideDown {
  from {
    opacity: 0;
    transform: translateY(-12px);
  }
  to {
    opacity: 1;
    transform: translateY(0);
  }
}

@keyframes dnxteFaqFade {
  from {
    opacity: 0;
  }
  to {
    opacity: 1;
  }
}

@keyframes dnxteFaqSlideLeft {
  from {
    opacity: 0;
    transform: translateX(24px);
  }
  to {
    opacity: 1;
    transform: translateX(0);
  }
}

@keyframes dnxteFaqSlideRight {
  from {
    opacity: 0;
    transform: translateX(-24px);
  }
  to {
    opacity: 1;
    transform: translateX(0);
  }
}

@keyframes dnxteFaqZoomIn {
  from {
    opacity: 0;
    transform: scale(0.92);
  }
  to {
    opacity: 1;
    transform: scale(1);
  }
}

@keyframes dnxteFaqFlip {
  from {
    opacity: 0;
    transform: perspective(600px) rotateX(-16deg);
  }
  to {
    opacity: 1;
    transform: perspective(600px) rotateX(0);
  }
}

@keyframes dnxteFaqBounce {
  0% {
    opacity: 0;
    transform: translateY(-16px);
  }
  55% {
    opacity: 1;
    transform: translateY(4px);
  }
  80% {
    transform: translateY(-2px);
  }
  100% {
    opacity: 1;
    transform: translateY(0);
  }
}

@keyframes dnxteFaqScaleUp {
  from {
    opacity: 0;
    transform: scaleY(0.8);
  }
  to {
    opacity: 1;
    transform: scaleY(1);
  }
}

@keyframes dnxteFaqRotateIn {
  from {
    opacity: 0;
    transform: rotate(-3deg);
  }
  to {
    opacity: 1;
    transform: rotate(0);
  }
}

/* ---------------------------------------------------------------------------
 * Answer media (image / video / button)
 * ------------------------------------------------------------------------- */

:where(.dnxte-next-faq-list) .next_faq__media-image {
  margin: 0;
  flex: 0 0 auto;
}

:where(.dnxte-next-faq-list) .next_faq__media-image img {
  max-width: 100%;
  height: auto;
  display: inline-block;
}

:where(.dnxte-next-faq-list) .next_faq__answer-wrap--img-bottom .next_faq__media-image {
  order: 2;
}

:where(.dnxte-next-faq-list) .next_faq__answer-wrap--img-left,
:where(.dnxte-next-faq-list) .next_faq__answer-wrap--img-right {
  flex-direction: row;
  align-items: flex-start;
}

:where(.dnxte-next-faq-list) .next_faq__answer-wrap--img-right .next_faq__media-image {
  order: 2;
}

:where(.dnxte-next-faq-list) .next_faq__answer-wrap--img-left .next_faq__media-image,
:where(.dnxte-next-faq-list) .next_faq__answer-wrap--img-right .next_faq__media-image {
  max-width: 40%;
}

@media (max-width: 767px) {
  :where(.dnxte-next-faq-list) .next_faq__answer-wrap--img-left,
  :where(.dnxte-next-faq-list) .next_faq__answer-wrap--img-right {
    flex-direction: column;
  }

  :where(.dnxte-next-faq-list) .next_faq__answer-wrap--img-left .next_faq__media-image,
  :where(.dnxte-next-faq-list) .next_faq__answer-wrap--img-right .next_faq__media-image {
    max-width: 100%;
    order: 0;
  }
}

:where(.dnxte-next-faq-list) .next_faq__media-video {
  position: relative;
  aspect-ratio: 16 / 9;
  margin: 0 20px 16px;
}

:where(.dnxte-next-faq-list) .next_faq__media-video iframe,
:where(.dnxte-next-faq-list) .next_faq__media-video video {
  position: absolute;
  inset: 0;
  width: 100%;
  height: 100%;
  border: 0;
}

:where(.dnxte-next-faq-list) .next_faq__media-video--align-left {
  margin-right: auto;
}

:where(.dnxte-next-faq-list) .next_faq__media-video--align-center {
  margin-left: auto;
  margin-right: auto;
}

:where(.dnxte-next-faq-list) .next_faq__media-video--align-right {
  margin-left: auto;
}

/* The list wrapper is in :where() so it adds 0 specificity, keeping these as
   overridable defaults — the button settings (scoped by the module order class)
   take priority for background, color, etc. */
:where(.dnxte-next-faq-list) .next_faq__button {
  display: block;
  width: -moz-fit-content;
  width: fit-content;
  max-width: 100%;
  margin: 0 20px 16px;
  padding: 10px 22px;
  background: #2b2b2b;
  color: #ffffff;
  text-decoration: none;
  border-radius: 4px;
}

:where(.dnxte-next-faq-list) .next_faq__button--align-left {
  margin-right: auto;
}

:where(.dnxte-next-faq-list) .next_faq__button--align-center {
  margin-left: auto;
  margin-right: auto;
}

:where(.dnxte-next-faq-list) .next_faq__button--align-right {
  margin-left: auto;
}

/* ---------------------------------------------------------------------------
 * Section title, toolbar (search + category tabs), empty state
 * ------------------------------------------------------------------------- */

.next_faq__title {
  margin: 0 0 20px;
}

.next_faq__toolbar {
  display: flex;
  flex-direction: column;
  gap: 12px;
  margin-bottom: 20px;
}

.next_faq__search input {
  width: 100%;
  padding: 10px 14px;
  border: 1px solid #dddddd;
  border-radius: 4px;
  font-size: 15px;
  box-sizing: border-box;
}

.next_faq__tabs {
  display: flex;
  flex-wrap: wrap;
  gap: 8px;
}

.next_faq__tabs--align-left {
  justify-content: flex-start;
}

.next_faq__tabs--align-center {
  justify-content: center;
}

.next_faq__tabs--align-right {
  justify-content: flex-end;
}

.next_faq__tab {
  cursor: pointer;
  border: none;
  background: #f0f0f0;
  color: inherit;
  padding: 8px 18px;
  font-size: 14px;
  line-height: 1.4;
  transition: background-color 0.2s ease, color 0.2s ease,
    border-color 0.2s ease;
}

.next_faq__tab:focus-visible {
  outline: 2px solid currentColor;
  outline-offset: 2px;
}

/* NOTE: the variant modifier is wrapped in :where() so it contributes 0
   specificity. This keeps these as easily-overridable defaults — the design
   controller styles (scoped by the module order class) always take priority. */
:where(.next_faq__tabs--pills) .next_faq__tab {
  border-radius: 999px;
}

:where(.next_faq__tabs--boxed) .next_faq__tab {
  border: 1px solid #dddddd;
  border-radius: 4px;
  background: transparent;
}

:where(.next_faq__tabs--underline) .next_faq__tab {
  background: transparent;
  border-radius: 0;
  border-bottom: 2px solid transparent;
  padding-left: 4px;
  padding-right: 4px;
}

:where(.next_faq__tabs--pills) .next_faq__tab.dnxte-active,
:where(.next_faq__tabs--boxed) .next_faq__tab.dnxte-active {
  background: #2b2b2b;
  color: #ffffff;
}

:where(.next_faq__tabs--underline) .next_faq__tab.dnxte-active {
  border-bottom-color: currentColor;
  font-weight: 600;
}

.next_faq__empty {
  padding: 24px 20px;
  text-align: center;
  opacity: 0.7;
}

/* Screen-reader-only live region used to announce expand/collapse. */
.next_faq__sr-live {
  position: absolute;
  width: 1px;
  height: 1px;
  margin: -1px;
  padding: 0;
  overflow: hidden;
  clip: rect(0, 0, 0, 0);
  white-space: nowrap;
  border: 0;
}

/* ---------------------------------------------------------------------------
 * Reduced motion
 * ------------------------------------------------------------------------- */

@media (prefers-reduced-motion: reduce) {
  :where(.dnxte-next-faq-list) .next_faq__body,
  :where(.dnxte-next-faq-list) .next_faq__icon,
  :where(.dnxte-next-faq-list) .next_faq__header,
  :where(.dnxte-next-faq-list) .next_faq__answer-wrap,
  .next_faq__tab {
    transition: none !important;
    animation: none !important;
  }
}