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

package/dist/visualization.es303.js

@@ -1,113 +1,9 @@
-import { time as v } from "./visualization.es304.js";
-import { JSAnimation as A } from "./visualization.es305.js";
-import { getFinalKeyframe as y } from "./visualization.es306.js";
-import { KeyframeResolver as g, flushKeyframeResolvers as R } from "./visualization.es307.js";
-import { NativeAnimationExtended as T } from "./visualization.es308.js";
-import { canAnimate as _ } from "./visualization.es309.js";
-import { makeAnimationInstant as w } from "./visualization.es310.js";
-import { WithPromise as K } from "./visualization.es311.js";
-import { supportsBrowserAnimation as D } from "./visualization.es312.js";
-import { MotionGlobalConfig as E } from "./visualization.es313.js";
-import { noop as k } from "./visualization.es314.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();
-  }
+import { getMixer as m } from "./visualization.es389.js";
+import { mixNumber as t } from "./visualization.es356.js";
+function o(e, r, i) {
+  return typeof e == "number" && typeof r == "number" && typeof i == "number" ? t(e, r, i) : m(e)(e, r);
 }
 export {
-  H as AsyncMotionValueAnimation
+  o as mix
 };
 //# sourceMappingURL=visualization.es303.js.map

package/dist/visualization.es303.js.map

@@ -1 +1 @@
-{"version":3,"file":"visualization.es303.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":";;;;;;;;;;;AAmBA,MAAMA,IAAoB;AAC1B,MAAMC,UAAkCC,EAAY;AAAA,EAChD,YAAY,EAAE,UAAAC,IAAW,IAAM,OAAAC,IAAQ,GAAG,MAAAC,IAAO,aAAa,QAAAC,IAAS,GAAG,aAAAC,IAAc,GAAG,YAAAC,IAAa,QAAQ,WAAAC,GAAW,MAAAC,GAAM,aAAAC,GAAa,SAAAC,GAAS,GAAGC,KAAW;AACjK,UAAK,GAIL,KAAK,OAAO,MAAM;AACd,MAAI,KAAK,eACL,KAAK,WAAW,KAAI,GACpB,KAAK,eAAY,IAErB,KAAK,kBAAkB,OAAM;AAAA,IACjC,GACA,KAAK,YAAYC,EAAK,IAAG;AACzB,UAAMC,IAAsB;AAAA,MACxB,UAAAZ;AAAA,MACA,OAAAC;AAAA,MACA,MAAAC;AAAA,MACA,QAAAC;AAAA,MACA,aAAAC;AAAA,MACA,YAAAC;AAAA,MACA,MAAAE;AAAA,MACA,aAAAC;AAAA,MACA,SAAAC;AAAA,MACA,GAAGC;AAAA,IACf,GACcG,IAAqBJ,GAAS,oBAAoBK;AACxD,SAAK,mBAAmB,IAAID,EAAmBP,GAAW,CAACS,GAAmBC,GAAeC,MAAW,KAAK,oBAAoBF,GAAmBC,GAAeJ,GAAqB,CAACK,CAAM,GAAGV,GAAMC,GAAaC,CAAO,GAC5N,KAAK,kBAAkB,gBAAe;AAAA,EAC1C;AAAA,EACA,oBAAoBH,GAAWU,GAAeN,GAASQ,GAAM;AACzD,SAAK,mBAAmB;AACxB,UAAM,EAAE,MAAAX,GAAM,MAAAL,GAAM,UAAAiB,GAAU,OAAAlB,GAAO,WAAAmB,GAAW,UAAAC,EAAQ,IAAKX;AAC7D,SAAK,aAAaC,EAAK,IAAG;AAK1B,QAAIW,IAAkB;AACtB,IAAKC,EAAWjB,GAAWC,GAAML,GAAMiB,CAAQ,MAC3CG,IAAkB,KACdE,EAAmB,qBAAqB,CAACvB,MACzCoB,IAAWI,EAAiBnB,GAAWI,GAASM,CAAa,CAAC,GAElEV,EAAU,CAAC,IAAIA,EAAUA,EAAU,SAAS,CAAC,GAC7CoB,EAAqBhB,CAAO,GAC5BA,EAAQ,SAAS;AAqBrB,UAAMiB,IAAkB;AAAA,MACpB,WARcT,IACX,KAAK,aAEF,KAAK,aAAa,KAAK,YAAYrB,IAC/B,KAAK,aACL,KAAK,YAHT,KAAK,YAIT;AAAA,MAGF,eAAAmB;AAAA,MACA,GAAGN;AAAA,MACH,WAAAJ;AAAA,IACZ,GAScsB,IAAWN,KACb,CAACF,KACDS,EAAyBF,CAAe,GACtClB,IAAUkB,EAAgB,aAAa,OAAO;AACpD,QAAIG;AACJ,QAAIF;AACA,UAAI;AACA,QAAAE,IAAY,IAAIC,EAAwB;AAAA,UACpC,GAAGJ;AAAA,UACH,SAAAlB;AAAA,QACpB,CAAiB;AAAA,MACL,QACM;AACF,QAAAqB,IAAY,IAAIE,EAAYL,CAAe;AAAA,MAC/C;AAAA;AAGA,MAAAG,IAAY,IAAIE,EAAYL,CAAe;AAE/C,IAAAG,EAAU,SAAS,KAAK,MAAM;AAC1B,WAAK,eAAc;AAAA,IACvB,CAAC,EAAE,MAAMG,CAAI,GACT,KAAK,oBACL,KAAK,eAAeH,EAAU,eAAe,KAAK,eAAe,GACjE,KAAK,kBAAkB,SAE3B,KAAK,aAAaA;AAAA,EACtB;AAAA,EACA,IAAI,WAAW;AACX,WAAK,KAAK,aAIC,KAAK,UAAU,WAHf,KAAK;AAAA,EAKpB;AAAA,EACA,KAAKI,GAAWC,GAAW;AACvB,WAAO,KAAK,SAAS,QAAQD,CAAS,EAAE,KAAK,MAAM;AAAA,IAAE,CAAC;AAAA,EAC1D;AAAA,EACA,IAAI,YAAY;AACZ,WAAK,KAAK,eACN,KAAK,kBAAkB,OAAM,GAC7BE,EAAsB,IAEnB,KAAK;AAAA,EAChB;AAAA,EACA,IAAI,WAAW;AACX,WAAO,KAAK,UAAU;AAAA,EAC1B;AAAA,EACA,IAAI,oBAAoB;AACpB,WAAO,KAAK,UAAU;AAAA,EAC1B;AAAA,EACA,IAAI,OAAO;AACP,WAAO,KAAK,UAAU;AAAA,EAC1B;AAAA,EACA,IAAI,KAAKC,GAAS;AACd,SAAK,UAAU,OAAOA;AAAA,EAC1B;AAAA,EACA,IAAI,QAAQ;AACR,WAAO,KAAK,UAAU;AAAA,EAC1B;AAAA,EACA,IAAI,QAAQ;AACR,WAAO,KAAK,UAAU;AAAA,EAC1B;AAAA,EACA,IAAI,MAAMC,GAAU;AAChB,SAAK,UAAU,QAAQA;AAAA,EAC3B;AAAA,EACA,IAAI,YAAY;AACZ,WAAO,KAAK,UAAU;AAAA,EAC1B;AAAA,EACA,eAAeC,GAAU;AACrB,WAAI,KAAK,aACL,KAAK,eAAe,KAAK,UAAU,eAAeA,CAAQ,IAG1D,KAAK,kBAAkBA,GAEpB,MAAM,KAAK,KAAI;AAAA,EAC1B;AAAA,EACA,OAAO;AACH,SAAK,UAAU,KAAI;AAAA,EACvB;AAAA,EACA,QAAQ;AACJ,SAAK,UAAU,MAAK;AAAA,EACxB;AAAA,EACA,WAAW;AACP,SAAK,UAAU,SAAQ;AAAA,EAC3B;AAAA,EACA,SAAS;AACL,IAAI,KAAK,cACL,KAAK,UAAU,OAAM,GAEzB,KAAK,kBAAkB,OAAM;AAAA,EACjC;AACJ;","x_google_ignoreList":[0]}
+{"version":3,"file":"visualization.es303.js","sources":["../../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/utils/mix/index.mjs"],"sourcesContent":["import { getMixer } from './complex.mjs';\nimport { mixNumber } from './number.mjs';\n\nfunction mix(from, to, p) {\n    if (typeof from === \"number\" &&\n        typeof to === \"number\" &&\n        typeof p === \"number\") {\n        return mixNumber(from, to, p);\n    }\n    const mixer = getMixer(from);\n    return mixer(from, to);\n}\n\nexport { mix };\n//# sourceMappingURL=index.mjs.map\n"],"names":["mix","from","to","p","mixNumber","getMixer"],"mappings":";;AAGA,SAASA,EAAIC,GAAMC,GAAIC,GAAG;AACtB,SAAI,OAAOF,KAAS,YAChB,OAAOC,KAAO,YACd,OAAOC,KAAM,WACNC,EAAUH,GAAMC,GAAIC,CAAC,IAElBE,EAASJ,CAAI,EACdA,GAAMC,CAAE;AACzB;","x_google_ignoreList":[0]}

package/dist/visualization.es304.js

@@ -1,16 +1,18 @@
-import { frameData as n } from "./visualization.es342.js";
-import { MotionGlobalConfig as i } from "./visualization.es313.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);
-  }
+import { time as o } from "./visualization.es292.js";
+import { frameData as e, cancelFrame as a, frame as s } from "./visualization.es330.js";
+const n = (m) => {
+  const t = ({ timestamp: r }) => m(r);
+  return {
+    start: (r = !0) => s.update(t, r),
+    stop: () => a(t),
+    /**
+     * If we're processing this frame we can use the
+     * framelocked timestamp to keep things in sync.
+     */
+    now: () => e.isProcessing ? e.timestamp : o.now()
+  };
 };
 export {
-  r as time
+  n as frameloopDriver
 };
 //# sourceMappingURL=visualization.es304.js.map

package/dist/visualization.es304.js.map

@@ -1 +1 @@
-{"version":3,"file":"visualization.es304.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]}
+{"version":3,"file":"visualization.es304.js","sources":["../../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/drivers/frame.mjs"],"sourcesContent":["import { time } from '../../frameloop/sync-time.mjs';\nimport { frameData, cancelFrame, frame } from '../../frameloop/frame.mjs';\n\nconst frameloopDriver = (update) => {\n    const passTimestamp = ({ timestamp }) => update(timestamp);\n    return {\n        start: (keepAlive = true) => frame.update(passTimestamp, keepAlive),\n        stop: () => cancelFrame(passTimestamp),\n        /**\n         * If we're processing this frame we can use the\n         * framelocked timestamp to keep things in sync.\n         */\n        now: () => (frameData.isProcessing ? frameData.timestamp : time.now()),\n    };\n};\n\nexport { frameloopDriver };\n//# sourceMappingURL=frame.mjs.map\n"],"names":["frameloopDriver","update","passTimestamp","timestamp","keepAlive","frame","cancelFrame","frameData","time"],"mappings":";;AAGK,MAACA,IAAkB,CAACC,MAAW;AAChC,QAAMC,IAAgB,CAAC,EAAE,WAAAC,EAAS,MAAOF,EAAOE,CAAS;AACzD,SAAO;AAAA,IACH,OAAO,CAACC,IAAY,OAASC,EAAM,OAAOH,GAAeE,CAAS;AAAA,IAClE,MAAM,MAAME,EAAYJ,CAAa;AAAA;AAAA;AAAA;AAAA;AAAA,IAKrC,KAAK,MAAOK,EAAU,eAAeA,EAAU,YAAYC,EAAK;EACxE;AACA;","x_google_ignoreList":[0]}

package/dist/visualization.es305.js

@@ -1,145 +1,38 @@
-import { time as p } from "./visualization.es304.js";
-import { mix as P } from "./visualization.es315.js";
-import { frameloopDriver as I } from "./visualization.es316.js";
-import { inertia as K } from "./visualization.es317.js";
-import { keyframes as u } from "./visualization.es318.js";
-import { calcGeneratorDuration as O } from "./visualization.es319.js";
-import { getGeneratorVelocity as V } from "./visualization.es320.js";
-import { getFinalKeyframe as C } from "./visualization.es306.js";
-import { replaceTransitionType as E } from "./visualization.es321.js";
-import { WithPromise as N } from "./visualization.es311.js";
-import { invariant as W } from "./visualization.es322.js";
-import { pipe as $ } from "./visualization.es323.js";
-import { millisecondsToSeconds as c, secondsToMilliseconds as B } from "./visualization.es324.js";
-import { clamp as J } from "./visualization.es325.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;
+import { spring as L } from "./visualization.es340.js";
+import { getGeneratorVelocity as R } from "./visualization.es308.js";
+function $({ keyframes: v, velocity: B = 0, power: M = 0.8, timeConstant: b = 325, bounceDamping: k = 10, bounceStiffness: F = 500, modifyTarget: l, min: t, max: a, restDelta: f = 0.5, restSpeed: O }) {
+  const s = v[0], n = {
+    done: !1,
+    value: s
+  }, C = (e) => t !== void 0 && e < t || a !== void 0 && e > a, D = (e) => t === void 0 ? a : a === void 0 || Math.abs(t - e) < Math.abs(a - e) ? t : a;
+  let d = M * B;
+  const i = s + d, u = l === void 0 ? i : l(i);
+  u !== i && (d = u - s);
+  const p = (e) => -d * Math.exp(-e / b), h = (e) => u + p(e), y = (e) => {
+    const o = p(e), G = h(e);
+    n.done = Math.abs(o) <= f, n.value = n.done ? u : G;
+  };
+  let r, c;
+  const g = (e) => {
+    C(n.value) && (r = e, c = L({
+      keyframes: [n.value, D(n.value)],
+      velocity: R(h, e, n.value),
+      // TODO: This should be passing * 1000
+      damping: k,
+      stiffness: F,
+      restDelta: f,
+      restSpeed: O
+    }));
+  };
+  return g(0), {
+    calculatedDuration: null,
+    next: (e) => {
+      let o = !1;
+      return !c && r === void 0 && (o = !0, y(e), g(e)), r !== void 0 && e >= r ? c.next(e - r) : (!o && y(e), n);
     }
-    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 {
-  rt as JSAnimation
+  $ as inertia
 };
 //# sourceMappingURL=visualization.es305.js.map

package/dist/visualization.es305.js.map

@@ -1 +1 @@
-{"version":3,"file":"visualization.es305.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":"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","x_google_ignoreList":[0]}
+{"version":3,"file":"visualization.es305.js","sources":["../../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/generators/inertia.mjs"],"sourcesContent":["import { spring } from './spring.mjs';\nimport { getGeneratorVelocity } from './utils/velocity.mjs';\n\nfunction inertia({ keyframes, velocity = 0.0, power = 0.8, timeConstant = 325, bounceDamping = 10, bounceStiffness = 500, modifyTarget, min, max, restDelta = 0.5, restSpeed, }) {\n    const origin = keyframes[0];\n    const state = {\n        done: false,\n        value: origin,\n    };\n    const isOutOfBounds = (v) => (min !== undefined && v < min) || (max !== undefined && v > max);\n    const nearestBoundary = (v) => {\n        if (min === undefined)\n            return max;\n        if (max === undefined)\n            return min;\n        return Math.abs(min - v) < Math.abs(max - v) ? min : max;\n    };\n    let amplitude = power * velocity;\n    const ideal = origin + amplitude;\n    const target = modifyTarget === undefined ? ideal : modifyTarget(ideal);\n    /**\n     * If the target has changed we need to re-calculate the amplitude, otherwise\n     * the animation will start from the wrong position.\n     */\n    if (target !== ideal)\n        amplitude = target - origin;\n    const calcDelta = (t) => -amplitude * Math.exp(-t / timeConstant);\n    const calcLatest = (t) => target + calcDelta(t);\n    const applyFriction = (t) => {\n        const delta = calcDelta(t);\n        const latest = calcLatest(t);\n        state.done = Math.abs(delta) <= restDelta;\n        state.value = state.done ? target : latest;\n    };\n    /**\n     * Ideally this would resolve for t in a stateless way, we could\n     * do that by always precalculating the animation but as we know\n     * this will be done anyway we can assume that spring will\n     * be discovered during that.\n     */\n    let timeReachedBoundary;\n    let spring$1;\n    const checkCatchBoundary = (t) => {\n        if (!isOutOfBounds(state.value))\n            return;\n        timeReachedBoundary = t;\n        spring$1 = spring({\n            keyframes: [state.value, nearestBoundary(state.value)],\n            velocity: getGeneratorVelocity(calcLatest, t, state.value), // TODO: This should be passing * 1000\n            damping: bounceDamping,\n            stiffness: bounceStiffness,\n            restDelta,\n            restSpeed,\n        });\n    };\n    checkCatchBoundary(0);\n    return {\n        calculatedDuration: null,\n        next: (t) => {\n            /**\n             * We need to resolve the friction to figure out if we need a\n             * spring but we don't want to do this twice per frame. So here\n             * we flag if we updated for this frame and later if we did\n             * we can skip doing it again.\n             */\n            let hasUpdatedFrame = false;\n            if (!spring$1 && timeReachedBoundary === undefined) {\n                hasUpdatedFrame = true;\n                applyFriction(t);\n                checkCatchBoundary(t);\n            }\n            /**\n             * If we have a spring and the provided t is beyond the moment the friction\n             * animation crossed the min/max boundary, use the spring.\n             */\n            if (timeReachedBoundary !== undefined && t >= timeReachedBoundary) {\n                return spring$1.next(t - timeReachedBoundary);\n            }\n            else {\n                !hasUpdatedFrame && applyFriction(t);\n                return state;\n            }\n        },\n    };\n}\n\nexport { inertia };\n//# sourceMappingURL=inertia.mjs.map\n"],"names":["inertia","keyframes","velocity","power","timeConstant","bounceDamping","bounceStiffness","modifyTarget","min","max","restDelta","restSpeed","origin","state","isOutOfBounds","v","nearestBoundary","amplitude","ideal","target","calcDelta","t","calcLatest","applyFriction","delta","latest","timeReachedBoundary","spring$1","checkCatchBoundary","spring","getGeneratorVelocity","hasUpdatedFrame"],"mappings":";;AAGA,SAASA,EAAQ,EAAE,WAAAC,GAAW,UAAAC,IAAW,GAAK,OAAAC,IAAQ,KAAK,cAAAC,IAAe,KAAK,eAAAC,IAAgB,IAAI,iBAAAC,IAAkB,KAAK,cAAAC,GAAc,KAAAC,GAAK,KAAAC,GAAK,WAAAC,IAAY,KAAK,WAAAC,KAAc;AAC7K,QAAMC,IAASX,EAAU,CAAC,GACpBY,IAAQ;AAAA,IACV,MAAM;AAAA,IACN,OAAOD;AAAA,EACf,GACUE,IAAgB,CAACC,MAAOP,MAAQ,UAAaO,IAAIP,KAASC,MAAQ,UAAaM,IAAIN,GACnFO,IAAkB,CAACD,MACjBP,MAAQ,SACDC,IACPA,MAAQ,UAEL,KAAK,IAAID,IAAMO,CAAC,IAAI,KAAK,IAAIN,IAAMM,CAAC,IADhCP,IAC0CC;AAEzD,MAAIQ,IAAYd,IAAQD;AACxB,QAAMgB,IAAQN,IAASK,GACjBE,IAASZ,MAAiB,SAAYW,IAAQX,EAAaW,CAAK;AAKtE,EAAIC,MAAWD,MACXD,IAAYE,IAASP;AACzB,QAAMQ,IAAY,CAACC,MAAM,CAACJ,IAAY,KAAK,IAAI,CAACI,IAAIjB,CAAY,GAC1DkB,IAAa,CAACD,MAAMF,IAASC,EAAUC,CAAC,GACxCE,IAAgB,CAACF,MAAM;AACzB,UAAMG,IAAQJ,EAAUC,CAAC,GACnBI,IAASH,EAAWD,CAAC;AAC3B,IAAAR,EAAM,OAAO,KAAK,IAAIW,CAAK,KAAKd,GAChCG,EAAM,QAAQA,EAAM,OAAOM,IAASM;AAAA,EACxC;AAOA,MAAIC,GACAC;AACJ,QAAMC,IAAqB,CAACP,MAAM;AAC9B,IAAKP,EAAcD,EAAM,KAAK,MAE9Ba,IAAsBL,GACtBM,IAAWE,EAAO;AAAA,MACd,WAAW,CAAChB,EAAM,OAAOG,EAAgBH,EAAM,KAAK,CAAC;AAAA,MACrD,UAAUiB,EAAqBR,GAAYD,GAAGR,EAAM,KAAK;AAAA;AAAA,MACzD,SAASR;AAAA,MACT,WAAWC;AAAA,MACX,WAAAI;AAAA,MACA,WAAAC;AAAA,IACZ,CAAS;AAAA,EACL;AACA,SAAAiB,EAAmB,CAAC,GACb;AAAA,IACH,oBAAoB;AAAA,IACpB,MAAM,CAACP,MAAM;AAOT,UAAIU,IAAkB;AAUtB,aATI,CAACJ,KAAYD,MAAwB,WACrCK,IAAkB,IAClBR,EAAcF,CAAC,GACfO,EAAmBP,CAAC,IAMpBK,MAAwB,UAAaL,KAAKK,IACnCC,EAAS,KAAKN,IAAIK,CAAmB,KAG5C,CAACK,KAAmBR,EAAcF,CAAC,GAC5BR;AAAA,IAEf;AAAA,EACR;AACA;","x_google_ignoreList":[0]}

package/dist/visualization.es306.js

@@ -1,9 +1,31 @@
-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;
+import { interpolate as c } from "./visualization.es341.js";
+import { defaultOffset as p } from "./visualization.es342.js";
+import { convertOffsetToTimes as u } from "./visualization.es343.js";
+import { isEasingArray as l } from "./visualization.es344.js";
+import { easingDefinitionToFunction as m } from "./visualization.es345.js";
+import { easeInOut as g } from "./visualization.es98.js";
+function T(n, t) {
+  return n.map(() => t || g).splice(0, n.length - 1);
+}
+function y({ duration: n = 300, keyframes: t, times: o, ease: r = "easeInOut" }) {
+  const e = l(r) ? r.map(m) : m(r), i = {
+    done: !1,
+    value: t[0]
+  }, s = u(
+    // Only use the provided offsets if they're the correct length
+    // TODO Maybe we should warn here if there's a length mismatch
+    o && o.length === t.length ? o : p(t),
+    n
+  ), a = c(s, t, {
+    ease: Array.isArray(e) ? e : T(t, e)
+  });
+  return {
+    calculatedDuration: n,
+    next: (f) => (i.value = a(f), i.done = f >= n, i)
+  };
 }
 export {
-  c as getFinalKeyframe
+  T as defaultEasing,
+  y as keyframes
 };
 //# sourceMappingURL=visualization.es306.js.map

package/dist/visualization.es306.js.map

@@ -1 +1 @@
-{"version":3,"file":"visualization.es306.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]}
+{"version":3,"file":"visualization.es306.js","sources":["../../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/generators/keyframes.mjs"],"sourcesContent":["import { easeInOut, isEasingArray, easingDefinitionToFunction } from 'motion-utils';\nimport { interpolate } from '../../utils/interpolate.mjs';\nimport { defaultOffset } from '../keyframes/offsets/default.mjs';\nimport { convertOffsetToTimes } from '../keyframes/offsets/time.mjs';\n\nfunction defaultEasing(values, easing) {\n    return values.map(() => easing || easeInOut).splice(0, values.length - 1);\n}\nfunction keyframes({ duration = 300, keyframes: keyframeValues, times, ease = \"easeInOut\", }) {\n    /**\n     * Easing functions can be externally defined as strings. Here we convert them\n     * into actual functions.\n     */\n    const easingFunctions = isEasingArray(ease)\n        ? ease.map(easingDefinitionToFunction)\n        : easingDefinitionToFunction(ease);\n    /**\n     * This is the Iterator-spec return value. We ensure it's mutable rather than using a generator\n     * to reduce GC during animation.\n     */\n    const state = {\n        done: false,\n        value: keyframeValues[0],\n    };\n    /**\n     * Create a times array based on the provided 0-1 offsets\n     */\n    const absoluteTimes = convertOffsetToTimes(\n    // Only use the provided offsets if they're the correct length\n    // TODO Maybe we should warn here if there's a length mismatch\n    times && times.length === keyframeValues.length\n        ? times\n        : defaultOffset(keyframeValues), duration);\n    const mapTimeToKeyframe = interpolate(absoluteTimes, keyframeValues, {\n        ease: Array.isArray(easingFunctions)\n            ? easingFunctions\n            : defaultEasing(keyframeValues, easingFunctions),\n    });\n    return {\n        calculatedDuration: duration,\n        next: (t) => {\n            state.value = mapTimeToKeyframe(t);\n            state.done = t >= duration;\n            return state;\n        },\n    };\n}\n\nexport { defaultEasing, keyframes };\n//# sourceMappingURL=keyframes.mjs.map\n"],"names":["defaultEasing","values","easing","easeInOut","keyframes","duration","keyframeValues","times","ease","easingFunctions","isEasingArray","easingDefinitionToFunction","state","absoluteTimes","convertOffsetToTimes","defaultOffset","mapTimeToKeyframe","interpolate","t"],"mappings":";;;;;;AAKA,SAASA,EAAcC,GAAQC,GAAQ;AACnC,SAAOD,EAAO,IAAI,MAAMC,KAAUC,CAAS,EAAE,OAAO,GAAGF,EAAO,SAAS,CAAC;AAC5E;AACA,SAASG,EAAU,EAAE,UAAAC,IAAW,KAAK,WAAWC,GAAgB,OAAAC,GAAO,MAAAC,IAAO,eAAgB;AAK1F,QAAMC,IAAkBC,EAAcF,CAAI,IACpCA,EAAK,IAAIG,CAA0B,IACnCA,EAA2BH,CAAI,GAK/BI,IAAQ;AAAA,IACV,MAAM;AAAA,IACN,OAAON,EAAe,CAAC;AAAA,EAC/B,GAIUO,IAAgBC;AAAA;AAAA;AAAA,IAGtBP,KAASA,EAAM,WAAWD,EAAe,SACnCC,IACAQ,EAAcT,CAAc;AAAA,IAAGD;AAAA,EAAQ,GACvCW,IAAoBC,EAAYJ,GAAeP,GAAgB;AAAA,IACjE,MAAM,MAAM,QAAQG,CAAe,IAC7BA,IACAT,EAAcM,GAAgBG,CAAe;AAAA,EAC3D,CAAK;AACD,SAAO;AAAA,IACH,oBAAoBJ;AAAA,IACpB,MAAM,CAACa,OACHN,EAAM,QAAQI,EAAkBE,CAAC,GACjCN,EAAM,OAAOM,KAAKb,GACXO;AAAA,EAEnB;AACA;","x_google_ignoreList":[0]}

package/dist/visualization.es307.js

@@ -1,75 +1,14 @@
-import { fillWildcards as y } from "./visualization.es366.js";
-import { removeNonTranslationalTransform as p } from "./visualization.es365.js";
-import { frame as c } from "./visualization.es342.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();
-  }
+const a = 2e4;
+function o(n) {
+  let t = 0;
+  const r = 50;
+  let e = n.next(t);
+  for (; !e.done && t < 2e4; )
+    t += r, e = n.next(t);
+  return t >= 2e4 ? 1 / 0 : t;
 }
 export {
-  g as KeyframeResolver,
-  S as flushKeyframeResolvers
+  o as calcGeneratorDuration,
+  a as maxGeneratorDuration
 };
 //# sourceMappingURL=visualization.es307.js.map

package/dist/visualization.es307.js.map

@@ -1 +1 @@
-{"version":3,"file":"visualization.es307.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]}
+{"version":3,"file":"visualization.es307.js","sources":["../../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/generators/utils/calc-duration.mjs"],"sourcesContent":["/**\n * Implement a practical max duration for keyframe generation\n * to prevent infinite loops\n */\nconst maxGeneratorDuration = 20000;\nfunction calcGeneratorDuration(generator) {\n    let duration = 0;\n    const timeStep = 50;\n    let state = generator.next(duration);\n    while (!state.done && duration < maxGeneratorDuration) {\n        duration += timeStep;\n        state = generator.next(duration);\n    }\n    return duration >= maxGeneratorDuration ? Infinity : duration;\n}\n\nexport { calcGeneratorDuration, maxGeneratorDuration };\n//# sourceMappingURL=calc-duration.mjs.map\n"],"names":["maxGeneratorDuration","calcGeneratorDuration","generator","duration","timeStep","state"],"mappings":"AAIK,MAACA,IAAuB;AAC7B,SAASC,EAAsBC,GAAW;AACtC,MAAIC,IAAW;AACf,QAAMC,IAAW;AACjB,MAAIC,IAAQH,EAAU,KAAKC,CAAQ;AACnC,SAAO,CAACE,EAAM,QAAQF,IAAW;AAC7B,IAAAA,KAAYC,GACZC,IAAQH,EAAU,KAAKC,CAAQ;AAEnC,SAAOA,KAAY,MAAuB,QAAWA;AACzD;","x_google_ignoreList":[0]}