@bbl-digital/snorre 4.2.93 → 4.2.94

package/dist/snorre.es616.js

@@ -1,66 +1,8 @@
-import { isNone as h } from "./snorre.es750.js";
-import { positionalKeys as p } from "./snorre.es751.js";
-import { makeNoneKeyframesAnimatable as y } from "./snorre.es752.js";
-import { KeyframeResolver as g } from "./snorre.es625.js";
-import { getVariableValue as c } from "./snorre.es753.js";
-import { isCSSVariableToken as K } from "./snorre.es651.js";
-import { isNumOrPxType as l, positionalValues as u } from "./snorre.es754.js";
-import { findDimensionValueType as d } from "./snorre.es755.js";
-class k extends g {
-  constructor(e, r, n, t, o) {
-    super(e, r, n, t, o, !0);
-  }
-  readKeyframes() {
-    const { unresolvedKeyframes: e, element: r, name: n } = this;
-    if (!r || !r.current)
-      return;
-    super.readKeyframes();
-    for (let s = 0; s < e.length; s++) {
-      let i = e[s];
-      if (typeof i == "string" && (i = i.trim(), K(i))) {
-        const m = c(i, r.current);
-        m !== void 0 && (e[s] = m), s === e.length - 1 && (this.finalKeyframe = i);
-      }
-    }
-    if (this.resolveNoneKeyframes(), !p.has(n) || e.length !== 2)
-      return;
-    const [t, o] = e, a = d(t), f = d(o);
-    if (a !== f)
-      if (l(a) && l(f))
-        for (let s = 0; s < e.length; s++) {
-          const i = e[s];
-          typeof i == "string" && (e[s] = parseFloat(i));
-        }
-      else
-        this.needsMeasurement = !0;
-  }
-  resolveNoneKeyframes() {
-    const { unresolvedKeyframes: e, name: r } = this, n = [];
-    for (let t = 0; t < e.length; t++)
-      h(e[t]) && n.push(t);
-    n.length && y(e, n, r);
-  }
-  measureInitialState() {
-    const { element: e, unresolvedKeyframes: r, name: n } = this;
-    if (!e || !e.current)
-      return;
-    n === "height" && (this.suspendedScrollY = window.pageYOffset), this.measuredOrigin = u[n](e.measureViewportBox(), window.getComputedStyle(e.current)), r[0] = this.measuredOrigin;
-    const t = r[r.length - 1];
-    t !== void 0 && e.getValue(n, t).jump(t, !1);
-  }
-  measureEndState() {
-    var e;
-    const { element: r, name: n, unresolvedKeyframes: t } = this;
-    if (!r || !r.current)
-      return;
-    const o = r.getValue(n);
-    o && o.jump(this.measuredOrigin, !1);
-    const a = t.length - 1, f = t[a];
-    t[a] = u[n](r.measureViewportBox(), window.getComputedStyle(r.current)), f !== null && this.finalKeyframe === void 0 && (this.finalKeyframe = f), !((e = this.removedTransforms) === null || e === void 0) && e.length && this.removedTransforms.forEach(([s, i]) => {
-      r.getValue(s).set(i);
-    }), this.resolveNoneKeyframes();
-  }
-}
+import { mirrorEasing as o } from "./snorre.es716.js";
+import { reverseEasing as t } from "./snorre.es717.js";
+const r = (c) => 1 - Math.sin(Math.acos(c)), s = t(r), a = o(r);
 export {
-  k as DOMKeyframesResolver
+  r as circIn,
+  a as circInOut,
+  s as circOut
 };

package/dist/snorre.es617.js

@@ -1,82 +1,66 @@
-import { time as a } from "./snorre.es658.js";
-import { flushKeyframeResolvers as m } from "./snorre.es625.js";
-import { canAnimate as p } from "./snorre.es756.js";
-import { getFinalKeyframe as v } from "./snorre.es621.js";
-const c = 40;
-class R {
-  constructor({ autoplay: e = !0, delay: t = 0, type: i = "keyframes", repeat: o = 0, repeatDelay: r = 0, repeatType: n = "loop", ...s }) {
-    this.isStopped = !1, this.hasAttemptedResolve = !1, this.createdAt = a.now(), this.options = {
-      autoplay: e,
-      delay: t,
-      type: i,
-      repeat: o,
-      repeatDelay: r,
-      repeatType: n,
-      ...s
-    }, this.updateFinishedPromise();
+import { isNone as h } from "./snorre.es853.js";
+import { positionalKeys as p } from "./snorre.es854.js";
+import { makeNoneKeyframesAnimatable as y } from "./snorre.es855.js";
+import { KeyframeResolver as g } from "./snorre.es626.js";
+import { getVariableValue as c } from "./snorre.es856.js";
+import { isCSSVariableToken as K } from "./snorre.es652.js";
+import { isNumOrPxType as l, positionalValues as u } from "./snorre.es857.js";
+import { findDimensionValueType as d } from "./snorre.es858.js";
+class k extends g {
+  constructor(e, r, n, t, o) {
+    super(e, r, n, t, o, !0);
   }
-  /**
-   * This method uses the createdAt and resolvedAt to calculate the
-   * animation startTime. *Ideally*, we would use the createdAt time as t=0
-   * as the following frame would then be the first frame of the animation in
-   * progress, which would feel snappier.
-   *
-   * However, if there's a delay (main thread work) between the creation of
-   * the animation and the first commited frame, we prefer to use resolvedAt
-   * to avoid a sudden jump into the animation.
-   */
-  calcStartTime() {
-    return this.resolvedAt ? this.resolvedAt - this.createdAt > c ? this.resolvedAt : this.createdAt : this.createdAt;
-  }
-  /**
-   * A getter for resolved data. If keyframes are not yet resolved, accessing
-   * this.resolved will synchronously flush all pending keyframe resolvers.
-   * This is a deoptimisation, but at its worst still batches read/writes.
-   */
-  get resolved() {
-    return !this._resolved && !this.hasAttemptedResolve && m(), this._resolved;
-  }
-  /**
-   * A method to be called when the keyframes resolver completes. This method
-   * will check if its possible to run the animation and, if not, skip it.
-   * Otherwise, it will call initPlayback on the implementing class.
-   */
-  onKeyframesResolved(e, t) {
-    this.resolvedAt = a.now(), this.hasAttemptedResolve = !0;
-    const { name: i, type: o, velocity: r, delay: n, onComplete: s, onUpdate: h, isGenerator: d } = this.options;
-    if (!d && !p(e, i, o, r))
-      if (n)
-        this.options.duration = 0;
-      else {
-        h && h(v(e, this.options, t)), s && s(), this.resolveFinishedPromise();
-        return;
+  readKeyframes() {
+    const { unresolvedKeyframes: e, element: r, name: n } = this;
+    if (!r || !r.current)
+      return;
+    super.readKeyframes();
+    for (let s = 0; s < e.length; s++) {
+      let i = e[s];
+      if (typeof i == "string" && (i = i.trim(), K(i))) {
+        const m = c(i, r.current);
+        m !== void 0 && (e[s] = m), s === e.length - 1 && (this.finalKeyframe = i);
       }
-    const l = this.initPlayback(e, t);
-    l !== !1 && (this._resolved = {
-      keyframes: e,
-      finalKeyframe: t,
-      ...l
-    }, this.onPostResolved());
-  }
-  onPostResolved() {
+    }
+    if (this.resolveNoneKeyframes(), !p.has(n) || e.length !== 2)
+      return;
+    const [t, o] = e, a = d(t), f = d(o);
+    if (a !== f)
+      if (l(a) && l(f))
+        for (let s = 0; s < e.length; s++) {
+          const i = e[s];
+          typeof i == "string" && (e[s] = parseFloat(i));
+        }
+      else
+        this.needsMeasurement = !0;
   }
-  /**
-   * Allows the returned animation to be awaited or promise-chained. Currently
-   * resolves when the animation finishes at all but in a future update could/should
-   * reject if its cancels.
-   */
-  then(e, t) {
-    return this.currentFinishedPromise.then(e, t);
+  resolveNoneKeyframes() {
+    const { unresolvedKeyframes: e, name: r } = this, n = [];
+    for (let t = 0; t < e.length; t++)
+      h(e[t]) && n.push(t);
+    n.length && y(e, n, r);
   }
-  flatten() {
-    this.options.allowFlatten && (this.options.type = "keyframes", this.options.ease = "linear");
+  measureInitialState() {
+    const { element: e, unresolvedKeyframes: r, name: n } = this;
+    if (!e || !e.current)
+      return;
+    n === "height" && (this.suspendedScrollY = window.pageYOffset), this.measuredOrigin = u[n](e.measureViewportBox(), window.getComputedStyle(e.current)), r[0] = this.measuredOrigin;
+    const t = r[r.length - 1];
+    t !== void 0 && e.getValue(n, t).jump(t, !1);
   }
-  updateFinishedPromise() {
-    this.currentFinishedPromise = new Promise((e) => {
-      this.resolveFinishedPromise = e;
-    });
+  measureEndState() {
+    var e;
+    const { element: r, name: n, unresolvedKeyframes: t } = this;
+    if (!r || !r.current)
+      return;
+    const o = r.getValue(n);
+    o && o.jump(this.measuredOrigin, !1);
+    const a = t.length - 1, f = t[a];
+    t[a] = u[n](r.measureViewportBox(), window.getComputedStyle(r.current)), f !== null && this.finalKeyframe === void 0 && (this.finalKeyframe = f), !((e = this.removedTransforms) === null || e === void 0) && e.length && this.removedTransforms.forEach(([s, i]) => {
+      r.getValue(s).set(i);
+    }), this.resolveNoneKeyframes();
   }
 }
 export {
-  R as BaseAnimation
+  k as DOMKeyframesResolver
 };

package/dist/snorre.es618.js

@@ -1,147 +1,82 @@
-import { invariant as w } from "./snorre.es623.js";
-import { millisecondsToSeconds as g, secondsToMilliseconds as x } from "./snorre.es608.js";
-import { calcGeneratorDuration as G } from "./snorre.es624.js";
-import { isGenerator as O } from "./snorre.es609.js";
-import { KeyframeResolver as I } from "./snorre.es625.js";
-import { clamp as A } from "./snorre.es626.js";
-import { mix as B } from "./snorre.es627.js";
-import { pipe as C } from "./snorre.es628.js";
-import { inertia as _ } from "./snorre.es629.js";
-import { keyframes as p } from "./snorre.es630.js";
-import { spring as E } from "./snorre.es631.js";
-import { BaseAnimation as N } from "./snorre.es617.js";
-import { frameloopDriver as V } from "./snorre.es632.js";
-import { getFinalKeyframe as j } from "./snorre.es621.js";
-const U = {
-  decay: _,
-  inertia: _,
-  tween: p,
-  keyframes: p,
-  spring: E
-}, W = (P) => P / 100;
-class nt extends N {
-  constructor(t) {
-    super(t), this.holdTime = null, this.cancelTime = null, this.currentTime = 0, this.playbackSpeed = 1, this.pendingPlayState = "running", this.startTime = null, this.state = "idle", this.stop = () => {
-      if (this.resolver.cancel(), this.isStopped = !0, this.state === "idle")
+import { time as a } from "./snorre.es659.js";
+import { flushKeyframeResolvers as m } from "./snorre.es626.js";
+import { canAnimate as p } from "./snorre.es859.js";
+import { getFinalKeyframe as v } from "./snorre.es622.js";
+const c = 40;
+class R {
+  constructor({ autoplay: e = !0, delay: t = 0, type: i = "keyframes", repeat: o = 0, repeatDelay: r = 0, repeatType: n = "loop", ...s }) {
+    this.isStopped = !1, this.hasAttemptedResolve = !1, this.createdAt = a.now(), this.options = {
+      autoplay: e,
+      delay: t,
+      type: i,
+      repeat: o,
+      repeatDelay: r,
+      repeatType: n,
+      ...s
+    }, this.updateFinishedPromise();
+  }
+  /**
+   * This method uses the createdAt and resolvedAt to calculate the
+   * animation startTime. *Ideally*, we would use the createdAt time as t=0
+   * as the following frame would then be the first frame of the animation in
+   * progress, which would feel snappier.
+   *
+   * However, if there's a delay (main thread work) between the creation of
+   * the animation and the first commited frame, we prefer to use resolvedAt
+   * to avoid a sudden jump into the animation.
+   */
+  calcStartTime() {
+    return this.resolvedAt ? this.resolvedAt - this.createdAt > c ? this.resolvedAt : this.createdAt : this.createdAt;
+  }
+  /**
+   * A getter for resolved data. If keyframes are not yet resolved, accessing
+   * this.resolved will synchronously flush all pending keyframe resolvers.
+   * This is a deoptimisation, but at its worst still batches read/writes.
+   */
+  get resolved() {
+    return !this._resolved && !this.hasAttemptedResolve && m(), this._resolved;
+  }
+  /**
+   * A method to be called when the keyframes resolver completes. This method
+   * will check if its possible to run the animation and, if not, skip it.
+   * Otherwise, it will call initPlayback on the implementing class.
+   */
+  onKeyframesResolved(e, t) {
+    this.resolvedAt = a.now(), this.hasAttemptedResolve = !0;
+    const { name: i, type: o, velocity: r, delay: n, onComplete: s, onUpdate: h, isGenerator: d } = this.options;
+    if (!d && !p(e, i, o, r))
+      if (n)
+        this.options.duration = 0;
+      else {
+        h && h(v(e, this.options, t)), s && s(), this.resolveFinishedPromise();
         return;
-      this.teardown();
-      const { onStop: n } = this.options;
-      n && n();
-    };
-    const { name: i, motionValue: r, element: e, keyframes: a } = this.options, u = (e == null ? void 0 : e.KeyframeResolver) || I, o = (n, l) => this.onKeyframesResolved(n, l);
-    this.resolver = new u(a, o, i, r, e), this.resolver.scheduleResolve();
-  }
-  flatten() {
-    super.flatten(), this._resolved && Object.assign(this._resolved, this.initPlayback(this._resolved.keyframes));
-  }
-  initPlayback(t) {
-    const { type: i = "keyframes", repeat: r = 0, repeatDelay: e = 0, repeatType: a, velocity: u = 0 } = this.options, o = O(i) ? i : U[i] || p;
-    let n, l;
-    process.env.NODE_ENV !== "production" && o !== p && w(t.length <= 2, `Only two keyframes currently supported with spring and inertia animations. Trying to animate ${t}`), o !== p && typeof t[0] != "number" && (n = C(W, B(t[0], t[1])), t = [0, 100]);
-    const s = o({ ...this.options, keyframes: t });
-    a === "mirror" && (l = o({
-      ...this.options,
-      keyframes: [...t].reverse(),
-      velocity: -u
-    })), s.calculatedDuration === null && (s.calculatedDuration = G(s));
-    const { calculatedDuration: d } = s, f = d + e, T = f * (r + 1) - e;
-    return {
-      generator: s,
-      mirroredGenerator: l,
-      mapPercentToKeyframes: n,
-      calculatedDuration: d,
-      resolvedDuration: f,
-      totalDuration: T
-    };
+      }
+    const l = this.initPlayback(e, t);
+    l !== !1 && (this._resolved = {
+      keyframes: e,
+      finalKeyframe: t,
+      ...l
+    }, this.onPostResolved());
   }
   onPostResolved() {
-    const { autoplay: t = !0 } = this.options;
-    this.play(), this.pendingPlayState === "paused" || !t ? this.pause() : this.state = this.pendingPlayState;
-  }
-  tick(t, i = !1) {
-    const { resolved: r } = this;
-    if (!r) {
-      const { keyframes: c } = this.options;
-      return { done: !0, value: c[c.length - 1] };
-    }
-    const { finalKeyframe: e, generator: a, mirroredGenerator: u, mapPercentToKeyframes: o, keyframes: n, calculatedDuration: l, totalDuration: s, resolvedDuration: d } = r;
-    if (this.startTime === null)
-      return a.next(0);
-    const { delay: f, repeat: T, repeatType: D, repeatDelay: S, onUpdate: k } = this.options;
-    this.speed > 0 ? this.startTime = Math.min(this.startTime, t) : this.speed < 0 && (this.startTime = Math.min(t - s / this.speed, this.startTime)), i ? this.currentTime = t : this.holdTime !== null ? this.currentTime = this.holdTime : this.currentTime = Math.round(t - this.startTime) * this.speed;
-    const y = this.currentTime - f * (this.speed >= 0 ? 1 : -1), M = this.speed >= 0 ? y < 0 : y > s;
-    this.currentTime = Math.max(y, 0), this.state === "finished" && this.holdTime === null && (this.currentTime = s);
-    let b = this.currentTime, K = a;
-    if (T) {
-      const c = Math.min(this.currentTime, s) / d;
-      let v = Math.floor(c), h = c % 1;
-      !h && c >= 1 && (h = 1), h === 1 && v--, v = Math.min(v, T + 1), !!(v % 2) && (D === "reverse" ? (h = 1 - h, S && (h -= S / d)) : D === "mirror" && (K = u)), b = A(0, 1, h) * d;
-    }
-    const m = M ? { done: !1, value: n[0] } : K.next(b);
-    o && (m.value = o(m.value));
-    let { done: F } = m;
-    !M && l !== null && (F = this.speed >= 0 ? this.currentTime >= s : this.currentTime <= 0);
-    const R = this.holdTime === null && (this.state === "finished" || this.state === "running" && F);
-    return R && e !== void 0 && (m.value = j(n, this.options, e)), k && k(m.value), R && this.finish(), m;
-  }
-  get duration() {
-    const { resolved: t } = this;
-    return t ? g(t.calculatedDuration) : 0;
-  }
-  get time() {
-    return g(this.currentTime);
-  }
-  set time(t) {
-    t = x(t), this.currentTime = t, this.holdTime !== null || this.speed === 0 ? this.holdTime = t : this.driver && (this.startTime = this.driver.now() - t / this.speed);
-  }
-  get speed() {
-    return this.playbackSpeed;
   }
-  set speed(t) {
-    const i = this.playbackSpeed !== t;
-    this.playbackSpeed = t, i && (this.time = g(this.currentTime));
+  /**
+   * Allows the returned animation to be awaited or promise-chained. Currently
+   * resolves when the animation finishes at all but in a future update could/should
+   * reject if its cancels.
+   */
+  then(e, t) {
+    return this.currentFinishedPromise.then(e, t);
   }
-  play() {
-    if (this.resolver.isScheduled || this.resolver.resume(), !this._resolved) {
-      this.pendingPlayState = "running";
-      return;
-    }
-    if (this.isStopped)
-      return;
-    const { driver: t = V, onPlay: i, startTime: r } = this.options;
-    this.driver || (this.driver = t((a) => this.tick(a))), i && i();
-    const e = this.driver.now();
-    this.holdTime !== null ? this.startTime = e - this.holdTime : this.startTime ? this.state === "finished" && (this.startTime = e) : this.startTime = r ?? this.calcStartTime(), this.state === "finished" && this.updateFinishedPromise(), this.cancelTime = this.startTime, this.holdTime = null, this.state = "running", this.driver.start();
-  }
-  pause() {
-    var t;
-    if (!this._resolved) {
-      this.pendingPlayState = "paused";
-      return;
-    }
-    this.state = "paused", this.holdTime = (t = this.currentTime) !== null && t !== void 0 ? t : 0;
-  }
-  complete() {
-    this.state !== "running" && this.play(), this.pendingPlayState = this.state = "finished", this.holdTime = null;
-  }
-  finish() {
-    this.teardown(), this.state = "finished";
-    const { onComplete: t } = this.options;
-    t && t();
-  }
-  cancel() {
-    this.cancelTime !== null && this.tick(this.cancelTime), this.teardown(), this.updateFinishedPromise();
-  }
-  teardown() {
-    this.state = "idle", this.stopDriver(), this.resolveFinishedPromise(), this.updateFinishedPromise(), this.startTime = this.cancelTime = null, this.resolver.cancel();
-  }
-  stopDriver() {
-    this.driver && (this.driver.stop(), this.driver = void 0);
+  flatten() {
+    this.options.allowFlatten && (this.options.type = "keyframes", this.options.ease = "linear");
   }
-  sample(t) {
-    return this.startTime = 0, this.tick(t, !0);
+  updateFinishedPromise() {
+    this.currentFinishedPromise = new Promise((e) => {
+      this.resolveFinishedPromise = e;
+    });
   }
 }
 export {
-  nt as MainThreadAnimation
+  R as BaseAnimation
 };

package/dist/snorre.es619.js

@@ -1,12 +1,147 @@
-const e = /* @__PURE__ */ new Set([
-  "opacity",
-  "clipPath",
-  "filter",
-  "transform"
-  // TODO: Can be accelerated but currently disabled until https://issues.chromium.org/issues/41491098 is resolved
-  // or until we implement support for linear() easing.
-  // "background-color"
-]);
+import { invariant as w } from "./snorre.es624.js";
+import { millisecondsToSeconds as g, secondsToMilliseconds as x } from "./snorre.es609.js";
+import { calcGeneratorDuration as G } from "./snorre.es625.js";
+import { isGenerator as O } from "./snorre.es610.js";
+import { KeyframeResolver as I } from "./snorre.es626.js";
+import { clamp as A } from "./snorre.es627.js";
+import { mix as B } from "./snorre.es628.js";
+import { pipe as C } from "./snorre.es629.js";
+import { inertia as _ } from "./snorre.es630.js";
+import { keyframes as p } from "./snorre.es631.js";
+import { spring as E } from "./snorre.es632.js";
+import { BaseAnimation as N } from "./snorre.es618.js";
+import { frameloopDriver as V } from "./snorre.es633.js";
+import { getFinalKeyframe as j } from "./snorre.es622.js";
+const U = {
+  decay: _,
+  inertia: _,
+  tween: p,
+  keyframes: p,
+  spring: E
+}, W = (P) => P / 100;
+class nt extends N {
+  constructor(t) {
+    super(t), this.holdTime = null, this.cancelTime = null, this.currentTime = 0, this.playbackSpeed = 1, this.pendingPlayState = "running", this.startTime = null, this.state = "idle", this.stop = () => {
+      if (this.resolver.cancel(), this.isStopped = !0, this.state === "idle")
+        return;
+      this.teardown();
+      const { onStop: n } = this.options;
+      n && n();
+    };
+    const { name: i, motionValue: r, element: e, keyframes: a } = this.options, u = (e == null ? void 0 : e.KeyframeResolver) || I, o = (n, l) => this.onKeyframesResolved(n, l);
+    this.resolver = new u(a, o, i, r, e), this.resolver.scheduleResolve();
+  }
+  flatten() {
+    super.flatten(), this._resolved && Object.assign(this._resolved, this.initPlayback(this._resolved.keyframes));
+  }
+  initPlayback(t) {
+    const { type: i = "keyframes", repeat: r = 0, repeatDelay: e = 0, repeatType: a, velocity: u = 0 } = this.options, o = O(i) ? i : U[i] || p;
+    let n, l;
+    process.env.NODE_ENV !== "production" && o !== p && w(t.length <= 2, `Only two keyframes currently supported with spring and inertia animations. Trying to animate ${t}`), o !== p && typeof t[0] != "number" && (n = C(W, B(t[0], t[1])), t = [0, 100]);
+    const s = o({ ...this.options, keyframes: t });
+    a === "mirror" && (l = o({
+      ...this.options,
+      keyframes: [...t].reverse(),
+      velocity: -u
+    })), s.calculatedDuration === null && (s.calculatedDuration = G(s));
+    const { calculatedDuration: d } = s, f = d + e, T = f * (r + 1) - e;
+    return {
+      generator: s,
+      mirroredGenerator: l,
+      mapPercentToKeyframes: n,
+      calculatedDuration: d,
+      resolvedDuration: f,
+      totalDuration: T
+    };
+  }
+  onPostResolved() {
+    const { autoplay: t = !0 } = this.options;
+    this.play(), this.pendingPlayState === "paused" || !t ? this.pause() : this.state = this.pendingPlayState;
+  }
+  tick(t, i = !1) {
+    const { resolved: r } = this;
+    if (!r) {
+      const { keyframes: c } = this.options;
+      return { done: !0, value: c[c.length - 1] };
+    }
+    const { finalKeyframe: e, generator: a, mirroredGenerator: u, mapPercentToKeyframes: o, keyframes: n, calculatedDuration: l, totalDuration: s, resolvedDuration: d } = r;
+    if (this.startTime === null)
+      return a.next(0);
+    const { delay: f, repeat: T, repeatType: D, repeatDelay: S, onUpdate: k } = this.options;
+    this.speed > 0 ? this.startTime = Math.min(this.startTime, t) : this.speed < 0 && (this.startTime = Math.min(t - s / this.speed, this.startTime)), i ? this.currentTime = t : this.holdTime !== null ? this.currentTime = this.holdTime : this.currentTime = Math.round(t - this.startTime) * this.speed;
+    const y = this.currentTime - f * (this.speed >= 0 ? 1 : -1), M = this.speed >= 0 ? y < 0 : y > s;
+    this.currentTime = Math.max(y, 0), this.state === "finished" && this.holdTime === null && (this.currentTime = s);
+    let b = this.currentTime, K = a;
+    if (T) {
+      const c = Math.min(this.currentTime, s) / d;
+      let v = Math.floor(c), h = c % 1;
+      !h && c >= 1 && (h = 1), h === 1 && v--, v = Math.min(v, T + 1), !!(v % 2) && (D === "reverse" ? (h = 1 - h, S && (h -= S / d)) : D === "mirror" && (K = u)), b = A(0, 1, h) * d;
+    }
+    const m = M ? { done: !1, value: n[0] } : K.next(b);
+    o && (m.value = o(m.value));
+    let { done: F } = m;
+    !M && l !== null && (F = this.speed >= 0 ? this.currentTime >= s : this.currentTime <= 0);
+    const R = this.holdTime === null && (this.state === "finished" || this.state === "running" && F);
+    return R && e !== void 0 && (m.value = j(n, this.options, e)), k && k(m.value), R && this.finish(), m;
+  }
+  get duration() {
+    const { resolved: t } = this;
+    return t ? g(t.calculatedDuration) : 0;
+  }
+  get time() {
+    return g(this.currentTime);
+  }
+  set time(t) {
+    t = x(t), this.currentTime = t, this.holdTime !== null || this.speed === 0 ? this.holdTime = t : this.driver && (this.startTime = this.driver.now() - t / this.speed);
+  }
+  get speed() {
+    return this.playbackSpeed;
+  }
+  set speed(t) {
+    const i = this.playbackSpeed !== t;
+    this.playbackSpeed = t, i && (this.time = g(this.currentTime));
+  }
+  play() {
+    if (this.resolver.isScheduled || this.resolver.resume(), !this._resolved) {
+      this.pendingPlayState = "running";
+      return;
+    }
+    if (this.isStopped)
+      return;
+    const { driver: t = V, onPlay: i, startTime: r } = this.options;
+    this.driver || (this.driver = t((a) => this.tick(a))), i && i();
+    const e = this.driver.now();
+    this.holdTime !== null ? this.startTime = e - this.holdTime : this.startTime ? this.state === "finished" && (this.startTime = e) : this.startTime = r ?? this.calcStartTime(), this.state === "finished" && this.updateFinishedPromise(), this.cancelTime = this.startTime, this.holdTime = null, this.state = "running", this.driver.start();
+  }
+  pause() {
+    var t;
+    if (!this._resolved) {
+      this.pendingPlayState = "paused";
+      return;
+    }
+    this.state = "paused", this.holdTime = (t = this.currentTime) !== null && t !== void 0 ? t : 0;
+  }
+  complete() {
+    this.state !== "running" && this.play(), this.pendingPlayState = this.state = "finished", this.holdTime = null;
+  }
+  finish() {
+    this.teardown(), this.state = "finished";
+    const { onComplete: t } = this.options;
+    t && t();
+  }
+  cancel() {
+    this.cancelTime !== null && this.tick(this.cancelTime), this.teardown(), this.updateFinishedPromise();
+  }
+  teardown() {
+    this.state = "idle", this.stopDriver(), this.resolveFinishedPromise(), this.updateFinishedPromise(), this.startTime = this.cancelTime = null, this.resolver.cancel();
+  }
+  stopDriver() {
+    this.driver && (this.driver.stop(), this.driver = void 0);
+  }
+  sample(t) {
+    return this.startTime = 0, this.tick(t, !0);
+  }
+}
 export {
-  e as acceleratedValues
+  nt as MainThreadAnimation
 };

package/dist/snorre.es62.js

@@ -1,5 +1,5 @@
-import { j as L } from "./snorre.es332.js";
-import t from "./snorre.es363.js";
+import { j as L } from "./snorre.es333.js";
+import t from "./snorre.es364.js";
 const n = (o) => /* @__PURE__ */ L.jsx("svg", { viewBox: "0 0 24 24", ...o, children: /* @__PURE__ */ L.jsx("path", { d: "M21.99,2 L2,2 L2,18 L18,18 L22,22 L21.99,2 Z M18,14 L6,14 L6,12 L18,12 L18,14 Z M18,11 L6,11 L6,9 L18,9 L18,11 Z M18,8 L6,8 L6,6 L18,6 L18,8 Z" }) }), s = t()(n);
 export {
   s as default

package/dist/snorre.es620.js

@@ -1,17 +1,12 @@
-import { mapEasingToNativeEasing as p } from "./snorre.es611.js";
-function y(t, e, o, { delay: s = 0, duration: n = 300, repeat: f = 0, repeatType: m = "loop", ease: l = "easeInOut", times: r } = {}) {
-  const i = { [e]: o };
-  r && (i.offset = r);
-  const a = p(l, n);
-  return Array.isArray(a) && (i.easing = a), t.animate(i, {
-    delay: s,
-    duration: n,
-    easing: Array.isArray(a) ? "linear" : a,
-    fill: "both",
-    iterations: f + 1,
-    direction: m === "reverse" ? "alternate" : "normal"
-  });
-}
+const e = /* @__PURE__ */ new Set([
+  "opacity",
+  "clipPath",
+  "filter",
+  "transform"
+  // TODO: Can be accelerated but currently disabled until https://issues.chromium.org/issues/41491098 is resolved
+  // or until we implement support for linear() easing.
+  // "background-color"
+]);
 export {
-  y as startWaapiAnimation
+  e as acceleratedValues
 };