@vkzstudio/muza-ui 1.0.0 → 1.0.2

package/dist/node_modules/imask/esm/masked/range.js

@@ -0,0 +1,78 @@
+import p from "../core/change-details.js";
+import u from "../core/holder.js";
+import m from "./pattern.js";
+import "./base.js";
+import "./factory.js";
+import "./pattern/input-definition.js";
+import "./regexp.js";
+class d extends m {
+  /**
+    Optionally sets max length of pattern.
+    Used when pattern length is longer then `to` param length. Pads zeros at start in this case.
+  */
+  /** Min bound */
+  /** Max bound */
+  get _matchFrom() {
+    return this.maxLength - String(this.from).length;
+  }
+  constructor(e) {
+    super(e);
+  }
+  updateOptions(e) {
+    super.updateOptions(e);
+  }
+  _update(e) {
+    const {
+      to: t = this.to || 0,
+      from: r = this.from || 0,
+      maxLength: i = this.maxLength || 0,
+      autofix: a = this.autofix,
+      ...h
+    } = e;
+    this.to = t, this.from = r, this.maxLength = Math.max(String(t).length, i), this.autofix = a;
+    const o = String(this.from).padStart(this.maxLength, "0"), n = String(this.to).padStart(this.maxLength, "0");
+    let s = 0;
+    for (; s < n.length && n[s] === o[s]; ) ++s;
+    h.mask = n.slice(0, s).replace(/0/g, "\\0") + "0".repeat(this.maxLength - s), super._update(h);
+  }
+  get isComplete() {
+    return super.isComplete && !!this.value;
+  }
+  boundaries(e) {
+    let t = "", r = "";
+    const [, i, a] = e.match(/^(\D*)(\d*)(\D*)/) || [];
+    return a && (t = "0".repeat(i.length) + a, r = "9".repeat(i.length) + a), t = t.padEnd(this.maxLength, "0"), r = r.padEnd(this.maxLength, "9"), [t, r];
+  }
+  doPrepareChar(e, t) {
+    t === void 0 && (t = {});
+    let r;
+    return [e, r] = super.doPrepareChar(e.replace(/\D/g, ""), t), e || (r.skip = !this.isComplete), [e, r];
+  }
+  _appendCharRaw(e, t) {
+    if (t === void 0 && (t = {}), !this.autofix || this.value.length + 1 > this.maxLength) return super._appendCharRaw(e, t);
+    const r = String(this.from).padStart(this.maxLength, "0"), i = String(this.to).padStart(this.maxLength, "0"), [a, h] = this.boundaries(this.value + e);
+    return Number(h) < this.from ? super._appendCharRaw(r[this.value.length], t) : Number(a) > this.to ? !t.tail && this.autofix === "pad" && this.value.length + 1 < this.maxLength ? super._appendCharRaw(r[this.value.length], t).aggregate(this._appendCharRaw(e, t)) : super._appendCharRaw(i[this.value.length], t) : super._appendCharRaw(e, t);
+  }
+  doValidate(e) {
+    const t = this.value;
+    if (t.search(/[^0]/) === -1 && t.length <= this._matchFrom) return !0;
+    const [i, a] = this.boundaries(t);
+    return this.from <= Number(a) && Number(i) <= this.to && super.doValidate(e);
+  }
+  pad(e) {
+    const t = new p();
+    if (this.value.length === this.maxLength) return t;
+    const r = this.value, i = this.maxLength - this.value.length;
+    if (i) {
+      this.reset();
+      for (let a = 0; a < i; ++a)
+        t.aggregate(super._appendCharRaw("0", e));
+      r.split("").forEach((a) => this._appendCharRaw(a));
+    }
+    return t;
+  }
+}
+u.MaskedRange = d;
+export {
+  d as default
+};

package/dist/node_modules/imask/esm/masked/regexp.js

@@ -0,0 +1,21 @@
+import p from "./base.js";
+import t from "../core/holder.js";
+import "../core/change-details.js";
+class d extends p {
+  /** */
+  /** Enable characters overwriting */
+  /** */
+  /** */
+  /** */
+  updateOptions(e) {
+    super.updateOptions(e);
+  }
+  _update(e) {
+    const a = e.mask;
+    a && (e.validate = (s) => s.search(a) >= 0), super._update(e);
+  }
+}
+t.MaskedRegExp = d;
+export {
+  d as default
+};

package/dist/node_modules/imask/esm/masked/repeat.js

@@ -0,0 +1,104 @@
+import k from "../core/change-details.js";
+import u from "../core/holder.js";
+import c, { normalizeOpts as d } from "./factory.js";
+import m from "./pattern.js";
+import "./base.js";
+import "./pattern/input-definition.js";
+import "./regexp.js";
+class _ extends m {
+  get repeatFrom() {
+    var t;
+    return (t = Array.isArray(this.repeat) ? this.repeat[0] : this.repeat === 1 / 0 ? 0 : this.repeat) != null ? t : 0;
+  }
+  get repeatTo() {
+    var t;
+    return (t = Array.isArray(this.repeat) ? this.repeat[1] : this.repeat) != null ? t : 1 / 0;
+  }
+  constructor(t) {
+    super(t);
+  }
+  updateOptions(t) {
+    super.updateOptions(t);
+  }
+  _update(t) {
+    var i, s, r;
+    const {
+      repeat: n,
+      ...l
+    } = d(t);
+    this._blockOpts = Object.assign({}, this._blockOpts, l);
+    const e = c(this._blockOpts);
+    this.repeat = (i = (s = n ?? e.repeat) != null ? s : this.repeat) != null ? i : 1 / 0, super._update({
+      mask: "m".repeat(Math.max(this.repeatTo === 1 / 0 && ((r = this._blocks) == null ? void 0 : r.length) || 0, this.repeatFrom)),
+      blocks: {
+        m: e
+      },
+      eager: e.eager,
+      overwrite: e.overwrite,
+      skipInvalid: e.skipInvalid,
+      lazy: e.lazy,
+      placeholderChar: e.placeholderChar,
+      displayChar: e.displayChar
+    });
+  }
+  _allocateBlock(t) {
+    if (t < this._blocks.length) return this._blocks[t];
+    if (this.repeatTo === 1 / 0 || this._blocks.length < this.repeatTo)
+      return this._blocks.push(c(this._blockOpts)), this.mask += "m", this._blocks[this._blocks.length - 1];
+  }
+  _appendCharRaw(t, i) {
+    i === void 0 && (i = {});
+    const s = new k();
+    for (
+      let a = (r = (n = this._mapPosToBlock(this.displayValue.length)) == null ? void 0 : n.index) != null ? r : Math.max(this._blocks.length - 1, 0), h, o;
+      // try to get a block or
+      // try to allocate a new block if not allocated already
+      h = (l = this._blocks[a]) != null ? l : o = !o && this._allocateBlock(a);
+      ++a
+    ) {
+      var r, n, l, e;
+      const p = h._appendChar(t, {
+        ...i,
+        _beforeTailState: (e = i._beforeTailState) == null || (e = e._blocks) == null ? void 0 : e[a]
+      });
+      if (p.skip && o) {
+        this._blocks.pop(), this.mask = this.mask.slice(1);
+        break;
+      }
+      if (s.aggregate(p), p.consumed) break;
+    }
+    return s;
+  }
+  _trimEmptyTail(t, i) {
+    var s, r;
+    t === void 0 && (t = 0);
+    const n = Math.max(((s = this._mapPosToBlock(t)) == null ? void 0 : s.index) || 0, this.repeatFrom, 0);
+    let l;
+    i != null && (l = (r = this._mapPosToBlock(i)) == null ? void 0 : r.index), l == null && (l = this._blocks.length - 1);
+    let e = 0;
+    for (let a = l; n <= a && !this._blocks[a].unmaskedValue; --a, ++e)
+      ;
+    e && (this._blocks.splice(l - e + 1, e), this.mask = this.mask.slice(e));
+  }
+  reset() {
+    super.reset(), this._trimEmptyTail();
+  }
+  remove(t, i) {
+    t === void 0 && (t = 0), i === void 0 && (i = this.displayValue.length);
+    const s = super.remove(t, i);
+    return this._trimEmptyTail(t, i), s;
+  }
+  totalInputPositions(t, i) {
+    return t === void 0 && (t = 0), i == null && this.repeatTo === 1 / 0 ? 1 / 0 : super.totalInputPositions(t, i);
+  }
+  get state() {
+    return super.state;
+  }
+  set state(t) {
+    this._blocks.length = t._blocks.length, this.mask = this.mask.slice(0, this._blocks.length), super.state = t;
+  }
+}
+u.RepeatBlock = _;
+export {
+  _ as default
+};

package/dist/node_modules/its-fine/dist/index.js

@@ -0,0 +1,116 @@
+import * as n from "react";
+var b = Object.defineProperty, y = Object.defineProperties, w = Object.getOwnPropertyDescriptors, u = Object.getOwnPropertySymbols, P = Object.prototype.hasOwnProperty, h = Object.prototype.propertyIsEnumerable, c = (e, t, r) => t in e ? b(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r, l = (e, t) => {
+  for (var r in t || (t = {}))
+    P.call(t, r) && c(e, r, t[r]);
+  if (u)
+    for (var r of u(t))
+      h.call(t, r) && c(e, r, t[r]);
+  return e;
+}, x = (e, t) => y(e, w(t)), p, d;
+typeof window < "u" && ((p = window.document) != null && p.createElement || ((d = window.navigator) == null ? void 0 : d.product) === "ReactNative") ? n.useLayoutEffect : n.useEffect;
+function m(e, t, r) {
+  if (!e)
+    return;
+  if (r(e) === !0)
+    return e;
+  let i = e.child;
+  for (; i; ) {
+    const o = m(i, t, r);
+    if (o)
+      return o;
+    i = i.sibling;
+  }
+}
+function v(e) {
+  try {
+    return Object.defineProperties(e, {
+      _currentRenderer: {
+        get() {
+          return null;
+        },
+        set() {
+        }
+      },
+      _currentRenderer2: {
+        get() {
+          return null;
+        },
+        set() {
+        }
+      }
+    });
+  } catch {
+    return e;
+  }
+}
+const f = console.error;
+console.error = function() {
+  const e = [...arguments].join("");
+  if (e != null && e.startsWith("Warning:") && e.includes("useContext")) {
+    console.error = f;
+    return;
+  }
+  return f.apply(this, arguments);
+};
+const a = v(n.createContext(null));
+class g extends n.Component {
+  render() {
+    return /* @__PURE__ */ n.createElement(a.Provider, {
+      value: this._reactInternals
+    }, this.props.children);
+  }
+}
+function O() {
+  const e = n.useContext(a);
+  if (e === null)
+    throw new Error("its-fine: useFiber must be called within a <FiberProvider />!");
+  const t = n.useId();
+  return n.useMemo(() => {
+    for (const i of [e, e == null ? void 0 : e.alternate]) {
+      if (!i)
+        continue;
+      const o = m(i, !1, (_) => {
+        let s = _.memoizedState;
+        for (; s; ) {
+          if (s.memoizedState === t)
+            return !0;
+          s = s.next;
+        }
+      });
+      if (o)
+        return o;
+    }
+  }, [e, t]);
+}
+function C() {
+  const e = O(), [t] = n.useState(() => /* @__PURE__ */ new Map());
+  t.clear();
+  let r = e;
+  for (; r; ) {
+    if (r.type && typeof r.type == "object") {
+      const o = r.type._context === void 0 && r.type.Provider === r.type ? r.type : r.type._context;
+      o && o !== a && !t.has(o) && t.set(o, n.useContext(v(o)));
+    }
+    r = r.return;
+  }
+  return t;
+}
+function E() {
+  const e = C();
+  return n.useMemo(
+    () => Array.from(e.keys()).reduce(
+      (t, r) => (i) => /* @__PURE__ */ n.createElement(t, null, /* @__PURE__ */ n.createElement(r.Provider, x(l({}, i), {
+        value: e.get(r)
+      }))),
+      (t) => /* @__PURE__ */ n.createElement(g, l({}, t))
+    ),
+    [e]
+  );
+}
+export {
+  g as FiberProvider,
+  m as traverseFiber,
+  E as useContextBridge,
+  C as useContextMap,
+  O as useFiber
+};

package/dist/node_modules/motion-dom/dist/es/animation/AsyncMotionValueAnimation.js

@@ -0,0 +1,103 @@
+import { time as v } from "../frameloop/sync-time.js";
+import { JSAnimation as y } from "./JSAnimation.js";
+import { getFinalKeyframe as g } from "./keyframes/get-final.js";
+import { KeyframeResolver as R, flushKeyframeResolvers as T } from "./keyframes/KeyframesResolver.js";
+import { NativeAnimationExtended as _ } from "./NativeAnimationExtended.js";
+import { canAnimate as w } from "./utils/can-animate.js";
+import { makeAnimationInstant as K } from "./utils/make-animation-instant.js";
+import { WithPromise as D } from "./utils/WithPromise.js";
+import { supportsBrowserAnimation as E } from "./waapi/supports/waapi.js";
+import { MotionGlobalConfig as k } from "../../../../motion-utils/dist/es/global-config.js";
+import { noop as x } from "../../../../motion-utils/dist/es/noop.js";
+const M = 40;
+class I extends D {
+  constructor({ autoplay: i = !0, delay: s = 0, type: e = "keyframes", repeat: l = 0, repeatDelay: f = 0, repeatType: d = "loop", keyframes: p, name: a, motionValue: r, element: t, ...c }) {
+    var u;
+    super(), this.stop = () => {
+      var m, h;
+      this._animation && (this._animation.stop(), (m = this.stopTimeline) == null || m.call(this)), (h = this.keyframeResolver) == null || h.cancel();
+    }, this.createdAt = v.now();
+    const n = {
+      autoplay: i,
+      delay: s,
+      type: e,
+      repeat: l,
+      repeatDelay: f,
+      repeatType: d,
+      name: a,
+      motionValue: r,
+      element: t,
+      ...c
+    }, o = (t == null ? void 0 : t.KeyframeResolver) || R;
+    this.keyframeResolver = new o(p, (m, h, A) => this.onKeyframesResolved(m, h, n, !A), a, r, t), (u = this.keyframeResolver) == null || u.scheduleResolve();
+  }
+  onKeyframesResolved(i, s, e, l) {
+    this.keyframeResolver = void 0;
+    const { name: f, type: d, velocity: p, delay: a, isHandoff: r, onUpdate: t } = e;
+    this.resolvedAt = v.now(), w(i, f, d, p) || ((k.instantAnimations || !a) && (t == null || t(g(i, e, s))), i[0] = i[i.length - 1], K(e), e.repeat = 0);
+    const n = {
+      startTime: l ? this.resolvedAt ? this.resolvedAt - this.createdAt > M ? this.resolvedAt : this.createdAt : this.createdAt : void 0,
+      finalKeyframe: s,
+      ...e,
+      keyframes: i
+    }, o = !r && E(n) ? new _({
+      ...n,
+      element: n.motionValue.owner.current
+    }) : new y(n);
+    o.finished.then(() => this.notifyFinished()).catch(x), this.pendingTimeline && (this.stopTimeline = o.attachTimeline(this.pendingTimeline), this.pendingTimeline = void 0), this._animation = o;
+  }
+  get finished() {
+    return this._animation ? this.animation.finished : this._finished;
+  }
+  then(i, s) {
+    return this.finished.finally(i).then(() => {
+    });
+  }
+  get animation() {
+    var i;
+    return this._animation || ((i = this.keyframeResolver) == null || i.resume(), T()), this._animation;
+  }
+  get duration() {
+    return this.animation.duration;
+  }
+  get iterationDuration() {
+    return this.animation.iterationDuration;
+  }
+  get time() {
+    return this.animation.time;
+  }
+  set time(i) {
+    this.animation.time = i;
+  }
+  get speed() {
+    return this.animation.speed;
+  }
+  get state() {
+    return this.animation.state;
+  }
+  set speed(i) {
+    this.animation.speed = i;
+  }
+  get startTime() {
+    return this.animation.startTime;
+  }
+  attachTimeline(i) {
+    return this._animation ? this.stopTimeline = this.animation.attachTimeline(i) : this.pendingTimeline = i, () => this.stop();
+  }
+  play() {
+    this.animation.play();
+  }
+  pause() {
+    this.animation.pause();
+  }
+  complete() {
+    this.animation.complete();
+  }
+  cancel() {
+    var i;
+    this._animation && this.animation.cancel(), (i = this.keyframeResolver) == null || i.cancel();
+  }
+}
+export {
+  I as AsyncMotionValueAnimation
+};

package/dist/node_modules/motion-dom/dist/es/animation/GroupAnimation.js

@@ -0,0 +1,76 @@
+class l {
+  constructor(t) {
+    this.stop = () => this.runAll("stop"), this.animations = t.filter(Boolean);
+  }
+  get finished() {
+    return Promise.all(this.animations.map((t) => t.finished));
+  }
+  /**
+   * TODO: Filter out cancelled or stopped animations before returning
+   */
+  getAll(t) {
+    return this.animations[0][t];
+  }
+  setAll(t, e) {
+    for (let i = 0; i < this.animations.length; i++)
+      this.animations[i][t] = e;
+  }
+  attachTimeline(t) {
+    const e = this.animations.map((i) => i.attachTimeline(t));
+    return () => {
+      e.forEach((i, s) => {
+        i && i(), this.animations[s].stop();
+      });
+    };
+  }
+  get time() {
+    return this.getAll("time");
+  }
+  set time(t) {
+    this.setAll("time", t);
+  }
+  get speed() {
+    return this.getAll("speed");
+  }
+  set speed(t) {
+    this.setAll("speed", t);
+  }
+  get state() {
+    return this.getAll("state");
+  }
+  get startTime() {
+    return this.getAll("startTime");
+  }
+  get duration() {
+    return a(this.animations, "duration");
+  }
+  get iterationDuration() {
+    return a(this.animations, "iterationDuration");
+  }
+  runAll(t) {
+    this.animations.forEach((e) => e[t]());
+  }
+  play() {
+    this.runAll("play");
+  }
+  pause() {
+    this.runAll("pause");
+  }
+  cancel() {
+    this.runAll("cancel");
+  }
+  complete() {
+    this.runAll("complete");
+  }
+}
+function a(n, t) {
+  let e = 0;
+  for (let i = 0; i < n.length; i++) {
+    const s = n[i][t];
+    s !== null && s > e && (e = s);
+  }
+  return e;
+}
+export {
+  l as GroupAnimation
+};

package/dist/node_modules/motion-dom/dist/es/animation/GroupAnimationWithThen.js

@@ -0,0 +1,10 @@
+import { GroupAnimation as t } from "./GroupAnimation.js";
+class r extends t {
+  then(n, i) {
+    return this.finished.finally(n).then(() => {
+    });
+  }
+}
+export {
+  r as GroupAnimationWithThen
+};

package/dist/node_modules/motion-dom/dist/es/animation/JSAnimation.js

@@ -0,0 +1,133 @@
+import { time as u } from "../frameloop/sync-time.js";
+import { mix as G } from "../utils/mix/index.js";
+import { frameloopDriver as I } from "./drivers/frame.js";
+import { inertia as K } from "./generators/inertia.js";
+import { keyframes as c } from "./generators/keyframes.js";
+import { calcGeneratorDuration as O } from "./generators/utils/calc-duration.js";
+import { getFinalKeyframe as C } from "./keyframes/get-final.js";
+import { replaceTransitionType as E } from "./utils/replace-transition-type.js";
+import { WithPromise as N } from "./utils/WithPromise.js";
+import { invariant as V } from "../../../../motion-utils/dist/es/errors.js";
+import { pipe as W } from "../../../../motion-utils/dist/es/pipe.js";
+import { millisecondsToSeconds as f, secondsToMilliseconds as $ } from "../../../../motion-utils/dist/es/time-conversion.js";
+import { clamp as B } from "../../../../motion-utils/dist/es/clamp.js";
+const J = (v) => v / 100;
+class et extends N {
+  constructor(t) {
+    super(), this.state = "idle", this.startTime = null, this.isStopped = !1, this.currentTime = 0, this.holdTime = null, this.playbackSpeed = 1, this.stop = () => {
+      var r, e;
+      const { motionValue: i } = this.options;
+      i && i.updatedAt !== u.now() && this.tick(u.now()), this.isStopped = !0, this.state !== "idle" && (this.teardown(), (e = (r = this.options).onStop) == null || e.call(r));
+    }, this.options = t, this.initAnimation(), this.play(), t.autoplay === !1 && this.pause();
+  }
+  initAnimation() {
+    const { options: t } = this;
+    E(t);
+    const { type: i = c, repeat: r = 0, repeatDelay: e = 0, repeatType: n, velocity: m = 0 } = t;
+    let { keyframes: s } = t;
+    const h = i || c;
+    process.env.NODE_ENV !== "production" && h !== c && V(s.length <= 2, `Only two keyframes currently supported with spring and inertia animations. Trying to animate ${s}`, "spring-two-frames"), h !== c && typeof s[0] != "number" && (this.mixKeyframes = W(J, G(s[0], s[1])), s = [0, 100]);
+    const a = h({ ...t, keyframes: s });
+    n === "mirror" && (this.mirroredGenerator = h({
+      ...t,
+      keyframes: [...s].reverse(),
+      velocity: -m
+    })), a.calculatedDuration === null && (a.calculatedDuration = O(a));
+    const { calculatedDuration: p } = a;
+    this.calculatedDuration = p, this.resolvedDuration = p + e, this.totalDuration = this.resolvedDuration * (r + 1) - e, this.generator = a;
+  }
+  updateTime(t) {
+    const i = Math.round(t - this.startTime) * this.playbackSpeed;
+    this.holdTime !== null ? this.currentTime = this.holdTime : this.currentTime = i;
+  }
+  tick(t, i = !1) {
+    const { generator: r, totalDuration: e, mixKeyframes: n, mirroredGenerator: m, resolvedDuration: s, calculatedDuration: h } = this;
+    if (this.startTime === null)
+      return r.next(0);
+    const { delay: a = 0, keyframes: p, repeat: k, repeatType: D, repeatDelay: g, type: F, onUpdate: S, finalKeyframe: P } = this.options;
+    this.speed > 0 ? this.startTime = Math.min(this.startTime, t) : this.speed < 0 && (this.startTime = Math.min(t - e / this.speed, this.startTime)), i ? this.currentTime = t : this.updateTime(t);
+    const T = this.currentTime - a * (this.playbackSpeed >= 0 ? 1 : -1), b = this.playbackSpeed >= 0 ? T < 0 : T > e;
+    this.currentTime = Math.max(T, 0), this.state === "finished" && this.holdTime === null && (this.currentTime = e);
+    let w = this.currentTime, x = r;
+    if (k) {
+      const y = Math.min(this.currentTime, e) / s;
+      let d = Math.floor(y), o = y % 1;
+      !o && y >= 1 && (o = 1), o === 1 && d--, d = Math.min(d, k + 1), !!(d % 2) && (D === "reverse" ? (o = 1 - o, g && (o -= g / s)) : D === "mirror" && (x = m)), w = B(0, 1, o) * s;
+    }
+    const l = b ? { done: !1, value: p[0] } : x.next(w);
+    n && (l.value = n(l.value));
+    let { done: M } = l;
+    !b && h !== null && (M = this.playbackSpeed >= 0 ? this.currentTime >= e : this.currentTime <= 0);
+    const A = this.holdTime === null && (this.state === "finished" || this.state === "running" && M);
+    return A && F !== K && (l.value = C(p, this.options, P, this.speed)), S && S(l.value), A && this.finish(), l;
+  }
+  /**
+   * 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(t, i) {
+    return this.finished.then(t, i);
+  }
+  get duration() {
+    return f(this.calculatedDuration);
+  }
+  get iterationDuration() {
+    const { delay: t = 0 } = this.options || {};
+    return this.duration + f(t);
+  }
+  get time() {
+    return f(this.currentTime);
+  }
+  set time(t) {
+    var i;
+    t = $(t), this.currentTime = t, this.startTime === null || this.holdTime !== null || this.playbackSpeed === 0 ? this.holdTime = t : this.driver && (this.startTime = this.driver.now() - t / this.playbackSpeed), (i = this.driver) == null || i.start(!1);
+  }
+  get speed() {
+    return this.playbackSpeed;
+  }
+  set speed(t) {
+    this.updateTime(u.now());
+    const i = this.playbackSpeed !== t;
+    this.playbackSpeed = t, i && (this.time = f(this.currentTime));
+  }
+  play() {
+    var e, n;
+    if (this.isStopped)
+      return;
+    const { driver: t = I, startTime: i } = this.options;
+    this.driver || (this.driver = t((m) => this.tick(m))), (n = (e = this.options).onPlay) == null || n.call(e);
+    const r = this.driver.now();
+    this.state === "finished" ? (this.updateFinished(), this.startTime = r) : this.holdTime !== null ? this.startTime = r - this.holdTime : this.startTime || (this.startTime = i ?? r), this.state === "finished" && this.speed < 0 && (this.startTime += this.calculatedDuration), this.holdTime = null, this.state = "running", this.driver.start();
+  }
+  pause() {
+    this.state = "paused", this.updateTime(u.now()), this.holdTime = this.currentTime;
+  }
+  complete() {
+    this.state !== "running" && this.play(), this.state = "finished", this.holdTime = null;
+  }
+  finish() {
+    var t, i;
+    this.notifyFinished(), this.teardown(), this.state = "finished", (i = (t = this.options).onComplete) == null || i.call(t);
+  }
+  cancel() {
+    var t, i;
+    this.holdTime = null, this.startTime = 0, this.tick(0), this.teardown(), (i = (t = this.options).onCancel) == null || i.call(t);
+  }
+  teardown() {
+    this.state = "idle", this.stopDriver(), this.startTime = this.holdTime = null;
+  }
+  stopDriver() {
+    this.driver && (this.driver.stop(), this.driver = void 0);
+  }
+  sample(t) {
+    return this.startTime = 0, this.tick(t, !0);
+  }
+  attachTimeline(t) {
+    var i;
+    return this.options.allowFlatten && (this.options.type = "keyframes", this.options.ease = "linear", this.initAnimation()), (i = this.driver) == null || i.stop(), t.observe(this);
+  }
+}
+export {
+  et as JSAnimation
+};