@wix/motion 1.665.0 → 2.0.0-rc.3

package/dist/es/motion.js

@@ -0,0 +1,749 @@
+class A {
+  animations;
+  options;
+  ready;
+  isCSS;
+  constructor(t, n) {
+    this.animations = t, this.options = n, this.ready = n?.measured || Promise.resolve(), this.isCSS = t[0] instanceof CSSAnimation;
+  }
+  getProgress() {
+    return this.animations[0]?.effect?.getComputedTiming().progress || 0;
+  }
+  async play(t) {
+    await this.ready;
+    for (const n of this.animations)
+      n.play();
+    await Promise.all(this.animations.map((n) => n.ready)), t && t();
+  }
+  pause() {
+    for (const t of this.animations)
+      t.pause();
+  }
+  async reverse(t) {
+    await this.ready;
+    for (const n of this.animations)
+      n.reverse();
+    await Promise.all(this.animations.map((n) => n.ready)), t && t();
+  }
+  progress(t) {
+    for (const n of this.animations) {
+      const { delay: i, duration: a, iterations: r } = n.effect.getTiming(), f = (Number.isFinite(a) ? a : 0) * (Number.isFinite(r) ? r : 1);
+      n.currentTime = ((i || 0) + f) * t;
+    }
+  }
+  cancel() {
+    for (const t of this.animations)
+      t.cancel();
+  }
+  setPlaybackRate(t) {
+    for (const n of this.animations)
+      n.playbackRate = t;
+  }
+  async onFinish(t) {
+    try {
+      await Promise.all(this.animations.map((i) => i.finished));
+      const n = this.animations[0];
+      if (n && !this.isCSS) {
+        const i = n.effect?.target;
+        if (i) {
+          const a = new Event("animationend");
+          i.dispatchEvent(a);
+        }
+      }
+      t();
+    } catch (n) {
+      console.warn("animation was interrupted - aborting onFinish callback - ", n);
+    }
+  }
+  get finished() {
+    return Promise.all(this.animations.map((t) => t.finished));
+  }
+  get playState() {
+    return this.animations[0]?.playState;
+  }
+}
+const H = (e) => e, V = (e) => 1 - Math.cos(e * Math.PI / 2), W = (e) => Math.sin(e * Math.PI / 2), K = (e) => -(Math.cos(Math.PI * e) - 1) / 2, G = (e) => e ** 2, B = (e) => 1 - (1 - e) ** 2, J = (e) => e < 0.5 ? 2 * e ** 2 : 1 - (-2 * e + 2) ** 2 / 2, U = (e) => e ** 3, Q = (e) => 1 - (1 - e) ** 3, X = (e) => e < 0.5 ? 4 * e ** 3 : 1 - (-2 * e + 2) ** 3 / 2, Y = (e) => e ** 4, Z = (e) => 1 - (1 - e) ** 4, ee = (e) => e < 0.5 ? 8 * e ** 4 : 1 - (-2 * e + 2) ** 4 / 2, te = (e) => e ** 5, ne = (e) => 1 - (1 - e) ** 5, ie = (e) => e < 0.5 ? 16 * e ** 5 : 1 - (-2 * e + 2) ** 5 / 2, se = (e) => e === 0 ? 0 : 2 ** (10 * e - 10), re = (e) => e === 1 ? 1 : 1 - 2 ** (-10 * e), ae = (e) => e === 0 ? 0 : e === 1 ? 1 : e < 0.5 ? 2 ** (20 * e - 10) / 2 : (2 - 2 ** (-20 * e + 10)) / 2, oe = (e) => 1 - Math.sqrt(1 - e ** 2), ce = (e) => Math.sqrt(1 - (e - 1) ** 2), ue = (e) => e < 0.5 ? (1 - Math.sqrt(1 - 4 * e ** 2)) / 2 : (Math.sqrt(-(2 * e - 3) * (2 * e - 1)) + 1) / 2, fe = (e) => 2.70158 * e ** 3 - 1.70158 * e ** 2, me = (e) => 1 + 2.70158 * (e - 1) ** 3 + 1.70158 * (e - 1) ** 2, le = (e, t = 1.70158 * 1.525) => e < 0.5 ? (2 * e) ** 2 * ((t + 1) * 2 * e - t) / 2 : ((2 * e - 2) ** 2 * ((t + 1) * (e * 2 - 2) + t) + 2) / 2, de = {
+  linear: H,
+  sineIn: V,
+  sineOut: W,
+  sineInOut: K,
+  quadIn: G,
+  quadOut: B,
+  quadInOut: J,
+  cubicIn: U,
+  cubicOut: Q,
+  cubicInOut: X,
+  quartIn: Y,
+  quartOut: Z,
+  quartInOut: ee,
+  quintIn: te,
+  quintOut: ne,
+  quintInOut: ie,
+  expoIn: se,
+  expoOut: re,
+  expoInOut: ae,
+  circIn: oe,
+  circOut: ce,
+  circInOut: ue,
+  backIn: fe,
+  backOut: me,
+  backInOut: le
+}, z = {
+  linear: "linear",
+  ease: "ease",
+  easeIn: "ease-in",
+  easeOut: "ease-out",
+  easeInOut: "ease-in-out",
+  sineIn: "cubic-bezier(0.47, 0, 0.745, 0.715)",
+  sineOut: "cubic-bezier(0.39, 0.575, 0.565, 1)",
+  sineInOut: "cubic-bezier(0.445, 0.05, 0.55, 0.95)",
+  quadIn: "cubic-bezier(0.55, 0.085, 0.68, 0.53)",
+  quadOut: "cubic-bezier(0.25, 0.46, 0.45, 0.94)",
+  quadInOut: "cubic-bezier(0.455, 0.03, 0.515, 0.955)",
+  cubicIn: "cubic-bezier(0.55, 0.055, 0.675, 0.19)",
+  cubicOut: "cubic-bezier(0.215, 0.61, 0.355, 1)",
+  cubicInOut: "cubic-bezier(0.645, 0.045, 0.355, 1)",
+  quartIn: "cubic-bezier(0.895, 0.03, 0.685, 0.22)",
+  quartOut: "cubic-bezier(0.165, 0.84, 0.44, 1)",
+  quartInOut: "cubic-bezier(0.77, 0, 0.175, 1)",
+  quintIn: "cubic-bezier(0.755, 0.05, 0.855, 0.06)",
+  quintOut: "cubic-bezier(0.23, 1, 0.32, 1)",
+  quintInOut: "cubic-bezier(0.86, 0, 0.07, 1)",
+  expoIn: "cubic-bezier(0.95, 0.05, 0.795, 0.035)",
+  expoOut: "cubic-bezier(0.19, 1, 0.22, 1)",
+  expoInOut: "cubic-bezier(1, 0, 0, 1)",
+  circIn: "cubic-bezier(0.6, 0.04, 0.98, 0.335)",
+  circOut: "cubic-bezier(0.075, 0.82, 0.165, 1)",
+  circInOut: "cubic-bezier(0.785, 0.135, 0.15, 0.86)",
+  backIn: "cubic-bezier(0.6, -0.28, 0.735, 0.045)",
+  backOut: "cubic-bezier(0.175, 0.885, 0.32, 1.275)",
+  backInOut: "cubic-bezier(0.68, -0.55, 0.265, 1.55)"
+};
+function he(e) {
+  return e === "percentage" ? "%" : e || "px";
+}
+function ge(e) {
+  return e ? z[e] || e : z.linear;
+}
+function pe(e) {
+  return e ? de[e] : void 0;
+}
+class be {
+  _animation;
+  customEffect;
+  progress;
+  _tickCbId;
+  _finishHandler;
+  constructor(t, n, i, a) {
+    const r = new KeyframeEffect(n, [], {
+      ...i,
+      composite: "add"
+    }), { timeline: f } = a;
+    this._animation = new Animation(r, f), this._tickCbId = null, this.progress = null, this.customEffect = (u) => t(r.target, u), this._finishHandler = (u) => {
+      this.effect.target?.getAnimations().find((m) => m === this._animation) || this.cancel();
+    }, this.addEventListener("finish", this._finishHandler), this.addEventListener("remove", this._finishHandler);
+  }
+  // private tick method for customEffect loop implementation
+  _tick() {
+    try {
+      const t = this.effect?.getComputedTiming().progress ?? null;
+      t !== this.progress && (this.customEffect?.(t), this.progress = t), this._tickCbId = requestAnimationFrame(() => {
+        this._tick();
+      });
+    } catch (t) {
+      this._tickCbId = null, console.error(
+        `failed to run customEffect! effectId: ${this.id}, error: ${t instanceof Error ? t.message : t}`
+      );
+    }
+  }
+  // Animation timing properties
+  get currentTime() {
+    return this._animation.currentTime;
+  }
+  set currentTime(t) {
+    this._animation.currentTime = t;
+  }
+  get startTime() {
+    return this._animation.startTime;
+  }
+  set startTime(t) {
+    this._animation.startTime = t;
+  }
+  get playbackRate() {
+    return this._animation.playbackRate;
+  }
+  set playbackRate(t) {
+    this._animation.playbackRate = t;
+  }
+  // Animation basic properties
+  get id() {
+    return this._animation.id;
+  }
+  set id(t) {
+    this._animation.id = t;
+  }
+  get effect() {
+    return this._animation.effect;
+  }
+  set effect(t) {
+    this._animation.effect = t;
+  }
+  get timeline() {
+    return this._animation.timeline;
+  }
+  set timeline(t) {
+    this._animation.timeline = t;
+  }
+  // Animation readonly state properties
+  get finished() {
+    return this._animation.finished;
+  }
+  get pending() {
+    return this._animation.pending;
+  }
+  get playState() {
+    return this._animation.playState;
+  }
+  get ready() {
+    return this._animation.ready;
+  }
+  get replaceState() {
+    return this._animation.replaceState;
+  }
+  // Animation event handlers
+  get oncancel() {
+    return this._animation.oncancel;
+  }
+  set oncancel(t) {
+    this._animation.oncancel = t;
+  }
+  get onfinish() {
+    return this._animation.onfinish;
+  }
+  set onfinish(t) {
+    this._animation.onfinish = t;
+  }
+  get onremove() {
+    return this._animation.onremove;
+  }
+  set onremove(t) {
+    this._animation.onremove = t;
+  }
+  // CustomAnimation overridden methods
+  play() {
+    this._animation.play(), cancelAnimationFrame(this._tickCbId), this._tickCbId = requestAnimationFrame(() => this._tick());
+  }
+  pause() {
+    this._animation.pause(), cancelAnimationFrame(this._tickCbId), this._tickCbId = null;
+  }
+  cancel() {
+    this.removeEventListener("finish", this._finishHandler), this.removeEventListener("remove", this._finishHandler), this._animation.cancel(), this.customEffect(null), cancelAnimationFrame(this._tickCbId), this._tickCbId = null;
+  }
+  commitStyles() {
+    console.warn(
+      "CustomEffect animations do not support commitStyles method as they have no style to commit"
+    );
+  }
+  // Animation methods without override
+  finish() {
+    this._animation.finish();
+  }
+  persist() {
+    this._animation.persist();
+  }
+  reverse() {
+    this._animation.reverse();
+  }
+  updatePlaybackRate(t) {
+    this._animation.updatePlaybackRate(t);
+  }
+  // Animation events API
+  addEventListener(t, n, i) {
+    this._animation.addEventListener(t, n, i);
+  }
+  removeEventListener(t, n, i) {
+    this._animation.removeEventListener(t, n, i);
+  }
+  dispatchEvent(t) {
+    return this._animation.dispatchEvent(t);
+  }
+}
+function ye(e) {
+  return e && e.__esModule && Object.prototype.hasOwnProperty.call(e, "default") ? e.default : e;
+}
+var I = { exports: {} }, C = I.exports, x;
+function ve() {
+  return x || (x = 1, (function(e) {
+    (function(t) {
+      var n = function() {
+      }, i = t.requestAnimationFrame || t.webkitRequestAnimationFrame || t.mozRequestAnimationFrame || t.msRequestAnimationFrame || function(s) {
+        return setTimeout(s, 16);
+      };
+      function a() {
+        var s = this;
+        s.reads = [], s.writes = [], s.raf = i.bind(t);
+      }
+      a.prototype = {
+        constructor: a,
+        /**
+         * We run this inside a try catch
+         * so that if any jobs error, we
+         * are able to recover and continue
+         * to flush the batch until it's empty.
+         *
+         * @param {Array} tasks
+         */
+        runTasks: function(s) {
+          for (var o; o = s.shift(); ) o();
+        },
+        /**
+         * Adds a job to the read batch and
+         * schedules a new frame if need be.
+         *
+         * @param  {Function} fn
+         * @param  {Object} ctx the context to be bound to `fn` (optional).
+         * @public
+         */
+        measure: function(s, o) {
+          var c = o ? s.bind(o) : s;
+          return this.reads.push(c), r(this), c;
+        },
+        /**
+         * Adds a job to the
+         * write batch and schedules
+         * a new frame if need be.
+         *
+         * @param  {Function} fn
+         * @param  {Object} ctx the context to be bound to `fn` (optional).
+         * @public
+         */
+        mutate: function(s, o) {
+          var c = o ? s.bind(o) : s;
+          return this.writes.push(c), r(this), c;
+        },
+        /**
+         * Clears a scheduled 'read' or 'write' task.
+         *
+         * @param {Object} task
+         * @return {Boolean} success
+         * @public
+         */
+        clear: function(s) {
+          return u(this.reads, s) || u(this.writes, s);
+        },
+        /**
+         * Extend this FastDom with some
+         * custom functionality.
+         *
+         * Because fastdom must *always* be a
+         * singleton, we're actually extending
+         * the fastdom instance. This means tasks
+         * scheduled by an extension still enter
+         * fastdom's global task queue.
+         *
+         * The 'super' instance can be accessed
+         * from `this.fastdom`.
+         *
+         * @example
+         *
+         * var myFastdom = fastdom.extend({
+         *   initialize: function() {
+         *     // runs on creation
+         *   },
+         *
+         *   // override a method
+         *   measure: function(fn) {
+         *     // do extra stuff ...
+         *
+         *     // then call the original
+         *     return this.fastdom.measure(fn);
+         *   },
+         *
+         *   ...
+         * });
+         *
+         * @param  {Object} props  properties to mixin
+         * @return {FastDom}
+         */
+        extend: function(s) {
+          if (typeof s != "object") throw new Error("expected object");
+          var o = Object.create(this);
+          return m(o, s), o.fastdom = this, o.initialize && o.initialize(), o;
+        },
+        // override this with a function
+        // to prevent Errors in console
+        // when tasks throw
+        catch: null
+      };
+      function r(s) {
+        s.scheduled || (s.scheduled = !0, s.raf(f.bind(null, s)));
+      }
+      function f(s) {
+        var o = s.writes, c = s.reads, d;
+        try {
+          n("flushing reads", c.length), s.runTasks(c), n("flushing writes", o.length), s.runTasks(o);
+        } catch (h) {
+          d = h;
+        }
+        if (s.scheduled = !1, (c.length || o.length) && r(s), d)
+          if (n("task errored", d.message), s.catch) s.catch(d);
+          else throw d;
+      }
+      function u(s, o) {
+        var c = s.indexOf(o);
+        return !!~c && !!s.splice(c, 1);
+      }
+      function m(s, o) {
+        for (var c in o)
+          o.hasOwnProperty(c) && (s[c] = o[c]);
+      }
+      var l = t.fastdom = t.fastdom || new a();
+      e.exports = l;
+    })(typeof window < "u" ? window : typeof C < "u" ? C : globalThis);
+  })(I)), I.exports;
+}
+var _e = ve();
+const g = /* @__PURE__ */ ye(_e), T = {};
+function Se(e) {
+  Object.assign(T, e);
+}
+function Ee(e) {
+  return e in T ? T[e] : (console.warn(
+    `${e} not found in registry. Please make sure to import and register the preset.`
+  ), null);
+}
+function y(e, t) {
+  return e ? (t || document).getElementById(e) : null;
+}
+function Ie(e, t) {
+  return e?.matches(`[data-motion-part~="${t}"]`) ? e : e?.querySelector(`[data-motion-part~="${t}"]`);
+}
+function we(e) {
+  const t = e.alternate ? "alternate" : "";
+  return e.reversed ? `${t ? `${t}-` : ""}reverse` : t || "normal";
+}
+function O(e) {
+  return `${e.value}${he(e.type)}`;
+}
+function F(e, t, n) {
+  return `${e.name || "cover"} ${n && e.offset.type !== "percentage" ? `calc(100% + ${O(e.offset)}${t ? ` + ${t}` : ""})` : t ? `calc(${O(e.offset)} + ${t})` : O(e.offset)}`;
+}
+function R(e) {
+  return {
+    start: F(e.startOffset, e.startOffsetAdd),
+    end: F(e.endOffset, e.endOffsetAdd, !0)
+  };
+}
+function N(e) {
+  return (t) => g.measure(() => t(e));
+}
+function L(e) {
+  return (t) => g.mutate(() => t(e));
+}
+function E(e) {
+  if (e.namedEffect) {
+    const t = e.namedEffect.type;
+    return typeof t == "string" ? Ee(t) : null;
+  } else if (e.keyframeEffect) {
+    const t = (i) => {
+      const { name: a, keyframes: r } = i.keyframeEffect;
+      return [{ ...i, name: a, keyframes: r }];
+    };
+    return { web: t, style: t, getNames: (i) => {
+      const { effectId: a } = i, { name: r } = i.keyframeEffect, f = r || a;
+      return f ? [f] : [];
+    } };
+  } else if (e.customEffect)
+    return (t) => [{ ...t, keyframes: [] }];
+  return null;
+}
+function D(e, t, n) {
+  return e.map((i, a) => {
+    const r = {
+      fill: i.fill,
+      easing: ge(i.easing),
+      iterations: i.iterations === 0 ? 1 / 0 : i.iterations || 1,
+      composite: i.composite,
+      direction: we(i)
+    };
+    return q(t) ? (r.duration = i.duration, r.delay = i.delay || 0) : window.ViewTimeline && t?.trigger === "view-progress" ? r.duration = "auto" : (r.duration = 99.99, r.delay = 0.01), {
+      effect: i,
+      options: r,
+      id: n && `${n}-${a + 1}`,
+      part: i.part
+    };
+  });
+}
+function q(e) {
+  return !e || e.trigger !== "pointer-move" && e.trigger !== "view-progress";
+}
+function M(e, t, n, i, a) {
+  if (e) {
+    if (q(i) && (t.duration = t.duration || 1, a?.reducedMotion))
+      if (t.iterations === 1 || t.iterations == null)
+        t = { ...t, duration: 1 };
+      else
+        return [];
+    let r;
+    return n instanceof HTMLElement && (r = { measure: N(n), mutate: L(n) }), e.web ? e.web(t, r, a) : e(t, r, a);
+  }
+  return [];
+}
+function j(e, t, n, i, a) {
+  const r = e instanceof HTMLElement ? e : y(e, a);
+  if (n?.trigger === "pointer-move" && !t.keyframeEffect) {
+    let c = t;
+    t.customEffect && (c = {
+      ...t,
+      namedEffect: { id: "", type: "CustomMouse" }
+    });
+    const d = E(
+      c
+    ), h = M(
+      d,
+      t,
+      r,
+      n,
+      i
+    );
+    return typeof h != "function" ? null : h(r);
+  }
+  const f = E(t), u = M(
+    f,
+    t,
+    r,
+    n,
+    i
+  );
+  if (!u || u.length === 0)
+    return null;
+  const m = D(u, n, t.effectId);
+  let l;
+  const s = n?.trigger === "view-progress";
+  s && window.ViewTimeline && (l = new ViewTimeline({
+    subject: n.element || y(n.componentId)
+  }));
+  const o = m.map(({ effect: c, options: d, id: h, part: v }) => {
+    const w = v ? Ie(r, v) : r, p = new KeyframeEffect(w || null, [], d);
+    g.mutate(() => {
+      "timing" in c && p.updateTiming(c.timing), p.setKeyframes(c.keyframes);
+    });
+    const _ = s && l ? { timeline: l } : {}, b = typeof c.customEffect == "function" ? new be(
+      c.customEffect,
+      w || null,
+      d,
+      _
+    ) : new Animation(p, _.timeline);
+    if (s)
+      if (l)
+        g.mutate(() => {
+          const { start: $, end: k } = R(c);
+          b.rangeStart = $, b.rangeEnd = k, b.play();
+        });
+      else {
+        const { startOffset: $, endOffset: k } = t;
+        g.mutate(() => {
+          const S = c.startOffset || $, P = c.endOffset || k;
+          Object.assign(b, {
+            start: {
+              name: S.name,
+              offset: S.offset?.value,
+              add: c.startOffsetAdd
+            },
+            end: {
+              name: P.name,
+              offset: P.offset?.value,
+              add: c.endOffsetAdd
+            }
+          });
+        });
+      }
+    return h && (b.id = h), b;
+  });
+  return new A(o, {
+    ...t,
+    trigger: { ...n || {} },
+    // make sure the group is ready after all animation targets are measured and mutated
+    measured: new Promise((c) => g.mutate(c))
+  });
+}
+function $e(e, t) {
+  return e ? `#${e}${t ? `[data-motion-part~="${t}"]` : ""}` : "";
+}
+function ke(e, t) {
+  const { duration: n, delay: i, iterations: a = 1, fill: r, easing: f = "linear", direction: u } = e.options, m = e.effect.name, l = n === "auto";
+  return `${m} ${l ? "auto" : `${n}ms`}${l ? " " : ` ${i || 1}ms `}${f}${r && r !== "none" ? ` ${r}` : ""} ${!a || a === 1 / 0 ? "infinite" : a}${u === "normal" ? "" : ` ${u}`} ${t ? "" : "paused"}`;
+}
+function Oe(e, t, n) {
+  return e?.style ? (q(n) && (t.duration = t.duration || 1), e.style(t)) : [];
+}
+function Pe(e, t, n) {
+  const i = E(t), a = Oe(i, t), r = D(a, n, t.effectId), f = n?.trigger === "view-progress";
+  return r.map((u, m) => {
+    const { start: l, end: s } = f ? R(u.effect) : {};
+    return {
+      target: $e(e, u.part),
+      animation: ke(u, f),
+      composition: u.options.composite,
+      custom: u.effect.custom,
+      name: u.effect.name,
+      keyframes: u.effect.keyframes,
+      id: u.id && `${u.id}-${m + 1}`,
+      animationTimeline: f ? `--${n?.id}` : "",
+      animationRange: l || s ? `${l} ${s}` : ""
+    };
+  });
+}
+function Te(e, t, n) {
+  const i = E(t), a = e instanceof HTMLElement ? e : y(e);
+  if (i && i.prepare && a) {
+    const r = { measure: N(a), mutate: L(a) };
+    i.prepare(t, r);
+  }
+  n && g.mutate(n);
+}
+function Ae(e, t) {
+  const n = E(t);
+  if (!n)
+    return null;
+  if (!n.style)
+    return t.effectId && e ? qe(e, t.effectId) : null;
+  const i = n.getNames(t), r = (typeof e == "string" ? y(e) : e)?.getAnimations(), f = r?.map((m) => m.animationName) || [], u = [];
+  return i.forEach((m) => {
+    f.includes(m) && u.push(
+      r?.find((l) => l.animationName === m)
+    );
+  }), u?.length ? new A(u) : null;
+}
+function qe(e, t) {
+  const i = (typeof e == "string" ? y(e) : e)?.getAnimations().filter((a) => {
+    const r = a.id || a.animationName;
+    return r ? r.startsWith(t) : !0;
+  });
+  return i?.length ? new A(i) : null;
+}
+function ze(e, t, n, i = {}) {
+  const { disabled: a, allowActiveEvent: r, ...f } = i, u = j(e, t, n, f);
+  if (!u)
+    return null;
+  let m = {};
+  if (n.trigger === "view-progress" && !window.ViewTimeline) {
+    const l = n.element || y(n.componentId), { ready: s } = u;
+    return u.animations.map((o) => ({
+      /* we use getters for start and end in order to access the animation's start and end
+         only when initializing the scrub scene rather than immediately */
+      get start() {
+        return o.start;
+      },
+      get end() {
+        return o.end;
+      },
+      viewSource: l,
+      ready: s,
+      getProgress() {
+        return u.getProgress();
+      },
+      effect(c, d) {
+        const { activeDuration: h } = o.effect.getComputedTiming(), { delay: v } = o.effect.getTiming();
+        o.currentTime = ((v || 0) + (h || 0)) * d;
+      },
+      disabled: a,
+      destroy() {
+        o.cancel();
+      }
+    }));
+  } else if (n.trigger === "pointer-move") {
+    const l = t, { centeredToTarget: s, transitionDuration: o, transitionEasing: c } = l, d = n.axis;
+    if (l.keyframeEffect) {
+      const h = u;
+      return h.animations?.length === 0 ? null : {
+        target: void 0,
+        centeredToTarget: s,
+        ready: h.ready,
+        _currentProgress: 0,
+        getProgress() {
+          return this._currentProgress;
+        },
+        effect(w, p) {
+          const _ = d === "x" ? p.x : p.y;
+          this._currentProgress = _, h.progress(_);
+        },
+        disabled: a ?? !1,
+        destroy() {
+          h.cancel();
+        }
+      };
+    }
+    m = {
+      centeredToTarget: s,
+      allowActiveEvent: r
+    }, t.customEffect && o && (m.transitionDuration = o, m.transitionEasing = pe(c)), m.target = u.target;
+  }
+  return {
+    ...m,
+    getProgress() {
+      return u.getProgress();
+    },
+    effect(l, s, o, c) {
+      u.progress(
+        o ? {
+          // @ts-expect-error spread error on p
+          ...s,
+          v: o,
+          active: c
+        } : s
+      );
+    },
+    disabled: a,
+    destroy() {
+      u.cancel();
+    }
+  };
+}
+function Ce(e, t, n, i = !1) {
+  const a = Ae(e, t);
+  return a ? (a.ready = new Promise((r) => {
+    Te(e, t, r);
+  }), a) : j(e, t, n, { reducedMotion: i });
+}
+export {
+  fe as backIn,
+  le as backInOut,
+  me as backOut,
+  oe as circIn,
+  ue as circInOut,
+  ce as circOut,
+  z as cssEasings,
+  U as cubicIn,
+  X as cubicInOut,
+  Q as cubicOut,
+  se as expoIn,
+  ae as expoInOut,
+  re as expoOut,
+  Ce as getAnimation,
+  Pe as getCSSAnimation,
+  he as getCssUnits,
+  ge as getEasing,
+  qe as getElementAnimation,
+  Ae as getElementCSSAnimation,
+  pe as getJsEasing,
+  ze as getScrubScene,
+  j as getWebAnimation,
+  de as jsEasings,
+  H as linear,
+  Te as prepareAnimation,
+  G as quadIn,
+  J as quadInOut,
+  B as quadOut,
+  Y as quartIn,
+  ee as quartInOut,
+  Z as quartOut,
+  te as quintIn,
+  ie as quintInOut,
+  ne as quintOut,
+  Se as registerEffects,
+  V as sineIn,
+  K as sineInOut,
+  W as sineOut
+};
+//# sourceMappingURL=motion.js.map