/*
 * semantic-animations/animate.css
 *
 * A curated set of UI animations. Pure CSS, no build step, no JS required.
 *
 *   import 'semantic-animations/animate.css';
 *   <div class="sa-fade-in">Welcome</div>
 *
 * Put the class on any element. Every animation here is transform- and
 * opacity-based (one exception noted below), so it composites cheaply and
 * works on any element regardless of its own color, size, or content.
 *
 * Tune any animation with custom properties, on the element or on a parent:
 *
 *   --sa-duration   how long one run takes           (default varies by class)
 *   --sa-delay      wait before the first run        (default 0s)
 *   --sa-timing     the easing curve                 (default per class)
 *   --sa-repeat     how many runs                     (default varies by class)
 *   --sa-distance   travel distance for slide-* moves (default 20px)
 *   --sa-stagger    gap between children (sa-dots-bounce) (default 0.15s)
 *
 *   <div class="sa-slide-in-up" style="--sa-duration: 600ms">Toast</div>
 *
 * `sa-ring` and `sa-glow` read the element's `color` (via `currentColor`),
 * the same one-property contract `semantic-icons` uses for stroke color.
 * Set `color` to tint them; nothing else here depends on color at all.
 */

[class*='sa-'] {
  --sa-delay: 0s;
  --sa-stagger: 0.15s;
  --sa-distance: 20px;
}

/* ================================================================ entrance
   An element arriving. Runs once and holds its finished state. */

.sa-fade-in {
  opacity: 0;
  animation: sa-fade-in var(--sa-duration, 0.4s) var(--sa-timing, ease-out) var(--sa-delay) var(--sa-repeat, 1) forwards;
}
@keyframes sa-fade-in {
  to {
    opacity: 1;
  }
}

.sa-slide-in-up {
  opacity: 0;
  transform: translateY(var(--sa-distance));
  animation: sa-slide-in-up var(--sa-duration, 0.45s) var(--sa-timing, cubic-bezier(0.16, 1, 0.3, 1)) var(--sa-delay)
    var(--sa-repeat, 1) forwards;
}
@keyframes sa-slide-in-up {
  to {
    opacity: 1;
    transform: translateY(0);
  }
}

.sa-slide-in-down {
  opacity: 0;
  transform: translateY(calc(var(--sa-distance) * -1));
  animation: sa-slide-in-down var(--sa-duration, 0.45s) var(--sa-timing, cubic-bezier(0.16, 1, 0.3, 1)) var(--sa-delay)
    var(--sa-repeat, 1) forwards;
}
@keyframes sa-slide-in-down {
  to {
    opacity: 1;
    transform: translateY(0);
  }
}

.sa-slide-in-left {
  opacity: 0;
  transform: translateX(calc(var(--sa-distance) * -1));
  animation: sa-slide-in-left var(--sa-duration, 0.45s) var(--sa-timing, cubic-bezier(0.16, 1, 0.3, 1)) var(--sa-delay)
    var(--sa-repeat, 1) forwards;
}
@keyframes sa-slide-in-left {
  to {
    opacity: 1;
    transform: translateX(0);
  }
}

.sa-slide-in-right {
  opacity: 0;
  transform: translateX(var(--sa-distance));
  animation: sa-slide-in-right var(--sa-duration, 0.45s) var(--sa-timing, cubic-bezier(0.16, 1, 0.3, 1)) var(--sa-delay)
    var(--sa-repeat, 1) forwards;
}
@keyframes sa-slide-in-right {
  to {
    opacity: 1;
    transform: translateX(0);
  }
}

.sa-scale-in {
  opacity: 0;
  transform: scale(0.85);
  animation: sa-scale-in var(--sa-duration, 0.35s) var(--sa-timing, cubic-bezier(0.16, 1, 0.3, 1)) var(--sa-delay)
    var(--sa-repeat, 1) forwards;
  transform-origin: center;
}
@keyframes sa-scale-in {
  to {
    opacity: 1;
    transform: scale(1);
  }
}

.sa-pop-in {
  opacity: 0;
  transform: scale(0.7);
  animation: sa-pop-in var(--sa-duration, 0.5s) var(--sa-timing, cubic-bezier(0.34, 1.56, 0.64, 1)) var(--sa-delay)
    var(--sa-repeat, 1) forwards;
  transform-origin: center;
}
@keyframes sa-pop-in {
  to {
    opacity: 1;
    transform: scale(1);
  }
}

/* ==================================================================== exit
   An element leaving. Runs once and holds its finished (hidden) state.
   Remove the element from the DOM on `animationend`; the class only
   animates it out of the way. */

.sa-fade-out {
  animation: sa-fade-out var(--sa-duration, 0.35s) var(--sa-timing, ease-in) var(--sa-delay) var(--sa-repeat, 1) forwards;
}
@keyframes sa-fade-out {
  to {
    opacity: 0;
  }
}

.sa-slide-out-up {
  animation: sa-slide-out-up var(--sa-duration, 0.35s) var(--sa-timing, cubic-bezier(0.7, 0, 0.84, 0)) var(--sa-delay)
    var(--sa-repeat, 1) forwards;
}
@keyframes sa-slide-out-up {
  to {
    opacity: 0;
    transform: translateY(calc(var(--sa-distance) * -1));
  }
}

.sa-slide-out-down {
  animation: sa-slide-out-down var(--sa-duration, 0.35s) var(--sa-timing, cubic-bezier(0.7, 0, 0.84, 0)) var(--sa-delay)
    var(--sa-repeat, 1) forwards;
}
@keyframes sa-slide-out-down {
  to {
    opacity: 0;
    transform: translateY(var(--sa-distance));
  }
}

.sa-slide-out-left {
  animation: sa-slide-out-left var(--sa-duration, 0.35s) var(--sa-timing, cubic-bezier(0.7, 0, 0.84, 0)) var(--sa-delay)
    var(--sa-repeat, 1) forwards;
}
@keyframes sa-slide-out-left {
  to {
    opacity: 0;
    transform: translateX(calc(var(--sa-distance) * -1));
  }
}

.sa-slide-out-right {
  animation: sa-slide-out-right var(--sa-duration, 0.35s) var(--sa-timing, cubic-bezier(0.7, 0, 0.84, 0)) var(--sa-delay)
    var(--sa-repeat, 1) forwards;
}
@keyframes sa-slide-out-right {
  to {
    opacity: 0;
    transform: translateX(var(--sa-distance));
  }
}

.sa-scale-out {
  animation: sa-scale-out var(--sa-duration, 0.3s) var(--sa-timing, cubic-bezier(0.7, 0, 0.84, 0)) var(--sa-delay)
    var(--sa-repeat, 1) forwards;
  transform-origin: center;
}
@keyframes sa-scale-out {
  to {
    opacity: 0;
    transform: scale(0.85);
  }
}

/* ================================================================ attention
   Draw the eye without changing whether the element is present. Loop by
   default except `sa-shake`, which reads as broken if it repeats forever. */

.sa-pulse {
  animation: sa-pulse var(--sa-duration, 1.8s) var(--sa-timing, ease-in-out) var(--sa-delay) var(--sa-repeat, infinite);
  transform-origin: center;
}
@keyframes sa-pulse {
  0%,
  100% {
    transform: scale(1);
  }
  50% {
    transform: scale(1.12);
  }
}

.sa-beat {
  animation: sa-beat var(--sa-duration, 1.2s) var(--sa-timing, ease-out) var(--sa-delay) var(--sa-repeat, infinite);
  transform-origin: center;
}
@keyframes sa-beat {
  0%,
  40%,
  100% {
    transform: scale(1);
  }
  15% {
    transform: scale(1.18);
  }
  28% {
    transform: scale(1.05);
  }
}

.sa-flash {
  animation: sa-flash var(--sa-duration, 1.4s) var(--sa-timing, ease-in-out) var(--sa-delay) var(--sa-repeat, infinite);
}
@keyframes sa-flash {
  0%,
  100% {
    opacity: 1;
  }
  50% {
    opacity: 0.35;
  }
}

.sa-wobble {
  animation: sa-wobble var(--sa-duration, 1.6s) var(--sa-timing, ease-in-out) var(--sa-delay) var(--sa-repeat, infinite);
  transform-origin: 50% 15%;
}
@keyframes sa-wobble {
  0%,
  55%,
  100% {
    transform: rotate(0deg);
  }
  10% {
    transform: rotate(11deg);
  }
  20% {
    transform: rotate(-9deg);
  }
  30% {
    transform: rotate(6deg);
  }
  40% {
    transform: rotate(-3deg);
  }
}

.sa-shake {
  animation: sa-shake var(--sa-duration, 0.5s) var(--sa-timing, ease-in-out) var(--sa-delay) var(--sa-repeat, 1);
  transform-origin: center;
}
@keyframes sa-shake {
  10%,
  50% {
    transform: translateX(-6px);
  }
  30%,
  70% {
    transform: translateX(6px);
  }
  90% {
    transform: translateX(-3px);
  }
  0%,
  100% {
    transform: translateX(0);
  }
}

.sa-jiggle {
  animation: sa-jiggle var(--sa-duration, 0.6s) var(--sa-timing, ease-in-out) var(--sa-delay) var(--sa-repeat, infinite);
  transform-origin: 50% 100%;
}
@keyframes sa-jiggle {
  0%,
  100% {
    transform: rotate(0deg) scale(1);
  }
  25% {
    transform: rotate(-4deg) scale(1.03);
  }
  75% {
    transform: rotate(4deg) scale(1.03);
  }
}

/* The one exception to the transform/opacity-only rule: box-shadow, to draw
   an expanding ring. Fine for one element; wrong for a whole list. */
.sa-ring {
  animation: sa-ring var(--sa-duration, 1.6s) var(--sa-timing, cubic-bezier(0.2, 0.6, 0.4, 1)) var(--sa-delay)
    var(--sa-repeat, infinite);
}
@keyframes sa-ring {
  0% {
    box-shadow: 0 0 0 0 currentColor;
    opacity: 1;
  }
  70% {
    opacity: 0.35;
  }
  100% {
    box-shadow: 0 0 0 14px transparent;
    opacity: 0;
  }
}

/* ================================================================= feedback
   The result of an action. Runs once by default and returns to rest, except
   `sa-success-pop` and `sa-saved-flash`, which hold their settled state. */

.sa-success-pop {
  animation: sa-success-pop var(--sa-duration, 0.55s) var(--sa-timing, cubic-bezier(0.34, 1.56, 0.64, 1)) var(--sa-delay)
    var(--sa-repeat, 1) forwards;
  transform-origin: center;
}
@keyframes sa-success-pop {
  0% {
    transform: scale(1);
  }
  40% {
    transform: scale(1.15);
  }
  100% {
    transform: scale(1);
  }
}

.sa-nope {
  animation: sa-nope var(--sa-duration, 0.4s) var(--sa-timing, ease-in-out) var(--sa-delay) var(--sa-repeat, 1);
  transform-origin: center;
}
@keyframes sa-nope {
  0%,
  100% {
    transform: translateX(0);
  }
  20%,
  60% {
    transform: translateX(-4px);
  }
  40%,
  80% {
    transform: translateX(4px);
  }
}

.sa-saved-flash {
  animation: sa-saved-flash var(--sa-duration, 0.45s) var(--sa-timing, ease-out) var(--sa-delay) var(--sa-repeat, 1)
    forwards;
  transform-origin: center;
}
@keyframes sa-saved-flash {
  0% {
    opacity: 1;
    transform: scale(1);
  }
  35% {
    opacity: 0.5;
    transform: scale(0.97);
  }
  100% {
    opacity: 1;
    transform: scale(1);
  }
}

/* ================================================================== loading
   An ongoing, indeterminate state. Always loops. */

.sa-spin {
  animation: sa-spin var(--sa-duration, 1.1s) var(--sa-timing, linear) var(--sa-delay) var(--sa-repeat, infinite);
  transform-origin: center;
}
@keyframes sa-spin {
  to {
    transform: rotate(360deg);
  }
}

.sa-spin-reverse {
  animation: sa-spin-reverse var(--sa-duration, 1.1s) var(--sa-timing, linear) var(--sa-delay) var(--sa-repeat, infinite);
  transform-origin: center;
}
@keyframes sa-spin-reverse {
  to {
    transform: rotate(-360deg);
  }
}

/* Needs a gradient background from the caller, e.g.
   `background-image: linear-gradient(90deg, #eee 25%, #f7f7f7 50%, #eee 75%)`
   and `background-size: 200% 100%`. */
.sa-shimmer {
  background-size: 200% 100%;
  animation: sa-shimmer var(--sa-duration, 1.4s) var(--sa-timing, linear) var(--sa-delay) var(--sa-repeat, infinite);
}
@keyframes sa-shimmer {
  0% {
    background-position: 150% 0;
  }
  100% {
    background-position: -50% 0;
  }
}

/* Three child elements (spans, dots) bounce in sequence. */
.sa-dots-bounce > * {
  display: inline-block;
  animation: sa-dots-bounce var(--sa-duration, 0.9s) var(--sa-timing, ease-in-out) var(--sa-delay) var(--sa-repeat, infinite);
}
.sa-dots-bounce > *:nth-child(2) {
  animation-delay: calc(var(--sa-delay) + var(--sa-stagger));
}
.sa-dots-bounce > *:nth-child(3) {
  animation-delay: calc(var(--sa-delay) + var(--sa-stagger) * 2);
}
@keyframes sa-dots-bounce {
  0%,
  60%,
  100% {
    transform: translateY(0);
    opacity: 0.5;
  }
  30% {
    transform: translateY(-6px);
    opacity: 1;
  }
}

/* Needs `position: relative; overflow: hidden` on the container. Draws its
   own moving bar; the container itself is the track. */
.sa-progress-sweep {
  position: relative;
  overflow: hidden;
}
.sa-progress-sweep::after {
  content: '';
  position: absolute;
  inset: 0 auto 0 0;
  width: 40%;
  background: currentColor;
  border-radius: inherit;
  animation: sa-progress-sweep var(--sa-duration, 1.2s) var(--sa-timing, ease-in-out) var(--sa-delay)
    var(--sa-repeat, infinite);
}
@keyframes sa-progress-sweep {
  0% {
    transform: translateX(-100%);
  }
  100% {
    transform: translateX(250%);
  }
}

/* ===================================================================== state
   An ambient, idle-state loop. Small amplitude by design: these earn their
   place at rest, not as the main event. */

.sa-float {
  animation: sa-float var(--sa-duration, 3s) var(--sa-timing, ease-in-out) var(--sa-delay) var(--sa-repeat, infinite);
}
@keyframes sa-float {
  0%,
  100% {
    transform: translateY(0);
  }
  50% {
    transform: translateY(-6px);
  }
}

.sa-breathe {
  animation: sa-breathe var(--sa-duration, 3.2s) var(--sa-timing, ease-in-out) var(--sa-delay) var(--sa-repeat, infinite);
  transform-origin: center;
}
@keyframes sa-breathe {
  0%,
  100% {
    transform: scale(1);
  }
  50% {
    transform: scale(1.035);
  }
}

.sa-sway {
  animation: sa-sway var(--sa-duration, 3.5s) var(--sa-timing, ease-in-out) var(--sa-delay) var(--sa-repeat, infinite);
  transform-origin: top center;
}
@keyframes sa-sway {
  0%,
  100% {
    transform: rotate(-2.5deg);
  }
  50% {
    transform: rotate(2.5deg);
  }
}

/* filter, not box-shadow: works on any element shape with no layout cost. */
.sa-glow {
  animation: sa-glow var(--sa-duration, 2.2s) var(--sa-timing, ease-in-out) var(--sa-delay) var(--sa-repeat, infinite);
}
@keyframes sa-glow {
  0%,
  100% {
    filter: drop-shadow(0 0 0 transparent);
  }
  50% {
    filter: drop-shadow(0 0 6px currentColor);
  }
}

.sa-nudge {
  animation: sa-nudge var(--sa-duration, 1.4s) var(--sa-timing, ease-in-out) var(--sa-delay) var(--sa-repeat, infinite);
}
@keyframes sa-nudge {
  0%,
  100% {
    transform: translateX(0);
  }
  50% {
    transform: translateX(4px);
  }
}

/* --------------------------------------------------------- reduced motion
 * Turning an animation off must never leave the element invisible or
 * displaced. Every entrance/exit class that starts or ends off-screen or
 * transparent is also returned to its settled state.
 */

@media (prefers-reduced-motion: reduce) {
  [class*='sa-'],
  [class*='sa-'] > *,
  .sa-progress-sweep::after {
    animation: none !important;
    transition: none !important;
  }

  .sa-fade-in,
  .sa-slide-in-up,
  .sa-slide-in-down,
  .sa-slide-in-left,
  .sa-slide-in-right,
  .sa-scale-in,
  .sa-pop-in {
    opacity: 1 !important;
    transform: none !important;
  }

  .sa-fade-out,
  .sa-slide-out-up,
  .sa-slide-out-down,
  .sa-slide-out-left,
  .sa-slide-out-right,
  .sa-scale-out {
    opacity: 0 !important;
  }

  .sa-dots-bounce > * {
    opacity: 1 !important;
  }
}