@weng-lab/visualization 2.5.1 → 2.6.0-beta.1

package/dist/visualization.es291.js

@@ -1,13 +1,113 @@
-function i(u) {
-  var e = 0, n = u.children, t = n && n.length;
-  if (!t) e = 1;
-  else for (; --t >= 0; ) e += n[t].value;
-  u.value = e;
-}
-function l() {
-  return this.eachAfter(i);
+import { time as v } from "./visualization.es292.js";
+import { JSAnimation as A } from "./visualization.es293.js";
+import { getFinalKeyframe as y } from "./visualization.es294.js";
+import { KeyframeResolver as g, flushKeyframeResolvers as R } from "./visualization.es295.js";
+import { NativeAnimationExtended as T } from "./visualization.es296.js";
+import { canAnimate as _ } from "./visualization.es297.js";
+import { makeAnimationInstant as w } from "./visualization.es298.js";
+import { WithPromise as K } from "./visualization.es299.js";
+import { supportsBrowserAnimation as D } from "./visualization.es300.js";
+import { MotionGlobalConfig as E } from "./visualization.es301.js";
+import { noop as k } from "./visualization.es302.js";
+const x = 40;
+class H extends K {
+  constructor({ autoplay: t = !0, delay: s = 0, type: e = "keyframes", repeat: h = 0, repeatDelay: l = 0, repeatType: f = "loop", keyframes: d, name: o, motionValue: r, element: a, ...m }) {
+    super(), this.stop = () => {
+      this._animation && (this._animation.stop(), this.stopTimeline?.()), this.keyframeResolver?.cancel();
+    }, this.createdAt = v.now();
+    const u = {
+      autoplay: t,
+      delay: s,
+      type: e,
+      repeat: h,
+      repeatDelay: l,
+      repeatType: f,
+      name: o,
+      motionValue: r,
+      element: a,
+      ...m
+    }, n = a?.KeyframeResolver || g;
+    this.keyframeResolver = new n(d, (c, p, i) => this.onKeyframesResolved(c, p, u, !i), o, r, a), this.keyframeResolver?.scheduleResolve();
+  }
+  onKeyframesResolved(t, s, e, h) {
+    this.keyframeResolver = void 0;
+    const { name: l, type: f, velocity: d, delay: o, isHandoff: r, onUpdate: a } = e;
+    this.resolvedAt = v.now();
+    let m = !0;
+    _(t, l, f, d) || (m = !1, (E.instantAnimations || !o) && a?.(y(t, e, s)), t[0] = t[t.length - 1], w(e), e.repeat = 0);
+    const n = {
+      startTime: h ? this.resolvedAt ? this.resolvedAt - this.createdAt > x ? this.resolvedAt : this.createdAt : this.createdAt : void 0,
+      finalKeyframe: s,
+      ...e,
+      keyframes: t
+    }, c = m && !r && D(n), p = n.motionValue?.owner?.current;
+    let i;
+    if (c)
+      try {
+        i = new T({
+          ...n,
+          element: p
+        });
+      } catch {
+        i = new A(n);
+      }
+    else
+      i = new A(n);
+    i.finished.then(() => {
+      this.notifyFinished();
+    }).catch(k), this.pendingTimeline && (this.stopTimeline = i.attachTimeline(this.pendingTimeline), this.pendingTimeline = void 0), this._animation = i;
+  }
+  get finished() {
+    return this._animation ? this.animation.finished : this._finished;
+  }
+  then(t, s) {
+    return this.finished.finally(t).then(() => {
+    });
+  }
+  get animation() {
+    return this._animation || (this.keyframeResolver?.resume(), R()), this._animation;
+  }
+  get duration() {
+    return this.animation.duration;
+  }
+  get iterationDuration() {
+    return this.animation.iterationDuration;
+  }
+  get time() {
+    return this.animation.time;
+  }
+  set time(t) {
+    this.animation.time = t;
+  }
+  get speed() {
+    return this.animation.speed;
+  }
+  get state() {
+    return this.animation.state;
+  }
+  set speed(t) {
+    this.animation.speed = t;
+  }
+  get startTime() {
+    return this.animation.startTime;
+  }
+  attachTimeline(t) {
+    return this._animation ? this.stopTimeline = this.animation.attachTimeline(t) : this.pendingTimeline = t, () => this.stop();
+  }
+  play() {
+    this.animation.play();
+  }
+  pause() {
+    this.animation.pause();
+  }
+  complete() {
+    this.animation.complete();
+  }
+  cancel() {
+    this._animation && this.animation.cancel(), this.keyframeResolver?.cancel();
+  }
 }
 export {
-  l as default
+  H as AsyncMotionValueAnimation
 };
 //# sourceMappingURL=visualization.es291.js.map

package/dist/visualization.es291.js.map

@@ -1 +1 @@
-{"version":3,"file":"visualization.es291.js","sources":["../../../node_modules/.pnpm/d3-hierarchy@1.1.9/node_modules/d3-hierarchy/src/hierarchy/count.js"],"sourcesContent":["function count(node) {\n  var sum = 0,\n      children = node.children,\n      i = children && children.length;\n  if (!i) sum = 1;\n  else while (--i >= 0) sum += children[i].value;\n  node.value = sum;\n}\n\nexport default function() {\n  return this.eachAfter(count);\n}\n"],"names":["count","node","sum","children","i","node_count"],"mappings":"AAAA,SAASA,EAAMC,GAAM;AACnB,MAAIC,IAAM,GACNC,IAAWF,EAAK,UAChBG,IAAID,KAAYA,EAAS;AAC7B,MAAI,CAACC,EAAG,CAAAF,IAAM;AAAA,MACT,QAAO,EAAEE,KAAK,IAAG,CAAAF,KAAOC,EAASC,CAAC,EAAE;AACzC,EAAAH,EAAK,QAAQC;AACf;AAEe,SAAAG,IAAW;AACxB,SAAO,KAAK,UAAUL,CAAK;AAC7B;","x_google_ignoreList":[0]}
+{"version":3,"file":"visualization.es291.js","sources":["../../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/AsyncMotionValueAnimation.mjs"],"sourcesContent":["import { MotionGlobalConfig, noop } from 'motion-utils';\nimport { time } from '../frameloop/sync-time.mjs';\nimport { JSAnimation } from './JSAnimation.mjs';\nimport { getFinalKeyframe } from './keyframes/get-final.mjs';\nimport { KeyframeResolver, flushKeyframeResolvers } from './keyframes/KeyframesResolver.mjs';\nimport { NativeAnimationExtended } from './NativeAnimationExtended.mjs';\nimport { canAnimate } from './utils/can-animate.mjs';\nimport { makeAnimationInstant } from './utils/make-animation-instant.mjs';\nimport { WithPromise } from './utils/WithPromise.mjs';\nimport { supportsBrowserAnimation } from './waapi/supports/waapi.mjs';\n\n/**\n * Maximum time allowed between an animation being created and it being\n * resolved for us to use the latter as the start time.\n *\n * This is to ensure that while we prefer to \"start\" an animation as soon\n * as it's triggered, we also want to avoid a visual jump if there's a big delay\n * between these two moments.\n */\nconst MAX_RESOLVE_DELAY = 40;\nclass AsyncMotionValueAnimation extends WithPromise {\n    constructor({ autoplay = true, delay = 0, type = \"keyframes\", repeat = 0, repeatDelay = 0, repeatType = \"loop\", keyframes, name, motionValue, element, ...options }) {\n        super();\n        /**\n         * Bound to support return animation.stop pattern\n         */\n        this.stop = () => {\n            if (this._animation) {\n                this._animation.stop();\n                this.stopTimeline?.();\n            }\n            this.keyframeResolver?.cancel();\n        };\n        this.createdAt = time.now();\n        const optionsWithDefaults = {\n            autoplay,\n            delay,\n            type,\n            repeat,\n            repeatDelay,\n            repeatType,\n            name,\n            motionValue,\n            element,\n            ...options,\n        };\n        const KeyframeResolver$1 = element?.KeyframeResolver || KeyframeResolver;\n        this.keyframeResolver = new KeyframeResolver$1(keyframes, (resolvedKeyframes, finalKeyframe, forced) => this.onKeyframesResolved(resolvedKeyframes, finalKeyframe, optionsWithDefaults, !forced), name, motionValue, element);\n        this.keyframeResolver?.scheduleResolve();\n    }\n    onKeyframesResolved(keyframes, finalKeyframe, options, sync) {\n        this.keyframeResolver = undefined;\n        const { name, type, velocity, delay, isHandoff, onUpdate } = options;\n        this.resolvedAt = time.now();\n        /**\n         * If we can't animate this value with the resolved keyframes\n         * then we should complete it immediately.\n         */\n        let canAnimateValue = true;\n        if (!canAnimate(keyframes, name, type, velocity)) {\n            canAnimateValue = false;\n            if (MotionGlobalConfig.instantAnimations || !delay) {\n                onUpdate?.(getFinalKeyframe(keyframes, options, finalKeyframe));\n            }\n            keyframes[0] = keyframes[keyframes.length - 1];\n            makeAnimationInstant(options);\n            options.repeat = 0;\n        }\n        /**\n         * Resolve startTime for the animation.\n         *\n         * This method uses the createdAt and resolvedAt to calculate the\n         * animation startTime. *Ideally*, we would use the createdAt time as t=0\n         * as the following frame would then be the first frame of the animation in\n         * progress, which would feel snappier.\n         *\n         * However, if there's a delay (main thread work) between the creation of\n         * the animation and the first committed frame, we prefer to use resolvedAt\n         * to avoid a sudden jump into the animation.\n         */\n        const startTime = sync\n            ? !this.resolvedAt\n                ? this.createdAt\n                : this.resolvedAt - this.createdAt > MAX_RESOLVE_DELAY\n                    ? this.resolvedAt\n                    : this.createdAt\n            : undefined;\n        const resolvedOptions = {\n            startTime,\n            finalKeyframe,\n            ...options,\n            keyframes,\n        };\n        /**\n         * Animate via WAAPI if possible. If this is a handoff animation, the optimised animation will be running via\n         * WAAPI. Therefore, this animation must be JS to ensure it runs \"under\" the\n         * optimised animation.\n         *\n         * Also skip WAAPI when keyframes aren't animatable, as the resolved\n         * values may not be valid CSS and would trigger browser warnings.\n         */\n        const useWaapi = canAnimateValue &&\n            !isHandoff &&\n            supportsBrowserAnimation(resolvedOptions);\n        const element = resolvedOptions.motionValue?.owner?.current;\n        let animation;\n        if (useWaapi) {\n            try {\n                animation = new NativeAnimationExtended({\n                    ...resolvedOptions,\n                    element,\n                });\n            }\n            catch {\n                animation = new JSAnimation(resolvedOptions);\n            }\n        }\n        else {\n            animation = new JSAnimation(resolvedOptions);\n        }\n        animation.finished.then(() => {\n            this.notifyFinished();\n        }).catch(noop);\n        if (this.pendingTimeline) {\n            this.stopTimeline = animation.attachTimeline(this.pendingTimeline);\n            this.pendingTimeline = undefined;\n        }\n        this._animation = animation;\n    }\n    get finished() {\n        if (!this._animation) {\n            return this._finished;\n        }\n        else {\n            return this.animation.finished;\n        }\n    }\n    then(onResolve, _onReject) {\n        return this.finished.finally(onResolve).then(() => { });\n    }\n    get animation() {\n        if (!this._animation) {\n            this.keyframeResolver?.resume();\n            flushKeyframeResolvers();\n        }\n        return this._animation;\n    }\n    get duration() {\n        return this.animation.duration;\n    }\n    get iterationDuration() {\n        return this.animation.iterationDuration;\n    }\n    get time() {\n        return this.animation.time;\n    }\n    set time(newTime) {\n        this.animation.time = newTime;\n    }\n    get speed() {\n        return this.animation.speed;\n    }\n    get state() {\n        return this.animation.state;\n    }\n    set speed(newSpeed) {\n        this.animation.speed = newSpeed;\n    }\n    get startTime() {\n        return this.animation.startTime;\n    }\n    attachTimeline(timeline) {\n        if (this._animation) {\n            this.stopTimeline = this.animation.attachTimeline(timeline);\n        }\n        else {\n            this.pendingTimeline = timeline;\n        }\n        return () => this.stop();\n    }\n    play() {\n        this.animation.play();\n    }\n    pause() {\n        this.animation.pause();\n    }\n    complete() {\n        this.animation.complete();\n    }\n    cancel() {\n        if (this._animation) {\n            this.animation.cancel();\n        }\n        this.keyframeResolver?.cancel();\n    }\n}\n\nexport { AsyncMotionValueAnimation };\n//# sourceMappingURL=AsyncMotionValueAnimation.mjs.map\n"],"names":["MAX_RESOLVE_DELAY","AsyncMotionValueAnimation","WithPromise","autoplay","delay","type","repeat","repeatDelay","repeatType","keyframes","name","motionValue","element","options","time","optionsWithDefaults","KeyframeResolver$1","KeyframeResolver","resolvedKeyframes","finalKeyframe","forced","sync","velocity","isHandoff","onUpdate","canAnimateValue","canAnimate","MotionGlobalConfig","getFinalKeyframe","makeAnimationInstant","resolvedOptions","useWaapi","supportsBrowserAnimation","animation","NativeAnimationExtended","JSAnimation","noop","onResolve","_onReject","flushKeyframeResolvers","newTime","newSpeed","timeline"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/visualization.es292.js

@@ -1,13 +1,16 @@
-function o(l) {
-  var e = this, t, n = [e], r, h, i;
-  do
-    for (t = n.reverse(), n = []; e = t.pop(); )
-      if (l(e), r = e.children, r) for (h = 0, i = r.length; h < i; ++h)
-        n.push(r[h]);
-  while (n.length);
-  return this;
+import { frameData as n } from "./visualization.es330.js";
+import { MotionGlobalConfig as i } from "./visualization.es301.js";
+let e;
+function t() {
+  e = void 0;
 }
+const r = {
+  now: () => (e === void 0 && r.set(n.isProcessing || i.useManualTiming ? n.timestamp : performance.now()), e),
+  set: (o) => {
+    e = o, queueMicrotask(t);
+  }
+};
 export {
-  o as default
+  r as time
 };
 //# sourceMappingURL=visualization.es292.js.map

package/dist/visualization.es292.js.map

@@ -1 +1 @@
-{"version":3,"file":"visualization.es292.js","sources":["../../../node_modules/.pnpm/d3-hierarchy@1.1.9/node_modules/d3-hierarchy/src/hierarchy/each.js"],"sourcesContent":["export default function(callback) {\n  var node = this, current, next = [node], children, i, n;\n  do {\n    current = next.reverse(), next = [];\n    while (node = current.pop()) {\n      callback(node), children = node.children;\n      if (children) for (i = 0, n = children.length; i < n; ++i) {\n        next.push(children[i]);\n      }\n    }\n  } while (next.length);\n  return this;\n}\n"],"names":["node_each","callback","node","current","next","children","i","n"],"mappings":"AAAe,SAAAA,EAASC,GAAU;AAChC,MAAIC,IAAO,MAAMC,GAASC,IAAO,CAACF,CAAI,GAAGG,GAAUC,GAAGC;AACtD;AAEE,SADAJ,IAAUC,EAAK,QAAO,GAAIA,IAAO,CAAA,GAC1BF,IAAOC,EAAQ;AAEpB,UADAF,EAASC,CAAI,GAAGG,IAAWH,EAAK,UAC5BG,EAAU,MAAKC,IAAI,GAAGC,IAAIF,EAAS,QAAQC,IAAIC,GAAG,EAAED;AACtD,QAAAF,EAAK,KAAKC,EAASC,CAAC,CAAC;AAAA,SAGlBF,EAAK;AACd,SAAO;AACT;","x_google_ignoreList":[0]}
+{"version":3,"file":"visualization.es292.js","sources":["../../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/frameloop/sync-time.mjs"],"sourcesContent":["import { MotionGlobalConfig } from 'motion-utils';\nimport { frameData } from './frame.mjs';\n\nlet now;\nfunction clearTime() {\n    now = undefined;\n}\n/**\n * An eventloop-synchronous alternative to performance.now().\n *\n * Ensures that time measurements remain consistent within a synchronous context.\n * Usually calling performance.now() twice within the same synchronous context\n * will return different values which isn't useful for animations when we're usually\n * trying to sync animations to the same frame.\n */\nconst time = {\n    now: () => {\n        if (now === undefined) {\n            time.set(frameData.isProcessing || MotionGlobalConfig.useManualTiming\n                ? frameData.timestamp\n                : performance.now());\n        }\n        return now;\n    },\n    set: (newTime) => {\n        now = newTime;\n        queueMicrotask(clearTime);\n    },\n};\n\nexport { time };\n//# sourceMappingURL=sync-time.mjs.map\n"],"names":["now","clearTime","time","frameData","MotionGlobalConfig","newTime"],"mappings":";;AAGA,IAAIA;AACJ,SAASC,IAAY;AACjB,EAAAD,IAAM;AACV;AASK,MAACE,IAAO;AAAA,EACT,KAAK,OACGF,MAAQ,UACRE,EAAK,IAAIC,EAAU,gBAAgBC,EAAmB,kBAChDD,EAAU,YACV,YAAY,IAAG,CAAE,GAEpBH;AAAA,EAEX,KAAK,CAACK,MAAY;AACd,IAAAL,IAAMK,GACN,eAAeJ,CAAS;AAAA,EAC5B;AACJ;","x_google_ignoreList":[0]}

package/dist/visualization.es293.js

@@ -1,10 +1,145 @@
-function r(o) {
-  for (var e = this, i = [e], n, h; e = i.pop(); )
-    if (o(e), n = e.children, n) for (h = n.length - 1; h >= 0; --h)
-      i.push(n[h]);
-  return this;
+import { time as p } from "./visualization.es292.js";
+import { mix as P } from "./visualization.es303.js";
+import { frameloopDriver as I } from "./visualization.es304.js";
+import { inertia as K } from "./visualization.es305.js";
+import { keyframes as u } from "./visualization.es306.js";
+import { calcGeneratorDuration as O } from "./visualization.es307.js";
+import { getGeneratorVelocity as V } from "./visualization.es308.js";
+import { getFinalKeyframe as C } from "./visualization.es294.js";
+import { replaceTransitionType as E } from "./visualization.es309.js";
+import { WithPromise as N } from "./visualization.es299.js";
+import { invariant as W } from "./visualization.es310.js";
+import { pipe as $ } from "./visualization.es311.js";
+import { millisecondsToSeconds as c, secondsToMilliseconds as B } from "./visualization.es312.js";
+import { clamp as J } from "./visualization.es313.js";
+const U = (g) => g / 100;
+class rt extends N {
+  constructor(t) {
+    super(), this.state = "idle", this.startTime = null, this.isStopped = !1, this.currentTime = 0, this.holdTime = null, this.playbackSpeed = 1, this.delayState = {
+      done: !1,
+      value: void 0
+    }, this.stop = () => {
+      const { motionValue: i } = this.options;
+      i && i.updatedAt !== p.now() && this.tick(p.now()), this.isStopped = !0, this.state !== "idle" && (this.teardown(), this.options.onStop?.());
+    }, this.options = t, this.initAnimation(), this.play(), t.autoplay === !1 && this.pause();
+  }
+  initAnimation() {
+    const { options: t } = this;
+    E(t);
+    const { type: i = u, repeat: s = 0, repeatDelay: r = 0, repeatType: m, velocity: f = 0 } = t;
+    let { keyframes: e } = t;
+    const h = i || u;
+    process.env.NODE_ENV !== "production" && h !== u && W(e.length <= 2, `Only two keyframes currently supported with spring and inertia animations. Trying to animate ${e}`, "spring-two-frames"), h !== u && typeof e[0] != "number" && (this.mixKeyframes = $(U, P(e[0], e[1])), e = [0, 100]);
+    const n = h({ ...t, keyframes: e });
+    m === "mirror" && (this.mirroredGenerator = h({
+      ...t,
+      keyframes: [...e].reverse(),
+      velocity: -f
+    })), n.calculatedDuration === null && (n.calculatedDuration = O(n));
+    const { calculatedDuration: l } = n;
+    this.calculatedDuration = l, this.resolvedDuration = l + r, this.totalDuration = this.resolvedDuration * (s + 1) - r, this.generator = n;
+  }
+  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: s, totalDuration: r, mixKeyframes: m, mirroredGenerator: f, resolvedDuration: e, calculatedDuration: h } = this;
+    if (this.startTime === null)
+      return s.next(0);
+    const { delay: n = 0, keyframes: l, repeat: k, repeatType: D, repeatDelay: S, type: F, onUpdate: b, finalKeyframe: G } = this.options;
+    this.speed > 0 ? this.startTime = Math.min(this.startTime, t) : this.speed < 0 && (this.startTime = Math.min(t - r / this.speed, this.startTime)), i ? this.currentTime = t : this.updateTime(t);
+    const T = this.currentTime - n * (this.playbackSpeed >= 0 ? 1 : -1), y = this.playbackSpeed >= 0 ? T < 0 : T > r;
+    this.currentTime = Math.max(T, 0), this.state === "finished" && this.holdTime === null && (this.currentTime = r);
+    let x = this.currentTime, w = s;
+    if (k) {
+      const v = Math.min(this.currentTime, r) / e;
+      let d = Math.floor(v), o = v % 1;
+      !o && v >= 1 && (o = 1), o === 1 && d--, d = Math.min(d, k + 1), d % 2 && (D === "reverse" ? (o = 1 - o, S && (o -= S / e)) : D === "mirror" && (w = f)), x = J(0, 1, o) * e;
+    }
+    let a;
+    y ? (this.delayState.value = l[0], a = this.delayState) : a = w.next(x), m && !y && (a.value = m(a.value));
+    let { done: M } = a;
+    !y && h !== null && (M = this.playbackSpeed >= 0 ? this.currentTime >= r : this.currentTime <= 0);
+    const A = this.holdTime === null && (this.state === "finished" || this.state === "running" && M);
+    return A && F !== K && (a.value = C(l, this.options, G, this.speed)), b && b(a.value), A && this.finish(), a;
+  }
+  /**
+   * 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 c(this.calculatedDuration);
+  }
+  get iterationDuration() {
+    const { delay: t = 0 } = this.options || {};
+    return this.duration + c(t);
+  }
+  get time() {
+    return c(this.currentTime);
+  }
+  set time(t) {
+    t = B(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), this.driver ? this.driver.start(!1) : (this.startTime = 0, this.state = "paused", this.holdTime = t, this.tick(t));
+  }
+  /**
+   * Returns the generator's velocity at the current time in units/second.
+   * Uses the analytical derivative when available (springs), avoiding
+   * the MotionValue's frame-dependent velocity estimation.
+   */
+  getGeneratorVelocity() {
+    const t = this.currentTime;
+    if (t <= 0)
+      return this.options.velocity || 0;
+    if (this.generator.velocity)
+      return this.generator.velocity(t);
+    const i = this.generator.next(t).value;
+    return V((s) => this.generator.next(s).value, t, i);
+  }
+  get speed() {
+    return this.playbackSpeed;
+  }
+  set speed(t) {
+    const i = this.playbackSpeed !== t;
+    i && this.driver && this.updateTime(p.now()), this.playbackSpeed = t, i && this.driver && (this.time = c(this.currentTime));
+  }
+  play() {
+    if (this.isStopped)
+      return;
+    const { driver: t = I, startTime: i } = this.options;
+    this.driver || (this.driver = t((r) => this.tick(r))), this.options.onPlay?.();
+    const s = this.driver.now();
+    this.state === "finished" ? (this.updateFinished(), this.startTime = s) : this.holdTime !== null ? this.startTime = s - this.holdTime : this.startTime || (this.startTime = i ?? s), 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(p.now()), this.holdTime = this.currentTime;
+  }
+  complete() {
+    this.state !== "running" && this.play(), this.state = "finished", this.holdTime = null;
+  }
+  finish() {
+    this.notifyFinished(), this.teardown(), this.state = "finished", this.options.onComplete?.();
+  }
+  cancel() {
+    this.holdTime = null, this.startTime = 0, this.tick(0), this.teardown(), this.options.onCancel?.();
+  }
+  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) {
+    return this.options.allowFlatten && (this.options.type = "keyframes", this.options.ease = "linear", this.initAnimation()), this.driver?.stop(), t.observe(this);
+  }
 }
 export {
-  r as default
+  rt as JSAnimation
 };
 //# sourceMappingURL=visualization.es293.js.map

package/dist/visualization.es293.js.map

@@ -1 +1 @@
-{"version":3,"file":"visualization.es293.js","sources":["../../../node_modules/.pnpm/d3-hierarchy@1.1.9/node_modules/d3-hierarchy/src/hierarchy/eachBefore.js"],"sourcesContent":["export default function(callback) {\n  var node = this, nodes = [node], children, i;\n  while (node = nodes.pop()) {\n    callback(node), children = node.children;\n    if (children) for (i = children.length - 1; i >= 0; --i) {\n      nodes.push(children[i]);\n    }\n  }\n  return this;\n}\n"],"names":["node_eachBefore","callback","node","nodes","children","i"],"mappings":"AAAe,SAAAA,EAASC,GAAU;AAEhC,WADIC,IAAO,MAAMC,IAAQ,CAACD,CAAI,GAAGE,GAAUC,GACpCH,IAAOC,EAAM;AAElB,QADAF,EAASC,CAAI,GAAGE,IAAWF,EAAK,UAC5BE,EAAU,MAAKC,IAAID,EAAS,SAAS,GAAGC,KAAK,GAAG,EAAEA;AACpD,MAAAF,EAAM,KAAKC,EAASC,CAAC,CAAC;AAG1B,SAAO;AACT;","x_google_ignoreList":[0]}
+{"version":3,"file":"visualization.es293.js","sources":["../../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/JSAnimation.mjs"],"sourcesContent":["import { invariant, pipe, clamp, millisecondsToSeconds, secondsToMilliseconds } from 'motion-utils';\nimport { time } from '../frameloop/sync-time.mjs';\nimport { activeAnimations } from '../stats/animation-count.mjs';\nimport { mix } from '../utils/mix/index.mjs';\nimport { frameloopDriver } from './drivers/frame.mjs';\nimport { inertia } from './generators/inertia.mjs';\nimport { keyframes } from './generators/keyframes.mjs';\nimport { calcGeneratorDuration } from './generators/utils/calc-duration.mjs';\nimport { getGeneratorVelocity } from './generators/utils/velocity.mjs';\nimport { getFinalKeyframe } from './keyframes/get-final.mjs';\nimport { replaceTransitionType } from './utils/replace-transition-type.mjs';\nimport { WithPromise } from './utils/WithPromise.mjs';\n\nconst percentToProgress = (percent) => percent / 100;\nclass JSAnimation extends WithPromise {\n    constructor(options) {\n        super();\n        this.state = \"idle\";\n        this.startTime = null;\n        this.isStopped = false;\n        /**\n         * The current time of the animation.\n         */\n        this.currentTime = 0;\n        /**\n         * The time at which the animation was paused.\n         */\n        this.holdTime = null;\n        /**\n         * Playback speed as a factor. 0 would be stopped, -1 reverse and 2 double speed.\n         */\n        this.playbackSpeed = 1;\n        /**\n         * Reusable state object for the delay phase to avoid\n         * allocating a new object every frame.\n         */\n        this.delayState = {\n            done: false,\n            value: undefined,\n        };\n        /**\n         * This method is bound to the instance to fix a pattern where\n         * animation.stop is returned as a reference from a useEffect.\n         */\n        this.stop = () => {\n            const { motionValue } = this.options;\n            if (motionValue && motionValue.updatedAt !== time.now()) {\n                this.tick(time.now());\n            }\n            this.isStopped = true;\n            if (this.state === \"idle\")\n                return;\n            this.teardown();\n            this.options.onStop?.();\n        };\n        activeAnimations.mainThread++;\n        this.options = options;\n        this.initAnimation();\n        this.play();\n        if (options.autoplay === false)\n            this.pause();\n    }\n    initAnimation() {\n        const { options } = this;\n        replaceTransitionType(options);\n        const { type = keyframes, repeat = 0, repeatDelay = 0, repeatType, velocity = 0, } = options;\n        let { keyframes: keyframes$1 } = options;\n        const generatorFactory = type || keyframes;\n        if (process.env.NODE_ENV !== \"production\" &&\n            generatorFactory !== keyframes) {\n            invariant(keyframes$1.length <= 2, `Only two keyframes currently supported with spring and inertia animations. Trying to animate ${keyframes$1}`, \"spring-two-frames\");\n        }\n        if (generatorFactory !== keyframes &&\n            typeof keyframes$1[0] !== \"number\") {\n            this.mixKeyframes = pipe(percentToProgress, mix(keyframes$1[0], keyframes$1[1]));\n            keyframes$1 = [0, 100];\n        }\n        const generator = generatorFactory({ ...options, keyframes: keyframes$1 });\n        /**\n         * If we have a mirror repeat type we need to create a second generator that outputs the\n         * mirrored (not reversed) animation and later ping pong between the two generators.\n         */\n        if (repeatType === \"mirror\") {\n            this.mirroredGenerator = generatorFactory({\n                ...options,\n                keyframes: [...keyframes$1].reverse(),\n                velocity: -velocity,\n            });\n        }\n        /**\n         * If duration is undefined and we have repeat options,\n         * we need to calculate a duration from the generator.\n         *\n         * We set it to the generator itself to cache the duration.\n         * Any timeline resolver will need to have already precalculated\n         * the duration by this step.\n         */\n        if (generator.calculatedDuration === null) {\n            generator.calculatedDuration = calcGeneratorDuration(generator);\n        }\n        const { calculatedDuration } = generator;\n        this.calculatedDuration = calculatedDuration;\n        this.resolvedDuration = calculatedDuration + repeatDelay;\n        this.totalDuration = this.resolvedDuration * (repeat + 1) - repeatDelay;\n        this.generator = generator;\n    }\n    updateTime(timestamp) {\n        const animationTime = Math.round(timestamp - this.startTime) * this.playbackSpeed;\n        // Update currentTime\n        if (this.holdTime !== null) {\n            this.currentTime = this.holdTime;\n        }\n        else {\n            // Rounding the time because floating point arithmetic is not always accurate, e.g. 3000.367 - 1000.367 =\n            // 2000.0000000000002. This is a problem when we are comparing the currentTime with the duration, for\n            // example.\n            this.currentTime = animationTime;\n        }\n    }\n    tick(timestamp, sample = false) {\n        const { generator, totalDuration, mixKeyframes, mirroredGenerator, resolvedDuration, calculatedDuration, } = this;\n        if (this.startTime === null)\n            return generator.next(0);\n        const { delay = 0, keyframes, repeat, repeatType, repeatDelay, type, onUpdate, finalKeyframe, } = this.options;\n        /**\n         * requestAnimationFrame timestamps can come through as lower than\n         * the startTime as set by performance.now(). Here we prevent this,\n         * though in the future it could be possible to make setting startTime\n         * a pending operation that gets resolved here.\n         */\n        if (this.speed > 0) {\n            this.startTime = Math.min(this.startTime, timestamp);\n        }\n        else if (this.speed < 0) {\n            this.startTime = Math.min(timestamp - totalDuration / this.speed, this.startTime);\n        }\n        if (sample) {\n            this.currentTime = timestamp;\n        }\n        else {\n            this.updateTime(timestamp);\n        }\n        // Rebase on delay\n        const timeWithoutDelay = this.currentTime - delay * (this.playbackSpeed >= 0 ? 1 : -1);\n        const isInDelayPhase = this.playbackSpeed >= 0\n            ? timeWithoutDelay < 0\n            : timeWithoutDelay > totalDuration;\n        this.currentTime = Math.max(timeWithoutDelay, 0);\n        // If this animation has finished, set the current time  to the total duration.\n        if (this.state === \"finished\" && this.holdTime === null) {\n            this.currentTime = totalDuration;\n        }\n        let elapsed = this.currentTime;\n        let frameGenerator = generator;\n        if (repeat) {\n            /**\n             * Get the current progress (0-1) of the animation. If t is >\n             * than duration we'll get values like 2.5 (midway through the\n             * third iteration)\n             */\n            const progress = Math.min(this.currentTime, totalDuration) / resolvedDuration;\n            /**\n             * Get the current iteration (0 indexed). For instance the floor of\n             * 2.5 is 2.\n             */\n            let currentIteration = Math.floor(progress);\n            /**\n             * Get the current progress of the iteration by taking the remainder\n             * so 2.5 is 0.5 through iteration 2\n             */\n            let iterationProgress = progress % 1.0;\n            /**\n             * If iteration progress is 1 we count that as the end\n             * of the previous iteration.\n             */\n            if (!iterationProgress && progress >= 1) {\n                iterationProgress = 1;\n            }\n            iterationProgress === 1 && currentIteration--;\n            currentIteration = Math.min(currentIteration, repeat + 1);\n            /**\n             * Reverse progress if we're not running in \"normal\" direction\n             */\n            const isOddIteration = Boolean(currentIteration % 2);\n            if (isOddIteration) {\n                if (repeatType === \"reverse\") {\n                    iterationProgress = 1 - iterationProgress;\n                    if (repeatDelay) {\n                        iterationProgress -= repeatDelay / resolvedDuration;\n                    }\n                }\n                else if (repeatType === \"mirror\") {\n                    frameGenerator = mirroredGenerator;\n                }\n            }\n            elapsed = clamp(0, 1, iterationProgress) * resolvedDuration;\n        }\n        /**\n         * If we're in negative time, set state as the initial keyframe.\n         * This prevents delay: x, duration: 0 animations from finishing\n         * instantly.\n         */\n        let state;\n        if (isInDelayPhase) {\n            this.delayState.value = keyframes[0];\n            state = this.delayState;\n        }\n        else {\n            state = frameGenerator.next(elapsed);\n        }\n        if (mixKeyframes && !isInDelayPhase) {\n            state.value = mixKeyframes(state.value);\n        }\n        let { done } = state;\n        if (!isInDelayPhase && calculatedDuration !== null) {\n            done =\n                this.playbackSpeed >= 0\n                    ? this.currentTime >= totalDuration\n                    : this.currentTime <= 0;\n        }\n        const isAnimationFinished = this.holdTime === null &&\n            (this.state === \"finished\" || (this.state === \"running\" && done));\n        // TODO: The exception for inertia could be cleaner here\n        if (isAnimationFinished && type !== inertia) {\n            state.value = getFinalKeyframe(keyframes, this.options, finalKeyframe, this.speed);\n        }\n        if (onUpdate) {\n            onUpdate(state.value);\n        }\n        if (isAnimationFinished) {\n            this.finish();\n        }\n        return state;\n    }\n    /**\n     * Allows the returned animation to be awaited or promise-chained. Currently\n     * resolves when the animation finishes at all but in a future update could/should\n     * reject if its cancels.\n     */\n    then(resolve, reject) {\n        return this.finished.then(resolve, reject);\n    }\n    get duration() {\n        return millisecondsToSeconds(this.calculatedDuration);\n    }\n    get iterationDuration() {\n        const { delay = 0 } = this.options || {};\n        return this.duration + millisecondsToSeconds(delay);\n    }\n    get time() {\n        return millisecondsToSeconds(this.currentTime);\n    }\n    set time(newTime) {\n        newTime = secondsToMilliseconds(newTime);\n        this.currentTime = newTime;\n        if (this.startTime === null ||\n            this.holdTime !== null ||\n            this.playbackSpeed === 0) {\n            this.holdTime = newTime;\n        }\n        else if (this.driver) {\n            this.startTime = this.driver.now() - newTime / this.playbackSpeed;\n        }\n        if (this.driver) {\n            this.driver.start(false);\n        }\n        else {\n            this.startTime = 0;\n            this.state = \"paused\";\n            this.holdTime = newTime;\n            this.tick(newTime);\n        }\n    }\n    /**\n     * Returns the generator's velocity at the current time in units/second.\n     * Uses the analytical derivative when available (springs), avoiding\n     * the MotionValue's frame-dependent velocity estimation.\n     */\n    getGeneratorVelocity() {\n        const t = this.currentTime;\n        if (t <= 0)\n            return this.options.velocity || 0;\n        if (this.generator.velocity) {\n            return this.generator.velocity(t);\n        }\n        // Fallback: finite difference\n        const current = this.generator.next(t).value;\n        return getGeneratorVelocity((s) => this.generator.next(s).value, t, current);\n    }\n    get speed() {\n        return this.playbackSpeed;\n    }\n    set speed(newSpeed) {\n        const hasChanged = this.playbackSpeed !== newSpeed;\n        if (hasChanged && this.driver) {\n            this.updateTime(time.now());\n        }\n        this.playbackSpeed = newSpeed;\n        if (hasChanged && this.driver) {\n            this.time = millisecondsToSeconds(this.currentTime);\n        }\n    }\n    play() {\n        if (this.isStopped)\n            return;\n        const { driver = frameloopDriver, startTime } = this.options;\n        if (!this.driver) {\n            this.driver = driver((timestamp) => this.tick(timestamp));\n        }\n        this.options.onPlay?.();\n        const now = this.driver.now();\n        if (this.state === \"finished\") {\n            this.updateFinished();\n            this.startTime = now;\n        }\n        else if (this.holdTime !== null) {\n            this.startTime = now - this.holdTime;\n        }\n        else if (!this.startTime) {\n            this.startTime = startTime ?? now;\n        }\n        if (this.state === \"finished\" && this.speed < 0) {\n            this.startTime += this.calculatedDuration;\n        }\n        this.holdTime = null;\n        /**\n         * Set playState to running only after we've used it in\n         * the previous logic.\n         */\n        this.state = \"running\";\n        this.driver.start();\n    }\n    pause() {\n        this.state = \"paused\";\n        this.updateTime(time.now());\n        this.holdTime = this.currentTime;\n    }\n    complete() {\n        if (this.state !== \"running\") {\n            this.play();\n        }\n        this.state = \"finished\";\n        this.holdTime = null;\n    }\n    finish() {\n        this.notifyFinished();\n        this.teardown();\n        this.state = \"finished\";\n        this.options.onComplete?.();\n    }\n    cancel() {\n        this.holdTime = null;\n        this.startTime = 0;\n        this.tick(0);\n        this.teardown();\n        this.options.onCancel?.();\n    }\n    teardown() {\n        this.state = \"idle\";\n        this.stopDriver();\n        this.startTime = this.holdTime = null;\n        activeAnimations.mainThread--;\n    }\n    stopDriver() {\n        if (!this.driver)\n            return;\n        this.driver.stop();\n        this.driver = undefined;\n    }\n    sample(sampleTime) {\n        this.startTime = 0;\n        return this.tick(sampleTime, true);\n    }\n    attachTimeline(timeline) {\n        if (this.options.allowFlatten) {\n            this.options.type = \"keyframes\";\n            this.options.ease = \"linear\";\n            this.initAnimation();\n        }\n        this.driver?.stop();\n        return timeline.observe(this);\n    }\n}\n// Legacy function support\nfunction animateValue(options) {\n    return new JSAnimation(options);\n}\n\nexport { JSAnimation, animateValue };\n//# sourceMappingURL=JSAnimation.mjs.map\n"],"names":["percentToProgress","percent","JSAnimation","WithPromise","options","motionValue","time","replaceTransitionType","type","keyframes","repeat","repeatDelay","repeatType","velocity","keyframes$1","generatorFactory","invariant","pipe","mix","generator","calcGeneratorDuration","calculatedDuration","timestamp","animationTime","sample","totalDuration","mixKeyframes","mirroredGenerator","resolvedDuration","delay","onUpdate","finalKeyframe","timeWithoutDelay","isInDelayPhase","elapsed","frameGenerator","progress","currentIteration","iterationProgress","clamp","state","done","isAnimationFinished","inertia","getFinalKeyframe","resolve","reject","millisecondsToSeconds","newTime","secondsToMilliseconds","current","getGeneratorVelocity","newSpeed","hasChanged","driver","frameloopDriver","startTime","now","sampleTime","timeline"],"mappings":";;;;;;;;;;;;;;AAaA,MAAMA,IAAoB,CAACC,MAAYA,IAAU;AACjD,MAAMC,WAAoBC,EAAY;AAAA,EAClC,YAAYC,GAAS;AACjB,UAAK,GACL,KAAK,QAAQ,QACb,KAAK,YAAY,MACjB,KAAK,YAAY,IAIjB,KAAK,cAAc,GAInB,KAAK,WAAW,MAIhB,KAAK,gBAAgB,GAKrB,KAAK,aAAa;AAAA,MACd,MAAM;AAAA,MACN,OAAO;AAAA,IACnB,GAKQ,KAAK,OAAO,MAAM;AACd,YAAM,EAAE,aAAAC,MAAgB,KAAK;AAK7B,MAJIA,KAAeA,EAAY,cAAcC,EAAK,IAAG,KACjD,KAAK,KAAKA,EAAK,KAAK,GAExB,KAAK,YAAY,IACb,KAAK,UAAU,WAEnB,KAAK,SAAQ,GACb,KAAK,QAAQ,SAAM;AAAA,IACvB,GAEA,KAAK,UAAUF,GACf,KAAK,cAAa,GAClB,KAAK,KAAI,GACLA,EAAQ,aAAa,MACrB,KAAK,MAAK;AAAA,EAClB;AAAA,EACA,gBAAgB;AACZ,UAAM,EAAE,SAAAA,EAAO,IAAK;AACpB,IAAAG,EAAsBH,CAAO;AAC7B,UAAM,EAAE,MAAAI,IAAOC,GAAW,QAAAC,IAAS,GAAG,aAAAC,IAAc,GAAG,YAAAC,GAAY,UAAAC,IAAW,EAAC,IAAMT;AACrF,QAAI,EAAE,WAAWU,EAAW,IAAKV;AACjC,UAAMW,IAAmBP,KAAQC;AACjC,IAAI,QAAQ,IAAI,aAAa,gBACzBM,MAAqBN,KACrBO,EAAUF,EAAY,UAAU,GAAG,gGAAgGA,CAAW,IAAI,mBAAmB,GAErKC,MAAqBN,KACrB,OAAOK,EAAY,CAAC,KAAM,aAC1B,KAAK,eAAeG,EAAKjB,GAAmBkB,EAAIJ,EAAY,CAAC,GAAGA,EAAY,CAAC,CAAC,CAAC,GAC/EA,IAAc,CAAC,GAAG,GAAG;AAEzB,UAAMK,IAAYJ,EAAiB,EAAE,GAAGX,GAAS,WAAWU,GAAa;AAKzE,IAAIF,MAAe,aACf,KAAK,oBAAoBG,EAAiB;AAAA,MACtC,GAAGX;AAAA,MACH,WAAW,CAAC,GAAGU,CAAW,EAAE,QAAO;AAAA,MACnC,UAAU,CAACD;AAAA,IAC3B,CAAa,IAUDM,EAAU,uBAAuB,SACjCA,EAAU,qBAAqBC,EAAsBD,CAAS;AAElE,UAAM,EAAE,oBAAAE,EAAkB,IAAKF;AAC/B,SAAK,qBAAqBE,GAC1B,KAAK,mBAAmBA,IAAqBV,GAC7C,KAAK,gBAAgB,KAAK,oBAAoBD,IAAS,KAAKC,GAC5D,KAAK,YAAYQ;AAAA,EACrB;AAAA,EACA,WAAWG,GAAW;AAClB,UAAMC,IAAgB,KAAK,MAAMD,IAAY,KAAK,SAAS,IAAI,KAAK;AAEpE,IAAI,KAAK,aAAa,OAClB,KAAK,cAAc,KAAK,WAMxB,KAAK,cAAcC;AAAA,EAE3B;AAAA,EACA,KAAKD,GAAWE,IAAS,IAAO;AAC5B,UAAM,EAAE,WAAAL,GAAW,eAAAM,GAAe,cAAAC,GAAc,mBAAAC,GAAmB,kBAAAC,GAAkB,oBAAAP,EAAkB,IAAM;AAC7G,QAAI,KAAK,cAAc;AACnB,aAAOF,EAAU,KAAK,CAAC;AAC3B,UAAM,EAAE,OAAAU,IAAQ,GAAG,WAAApB,GAAW,QAAAC,GAAQ,YAAAE,GAAY,aAAAD,GAAa,MAAAH,GAAM,UAAAsB,GAAU,eAAAC,EAAa,IAAM,KAAK;AAOvG,IAAI,KAAK,QAAQ,IACb,KAAK,YAAY,KAAK,IAAI,KAAK,WAAWT,CAAS,IAE9C,KAAK,QAAQ,MAClB,KAAK,YAAY,KAAK,IAAIA,IAAYG,IAAgB,KAAK,OAAO,KAAK,SAAS,IAEhFD,IACA,KAAK,cAAcF,IAGnB,KAAK,WAAWA,CAAS;AAG7B,UAAMU,IAAmB,KAAK,cAAcH,KAAS,KAAK,iBAAiB,IAAI,IAAI,KAC7EI,IAAiB,KAAK,iBAAiB,IACvCD,IAAmB,IACnBA,IAAmBP;AACzB,SAAK,cAAc,KAAK,IAAIO,GAAkB,CAAC,GAE3C,KAAK,UAAU,cAAc,KAAK,aAAa,SAC/C,KAAK,cAAcP;AAEvB,QAAIS,IAAU,KAAK,aACfC,IAAiBhB;AACrB,QAAIT,GAAQ;AAMR,YAAM0B,IAAW,KAAK,IAAI,KAAK,aAAaX,CAAa,IAAIG;AAK7D,UAAIS,IAAmB,KAAK,MAAMD,CAAQ,GAKtCE,IAAoBF,IAAW;AAKnC,MAAI,CAACE,KAAqBF,KAAY,MAClCE,IAAoB,IAExBA,MAAsB,KAAKD,KAC3BA,IAAmB,KAAK,IAAIA,GAAkB3B,IAAS,CAAC,GAIzB2B,IAAmB,MAE1CzB,MAAe,aACf0B,IAAoB,IAAIA,GACpB3B,MACA2B,KAAqB3B,IAAciB,MAGlChB,MAAe,aACpBuB,IAAiBR,KAGzBO,IAAUK,EAAM,GAAG,GAAGD,CAAiB,IAAIV;AAAA,IAC/C;AAMA,QAAIY;AACJ,IAAIP,KACA,KAAK,WAAW,QAAQxB,EAAU,CAAC,GACnC+B,IAAQ,KAAK,cAGbA,IAAQL,EAAe,KAAKD,CAAO,GAEnCR,KAAgB,CAACO,MACjBO,EAAM,QAAQd,EAAac,EAAM,KAAK;AAE1C,QAAI,EAAE,MAAAC,EAAI,IAAKD;AACf,IAAI,CAACP,KAAkBZ,MAAuB,SAC1CoB,IACI,KAAK,iBAAiB,IAChB,KAAK,eAAehB,IACpB,KAAK,eAAe;AAElC,UAAMiB,IAAsB,KAAK,aAAa,SACzC,KAAK,UAAU,cAAe,KAAK,UAAU,aAAaD;AAE/D,WAAIC,KAAuBlC,MAASmC,MAChCH,EAAM,QAAQI,EAAiBnC,GAAW,KAAK,SAASsB,GAAe,KAAK,KAAK,IAEjFD,KACAA,EAASU,EAAM,KAAK,GAEpBE,KACA,KAAK,OAAM,GAERF;AAAA,EACX;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,KAAKK,GAASC,GAAQ;AAClB,WAAO,KAAK,SAAS,KAAKD,GAASC,CAAM;AAAA,EAC7C;AAAA,EACA,IAAI,WAAW;AACX,WAAOC,EAAsB,KAAK,kBAAkB;AAAA,EACxD;AAAA,EACA,IAAI,oBAAoB;AACpB,UAAM,EAAE,OAAAlB,IAAQ,EAAC,IAAK,KAAK,WAAW,CAAA;AACtC,WAAO,KAAK,WAAWkB,EAAsBlB,CAAK;AAAA,EACtD;AAAA,EACA,IAAI,OAAO;AACP,WAAOkB,EAAsB,KAAK,WAAW;AAAA,EACjD;AAAA,EACA,IAAI,KAAKC,GAAS;AACd,IAAAA,IAAUC,EAAsBD,CAAO,GACvC,KAAK,cAAcA,GACf,KAAK,cAAc,QACnB,KAAK,aAAa,QAClB,KAAK,kBAAkB,IACvB,KAAK,WAAWA,IAEX,KAAK,WACV,KAAK,YAAY,KAAK,OAAO,QAAQA,IAAU,KAAK,gBAEpD,KAAK,SACL,KAAK,OAAO,MAAM,EAAK,KAGvB,KAAK,YAAY,GACjB,KAAK,QAAQ,UACb,KAAK,WAAWA,GAChB,KAAK,KAAKA,CAAO;AAAA,EAEzB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,uBAAuB;AACnB,UAAM,IAAI,KAAK;AACf,QAAI,KAAK;AACL,aAAO,KAAK,QAAQ,YAAY;AACpC,QAAI,KAAK,UAAU;AACf,aAAO,KAAK,UAAU,SAAS,CAAC;AAGpC,UAAME,IAAU,KAAK,UAAU,KAAK,CAAC,EAAE;AACvC,WAAOC,EAAqB,CAAC,MAAM,KAAK,UAAU,KAAK,CAAC,EAAE,OAAO,GAAGD,CAAO;AAAA,EAC/E;AAAA,EACA,IAAI,QAAQ;AACR,WAAO,KAAK;AAAA,EAChB;AAAA,EACA,IAAI,MAAME,GAAU;AAChB,UAAMC,IAAa,KAAK,kBAAkBD;AAC1C,IAAIC,KAAc,KAAK,UACnB,KAAK,WAAW/C,EAAK,KAAK,GAE9B,KAAK,gBAAgB8C,GACjBC,KAAc,KAAK,WACnB,KAAK,OAAON,EAAsB,KAAK,WAAW;AAAA,EAE1D;AAAA,EACA,OAAO;AACH,QAAI,KAAK;AACL;AACJ,UAAM,EAAE,QAAAO,IAASC,GAAiB,WAAAC,EAAS,IAAK,KAAK;AACrD,IAAK,KAAK,WACN,KAAK,SAASF,EAAO,CAAChC,MAAc,KAAK,KAAKA,CAAS,CAAC,IAE5D,KAAK,QAAQ,SAAM;AACnB,UAAMmC,IAAM,KAAK,OAAO,IAAG;AAC3B,IAAI,KAAK,UAAU,cACf,KAAK,eAAc,GACnB,KAAK,YAAYA,KAEZ,KAAK,aAAa,OACvB,KAAK,YAAYA,IAAM,KAAK,WAEtB,KAAK,cACX,KAAK,YAAYD,KAAaC,IAE9B,KAAK,UAAU,cAAc,KAAK,QAAQ,MAC1C,KAAK,aAAa,KAAK,qBAE3B,KAAK,WAAW,MAKhB,KAAK,QAAQ,WACb,KAAK,OAAO,MAAK;AAAA,EACrB;AAAA,EACA,QAAQ;AACJ,SAAK,QAAQ,UACb,KAAK,WAAWnD,EAAK,KAAK,GAC1B,KAAK,WAAW,KAAK;AAAA,EACzB;AAAA,EACA,WAAW;AACP,IAAI,KAAK,UAAU,aACf,KAAK,KAAI,GAEb,KAAK,QAAQ,YACb,KAAK,WAAW;AAAA,EACpB;AAAA,EACA,SAAS;AACL,SAAK,eAAc,GACnB,KAAK,SAAQ,GACb,KAAK,QAAQ,YACb,KAAK,QAAQ,aAAU;AAAA,EAC3B;AAAA,EACA,SAAS;AACL,SAAK,WAAW,MAChB,KAAK,YAAY,GACjB,KAAK,KAAK,CAAC,GACX,KAAK,SAAQ,GACb,KAAK,QAAQ,WAAQ;AAAA,EACzB;AAAA,EACA,WAAW;AACP,SAAK,QAAQ,QACb,KAAK,WAAU,GACf,KAAK,YAAY,KAAK,WAAW;AAAA,EAErC;AAAA,EACA,aAAa;AACT,IAAK,KAAK,WAEV,KAAK,OAAO,KAAI,GAChB,KAAK,SAAS;AAAA,EAClB;AAAA,EACA,OAAOoD,GAAY;AACf,gBAAK,YAAY,GACV,KAAK,KAAKA,GAAY,EAAI;AAAA,EACrC;AAAA,EACA,eAAeC,GAAU;AACrB,WAAI,KAAK,QAAQ,iBACb,KAAK,QAAQ,OAAO,aACpB,KAAK,QAAQ,OAAO,UACpB,KAAK,cAAa,IAEtB,KAAK,QAAQ,KAAI,GACVA,EAAS,QAAQ,IAAI;AAAA,EAChC;AACJ;","x_google_ignoreList":[0]}

package/dist/visualization.es294.js

@@ -1,12 +1,9 @@
-function p(r) {
-  for (var e = this, i = [e], t = [], n, h, o; e = i.pop(); )
-    if (t.push(e), n = e.children, n) for (h = 0, o = n.length; h < o; ++h)
-      i.push(n[h]);
-  for (; e = t.pop(); )
-    r(e);
-  return this;
+const i = (e) => e !== null;
+function c(e, { repeat: n, repeatType: l = "loop" }, o, r = 1) {
+  const t = e.filter(i), s = r < 0 || n && l !== "loop" && n % 2 === 1 ? 0 : t.length - 1;
+  return !s || o === void 0 ? t[s] : o;
 }
 export {
-  p as default
+  c as getFinalKeyframe
 };
 //# sourceMappingURL=visualization.es294.js.map

package/dist/visualization.es294.js.map

@@ -1 +1 @@
-{"version":3,"file":"visualization.es294.js","sources":["../../../node_modules/.pnpm/d3-hierarchy@1.1.9/node_modules/d3-hierarchy/src/hierarchy/eachAfter.js"],"sourcesContent":["export default function(callback) {\n  var node = this, nodes = [node], next = [], children, i, n;\n  while (node = nodes.pop()) {\n    next.push(node), children = node.children;\n    if (children) for (i = 0, n = children.length; i < n; ++i) {\n      nodes.push(children[i]);\n    }\n  }\n  while (node = next.pop()) {\n    callback(node);\n  }\n  return this;\n}\n"],"names":["node_eachAfter","callback","node","nodes","next","children","i","n"],"mappings":"AAAe,SAAAA,EAASC,GAAU;AAEhC,WADIC,IAAO,MAAMC,IAAQ,CAACD,CAAI,GAAGE,IAAO,CAAA,GAAIC,GAAUC,GAAGC,GAClDL,IAAOC,EAAM;AAElB,QADAC,EAAK,KAAKF,CAAI,GAAGG,IAAWH,EAAK,UAC7BG,EAAU,MAAKC,IAAI,GAAGC,IAAIF,EAAS,QAAQC,IAAIC,GAAG,EAAED;AACtD,MAAAH,EAAM,KAAKE,EAASC,CAAC,CAAC;AAG1B,SAAOJ,IAAOE,EAAK;AACjB,IAAAH,EAASC,CAAI;AAEf,SAAO;AACT;","x_google_ignoreList":[0]}
+{"version":3,"file":"visualization.es294.js","sources":["../../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/keyframes/get-final.mjs"],"sourcesContent":["const isNotNull = (value) => value !== null;\nfunction getFinalKeyframe(keyframes, { repeat, repeatType = \"loop\" }, finalKeyframe, speed = 1) {\n    const resolvedKeyframes = keyframes.filter(isNotNull);\n    const useFirstKeyframe = speed < 0 || (repeat && repeatType !== \"loop\" && repeat % 2 === 1);\n    const index = useFirstKeyframe ? 0 : resolvedKeyframes.length - 1;\n    return !index || finalKeyframe === undefined\n        ? resolvedKeyframes[index]\n        : finalKeyframe;\n}\n\nexport { getFinalKeyframe };\n//# sourceMappingURL=get-final.mjs.map\n"],"names":["isNotNull","value","getFinalKeyframe","keyframes","repeat","repeatType","finalKeyframe","speed","resolvedKeyframes","index"],"mappings":"AAAA,MAAMA,IAAY,CAACC,MAAUA,MAAU;AACvC,SAASC,EAAiBC,GAAW,EAAE,QAAAC,GAAQ,YAAAC,IAAa,UAAUC,GAAeC,IAAQ,GAAG;AAC5F,QAAMC,IAAoBL,EAAU,OAAOH,CAAS,GAE9CS,IADmBF,IAAQ,KAAMH,KAAUC,MAAe,UAAUD,IAAS,MAAM,IACxD,IAAII,EAAkB,SAAS;AAChE,SAAO,CAACC,KAASH,MAAkB,SAC7BE,EAAkBC,CAAK,IACvBH;AACV;","x_google_ignoreList":[0]}

package/dist/visualization.es295.js

@@ -1,10 +1,75 @@
-function l(i) {
-  return this.eachAfter(function(e) {
-    for (var a = +i(e.data) || 0, t = e.children, u = t && t.length; --u >= 0; ) a += t[u].value;
-    e.value = a;
+import { fillWildcards as y } from "./visualization.es354.js";
+import { removeNonTranslationalTransform as p } from "./visualization.es353.js";
+import { frame as c } from "./visualization.es330.js";
+const l = /* @__PURE__ */ new Set();
+let f = !1, d = !1, m = !1;
+function u() {
+  if (d) {
+    const a = Array.from(l).filter((e) => e.needsMeasurement), s = new Set(a.map((e) => e.element)), r = /* @__PURE__ */ new Map();
+    s.forEach((e) => {
+      const t = p(e);
+      t.length && (r.set(e, t), e.render());
+    }), a.forEach((e) => e.measureInitialState()), s.forEach((e) => {
+      e.render();
+      const t = r.get(e);
+      t && t.forEach(([n, i]) => {
+        e.getValue(n)?.set(i);
+      });
+    }), a.forEach((e) => e.measureEndState()), a.forEach((e) => {
+      e.suspendedScrollY !== void 0 && window.scrollTo(0, e.suspendedScrollY);
+    });
+  }
+  d = !1, f = !1, l.forEach((a) => a.complete(m)), l.clear();
+}
+function h() {
+  l.forEach((a) => {
+    a.readKeyframes(), a.needsMeasurement && (d = !0);
   });
 }
+function S() {
+  m = !0, h(), u(), m = !1;
+}
+class g {
+  constructor(s, r, e, t, n, i = !1) {
+    this.state = "pending", this.isAsync = !1, this.needsMeasurement = !1, this.unresolvedKeyframes = [...s], this.onComplete = r, this.name = e, this.motionValue = t, this.element = n, this.isAsync = i;
+  }
+  scheduleResolve() {
+    this.state = "scheduled", this.isAsync ? (l.add(this), f || (f = !0, c.read(h), c.resolveKeyframes(u))) : (this.readKeyframes(), this.complete());
+  }
+  readKeyframes() {
+    const { unresolvedKeyframes: s, name: r, element: e, motionValue: t } = this;
+    if (s[0] === null) {
+      const n = t?.get(), i = s[s.length - 1];
+      if (n !== void 0)
+        s[0] = n;
+      else if (e && r) {
+        const o = e.readValue(r, i);
+        o != null && (s[0] = o);
+      }
+      s[0] === void 0 && (s[0] = i), t && n === void 0 && t.set(s[0]);
+    }
+    y(s);
+  }
+  setFinalKeyframe() {
+  }
+  measureInitialState() {
+  }
+  renderEndStyles() {
+  }
+  measureEndState() {
+  }
+  complete(s = !1) {
+    this.state = "complete", this.onComplete(this.unresolvedKeyframes, this.finalKeyframe, s), l.delete(this);
+  }
+  cancel() {
+    this.state === "scheduled" && (l.delete(this), this.state = "pending");
+  }
+  resume() {
+    this.state === "pending" && this.scheduleResolve();
+  }
+}
 export {
-  l as default
+  g as KeyframeResolver,
+  S as flushKeyframeResolvers
 };
 //# sourceMappingURL=visualization.es295.js.map

package/dist/visualization.es295.js.map

@@ -1 +1 @@
-{"version":3,"file":"visualization.es295.js","sources":["../../../node_modules/.pnpm/d3-hierarchy@1.1.9/node_modules/d3-hierarchy/src/hierarchy/sum.js"],"sourcesContent":["export default function(value) {\n  return this.eachAfter(function(node) {\n    var sum = +value(node.data) || 0,\n        children = node.children,\n        i = children && children.length;\n    while (--i >= 0) sum += children[i].value;\n    node.value = sum;\n  });\n}\n"],"names":["node_sum","value","node","sum","children","i"],"mappings":"AAAe,SAAAA,EAASC,GAAO;AAC7B,SAAO,KAAK,UAAU,SAASC,GAAM;AAInC,aAHIC,IAAM,CAACF,EAAMC,EAAK,IAAI,KAAK,GAC3BE,IAAWF,EAAK,UAChBG,IAAID,KAAYA,EAAS,QACtB,EAAEC,KAAK,IAAG,CAAAF,KAAOC,EAASC,CAAC,EAAE;AACpC,IAAAH,EAAK,QAAQC;AAAA,EACf,CAAC;AACH;","x_google_ignoreList":[0]}
+{"version":3,"file":"visualization.es295.js","sources":["../../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/keyframes/KeyframesResolver.mjs"],"sourcesContent":["import { fillWildcards } from './utils/fill-wildcards.mjs';\nimport { removeNonTranslationalTransform } from './utils/unit-conversion.mjs';\nimport { frame } from '../../frameloop/frame.mjs';\n\nconst toResolve = new Set();\nlet isScheduled = false;\nlet anyNeedsMeasurement = false;\nlet isForced = false;\nfunction measureAllKeyframes() {\n    if (anyNeedsMeasurement) {\n        const resolversToMeasure = Array.from(toResolve).filter((resolver) => resolver.needsMeasurement);\n        const elementsToMeasure = new Set(resolversToMeasure.map((resolver) => resolver.element));\n        const transformsToRestore = new Map();\n        /**\n         * Write pass\n         * If we're measuring elements we want to remove bounding box-changing transforms.\n         */\n        elementsToMeasure.forEach((element) => {\n            const removedTransforms = removeNonTranslationalTransform(element);\n            if (!removedTransforms.length)\n                return;\n            transformsToRestore.set(element, removedTransforms);\n            element.render();\n        });\n        // Read\n        resolversToMeasure.forEach((resolver) => resolver.measureInitialState());\n        // Write\n        elementsToMeasure.forEach((element) => {\n            element.render();\n            const restore = transformsToRestore.get(element);\n            if (restore) {\n                restore.forEach(([key, value]) => {\n                    element.getValue(key)?.set(value);\n                });\n            }\n        });\n        // Read\n        resolversToMeasure.forEach((resolver) => resolver.measureEndState());\n        // Write\n        resolversToMeasure.forEach((resolver) => {\n            if (resolver.suspendedScrollY !== undefined) {\n                window.scrollTo(0, resolver.suspendedScrollY);\n            }\n        });\n    }\n    anyNeedsMeasurement = false;\n    isScheduled = false;\n    toResolve.forEach((resolver) => resolver.complete(isForced));\n    toResolve.clear();\n}\nfunction readAllKeyframes() {\n    toResolve.forEach((resolver) => {\n        resolver.readKeyframes();\n        if (resolver.needsMeasurement) {\n            anyNeedsMeasurement = true;\n        }\n    });\n}\nfunction flushKeyframeResolvers() {\n    isForced = true;\n    readAllKeyframes();\n    measureAllKeyframes();\n    isForced = false;\n}\nclass KeyframeResolver {\n    constructor(unresolvedKeyframes, onComplete, name, motionValue, element, isAsync = false) {\n        this.state = \"pending\";\n        /**\n         * Track whether this resolver is async. If it is, it'll be added to the\n         * resolver queue and flushed in the next frame. Resolvers that aren't going\n         * to trigger read/write thrashing don't need to be async.\n         */\n        this.isAsync = false;\n        /**\n         * Track whether this resolver needs to perform a measurement\n         * to resolve its keyframes.\n         */\n        this.needsMeasurement = false;\n        this.unresolvedKeyframes = [...unresolvedKeyframes];\n        this.onComplete = onComplete;\n        this.name = name;\n        this.motionValue = motionValue;\n        this.element = element;\n        this.isAsync = isAsync;\n    }\n    scheduleResolve() {\n        this.state = \"scheduled\";\n        if (this.isAsync) {\n            toResolve.add(this);\n            if (!isScheduled) {\n                isScheduled = true;\n                frame.read(readAllKeyframes);\n                frame.resolveKeyframes(measureAllKeyframes);\n            }\n        }\n        else {\n            this.readKeyframes();\n            this.complete();\n        }\n    }\n    readKeyframes() {\n        const { unresolvedKeyframes, name, element, motionValue } = this;\n        // If initial keyframe is null we need to read it from the DOM\n        if (unresolvedKeyframes[0] === null) {\n            const currentValue = motionValue?.get();\n            // TODO: This doesn't work if the final keyframe is a wildcard\n            const finalKeyframe = unresolvedKeyframes[unresolvedKeyframes.length - 1];\n            if (currentValue !== undefined) {\n                unresolvedKeyframes[0] = currentValue;\n            }\n            else if (element && name) {\n                const valueAsRead = element.readValue(name, finalKeyframe);\n                if (valueAsRead !== undefined && valueAsRead !== null) {\n                    unresolvedKeyframes[0] = valueAsRead;\n                }\n            }\n            if (unresolvedKeyframes[0] === undefined) {\n                unresolvedKeyframes[0] = finalKeyframe;\n            }\n            if (motionValue && currentValue === undefined) {\n                motionValue.set(unresolvedKeyframes[0]);\n            }\n        }\n        fillWildcards(unresolvedKeyframes);\n    }\n    setFinalKeyframe() { }\n    measureInitialState() { }\n    renderEndStyles() { }\n    measureEndState() { }\n    complete(isForcedComplete = false) {\n        this.state = \"complete\";\n        this.onComplete(this.unresolvedKeyframes, this.finalKeyframe, isForcedComplete);\n        toResolve.delete(this);\n    }\n    cancel() {\n        if (this.state === \"scheduled\") {\n            toResolve.delete(this);\n            this.state = \"pending\";\n        }\n    }\n    resume() {\n        if (this.state === \"pending\")\n            this.scheduleResolve();\n    }\n}\n\nexport { KeyframeResolver, flushKeyframeResolvers };\n//# sourceMappingURL=KeyframesResolver.mjs.map\n"],"names":["toResolve","isScheduled","anyNeedsMeasurement","isForced","measureAllKeyframes","resolversToMeasure","resolver","elementsToMeasure","transformsToRestore","element","removedTransforms","removeNonTranslationalTransform","restore","key","value","readAllKeyframes","flushKeyframeResolvers","KeyframeResolver","unresolvedKeyframes","onComplete","name","motionValue","isAsync","frame","currentValue","finalKeyframe","valueAsRead","fillWildcards","isForcedComplete"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/visualization.es296.js

@@ -1,9 +1,39 @@
-function t(r) {
-  return this.eachBefore(function(e) {
-    e.children && e.children.sort(r);
-  });
+import { time as p } from "./visualization.es292.js";
+import { setStyle as c } from "./visualization.es315.js";
+import { JSAnimation as f } from "./visualization.es293.js";
+import { NativeAnimation as u } from "./visualization.es314.js";
+import { replaceTransitionType as d } from "./visualization.es309.js";
+import { replaceStringEasing as h } from "./visualization.es319.js";
+import { clamp as T } from "./visualization.es313.js";
+const o = 10;
+class N extends u {
+  constructor(t) {
+    h(t), d(t), super(t), t.startTime !== void 0 && t.autoplay !== !1 && (this.startTime = t.startTime), this.options = t;
+  }
+  /**
+   * WAAPI doesn't natively have any interruption capabilities.
+   *
+   * Rather than read committed styles back out of the DOM, we can
+   * create a renderless JS animation and sample it twice to calculate
+   * its current value, "previous" value, and therefore allow
+   * Motion to calculate velocity for any subsequent animation.
+   */
+  updateMotionValue(t) {
+    const { motionValue: e, onUpdate: y, onComplete: A, element: m, ...l } = this.options;
+    if (!e)
+      return;
+    if (t !== void 0) {
+      e.set(t);
+      return;
+    }
+    const i = new f({
+      ...l,
+      autoplay: !1
+    }), a = Math.max(o, p.now() - this.startTime), n = T(0, o, a - o), r = i.sample(a).value, { name: s } = this.options;
+    m && s && c(m, s, r), e.setWithVelocity(i.sample(Math.max(0, a - n)).value, r, n), i.stop();
+  }
 }
 export {
-  t as default
+  N as NativeAnimationExtended
 };
 //# sourceMappingURL=visualization.es296.js.map

package/dist/visualization.es296.js.map

@@ -1 +1 @@
-{"version":3,"file":"visualization.es296.js","sources":["../../../node_modules/.pnpm/d3-hierarchy@1.1.9/node_modules/d3-hierarchy/src/hierarchy/sort.js"],"sourcesContent":["export default function(compare) {\n  return this.eachBefore(function(node) {\n    if (node.children) {\n      node.children.sort(compare);\n    }\n  });\n}\n"],"names":["node_sort","compare","node"],"mappings":"AAAe,SAAAA,EAASC,GAAS;AAC/B,SAAO,KAAK,WAAW,SAASC,GAAM;AACpC,IAAIA,EAAK,YACPA,EAAK,SAAS,KAAKD,CAAO;AAAA,EAE9B,CAAC;AACH;","x_google_ignoreList":[0]}
+{"version":3,"file":"visualization.es296.js","sources":["../../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/NativeAnimationExtended.mjs"],"sourcesContent":["import { clamp } from 'motion-utils';\nimport { time } from '../frameloop/sync-time.mjs';\nimport { setStyle } from '../render/dom/style-set.mjs';\nimport { JSAnimation } from './JSAnimation.mjs';\nimport { NativeAnimation } from './NativeAnimation.mjs';\nimport { replaceTransitionType } from './utils/replace-transition-type.mjs';\nimport { replaceStringEasing } from './waapi/utils/unsupported-easing.mjs';\n\n/**\n * 10ms is chosen here as it strikes a balance between smooth\n * results (more than one keyframe per frame at 60fps) and\n * keyframe quantity.\n */\nconst sampleDelta = 10; //ms\nclass NativeAnimationExtended extends NativeAnimation {\n    constructor(options) {\n        /**\n         * The base NativeAnimation function only supports a subset\n         * of Motion easings, and WAAPI also only supports some\n         * easing functions via string/cubic-bezier definitions.\n         *\n         * This function replaces those unsupported easing functions\n         * with a JS easing function. This will later get compiled\n         * to a linear() easing function.\n         */\n        replaceStringEasing(options);\n        /**\n         * Ensure we replace the transition type with a generator function\n         * before passing to WAAPI.\n         *\n         * TODO: Does this have a better home? It could be shared with\n         * JSAnimation.\n         */\n        replaceTransitionType(options);\n        super(options);\n        /**\n         * Only set startTime when the animation should autoplay.\n         * Setting startTime on a paused WAAPI animation unpauses it\n         * (per the WAAPI spec), which breaks autoplay: false.\n         */\n        if (options.startTime !== undefined && options.autoplay !== false) {\n            this.startTime = options.startTime;\n        }\n        this.options = options;\n    }\n    /**\n     * WAAPI doesn't natively have any interruption capabilities.\n     *\n     * Rather than read committed styles back out of the DOM, we can\n     * create a renderless JS animation and sample it twice to calculate\n     * its current value, \"previous\" value, and therefore allow\n     * Motion to calculate velocity for any subsequent animation.\n     */\n    updateMotionValue(value) {\n        const { motionValue, onUpdate, onComplete, element, ...options } = this.options;\n        if (!motionValue)\n            return;\n        if (value !== undefined) {\n            motionValue.set(value);\n            return;\n        }\n        const sampleAnimation = new JSAnimation({\n            ...options,\n            autoplay: false,\n        });\n        /**\n         * Use wall-clock elapsed time for sampling.\n         * Under CPU load, WAAPI's currentTime may not reflect actual\n         * elapsed time, causing incorrect sampling and visual jumps.\n         */\n        const sampleTime = Math.max(sampleDelta, time.now() - this.startTime);\n        const delta = clamp(0, sampleDelta, sampleTime - sampleDelta);\n        const current = sampleAnimation.sample(sampleTime).value;\n        /**\n         * Write the estimated value to inline style so it persists\n         * after cancel(), covering the async gap before the next\n         * animation starts.\n         */\n        const { name } = this.options;\n        if (element && name)\n            setStyle(element, name, current);\n        motionValue.setWithVelocity(sampleAnimation.sample(Math.max(0, sampleTime - delta)).value, current, delta);\n        sampleAnimation.stop();\n    }\n}\n\nexport { NativeAnimationExtended };\n//# sourceMappingURL=NativeAnimationExtended.mjs.map\n"],"names":["sampleDelta","NativeAnimationExtended","NativeAnimation","options","replaceStringEasing","replaceTransitionType","value","motionValue","onUpdate","onComplete","element","sampleAnimation","JSAnimation","sampleTime","time","delta","clamp","current","name","setStyle"],"mappings":";;;;;;;AAaA,MAAMA,IAAc;AACpB,MAAMC,UAAgCC,EAAgB;AAAA,EAClD,YAAYC,GAAS;AAUjB,IAAAC,EAAoBD,CAAO,GAQ3BE,EAAsBF,CAAO,GAC7B,MAAMA,CAAO,GAMTA,EAAQ,cAAc,UAAaA,EAAQ,aAAa,OACxD,KAAK,YAAYA,EAAQ,YAE7B,KAAK,UAAUA;AAAA,EACnB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,kBAAkBG,GAAO;AACrB,UAAM,EAAE,aAAAC,GAAa,UAAAC,GAAU,YAAAC,GAAY,SAAAC,GAAS,GAAGP,EAAO,IAAK,KAAK;AACxE,QAAI,CAACI;AACD;AACJ,QAAID,MAAU,QAAW;AACrB,MAAAC,EAAY,IAAID,CAAK;AACrB;AAAA,IACJ;AACA,UAAMK,IAAkB,IAAIC,EAAY;AAAA,MACpC,GAAGT;AAAA,MACH,UAAU;AAAA,IACtB,CAAS,GAMKU,IAAa,KAAK,IAAIb,GAAac,EAAK,IAAG,IAAK,KAAK,SAAS,GAC9DC,IAAQC,EAAM,GAAGhB,GAAaa,IAAab,CAAW,GACtDiB,IAAUN,EAAgB,OAAOE,CAAU,EAAE,OAM7C,EAAE,MAAAK,MAAS,KAAK;AACtB,IAAIR,KAAWQ,KACXC,EAAST,GAASQ,GAAMD,CAAO,GACnCV,EAAY,gBAAgBI,EAAgB,OAAO,KAAK,IAAI,GAAGE,IAAaE,CAAK,CAAC,EAAE,OAAOE,GAASF,CAAK,GACzGJ,EAAgB,KAAI;AAAA,EACxB;AACJ;","x_google_ignoreList":[0]}