@weng-lab/visualization 2.4.2 → 2.4.3

package/dist/visualization.es304.js

@@ -1,30 +1,11 @@
-import { extractEventInfo as m } from "./visualization.es199.js";
-import { Feature as u } from "./visualization.es299.js";
-import { press as c } from "./visualization.es393.js";
-import { frame as f } from "./visualization.es349.js";
-function s(t, e, n) {
-  const { props: r } = t;
-  if (t.current instanceof HTMLButtonElement && t.current.disabled)
-    return;
-  t.animationState && r.whileTap && t.animationState.setActive("whileTap", n === "Start");
-  const o = "onTap" + (n === "End" ? "" : n), a = r[o];
-  a && f.postRender(() => a(e, m(e)));
-}
-class g extends u {
-  mount() {
-    const { current: e } = this.node;
-    if (!e)
-      return;
-    const { globalTapTarget: n, propagate: r } = this.node.props;
-    this.unmount = c(e, (o, a) => (s(this.node, a, "Start"), (i, { success: p }) => s(this.node, i, p ? "End" : "Cancel")), {
-      useGlobalTarget: n,
-      stopPropagation: r?.tap === !1
-    });
+class s {
+  constructor(t) {
+    this.isMounted = !1, this.node = t;
   }
-  unmount() {
+  update() {
   }
 }
 export {
-  g as PressGesture
+  s as Feature
 };
 //# sourceMappingURL=visualization.es304.js.map

package/dist/visualization.es304.js.map

@@ -1 +1 @@
-{"version":3,"file":"visualization.es304.js","sources":["../../../node_modules/.pnpm/framer-motion@12.38.0_@emotion+is-prop-valid@1.4.0_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/gestures/press.mjs"],"sourcesContent":["import { Feature, press, frame } from 'motion-dom';\nimport { extractEventInfo } from '../events/event-info.mjs';\n\nfunction handlePressEvent(node, event, lifecycle) {\n    const { props } = node;\n    if (node.current instanceof HTMLButtonElement && node.current.disabled) {\n        return;\n    }\n    if (node.animationState && props.whileTap) {\n        node.animationState.setActive(\"whileTap\", lifecycle === \"Start\");\n    }\n    const eventName = (\"onTap\" + (lifecycle === \"End\" ? \"\" : lifecycle));\n    const callback = props[eventName];\n    if (callback) {\n        frame.postRender(() => callback(event, extractEventInfo(event)));\n    }\n}\nclass PressGesture extends Feature {\n    mount() {\n        const { current } = this.node;\n        if (!current)\n            return;\n        const { globalTapTarget, propagate } = this.node.props;\n        this.unmount = press(current, (_element, startEvent) => {\n            handlePressEvent(this.node, startEvent, \"Start\");\n            return (endEvent, { success }) => handlePressEvent(this.node, endEvent, success ? \"End\" : \"Cancel\");\n        }, {\n            useGlobalTarget: globalTapTarget,\n            stopPropagation: propagate?.tap === false,\n        });\n    }\n    unmount() { }\n}\n\nexport { PressGesture };\n//# sourceMappingURL=press.mjs.map\n"],"names":["handlePressEvent","node","event","lifecycle","props","eventName","callback","frame","extractEventInfo","PressGesture","Feature","current","globalTapTarget","propagate","press","_element","startEvent","endEvent","success"],"mappings":";;;;AAGA,SAASA,EAAiBC,GAAMC,GAAOC,GAAW;AAC9C,QAAM,EAAE,OAAAC,EAAK,IAAKH;AAClB,MAAIA,EAAK,mBAAmB,qBAAqBA,EAAK,QAAQ;AAC1D;AAEJ,EAAIA,EAAK,kBAAkBG,EAAM,YAC7BH,EAAK,eAAe,UAAU,YAAYE,MAAc,OAAO;AAEnE,QAAME,IAAa,WAAWF,MAAc,QAAQ,KAAKA,IACnDG,IAAWF,EAAMC,CAAS;AAChC,EAAIC,KACAC,EAAM,WAAW,MAAMD,EAASJ,GAAOM,EAAiBN,CAAK,CAAC,CAAC;AAEvE;AACA,MAAMO,UAAqBC,EAAQ;AAAA,EAC/B,QAAQ;AACJ,UAAM,EAAE,SAAAC,MAAY,KAAK;AACzB,QAAI,CAACA;AACD;AACJ,UAAM,EAAE,iBAAAC,GAAiB,WAAAC,EAAS,IAAK,KAAK,KAAK;AACjD,SAAK,UAAUC,EAAMH,GAAS,CAACI,GAAUC,OACrChB,EAAiB,KAAK,MAAMgB,GAAY,OAAO,GACxC,CAACC,GAAU,EAAE,SAAAC,EAAO,MAAOlB,EAAiB,KAAK,MAAMiB,GAAUC,IAAU,QAAQ,QAAQ,IACnG;AAAA,MACC,iBAAiBN;AAAA,MACjB,iBAAiBC,GAAW,QAAQ;AAAA,IAChD,CAAS;AAAA,EACL;AAAA,EACA,UAAU;AAAA,EAAE;AAChB;","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/render/Feature.mjs"],"sourcesContent":["/**\n * Feature base class for extending VisualElement functionality.\n * Features are plugins that can be mounted/unmounted to add behavior\n * like gestures, animations, or layout tracking.\n */\nclass Feature {\n    constructor(node) {\n        this.isMounted = false;\n        this.node = node;\n    }\n    update() { }\n}\n\nexport { Feature };\n//# sourceMappingURL=Feature.mjs.map\n"],"names":["Feature","node"],"mappings":"AAKA,MAAMA,EAAQ;AAAA,EACV,YAAYC,GAAM;AACd,SAAK,YAAY,IACjB,KAAK,OAAOA;AAAA,EAChB;AAAA,EACA,SAAS;AAAA,EAAE;AACf;","x_google_ignoreList":[0]}

package/dist/visualization.es305.js

@@ -1,46 +1,144 @@
-import { observeIntersection as f } from "./visualization.es550.js";
-import { Feature as m } from "./visualization.es299.js";
-const w = {
-  some: 0,
-  all: 1
-};
-class b extends m {
-  constructor() {
-    super(...arguments), this.hasEnteredView = !1, this.isInView = !1;
-  }
-  startObserver() {
-    this.stopObserver?.();
-    const { viewport: s = {} } = this.node.getProps(), { root: e, margin: r, amount: n = "some", once: h } = s, p = {
-      root: e ? e.current : void 0,
-      rootMargin: r,
-      threshold: typeof n == "number" ? n : w[n]
-    }, c = (i) => {
-      const { isIntersecting: t } = i;
-      if (this.isInView === t || (this.isInView = t, h && !t && this.hasEnteredView))
-        return;
-      t && (this.hasEnteredView = !0), this.node.animationState && this.node.animationState.setActive("whileInView", t);
-      const { onViewportEnter: d, onViewportLeave: u } = this.node.getProps(), a = t ? d : u;
-      a && a(i);
-    };
-    this.stopObserver = f(this.node.current, p, c);
-  }
-  mount() {
-    this.startObserver();
+import { animateVisualElement as N } from "./visualization.es347.js";
+import { calcChildStagger as Q } from "./visualization.es336.js";
+import { getVariantContext as U } from "./visualization.es455.js";
+import { isAnimationControls as W } from "./visualization.es195.js";
+import { isKeyframesTarget as k } from "./visualization.es398.js";
+import { isVariantLabel as X } from "./visualization.es456.js";
+import { resolveVariant as T } from "./visualization.es306.js";
+import { shallowCompare as H } from "./visualization.es457.js";
+import { variantPriorityOrder as L } from "./visualization.es458.js";
+const Y = [...L].reverse(), Z = L.length;
+function _(e) {
+  return (f) => Promise.all(f.map(({ animation: c, options: p }) => N(e, c, p)));
+}
+function fe(e) {
+  let f = _(e), c = B(), p = !0, V = !1;
+  const z = (s) => (n, y) => {
+    const l = T(e, y, s === "exit" ? e.presenceContext?.custom : void 0);
+    if (l) {
+      const { transition: m, transitionEnd: d, ...C } = l;
+      n = { ...n, ...C, ...d };
+    }
+    return n;
+  };
+  function j(s) {
+    f = s(e);
   }
-  update() {
-    if (typeof IntersectionObserver > "u")
-      return;
-    const { props: s, prevProps: e } = this.node;
-    ["amount", "margin", "root"].some(l(s, e)) && this.startObserver();
+  function K(s) {
+    const { props: n } = e, y = U(e.parent) || {}, l = [], m = /* @__PURE__ */ new Set();
+    let d = {}, C = 1 / 0;
+    for (let u = 0; u < Z; u++) {
+      const t = Y[u], i = c[t], o = n[t] !== void 0 ? n[t] : y[t], S = X(o), w = t === s ? i.isActive : null;
+      w === !1 && (C = u);
+      let P = o === y[t] && o !== n[t] && S;
+      if (P && (p || V) && e.manuallyAnimateOnMount && (P = !1), i.protectedKeys = { ...d }, // If it isn't active and hasn't *just* been set as inactive
+      !i.isActive && w === null || // If we didn't and don't have any defined prop for this animation type
+      !o && !i.prevProp || // Or if the prop doesn't define an animation
+      W(o) || typeof o == "boolean")
+        continue;
+      if (t === "exit" && i.isActive && w !== !0) {
+        i.prevResolvedValues && (d = {
+          ...d,
+          ...i.prevResolvedValues
+        });
+        continue;
+      }
+      const I = $(i.prevProp, o);
+      let R = I || // If we're making this variant active, we want to always make it active
+      t === s && i.isActive && !P && S || // If we removed a higher-priority variant (i is in reverse order)
+      u > C && S, x = !1;
+      const O = Array.isArray(o) ? o : [o];
+      let v = O.reduce(z(t), {});
+      w === !1 && (v = {});
+      const { prevResolvedValues: D = {} } = i, G = {
+        ...D,
+        ...v
+      }, F = (r) => {
+        R = !0, m.has(r) && (x = !0, m.delete(r)), i.needsAnimating[r] = !0;
+        const a = e.getValue(r);
+        a && (a.liveStyle = !1);
+      };
+      for (const r in G) {
+        const a = v[r], A = D[r];
+        if (d.hasOwnProperty(r))
+          continue;
+        let g = !1;
+        k(a) && k(A) ? g = !H(a, A) : g = a !== A, g ? a != null ? F(r) : m.add(r) : a !== void 0 && m.has(r) ? F(r) : i.protectedKeys[r] = !0;
+      }
+      i.prevProp = o, i.prevResolvedValues = v, i.isActive && (d = { ...d, ...v }), (p || V) && e.blockInitialAnimation && (R = !1);
+      const M = P && I;
+      R && (!M || x) && l.push(...O.map((r) => {
+        const a = { type: t };
+        if (typeof r == "string" && (p || V) && !M && e.manuallyAnimateOnMount && e.parent) {
+          const { parent: A } = e, g = T(A, r);
+          if (A.enteringChildren && g) {
+            const { delayChildren: J } = g.transition || {};
+            a.delay = Q(A.enteringChildren, e, J);
+          }
+        }
+        return {
+          animation: r,
+          options: a
+        };
+      }));
+    }
+    if (m.size) {
+      const u = {};
+      if (typeof n.initial != "boolean") {
+        const t = T(e, Array.isArray(n.initial) ? n.initial[0] : n.initial);
+        t && t.transition && (u.transition = t.transition);
+      }
+      m.forEach((t) => {
+        const i = e.getBaseTarget(t), o = e.getValue(t);
+        o && (o.liveStyle = !0), u[t] = i ?? null;
+      }), l.push({ animation: u });
+    }
+    let b = !!l.length;
+    return p && (n.initial === !1 || n.initial === n.animate) && !e.manuallyAnimateOnMount && (b = !1), p = !1, V = !1, b ? f(l) : Promise.resolve();
   }
-  unmount() {
-    this.stopObserver?.(), this.hasEnteredView = !1, this.isInView = !1;
+  function q(s, n) {
+    if (c[s].isActive === n)
+      return Promise.resolve();
+    e.variantChildren?.forEach((l) => l.animationState?.setActive(s, n)), c[s].isActive = n;
+    const y = K(s);
+    for (const l in c)
+      c[l].protectedKeys = {};
+    return y;
   }
+  return {
+    animateChanges: K,
+    setActive: q,
+    setAnimateFunction: j,
+    getState: () => c,
+    reset: () => {
+      c = B(), V = !0;
+    }
+  };
+}
+function $(e, f) {
+  return typeof f == "string" ? f !== e : Array.isArray(f) ? !H(f, e) : !1;
+}
+function h(e = !1) {
+  return {
+    isActive: e,
+    protectedKeys: {},
+    needsAnimating: {},
+    prevResolvedValues: {}
+  };
 }
-function l({ viewport: o = {} }, { viewport: s = {} } = {}) {
-  return (e) => o[e] !== s[e];
+function B() {
+  return {
+    animate: h(!0),
+    whileInView: h(),
+    whileHover: h(),
+    whileTap: h(),
+    whileDrag: h(),
+    whileFocus: h(),
+    exit: h()
+  };
 }
 export {
-  b as InViewFeature
+  $ as checkVariantsDidChange,
+  fe as createAnimationState
 };
 //# sourceMappingURL=visualization.es305.js.map

package/dist/visualization.es305.js.map

@@ -1 +1 @@
-{"version":3,"file":"visualization.es305.js","sources":["../../../node_modules/.pnpm/framer-motion@12.38.0_@emotion+is-prop-valid@1.4.0_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/motion/features/viewport/index.mjs"],"sourcesContent":["import { Feature } from 'motion-dom';\nimport { observeIntersection } from './observers.mjs';\n\nconst thresholdNames = {\n    some: 0,\n    all: 1,\n};\nclass InViewFeature extends Feature {\n    constructor() {\n        super(...arguments);\n        this.hasEnteredView = false;\n        this.isInView = false;\n    }\n    startObserver() {\n        this.stopObserver?.();\n        const { viewport = {} } = this.node.getProps();\n        const { root, margin: rootMargin, amount = \"some\", once } = viewport;\n        const options = {\n            root: root ? root.current : undefined,\n            rootMargin,\n            threshold: typeof amount === \"number\" ? amount : thresholdNames[amount],\n        };\n        const onIntersectionUpdate = (entry) => {\n            const { isIntersecting } = entry;\n            /**\n             * If there's been no change in the viewport state, early return.\n             */\n            if (this.isInView === isIntersecting)\n                return;\n            this.isInView = isIntersecting;\n            /**\n             * Handle hasEnteredView. If this is only meant to run once, and\n             * element isn't visible, early return. Otherwise set hasEnteredView to true.\n             */\n            if (once && !isIntersecting && this.hasEnteredView) {\n                return;\n            }\n            else if (isIntersecting) {\n                this.hasEnteredView = true;\n            }\n            if (this.node.animationState) {\n                this.node.animationState.setActive(\"whileInView\", isIntersecting);\n            }\n            /**\n             * Use the latest committed props rather than the ones in scope\n             * when this observer is created\n             */\n            const { onViewportEnter, onViewportLeave } = this.node.getProps();\n            const callback = isIntersecting ? onViewportEnter : onViewportLeave;\n            callback && callback(entry);\n        };\n        this.stopObserver = observeIntersection(this.node.current, options, onIntersectionUpdate);\n    }\n    mount() {\n        this.startObserver();\n    }\n    update() {\n        if (typeof IntersectionObserver === \"undefined\")\n            return;\n        const { props, prevProps } = this.node;\n        const hasOptionsChanged = [\"amount\", \"margin\", \"root\"].some(hasViewportOptionChanged(props, prevProps));\n        if (hasOptionsChanged) {\n            this.startObserver();\n        }\n    }\n    unmount() {\n        this.stopObserver?.();\n        this.hasEnteredView = false;\n        this.isInView = false;\n    }\n}\nfunction hasViewportOptionChanged({ viewport = {} }, { viewport: prevViewport = {} } = {}) {\n    return (name) => viewport[name] !== prevViewport[name];\n}\n\nexport { InViewFeature };\n//# sourceMappingURL=index.mjs.map\n"],"names":["thresholdNames","InViewFeature","Feature","viewport","root","rootMargin","amount","once","options","onIntersectionUpdate","entry","isIntersecting","onViewportEnter","onViewportLeave","callback","observeIntersection","props","prevProps","hasViewportOptionChanged","prevViewport","name"],"mappings":";;AAGA,MAAMA,IAAiB;AAAA,EACnB,MAAM;AAAA,EACN,KAAK;AACT;AACA,MAAMC,UAAsBC,EAAQ;AAAA,EAChC,cAAc;AACV,UAAM,GAAG,SAAS,GAClB,KAAK,iBAAiB,IACtB,KAAK,WAAW;AAAA,EACpB;AAAA,EACA,gBAAgB;AACZ,SAAK,eAAY;AACjB,UAAM,EAAE,UAAAC,IAAW,CAAA,EAAE,IAAK,KAAK,KAAK,SAAQ,GACtC,EAAE,MAAAC,GAAM,QAAQC,GAAY,QAAAC,IAAS,QAAQ,MAAAC,EAAI,IAAKJ,GACtDK,IAAU;AAAA,MACZ,MAAMJ,IAAOA,EAAK,UAAU;AAAA,MAC5B,YAAAC;AAAA,MACA,WAAW,OAAOC,KAAW,WAAWA,IAASN,EAAeM,CAAM;AAAA,IAClF,GACcG,IAAuB,CAACC,MAAU;AACpC,YAAM,EAAE,gBAAAC,EAAc,IAAKD;AAW3B,UAPI,KAAK,aAAaC,MAEtB,KAAK,WAAWA,GAKZJ,KAAQ,CAACI,KAAkB,KAAK;AAChC;AAEC,MAAIA,MACL,KAAK,iBAAiB,KAEtB,KAAK,KAAK,kBACV,KAAK,KAAK,eAAe,UAAU,eAAeA,CAAc;AAMpE,YAAM,EAAE,iBAAAC,GAAiB,iBAAAC,EAAe,IAAK,KAAK,KAAK,SAAQ,GACzDC,IAAWH,IAAiBC,IAAkBC;AACpD,MAAAC,KAAYA,EAASJ,CAAK;AAAA,IAC9B;AACA,SAAK,eAAeK,EAAoB,KAAK,KAAK,SAASP,GAASC,CAAoB;AAAA,EAC5F;AAAA,EACA,QAAQ;AACJ,SAAK,cAAa;AAAA,EACtB;AAAA,EACA,SAAS;AACL,QAAI,OAAO,uBAAyB;AAChC;AACJ,UAAM,EAAE,OAAAO,GAAO,WAAAC,EAAS,IAAK,KAAK;AAElC,IAD0B,CAAC,UAAU,UAAU,MAAM,EAAE,KAAKC,EAAyBF,GAAOC,CAAS,CAAC,KAElG,KAAK,cAAa;AAAA,EAE1B;AAAA,EACA,UAAU;AACN,SAAK,eAAY,GACjB,KAAK,iBAAiB,IACtB,KAAK,WAAW;AAAA,EACpB;AACJ;AACA,SAASC,EAAyB,EAAE,UAAAf,IAAW,GAAE,GAAI,EAAE,UAAUgB,IAAe,GAAE,IAAK,IAAI;AACvF,SAAO,CAACC,MAASjB,EAASiB,CAAI,MAAMD,EAAaC,CAAI;AACzD;","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/render/utils/animation-state.mjs"],"sourcesContent":["import { animateVisualElement } from '../../animation/interfaces/visual-element.mjs';\nimport { calcChildStagger } from '../../animation/utils/calc-child-stagger.mjs';\nimport { getVariantContext } from './get-variant-context.mjs';\nimport { isAnimationControls } from './is-animation-controls.mjs';\nimport { isKeyframesTarget } from './is-keyframes-target.mjs';\nimport { isVariantLabel } from './is-variant-label.mjs';\nimport { resolveVariant } from './resolve-dynamic-variants.mjs';\nimport { shallowCompare } from './shallow-compare.mjs';\nimport { variantPriorityOrder } from './variant-props.mjs';\n\nconst reversePriorityOrder = [...variantPriorityOrder].reverse();\nconst numAnimationTypes = variantPriorityOrder.length;\nfunction createAnimateFunction(visualElement) {\n    return (animations) => {\n        return Promise.all(animations.map(({ animation, options }) => animateVisualElement(visualElement, animation, options)));\n    };\n}\nfunction createAnimationState(visualElement) {\n    let animate = createAnimateFunction(visualElement);\n    let state = createState();\n    let isInitialRender = true;\n    /**\n     * Track whether the animation state has been reset (e.g. via StrictMode\n     * double-invocation or Suspense unmount/remount). On the first\n     * animateChanges() call after a reset we need to behave like the initial\n     * render for variant-inheritance checks, even though isInitialRender is\n     * already false.\n     */\n    let wasReset = false;\n    /**\n     * This function will be used to reduce the animation definitions for\n     * each active animation type into an object of resolved values for it.\n     */\n    const buildResolvedTypeValues = (type) => (acc, definition) => {\n        const resolved = resolveVariant(visualElement, definition, type === \"exit\"\n            ? visualElement.presenceContext?.custom\n            : undefined);\n        if (resolved) {\n            const { transition, transitionEnd, ...target } = resolved;\n            acc = { ...acc, ...target, ...transitionEnd };\n        }\n        return acc;\n    };\n    /**\n     * This just allows us to inject mocked animation functions\n     * @internal\n     */\n    function setAnimateFunction(makeAnimator) {\n        animate = makeAnimator(visualElement);\n    }\n    /**\n     * When we receive new props, we need to:\n     * 1. Create a list of protected keys for each type. This is a directory of\n     *    value keys that are currently being \"handled\" by types of a higher priority\n     *    so that whenever an animation is played of a given type, these values are\n     *    protected from being animated.\n     * 2. Determine if an animation type needs animating.\n     * 3. Determine if any values have been removed from a type and figure out\n     *    what to animate those to.\n     */\n    function animateChanges(changedActiveType) {\n        const { props } = visualElement;\n        const context = getVariantContext(visualElement.parent) || {};\n        /**\n         * A list of animations that we'll build into as we iterate through the animation\n         * types. This will get executed at the end of the function.\n         */\n        const animations = [];\n        /**\n         * Keep track of which values have been removed. Then, as we hit lower priority\n         * animation types, we can check if they contain removed values and animate to that.\n         */\n        const removedKeys = new Set();\n        /**\n         * A dictionary of all encountered keys. This is an object to let us build into and\n         * copy it without iteration. Each time we hit an animation type we set its protected\n         * keys - the keys its not allowed to animate - to the latest version of this object.\n         */\n        let encounteredKeys = {};\n        /**\n         * If a variant has been removed at a given index, and this component is controlling\n         * variant animations, we want to ensure lower-priority variants are forced to animate.\n         */\n        let removedVariantIndex = Infinity;\n        /**\n         * Iterate through all animation types in reverse priority order. For each, we want to\n         * detect which values it's handling and whether or not they've changed (and therefore\n         * need to be animated). If any values have been removed, we want to detect those in\n         * lower priority props and flag for animation.\n         */\n        for (let i = 0; i < numAnimationTypes; i++) {\n            const type = reversePriorityOrder[i];\n            const typeState = state[type];\n            const prop = props[type] !== undefined\n                ? props[type]\n                : context[type];\n            const propIsVariant = isVariantLabel(prop);\n            /**\n             * If this type has *just* changed isActive status, set activeDelta\n             * to that status. Otherwise set to null.\n             */\n            const activeDelta = type === changedActiveType ? typeState.isActive : null;\n            if (activeDelta === false)\n                removedVariantIndex = i;\n            /**\n             * If this prop is an inherited variant, rather than been set directly on the\n             * component itself, we want to make sure we allow the parent to trigger animations.\n             *\n             * TODO: Can probably change this to a !isControllingVariants check\n             */\n            let isInherited = prop === context[type] &&\n                prop !== props[type] &&\n                propIsVariant;\n            if (isInherited &&\n                (isInitialRender || wasReset) &&\n                visualElement.manuallyAnimateOnMount) {\n                isInherited = false;\n            }\n            /**\n             * Set all encountered keys so far as the protected keys for this type. This will\n             * be any key that has been animated or otherwise handled by active, higher-priortiy types.\n             */\n            typeState.protectedKeys = { ...encounteredKeys };\n            // Check if we can skip analysing this prop early\n            if (\n            // If it isn't active and hasn't *just* been set as inactive\n            (!typeState.isActive && activeDelta === null) ||\n                // If we didn't and don't have any defined prop for this animation type\n                (!prop && !typeState.prevProp) ||\n                // Or if the prop doesn't define an animation\n                isAnimationControls(prop) ||\n                typeof prop === \"boolean\") {\n                continue;\n            }\n            /**\n             * If exit is already active and wasn't just activated, skip\n             * re-processing to prevent interrupting running exit animations.\n             * Re-resolving exit with a changed custom value can start new\n             * value animations that stop the originals, leaving the exit\n             * animation promise unresolved and the component stuck in the DOM.\n             */\n            if (type === \"exit\" && typeState.isActive && activeDelta !== true) {\n                if (typeState.prevResolvedValues) {\n                    encounteredKeys = {\n                        ...encounteredKeys,\n                        ...typeState.prevResolvedValues,\n                    };\n                }\n                continue;\n            }\n            /**\n             * As we go look through the values defined on this type, if we detect\n             * a changed value or a value that was removed in a higher priority, we set\n             * this to true and add this prop to the animation list.\n             */\n            const variantDidChange = checkVariantsDidChange(typeState.prevProp, prop);\n            let shouldAnimateType = variantDidChange ||\n                // If we're making this variant active, we want to always make it active\n                (type === changedActiveType &&\n                    typeState.isActive &&\n                    !isInherited &&\n                    propIsVariant) ||\n                // If we removed a higher-priority variant (i is in reverse order)\n                (i > removedVariantIndex && propIsVariant);\n            let handledRemovedValues = false;\n            /**\n             * As animations can be set as variant lists, variants or target objects, we\n             * coerce everything to an array if it isn't one already\n             */\n            const definitionList = Array.isArray(prop) ? prop : [prop];\n            /**\n             * Build an object of all the resolved values. We'll use this in the subsequent\n             * animateChanges calls to determine whether a value has changed.\n             */\n            let resolvedValues = definitionList.reduce(buildResolvedTypeValues(type), {});\n            if (activeDelta === false)\n                resolvedValues = {};\n            /**\n             * Now we need to loop through all the keys in the prev prop and this prop,\n             * and decide:\n             * 1. If the value has changed, and needs animating\n             * 2. If it has been removed, and needs adding to the removedKeys set\n             * 3. If it has been removed in a higher priority type and needs animating\n             * 4. If it hasn't been removed in a higher priority but hasn't changed, and\n             *    needs adding to the type's protectedKeys list.\n             */\n            const { prevResolvedValues = {} } = typeState;\n            const allKeys = {\n                ...prevResolvedValues,\n                ...resolvedValues,\n            };\n            const markToAnimate = (key) => {\n                shouldAnimateType = true;\n                if (removedKeys.has(key)) {\n                    handledRemovedValues = true;\n                    removedKeys.delete(key);\n                }\n                typeState.needsAnimating[key] = true;\n                const motionValue = visualElement.getValue(key);\n                if (motionValue)\n                    motionValue.liveStyle = false;\n            };\n            for (const key in allKeys) {\n                const next = resolvedValues[key];\n                const prev = prevResolvedValues[key];\n                // If we've already handled this we can just skip ahead\n                if (encounteredKeys.hasOwnProperty(key))\n                    continue;\n                /**\n                 * If the value has changed, we probably want to animate it.\n                 */\n                let valueHasChanged = false;\n                if (isKeyframesTarget(next) && isKeyframesTarget(prev)) {\n                    valueHasChanged = !shallowCompare(next, prev);\n                }\n                else {\n                    valueHasChanged = next !== prev;\n                }\n                if (valueHasChanged) {\n                    if (next !== undefined && next !== null) {\n                        // If next is defined and doesn't equal prev, it needs animating\n                        markToAnimate(key);\n                    }\n                    else {\n                        // If it's undefined, it's been removed.\n                        removedKeys.add(key);\n                    }\n                }\n                else if (next !== undefined && removedKeys.has(key)) {\n                    /**\n                     * If next hasn't changed and it isn't undefined, we want to check if it's\n                     * been removed by a higher priority\n                     */\n                    markToAnimate(key);\n                }\n                else {\n                    /**\n                     * If it hasn't changed, we add it to the list of protected values\n                     * to ensure it doesn't get animated.\n                     */\n                    typeState.protectedKeys[key] = true;\n                }\n            }\n            /**\n             * Update the typeState so next time animateChanges is called we can compare the\n             * latest prop and resolvedValues to these.\n             */\n            typeState.prevProp = prop;\n            typeState.prevResolvedValues = resolvedValues;\n            if (typeState.isActive) {\n                encounteredKeys = { ...encounteredKeys, ...resolvedValues };\n            }\n            if ((isInitialRender || wasReset) &&\n                visualElement.blockInitialAnimation) {\n                shouldAnimateType = false;\n            }\n            /**\n             * If this is an inherited prop we want to skip this animation\n             * unless the inherited variants haven't changed on this render.\n             */\n            const willAnimateViaParent = isInherited && variantDidChange;\n            const needsAnimating = !willAnimateViaParent || handledRemovedValues;\n            if (shouldAnimateType && needsAnimating) {\n                animations.push(...definitionList.map((animation) => {\n                    const options = { type };\n                    /**\n                     * If we're performing the initial animation, but we're not\n                     * rendering at the same time as the variant-controlling parent,\n                     * we want to use the parent's transition to calculate the stagger.\n                     */\n                    if (typeof animation === \"string\" &&\n                        (isInitialRender || wasReset) &&\n                        !willAnimateViaParent &&\n                        visualElement.manuallyAnimateOnMount &&\n                        visualElement.parent) {\n                        const { parent } = visualElement;\n                        const parentVariant = resolveVariant(parent, animation);\n                        if (parent.enteringChildren && parentVariant) {\n                            const { delayChildren } = parentVariant.transition || {};\n                            options.delay = calcChildStagger(parent.enteringChildren, visualElement, delayChildren);\n                        }\n                    }\n                    return {\n                        animation: animation,\n                        options,\n                    };\n                }));\n            }\n        }\n        /**\n         * If there are some removed value that haven't been dealt with,\n         * we need to create a new animation that falls back either to the value\n         * defined in the style prop, or the last read value.\n         */\n        if (removedKeys.size) {\n            const fallbackAnimation = {};\n            /**\n             * If the initial prop contains a transition we can use that, otherwise\n             * allow the animation function to use the visual element's default.\n             */\n            if (typeof props.initial !== \"boolean\") {\n                const initialTransition = resolveVariant(visualElement, Array.isArray(props.initial)\n                    ? props.initial[0]\n                    : props.initial);\n                if (initialTransition && initialTransition.transition) {\n                    fallbackAnimation.transition = initialTransition.transition;\n                }\n            }\n            removedKeys.forEach((key) => {\n                const fallbackTarget = visualElement.getBaseTarget(key);\n                const motionValue = visualElement.getValue(key);\n                if (motionValue)\n                    motionValue.liveStyle = true;\n                // @ts-expect-error - @mattgperry to figure if we should do something here\n                fallbackAnimation[key] = fallbackTarget ?? null;\n            });\n            animations.push({ animation: fallbackAnimation });\n        }\n        let shouldAnimate = Boolean(animations.length);\n        if (isInitialRender &&\n            (props.initial === false || props.initial === props.animate) &&\n            !visualElement.manuallyAnimateOnMount) {\n            shouldAnimate = false;\n        }\n        isInitialRender = false;\n        wasReset = false;\n        return shouldAnimate ? animate(animations) : Promise.resolve();\n    }\n    /**\n     * Change whether a certain animation type is active.\n     */\n    function setActive(type, isActive) {\n        // If the active state hasn't changed, we can safely do nothing here\n        if (state[type].isActive === isActive)\n            return Promise.resolve();\n        // Propagate active change to children\n        visualElement.variantChildren?.forEach((child) => child.animationState?.setActive(type, isActive));\n        state[type].isActive = isActive;\n        const animations = animateChanges(type);\n        for (const key in state) {\n            state[key].protectedKeys = {};\n        }\n        return animations;\n    }\n    return {\n        animateChanges,\n        setActive,\n        setAnimateFunction,\n        getState: () => state,\n        reset: () => {\n            state = createState();\n            wasReset = true;\n        },\n    };\n}\nfunction checkVariantsDidChange(prev, next) {\n    if (typeof next === \"string\") {\n        return next !== prev;\n    }\n    else if (Array.isArray(next)) {\n        return !shallowCompare(next, prev);\n    }\n    return false;\n}\nfunction createTypeState(isActive = false) {\n    return {\n        isActive,\n        protectedKeys: {},\n        needsAnimating: {},\n        prevResolvedValues: {},\n    };\n}\nfunction createState() {\n    return {\n        animate: createTypeState(true),\n        whileInView: createTypeState(),\n        whileHover: createTypeState(),\n        whileTap: createTypeState(),\n        whileDrag: createTypeState(),\n        whileFocus: createTypeState(),\n        exit: createTypeState(),\n    };\n}\n\nexport { checkVariantsDidChange, createAnimationState };\n//# sourceMappingURL=animation-state.mjs.map\n"],"names":["reversePriorityOrder","variantPriorityOrder","numAnimationTypes","createAnimateFunction","visualElement","animations","animation","options","animateVisualElement","createAnimationState","animate","state","createState","isInitialRender","wasReset","buildResolvedTypeValues","type","acc","definition","resolved","resolveVariant","transition","transitionEnd","target","setAnimateFunction","makeAnimator","animateChanges","changedActiveType","props","context","getVariantContext","removedKeys","encounteredKeys","removedVariantIndex","i","typeState","prop","propIsVariant","isVariantLabel","activeDelta","isInherited","isAnimationControls","variantDidChange","checkVariantsDidChange","shouldAnimateType","handledRemovedValues","definitionList","resolvedValues","prevResolvedValues","allKeys","markToAnimate","key","motionValue","next","prev","valueHasChanged","isKeyframesTarget","shallowCompare","willAnimateViaParent","parent","parentVariant","delayChildren","calcChildStagger","fallbackAnimation","initialTransition","fallbackTarget","shouldAnimate","setActive","isActive","child","createTypeState"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/visualization.es306.js

@@ -1,23 +1,9 @@
-import { VisualElementDragControls as t } from "./visualization.es547.js";
-import { Feature as e } from "./visualization.es299.js";
-import { noop as s } from "./visualization.es321.js";
-class m extends e {
-  constructor(o) {
-    super(o), this.removeGroupControls = s, this.removeListeners = s, this.controls = new t(o);
-  }
-  mount() {
-    const { dragControls: o } = this.node.getProps();
-    o && (this.removeGroupControls = o.subscribe(this.controls)), this.removeListeners = this.controls.addListeners() || s;
-  }
-  update() {
-    const { dragControls: o } = this.node.getProps(), { dragControls: r } = this.node.prevProps || {};
-    o !== r && (this.removeGroupControls(), o && (this.removeGroupControls = o.subscribe(this.controls)));
-  }
-  unmount() {
-    this.removeGroupControls(), this.removeListeners(), this.controls.isDragging || this.controls.endPanSession();
-  }
+import { resolveVariantFromProps as t } from "./visualization.es196.js";
+function s(r, n, o) {
+  const e = r.getProps();
+  return t(e, n, o !== void 0 ? o : e.custom, r);
 }
 export {
-  m as DragGesture
+  s as resolveVariant
 };
 //# sourceMappingURL=visualization.es306.js.map

package/dist/visualization.es306.js.map

@@ -1 +1 @@
-{"version":3,"file":"visualization.es306.js","sources":["../../../node_modules/.pnpm/framer-motion@12.38.0_@emotion+is-prop-valid@1.4.0_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/gestures/drag/index.mjs"],"sourcesContent":["import { Feature } from 'motion-dom';\nimport { noop } from 'motion-utils';\nimport { VisualElementDragControls } from './VisualElementDragControls.mjs';\n\nclass DragGesture extends Feature {\n    constructor(node) {\n        super(node);\n        this.removeGroupControls = noop;\n        this.removeListeners = noop;\n        this.controls = new VisualElementDragControls(node);\n    }\n    mount() {\n        // If we've been provided a DragControls for manual control over the drag gesture,\n        // subscribe this component to it on mount.\n        const { dragControls } = this.node.getProps();\n        if (dragControls) {\n            this.removeGroupControls = dragControls.subscribe(this.controls);\n        }\n        this.removeListeners = this.controls.addListeners() || noop;\n    }\n    update() {\n        const { dragControls } = this.node.getProps();\n        const { dragControls: prevDragControls } = this.node.prevProps || {};\n        if (dragControls !== prevDragControls) {\n            this.removeGroupControls();\n            if (dragControls) {\n                this.removeGroupControls = dragControls.subscribe(this.controls);\n            }\n        }\n    }\n    unmount() {\n        this.removeGroupControls();\n        this.removeListeners();\n        /**\n         * In React 19, during list reorder reconciliation, components may\n         * briefly unmount and remount while the drag is still active. If we're\n         * actively dragging, we should NOT end the pan session - it will\n         * continue tracking pointer events via its window-level listeners.\n         *\n         * The pan session will be properly cleaned up when:\n         * 1. The drag ends naturally (pointerup/pointercancel)\n         * 2. The component is truly removed from the DOM\n         */\n        if (!this.controls.isDragging) {\n            this.controls.endPanSession();\n        }\n    }\n}\n\nexport { DragGesture };\n//# sourceMappingURL=index.mjs.map\n"],"names":["DragGesture","Feature","node","noop","VisualElementDragControls","dragControls","prevDragControls"],"mappings":";;;AAIA,MAAMA,UAAoBC,EAAQ;AAAA,EAC9B,YAAYC,GAAM;AACd,UAAMA,CAAI,GACV,KAAK,sBAAsBC,GAC3B,KAAK,kBAAkBA,GACvB,KAAK,WAAW,IAAIC,EAA0BF,CAAI;AAAA,EACtD;AAAA,EACA,QAAQ;AAGJ,UAAM,EAAE,cAAAG,EAAY,IAAK,KAAK,KAAK,SAAQ;AAC3C,IAAIA,MACA,KAAK,sBAAsBA,EAAa,UAAU,KAAK,QAAQ,IAEnE,KAAK,kBAAkB,KAAK,SAAS,aAAY,KAAMF;AAAA,EAC3D;AAAA,EACA,SAAS;AACL,UAAM,EAAE,cAAAE,EAAY,IAAK,KAAK,KAAK,SAAQ,GACrC,EAAE,cAAcC,EAAgB,IAAK,KAAK,KAAK,aAAa,CAAA;AAClE,IAAID,MAAiBC,MACjB,KAAK,oBAAmB,GACpBD,MACA,KAAK,sBAAsBA,EAAa,UAAU,KAAK,QAAQ;AAAA,EAG3E;AAAA,EACA,UAAU;AACN,SAAK,oBAAmB,GACxB,KAAK,gBAAe,GAWf,KAAK,SAAS,cACf,KAAK,SAAS,cAAa;AAAA,EAEnC;AACJ;","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/render/utils/resolve-dynamic-variants.mjs"],"sourcesContent":["import { resolveVariantFromProps } from './resolve-variants.mjs';\n\nfunction resolveVariant(visualElement, definition, custom) {\n    const props = visualElement.getProps();\n    return resolveVariantFromProps(props, definition, custom !== undefined ? custom : props.custom, visualElement);\n}\n\nexport { resolveVariant };\n//# sourceMappingURL=resolve-dynamic-variants.mjs.map\n"],"names":["resolveVariant","visualElement","definition","custom","props","resolveVariantFromProps"],"mappings":";AAEA,SAASA,EAAeC,GAAeC,GAAYC,GAAQ;AACvD,QAAMC,IAAQH,EAAc,SAAQ;AACpC,SAAOI,EAAwBD,GAAOF,GAAYC,MAAW,SAAYA,IAASC,EAAM,QAAQH,CAAa;AACjH;","x_google_ignoreList":[0]}

package/dist/visualization.es307.js

@@ -1,44 +1,113 @@
-import { addPointerEvent as m } from "./visualization.es198.js";
-import { getContextWindow as P } from "./visualization.es548.js";
-import { PanSession as h } from "./visualization.es549.js";
-import { Feature as p } from "./visualization.es299.js";
-import { noop as u } from "./visualization.es321.js";
-import { frame as r } from "./visualization.es349.js";
-const o = (e) => (n, t) => {
-  e && r.update(() => e(n, t), !1, !0);
-};
-class v extends p {
-  constructor() {
-    super(...arguments), this.removePointerDownListener = u;
-  }
-  onPointerDown(n) {
-    this.session = new h(n, this.createPanHandlers(), {
-      transformPagePoint: this.node.getTransformPagePoint(),
-      contextWindow: P(this.node)
-    });
+import { time as v } from "./visualization.es308.js";
+import { JSAnimation as A } from "./visualization.es309.js";
+import { getFinalKeyframe as y } from "./visualization.es310.js";
+import { KeyframeResolver as g, flushKeyframeResolvers as R } from "./visualization.es311.js";
+import { NativeAnimationExtended as T } from "./visualization.es312.js";
+import { canAnimate as _ } from "./visualization.es313.js";
+import { makeAnimationInstant as w } from "./visualization.es314.js";
+import { WithPromise as K } from "./visualization.es315.js";
+import { supportsBrowserAnimation as D } from "./visualization.es316.js";
+import { MotionGlobalConfig as E } from "./visualization.es317.js";
+import { noop as k } from "./visualization.es318.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();
   }
-  createPanHandlers() {
-    const { onPanSessionStart: n, onPanStart: t, onPan: i, onPanEnd: s } = this.node.getProps();
-    return {
-      onSessionStart: o(n),
-      onStart: o(t),
-      onMove: o(i),
-      onEnd: (a, d) => {
-        delete this.session, s && r.postRender(() => s(a, d));
+  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();
   }
-  mount() {
-    this.removePointerDownListener = m(this.node.current, "pointerdown", (n) => this.onPointerDown(n));
+  pause() {
+    this.animation.pause();
   }
-  update() {
-    this.session && this.session.updateHandlers(this.createPanHandlers());
+  complete() {
+    this.animation.complete();
   }
-  unmount() {
-    this.removePointerDownListener(), this.session && this.session.end();
+  cancel() {
+    this._animation && this.animation.cancel(), this.keyframeResolver?.cancel();
   }
 }
 export {
-  v as PanGesture
+  H as AsyncMotionValueAnimation
 };
 //# sourceMappingURL=visualization.es307.js.map

package/dist/visualization.es307.js.map

@@ -1 +1 @@
-{"version":3,"file":"visualization.es307.js","sources":["../../../node_modules/.pnpm/framer-motion@12.38.0_@emotion+is-prop-valid@1.4.0_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/gestures/pan/index.mjs"],"sourcesContent":["import { Feature, frame } from 'motion-dom';\nimport { noop } from 'motion-utils';\nimport { addPointerEvent } from '../../events/add-pointer-event.mjs';\nimport { getContextWindow } from '../../utils/get-context-window.mjs';\nimport { PanSession } from './PanSession.mjs';\n\nconst asyncHandler = (handler) => (event, info) => {\n    if (handler) {\n        frame.update(() => handler(event, info), false, true);\n    }\n};\nclass PanGesture extends Feature {\n    constructor() {\n        super(...arguments);\n        this.removePointerDownListener = noop;\n    }\n    onPointerDown(pointerDownEvent) {\n        this.session = new PanSession(pointerDownEvent, this.createPanHandlers(), {\n            transformPagePoint: this.node.getTransformPagePoint(),\n            contextWindow: getContextWindow(this.node),\n        });\n    }\n    createPanHandlers() {\n        const { onPanSessionStart, onPanStart, onPan, onPanEnd } = this.node.getProps();\n        return {\n            onSessionStart: asyncHandler(onPanSessionStart),\n            onStart: asyncHandler(onPanStart),\n            onMove: asyncHandler(onPan),\n            onEnd: (event, info) => {\n                delete this.session;\n                if (onPanEnd) {\n                    frame.postRender(() => onPanEnd(event, info));\n                }\n            },\n        };\n    }\n    mount() {\n        this.removePointerDownListener = addPointerEvent(this.node.current, \"pointerdown\", (event) => this.onPointerDown(event));\n    }\n    update() {\n        this.session && this.session.updateHandlers(this.createPanHandlers());\n    }\n    unmount() {\n        this.removePointerDownListener();\n        this.session && this.session.end();\n    }\n}\n\nexport { PanGesture };\n//# sourceMappingURL=index.mjs.map\n"],"names":["asyncHandler","handler","event","info","frame","PanGesture","Feature","noop","pointerDownEvent","PanSession","getContextWindow","onPanSessionStart","onPanStart","onPan","onPanEnd","addPointerEvent"],"mappings":";;;;;;AAMA,MAAMA,IAAe,CAACC,MAAY,CAACC,GAAOC,MAAS;AAC/C,EAAIF,KACAG,EAAM,OAAO,MAAMH,EAAQC,GAAOC,CAAI,GAAG,IAAO,EAAI;AAE5D;AACA,MAAME,UAAmBC,EAAQ;AAAA,EAC7B,cAAc;AACV,UAAM,GAAG,SAAS,GAClB,KAAK,4BAA4BC;AAAA,EACrC;AAAA,EACA,cAAcC,GAAkB;AAC5B,SAAK,UAAU,IAAIC,EAAWD,GAAkB,KAAK,qBAAqB;AAAA,MACtE,oBAAoB,KAAK,KAAK,sBAAqB;AAAA,MACnD,eAAeE,EAAiB,KAAK,IAAI;AAAA,IACrD,CAAS;AAAA,EACL;AAAA,EACA,oBAAoB;AAChB,UAAM,EAAE,mBAAAC,GAAmB,YAAAC,GAAY,OAAAC,GAAO,UAAAC,EAAQ,IAAK,KAAK,KAAK,SAAQ;AAC7E,WAAO;AAAA,MACH,gBAAgBd,EAAaW,CAAiB;AAAA,MAC9C,SAASX,EAAaY,CAAU;AAAA,MAChC,QAAQZ,EAAaa,CAAK;AAAA,MAC1B,OAAO,CAACX,GAAOC,MAAS;AACpB,eAAO,KAAK,SACRW,KACAV,EAAM,WAAW,MAAMU,EAASZ,GAAOC,CAAI,CAAC;AAAA,MAEpD;AAAA,IACZ;AAAA,EACI;AAAA,EACA,QAAQ;AACJ,SAAK,4BAA4BY,EAAgB,KAAK,KAAK,SAAS,eAAe,CAACb,MAAU,KAAK,cAAcA,CAAK,CAAC;AAAA,EAC3H;AAAA,EACA,SAAS;AACL,SAAK,WAAW,KAAK,QAAQ,eAAe,KAAK,mBAAmB;AAAA,EACxE;AAAA,EACA,UAAU;AACN,SAAK,0BAAyB,GAC9B,KAAK,WAAW,KAAK,QAAQ,IAAG;AAAA,EACpC;AACJ;","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/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]}

package/dist/visualization.es308.js

@@ -1,61 +1,16 @@
-import { jsx as m } from "react/jsx-runtime";
-import { useContext as u, Component as l } from "react";
-import { usePresence as c } from "./visualization.es218.js";
-import { LayoutGroupContext as f } from "./visualization.es219.js";
-import { SwitchLayoutGroupContext as d } from "./visualization.es221.js";
-import { frame as h } from "./visualization.es349.js";
-import { microtask as y } from "./visualization.es388.js";
-import { globalProjectionState as g } from "./visualization.es484.js";
-let i = !1;
-class v extends l {
-  /**
-   * This only mounts projection nodes for components that
-   * need measuring, we might want to do it for all components
-   * in order to incorporate transforms
-   */
-  componentDidMount() {
-    const { visualElement: t, layoutGroup: o, switchLayoutGroup: e, layoutId: s } = this.props, { projection: n } = t;
-    n && (o.group && o.group.add(n), e && e.register && s && e.register(n), i && n.root.didUpdate(), n.addEventListener("animationComplete", () => {
-      this.safeToRemove();
-    }), n.setOptions({
-      ...n.options,
-      layoutDependency: this.props.layoutDependency,
-      onExitComplete: () => this.safeToRemove()
-    })), g.hasEverUpdated = !0;
-  }
-  getSnapshotBeforeUpdate(t) {
-    const { layoutDependency: o, visualElement: e, drag: s, isPresent: n } = this.props, { projection: r } = e;
-    return r && (r.isPresent = n, t.layoutDependency !== o && r.setOptions({
-      ...r.options,
-      layoutDependency: o
-    }), i = !0, s || t.layoutDependency !== o || o === void 0 || t.isPresent !== n ? r.willUpdate() : this.safeToRemove(), t.isPresent !== n && (n ? r.promote() : r.relegate() || h.postRender(() => {
-      const p = r.getStack();
-      (!p || !p.members.length) && this.safeToRemove();
-    }))), null;
-  }
-  componentDidUpdate() {
-    const { visualElement: t, layoutAnchor: o } = this.props, { projection: e } = t;
-    e && (e.options.layoutAnchor = o, e.root.didUpdate(), y.postRender(() => {
-      !e.currentAnimation && e.isLead() && this.safeToRemove();
-    }));
-  }
-  componentWillUnmount() {
-    const { visualElement: t, layoutGroup: o, switchLayoutGroup: e } = this.props, { projection: s } = t;
-    i = !0, s && (s.scheduleCheckAfterUnmount(), o && o.group && o.group.remove(s), e && e.deregister && e.deregister(s));
-  }
-  safeToRemove() {
-    const { safeToRemove: t } = this.props;
-    t && t();
-  }
-  render() {
-    return null;
-  }
-}
-function E(a) {
-  const [t, o] = c(), e = u(f);
-  return m(v, { ...a, layoutGroup: e, switchLayoutGroup: u(d), isPresent: t, safeToRemove: o });
+import { frameData as n } from "./visualization.es346.js";
+import { MotionGlobalConfig as i } from "./visualization.es317.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 {
-  E as MeasureLayout
+  r as time
 };
 //# sourceMappingURL=visualization.es308.js.map