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

package/dist/visualization.es287.js

@@ -1,38 +1,113 @@
-import { isCSSVariableName as s } from "./visualization.es322.js";
-import { transformProps as n } from "./visualization.es325.js";
-import { defaultTransformValue as a, readTransformValue as i } from "./visualization.es380.js";
-import { measureViewportBox as u } from "./visualization.es424.js";
-import { DOMVisualElement as p } from "./visualization.es423.js";
-import { buildHTMLStyles as l } from "./visualization.es425.js";
-import { renderHTML as f } from "./visualization.es426.js";
-import { scrapeMotionValuesFromProps as c } from "./visualization.es427.js";
-function d(m) {
-  return window.getComputedStyle(m);
-}
-class x extends p {
-  constructor() {
-    super(...arguments), this.type = "html", this.renderInstance = f;
+import { time as v } from "./visualization.es288.js";
+import { JSAnimation as A } from "./visualization.es289.js";
+import { getFinalKeyframe as y } from "./visualization.es290.js";
+import { KeyframeResolver as g, flushKeyframeResolvers as R } from "./visualization.es291.js";
+import { NativeAnimationExtended as T } from "./visualization.es292.js";
+import { canAnimate as _ } from "./visualization.es293.js";
+import { makeAnimationInstant as w } from "./visualization.es294.js";
+import { WithPromise as K } from "./visualization.es295.js";
+import { supportsBrowserAnimation as D } from "./visualization.es296.js";
+import { MotionGlobalConfig as E } from "./visualization.es297.js";
+import { noop as k } from "./visualization.es298.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();
   }
-  readValueFromInstance(e, r) {
-    if (n.has(r))
-      return this.projection?.isProjecting ? a(r) : i(e, r);
-    {
-      const t = d(e), o = (s(r) ? t.getPropertyValue(r) : t[r]) || 0;
-      return typeof o == "string" ? o.trim() : o;
-    }
+  play() {
+    this.animation.play();
   }
-  measureInstanceViewportBox(e, { transformPagePoint: r }) {
-    return u(e, r);
+  pause() {
+    this.animation.pause();
   }
-  build(e, r, t) {
-    l(e, r, t.transformTemplate);
+  complete() {
+    this.animation.complete();
   }
-  scrapeMotionValuesFromProps(e, r, t) {
-    return c(e, r, t);
+  cancel() {
+    this._animation && this.animation.cancel(), this.keyframeResolver?.cancel();
   }
 }
 export {
-  x as HTMLVisualElement,
-  d as getComputedStyle
+  H as AsyncMotionValueAnimation
 };
 //# sourceMappingURL=visualization.es287.js.map

package/dist/visualization.es287.js.map

@@ -1 +1 @@
-{"version":3,"file":"visualization.es287.js","sources":["../../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/render/html/HTMLVisualElement.mjs"],"sourcesContent":["import { isCSSVariableName } from '../../animation/utils/is-css-variable.mjs';\nimport { transformProps } from '../utils/keys-transform.mjs';\nimport { defaultTransformValue, readTransformValue } from '../dom/parse-transform.mjs';\nimport { measureViewportBox } from '../../projection/utils/measure.mjs';\nimport { DOMVisualElement } from '../dom/DOMVisualElement.mjs';\nimport { buildHTMLStyles } from './utils/build-styles.mjs';\nimport { renderHTML } from './utils/render.mjs';\nimport { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.mjs';\n\nfunction getComputedStyle(element) {\n    return window.getComputedStyle(element);\n}\nclass HTMLVisualElement extends DOMVisualElement {\n    constructor() {\n        super(...arguments);\n        this.type = \"html\";\n        this.renderInstance = renderHTML;\n    }\n    readValueFromInstance(instance, key) {\n        if (transformProps.has(key)) {\n            return this.projection?.isProjecting\n                ? defaultTransformValue(key)\n                : readTransformValue(instance, key);\n        }\n        else {\n            const computedStyle = getComputedStyle(instance);\n            const value = (isCSSVariableName(key)\n                ? computedStyle.getPropertyValue(key)\n                : computedStyle[key]) || 0;\n            return typeof value === \"string\" ? value.trim() : value;\n        }\n    }\n    measureInstanceViewportBox(instance, { transformPagePoint }) {\n        return measureViewportBox(instance, transformPagePoint);\n    }\n    build(renderState, latestValues, props) {\n        buildHTMLStyles(renderState, latestValues, props.transformTemplate);\n    }\n    scrapeMotionValuesFromProps(props, prevProps, visualElement) {\n        return scrapeMotionValuesFromProps(props, prevProps, visualElement);\n    }\n}\n\nexport { HTMLVisualElement, getComputedStyle };\n//# sourceMappingURL=HTMLVisualElement.mjs.map\n"],"names":["getComputedStyle","element","HTMLVisualElement","DOMVisualElement","renderHTML","instance","key","transformProps","defaultTransformValue","readTransformValue","computedStyle","value","isCSSVariableName","transformPagePoint","measureViewportBox","renderState","latestValues","props","buildHTMLStyles","prevProps","visualElement","scrapeMotionValuesFromProps"],"mappings":";;;;;;;;AASA,SAASA,EAAiBC,GAAS;AAC/B,SAAO,OAAO,iBAAiBA,CAAO;AAC1C;AACA,MAAMC,UAA0BC,EAAiB;AAAA,EAC7C,cAAc;AACV,UAAM,GAAG,SAAS,GAClB,KAAK,OAAO,QACZ,KAAK,iBAAiBC;AAAA,EAC1B;AAAA,EACA,sBAAsBC,GAAUC,GAAK;AACjC,QAAIC,EAAe,IAAID,CAAG;AACtB,aAAO,KAAK,YAAY,eAClBE,EAAsBF,CAAG,IACzBG,EAAmBJ,GAAUC,CAAG;AAErC;AACD,YAAMI,IAAgBV,EAAiBK,CAAQ,GACzCM,KAASC,EAAkBN,CAAG,IAC9BI,EAAc,iBAAiBJ,CAAG,IAClCI,EAAcJ,CAAG,MAAM;AAC7B,aAAO,OAAOK,KAAU,WAAWA,EAAM,KAAI,IAAKA;AAAA,IACtD;AAAA,EACJ;AAAA,EACA,2BAA2BN,GAAU,EAAE,oBAAAQ,KAAsB;AACzD,WAAOC,EAAmBT,GAAUQ,CAAkB;AAAA,EAC1D;AAAA,EACA,MAAME,GAAaC,GAAcC,GAAO;AACpC,IAAAC,EAAgBH,GAAaC,GAAcC,EAAM,iBAAiB;AAAA,EACtE;AAAA,EACA,4BAA4BA,GAAOE,GAAWC,GAAe;AACzD,WAAOC,EAA4BJ,GAAOE,GAAWC,CAAa;AAAA,EACtE;AACJ;","x_google_ignoreList":[0]}
+{"version":3,"file":"visualization.es287.js","sources":["../../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/AsyncMotionValueAnimation.mjs"],"sourcesContent":["import { MotionGlobalConfig, noop } from 'motion-utils';\nimport { time } from '../frameloop/sync-time.mjs';\nimport { JSAnimation } from './JSAnimation.mjs';\nimport { getFinalKeyframe } from './keyframes/get-final.mjs';\nimport { KeyframeResolver, flushKeyframeResolvers } from './keyframes/KeyframesResolver.mjs';\nimport { NativeAnimationExtended } from './NativeAnimationExtended.mjs';\nimport { canAnimate } from './utils/can-animate.mjs';\nimport { makeAnimationInstant } from './utils/make-animation-instant.mjs';\nimport { WithPromise } from './utils/WithPromise.mjs';\nimport { supportsBrowserAnimation } from './waapi/supports/waapi.mjs';\n\n/**\n * Maximum time allowed between an animation being created and it being\n * resolved for us to use the latter as the start time.\n *\n * This is to ensure that while we prefer to \"start\" an animation as soon\n * as it's triggered, we also want to avoid a visual jump if there's a big delay\n * between these two moments.\n */\nconst MAX_RESOLVE_DELAY = 40;\nclass AsyncMotionValueAnimation extends WithPromise {\n    constructor({ autoplay = true, delay = 0, type = \"keyframes\", repeat = 0, repeatDelay = 0, repeatType = \"loop\", keyframes, name, motionValue, element, ...options }) {\n        super();\n        /**\n         * Bound to support return animation.stop pattern\n         */\n        this.stop = () => {\n            if (this._animation) {\n                this._animation.stop();\n                this.stopTimeline?.();\n            }\n            this.keyframeResolver?.cancel();\n        };\n        this.createdAt = time.now();\n        const optionsWithDefaults = {\n            autoplay,\n            delay,\n            type,\n            repeat,\n            repeatDelay,\n            repeatType,\n            name,\n            motionValue,\n            element,\n            ...options,\n        };\n        const KeyframeResolver$1 = element?.KeyframeResolver || KeyframeResolver;\n        this.keyframeResolver = new KeyframeResolver$1(keyframes, (resolvedKeyframes, finalKeyframe, forced) => this.onKeyframesResolved(resolvedKeyframes, finalKeyframe, optionsWithDefaults, !forced), name, motionValue, element);\n        this.keyframeResolver?.scheduleResolve();\n    }\n    onKeyframesResolved(keyframes, finalKeyframe, options, sync) {\n        this.keyframeResolver = undefined;\n        const { name, type, velocity, delay, isHandoff, onUpdate } = options;\n        this.resolvedAt = time.now();\n        /**\n         * If we can't animate this value with the resolved keyframes\n         * then we should complete it immediately.\n         */\n        let canAnimateValue = true;\n        if (!canAnimate(keyframes, name, type, velocity)) {\n            canAnimateValue = false;\n            if (MotionGlobalConfig.instantAnimations || !delay) {\n                onUpdate?.(getFinalKeyframe(keyframes, options, finalKeyframe));\n            }\n            keyframes[0] = keyframes[keyframes.length - 1];\n            makeAnimationInstant(options);\n            options.repeat = 0;\n        }\n        /**\n         * Resolve startTime for the animation.\n         *\n         * This method uses the createdAt and resolvedAt to calculate the\n         * animation startTime. *Ideally*, we would use the createdAt time as t=0\n         * as the following frame would then be the first frame of the animation in\n         * progress, which would feel snappier.\n         *\n         * However, if there's a delay (main thread work) between the creation of\n         * the animation and the first committed frame, we prefer to use resolvedAt\n         * to avoid a sudden jump into the animation.\n         */\n        const startTime = sync\n            ? !this.resolvedAt\n                ? this.createdAt\n                : this.resolvedAt - this.createdAt > MAX_RESOLVE_DELAY\n                    ? this.resolvedAt\n                    : this.createdAt\n            : undefined;\n        const resolvedOptions = {\n            startTime,\n            finalKeyframe,\n            ...options,\n            keyframes,\n        };\n        /**\n         * Animate via WAAPI if possible. If this is a handoff animation, the optimised animation will be running via\n         * WAAPI. Therefore, this animation must be JS to ensure it runs \"under\" the\n         * optimised animation.\n         *\n         * Also skip WAAPI when keyframes aren't animatable, as the resolved\n         * values may not be valid CSS and would trigger browser warnings.\n         */\n        const useWaapi = canAnimateValue &&\n            !isHandoff &&\n            supportsBrowserAnimation(resolvedOptions);\n        const element = resolvedOptions.motionValue?.owner?.current;\n        let animation;\n        if (useWaapi) {\n            try {\n                animation = new NativeAnimationExtended({\n                    ...resolvedOptions,\n                    element,\n                });\n            }\n            catch {\n                animation = new JSAnimation(resolvedOptions);\n            }\n        }\n        else {\n            animation = new JSAnimation(resolvedOptions);\n        }\n        animation.finished.then(() => {\n            this.notifyFinished();\n        }).catch(noop);\n        if (this.pendingTimeline) {\n            this.stopTimeline = animation.attachTimeline(this.pendingTimeline);\n            this.pendingTimeline = undefined;\n        }\n        this._animation = animation;\n    }\n    get finished() {\n        if (!this._animation) {\n            return this._finished;\n        }\n        else {\n            return this.animation.finished;\n        }\n    }\n    then(onResolve, _onReject) {\n        return this.finished.finally(onResolve).then(() => { });\n    }\n    get animation() {\n        if (!this._animation) {\n            this.keyframeResolver?.resume();\n            flushKeyframeResolvers();\n        }\n        return this._animation;\n    }\n    get duration() {\n        return this.animation.duration;\n    }\n    get iterationDuration() {\n        return this.animation.iterationDuration;\n    }\n    get time() {\n        return this.animation.time;\n    }\n    set time(newTime) {\n        this.animation.time = newTime;\n    }\n    get speed() {\n        return this.animation.speed;\n    }\n    get state() {\n        return this.animation.state;\n    }\n    set speed(newSpeed) {\n        this.animation.speed = newSpeed;\n    }\n    get startTime() {\n        return this.animation.startTime;\n    }\n    attachTimeline(timeline) {\n        if (this._animation) {\n            this.stopTimeline = this.animation.attachTimeline(timeline);\n        }\n        else {\n            this.pendingTimeline = timeline;\n        }\n        return () => this.stop();\n    }\n    play() {\n        this.animation.play();\n    }\n    pause() {\n        this.animation.pause();\n    }\n    complete() {\n        this.animation.complete();\n    }\n    cancel() {\n        if (this._animation) {\n            this.animation.cancel();\n        }\n        this.keyframeResolver?.cancel();\n    }\n}\n\nexport { AsyncMotionValueAnimation };\n//# sourceMappingURL=AsyncMotionValueAnimation.mjs.map\n"],"names":["MAX_RESOLVE_DELAY","AsyncMotionValueAnimation","WithPromise","autoplay","delay","type","repeat","repeatDelay","repeatType","keyframes","name","motionValue","element","options","time","optionsWithDefaults","KeyframeResolver$1","KeyframeResolver","resolvedKeyframes","finalKeyframe","forced","sync","velocity","isHandoff","onUpdate","canAnimateValue","canAnimate","MotionGlobalConfig","getFinalKeyframe","makeAnimationInstant","resolvedOptions","useWaapi","supportsBrowserAnimation","animation","NativeAnimationExtended","JSAnimation","noop","onResolve","_onReject","flushKeyframeResolvers","newTime","newSpeed","timeline"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/visualization.es288.js

@@ -1,18 +1,16 @@
-import { DragGesture as r } from "./visualization.es474.js";
-import { PanGesture as o } from "./visualization.es475.js";
-import { MeasureLayout as e } from "./visualization.es476.js";
-import { HTMLProjectionNode as t } from "./visualization.es467.js";
-const u = {
-  pan: {
-    Feature: o
-  },
-  drag: {
-    Feature: r,
-    ProjectionNode: t,
-    MeasureLayout: e
+import { frameData as n } from "./visualization.es326.js";
+import { MotionGlobalConfig as i } from "./visualization.es297.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 {
-  u as drag
+  r as time
 };
 //# sourceMappingURL=visualization.es288.js.map

package/dist/visualization.es288.js.map

@@ -1 +1 @@
-{"version":3,"file":"visualization.es288.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/drag.mjs"],"sourcesContent":["import { DragGesture } from '../../gestures/drag/index.mjs';\nimport { PanGesture } from '../../gestures/pan/index.mjs';\nimport { MeasureLayout } from './layout/MeasureLayout.mjs';\nimport { HTMLProjectionNode } from 'motion-dom';\n\nconst drag = {\n    pan: {\n        Feature: PanGesture,\n    },\n    drag: {\n        Feature: DragGesture,\n        ProjectionNode: HTMLProjectionNode,\n        MeasureLayout,\n    },\n};\n\nexport { drag };\n//# sourceMappingURL=drag.mjs.map\n"],"names":["drag","PanGesture","DragGesture","HTMLProjectionNode","MeasureLayout"],"mappings":";;;;AAKK,MAACA,IAAO;AAAA,EACT,KAAK;AAAA,IACD,SAASC;AAAA,EACjB;AAAA,EACI,MAAM;AAAA,IACF,SAASC;AAAA,IACT,gBAAgBC;AAAA,IAChB,eAAAC;AAAA,EACR;AACA;","x_google_ignoreList":[0]}
+{"version":3,"file":"visualization.es288.js","sources":["../../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/frameloop/sync-time.mjs"],"sourcesContent":["import { MotionGlobalConfig } from 'motion-utils';\nimport { frameData } from './frame.mjs';\n\nlet now;\nfunction clearTime() {\n    now = undefined;\n}\n/**\n * An eventloop-synchronous alternative to performance.now().\n *\n * Ensures that time measurements remain consistent within a synchronous context.\n * Usually calling performance.now() twice within the same synchronous context\n * will return different values which isn't useful for animations when we're usually\n * trying to sync animations to the same frame.\n */\nconst time = {\n    now: () => {\n        if (now === undefined) {\n            time.set(frameData.isProcessing || MotionGlobalConfig.useManualTiming\n                ? frameData.timestamp\n                : performance.now());\n        }\n        return now;\n    },\n    set: (newTime) => {\n        now = newTime;\n        queueMicrotask(clearTime);\n    },\n};\n\nexport { time };\n//# sourceMappingURL=sync-time.mjs.map\n"],"names":["now","clearTime","time","frameData","MotionGlobalConfig","newTime"],"mappings":";;AAGA,IAAIA;AACJ,SAASC,IAAY;AACjB,EAAAD,IAAM;AACV;AASK,MAACE,IAAO;AAAA,EACT,KAAK,OACGF,MAAQ,UACRE,EAAK,IAAIC,EAAU,gBAAgBC,EAAmB,kBAChDD,EAAU,YACV,YAAY,IAAG,CAAE,GAEpBH;AAAA,EAEX,KAAK,CAACK,MAAY;AACd,IAAAL,IAAMK,GACN,eAAeJ,CAAS;AAAA,EAC5B;AACJ;","x_google_ignoreList":[0]}

package/dist/visualization.es289.js

@@ -1,22 +1,145 @@
-import { HoverGesture as e } from "./visualization.es470.js";
-import { FocusGesture as r } from "./visualization.es471.js";
-import { PressGesture as t } from "./visualization.es472.js";
-import { InViewFeature as o } from "./visualization.es473.js";
-const a = {
-  inView: {
-    Feature: o
-  },
-  tap: {
-    Feature: t
-  },
-  focus: {
-    Feature: r
-  },
-  hover: {
-    Feature: e
+import { time as p } from "./visualization.es288.js";
+import { mix as P } from "./visualization.es299.js";
+import { frameloopDriver as I } from "./visualization.es300.js";
+import { inertia as K } from "./visualization.es301.js";
+import { keyframes as u } from "./visualization.es302.js";
+import { calcGeneratorDuration as O } from "./visualization.es303.js";
+import { getGeneratorVelocity as V } from "./visualization.es304.js";
+import { getFinalKeyframe as C } from "./visualization.es290.js";
+import { replaceTransitionType as E } from "./visualization.es305.js";
+import { WithPromise as N } from "./visualization.es295.js";
+import { invariant as W } from "./visualization.es306.js";
+import { pipe as $ } from "./visualization.es307.js";
+import { millisecondsToSeconds as c, secondsToMilliseconds as B } from "./visualization.es308.js";
+import { clamp as J } from "./visualization.es309.js";
+const U = (g) => g / 100;
+class rt extends N {
+  constructor(t) {
+    super(), this.state = "idle", this.startTime = null, this.isStopped = !1, this.currentTime = 0, this.holdTime = null, this.playbackSpeed = 1, this.delayState = {
+      done: !1,
+      value: void 0
+    }, this.stop = () => {
+      const { motionValue: i } = this.options;
+      i && i.updatedAt !== p.now() && this.tick(p.now()), this.isStopped = !0, this.state !== "idle" && (this.teardown(), this.options.onStop?.());
+    }, this.options = t, this.initAnimation(), this.play(), t.autoplay === !1 && this.pause();
   }
-};
+  initAnimation() {
+    const { options: t } = this;
+    E(t);
+    const { type: i = u, repeat: s = 0, repeatDelay: r = 0, repeatType: m, velocity: f = 0 } = t;
+    let { keyframes: e } = t;
+    const h = i || u;
+    process.env.NODE_ENV !== "production" && h !== u && W(e.length <= 2, `Only two keyframes currently supported with spring and inertia animations. Trying to animate ${e}`, "spring-two-frames"), h !== u && typeof e[0] != "number" && (this.mixKeyframes = $(U, P(e[0], e[1])), e = [0, 100]);
+    const n = h({ ...t, keyframes: e });
+    m === "mirror" && (this.mirroredGenerator = h({
+      ...t,
+      keyframes: [...e].reverse(),
+      velocity: -f
+    })), n.calculatedDuration === null && (n.calculatedDuration = O(n));
+    const { calculatedDuration: l } = n;
+    this.calculatedDuration = l, this.resolvedDuration = l + r, this.totalDuration = this.resolvedDuration * (s + 1) - r, this.generator = n;
+  }
+  updateTime(t) {
+    const i = Math.round(t - this.startTime) * this.playbackSpeed;
+    this.holdTime !== null ? this.currentTime = this.holdTime : this.currentTime = i;
+  }
+  tick(t, i = !1) {
+    const { generator: s, totalDuration: r, mixKeyframes: m, mirroredGenerator: f, resolvedDuration: e, calculatedDuration: h } = this;
+    if (this.startTime === null)
+      return s.next(0);
+    const { delay: n = 0, keyframes: l, repeat: k, repeatType: D, repeatDelay: S, type: F, onUpdate: b, finalKeyframe: G } = this.options;
+    this.speed > 0 ? this.startTime = Math.min(this.startTime, t) : this.speed < 0 && (this.startTime = Math.min(t - r / this.speed, this.startTime)), i ? this.currentTime = t : this.updateTime(t);
+    const T = this.currentTime - n * (this.playbackSpeed >= 0 ? 1 : -1), y = this.playbackSpeed >= 0 ? T < 0 : T > r;
+    this.currentTime = Math.max(T, 0), this.state === "finished" && this.holdTime === null && (this.currentTime = r);
+    let x = this.currentTime, w = s;
+    if (k) {
+      const v = Math.min(this.currentTime, r) / e;
+      let d = Math.floor(v), o = v % 1;
+      !o && v >= 1 && (o = 1), o === 1 && d--, d = Math.min(d, k + 1), d % 2 && (D === "reverse" ? (o = 1 - o, S && (o -= S / e)) : D === "mirror" && (w = f)), x = J(0, 1, o) * e;
+    }
+    let a;
+    y ? (this.delayState.value = l[0], a = this.delayState) : a = w.next(x), m && !y && (a.value = m(a.value));
+    let { done: M } = a;
+    !y && h !== null && (M = this.playbackSpeed >= 0 ? this.currentTime >= r : this.currentTime <= 0);
+    const A = this.holdTime === null && (this.state === "finished" || this.state === "running" && M);
+    return A && F !== K && (a.value = C(l, this.options, G, this.speed)), b && b(a.value), A && this.finish(), a;
+  }
+  /**
+   * Allows the returned animation to be awaited or promise-chained. Currently
+   * resolves when the animation finishes at all but in a future update could/should
+   * reject if its cancels.
+   */
+  then(t, i) {
+    return this.finished.then(t, i);
+  }
+  get duration() {
+    return c(this.calculatedDuration);
+  }
+  get iterationDuration() {
+    const { delay: t = 0 } = this.options || {};
+    return this.duration + c(t);
+  }
+  get time() {
+    return c(this.currentTime);
+  }
+  set time(t) {
+    t = B(t), this.currentTime = t, this.startTime === null || this.holdTime !== null || this.playbackSpeed === 0 ? this.holdTime = t : this.driver && (this.startTime = this.driver.now() - t / this.playbackSpeed), this.driver ? this.driver.start(!1) : (this.startTime = 0, this.state = "paused", this.holdTime = t, this.tick(t));
+  }
+  /**
+   * Returns the generator's velocity at the current time in units/second.
+   * Uses the analytical derivative when available (springs), avoiding
+   * the MotionValue's frame-dependent velocity estimation.
+   */
+  getGeneratorVelocity() {
+    const t = this.currentTime;
+    if (t <= 0)
+      return this.options.velocity || 0;
+    if (this.generator.velocity)
+      return this.generator.velocity(t);
+    const i = this.generator.next(t).value;
+    return V((s) => this.generator.next(s).value, t, i);
+  }
+  get speed() {
+    return this.playbackSpeed;
+  }
+  set speed(t) {
+    const i = this.playbackSpeed !== t;
+    i && this.driver && this.updateTime(p.now()), this.playbackSpeed = t, i && this.driver && (this.time = c(this.currentTime));
+  }
+  play() {
+    if (this.isStopped)
+      return;
+    const { driver: t = I, startTime: i } = this.options;
+    this.driver || (this.driver = t((r) => this.tick(r))), this.options.onPlay?.();
+    const s = this.driver.now();
+    this.state === "finished" ? (this.updateFinished(), this.startTime = s) : this.holdTime !== null ? this.startTime = s - this.holdTime : this.startTime || (this.startTime = i ?? s), this.state === "finished" && this.speed < 0 && (this.startTime += this.calculatedDuration), this.holdTime = null, this.state = "running", this.driver.start();
+  }
+  pause() {
+    this.state = "paused", this.updateTime(p.now()), this.holdTime = this.currentTime;
+  }
+  complete() {
+    this.state !== "running" && this.play(), this.state = "finished", this.holdTime = null;
+  }
+  finish() {
+    this.notifyFinished(), this.teardown(), this.state = "finished", this.options.onComplete?.();
+  }
+  cancel() {
+    this.holdTime = null, this.startTime = 0, this.tick(0), this.teardown(), this.options.onCancel?.();
+  }
+  teardown() {
+    this.state = "idle", this.stopDriver(), this.startTime = this.holdTime = null;
+  }
+  stopDriver() {
+    this.driver && (this.driver.stop(), this.driver = void 0);
+  }
+  sample(t) {
+    return this.startTime = 0, this.tick(t, !0);
+  }
+  attachTimeline(t) {
+    return this.options.allowFlatten && (this.options.type = "keyframes", this.options.ease = "linear", this.initAnimation()), this.driver?.stop(), t.observe(this);
+  }
+}
 export {
-  a as gestureAnimations
+  rt as JSAnimation
 };
 //# sourceMappingURL=visualization.es289.js.map

package/dist/visualization.es289.js.map

@@ -1 +1 @@
-{"version":3,"file":"visualization.es289.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/gestures.mjs"],"sourcesContent":["import { HoverGesture } from '../../gestures/hover.mjs';\nimport { FocusGesture } from '../../gestures/focus.mjs';\nimport { PressGesture } from '../../gestures/press.mjs';\nimport { InViewFeature } from './viewport/index.mjs';\n\nconst gestureAnimations = {\n    inView: {\n        Feature: InViewFeature,\n    },\n    tap: {\n        Feature: PressGesture,\n    },\n    focus: {\n        Feature: FocusGesture,\n    },\n    hover: {\n        Feature: HoverGesture,\n    },\n};\n\nexport { gestureAnimations };\n//# sourceMappingURL=gestures.mjs.map\n"],"names":["gestureAnimations","InViewFeature","PressGesture","FocusGesture","HoverGesture"],"mappings":";;;;AAKK,MAACA,IAAoB;AAAA,EACtB,QAAQ;AAAA,IACJ,SAASC;AAAA,EACjB;AAAA,EACI,KAAK;AAAA,IACD,SAASC;AAAA,EACjB;AAAA,EACI,OAAO;AAAA,IACH,SAASC;AAAA,EACjB;AAAA,EACI,OAAO;AAAA,IACH,SAASC;AAAA,EACjB;AACA;","x_google_ignoreList":[0]}
+{"version":3,"file":"visualization.es289.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]}

package/dist/visualization.es29.js

@@ -1,8 +1,51 @@
-import { createDomVisualElement as o } from "./visualization.es158.js";
-import { createMotionProxy as r } from "./visualization.es159.js";
-import { featureBundle as t } from "./visualization.es160.js";
-const n = /* @__PURE__ */ r(t, o);
+import g from "./visualization.es154.js";
+import { jsx as t } from "react/jsx-runtime";
+const p = {
+  overflow: "visible"
+};
+function z(e) {
+  const {
+    dx: s = 0,
+    dy: i = 0,
+    textAnchor: l = "start",
+    innerRef: c,
+    innerTextRef: f,
+    verticalAnchor: u,
+    angle: T,
+    lineHeight: a = "1em",
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    scaleToFit: v = !1,
+    capHeight: w,
+    width: S,
+    ...n
+  } = e, {
+    x = 0,
+    fontSize: h
+  } = n, {
+    wordsByLines: r,
+    startDy: d,
+    transform: m
+  } = g(e);
+  return /* @__PURE__ */ t("svg", {
+    ref: c,
+    x: s,
+    y: i,
+    fontSize: h,
+    style: p,
+    children: r.length > 0 ? /* @__PURE__ */ t("text", {
+      ref: f,
+      transform: m,
+      ...n,
+      textAnchor: l,
+      children: r.map((y, o) => /* @__PURE__ */ t("tspan", {
+        x,
+        dy: o === 0 ? d : a,
+        children: y.words.join(" ")
+      }, o))
+    }) : null
+  });
+}
 export {
-  n as motion
+  z as default
 };
 //# sourceMappingURL=visualization.es29.js.map

package/dist/visualization.es29.js.map

@@ -1 +1 @@
-{"version":3,"file":"visualization.es29.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/render/components/motion/proxy.mjs"],"sourcesContent":["import { createDomVisualElement } from '../../dom/create-visual-element.mjs';\nimport { createMotionProxy } from '../create-proxy.mjs';\nimport { featureBundle } from './feature-bundle.mjs';\n\nconst motion = /*@__PURE__*/ createMotionProxy(featureBundle, createDomVisualElement);\n\nexport { motion };\n//# sourceMappingURL=proxy.mjs.map\n"],"names":["motion","createMotionProxy","featureBundle","createDomVisualElement"],"mappings":";;;AAIK,MAACA,IAAuB,gBAAAC,EAAkBC,GAAeC,CAAsB;","x_google_ignoreList":[0]}
+{"version":3,"file":"visualization.es29.js","sources":["../../../node_modules/.pnpm/@visx+text@4.0.0_@types+react@19.2.14_react@19.2.4/node_modules/@visx/text/esm/Text.js"],"sourcesContent":["import useText from \"./hooks/useText.js\";\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst SVG_STYLE = {\n  overflow: 'visible'\n};\nexport default function Text(props) {\n  const {\n    dx = 0,\n    dy = 0,\n    textAnchor = 'start',\n    innerRef,\n    innerTextRef,\n    verticalAnchor,\n    angle,\n    lineHeight = '1em',\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    scaleToFit = false,\n    capHeight,\n    width,\n    ...textProps\n  } = props;\n  const {\n    x = 0,\n    fontSize\n  } = textProps;\n  const {\n    wordsByLines,\n    startDy,\n    transform\n  } = useText(props);\n  return /*#__PURE__*/_jsx(\"svg\", {\n    ref: innerRef,\n    x: dx,\n    y: dy,\n    fontSize: fontSize,\n    style: SVG_STYLE,\n    children: wordsByLines.length > 0 ? /*#__PURE__*/_jsx(\"text\", {\n      ref: innerTextRef,\n      transform: transform,\n      ...textProps,\n      textAnchor: textAnchor,\n      children: wordsByLines.map((line, index) => /*#__PURE__*/_jsx(\"tspan\", {\n        x: x,\n        dy: index === 0 ? startDy : lineHeight,\n        children: line.words.join(' ')\n      }, index))\n    }) : null\n  });\n}"],"names":["SVG_STYLE","Text","props","dx","dy","textAnchor","innerRef","innerTextRef","verticalAnchor","angle","lineHeight","scaleToFit","capHeight","width","textProps","fontSize","wordsByLines","startDy","transform","useText","_jsx","line","index"],"mappings":";;AAEA,MAAMA,IAAY;AAAA,EAChB,UAAU;AACZ;AACe,SAASC,EAAKC,GAAO;AAClC,QAAM;AAAA,IACJ,IAAAC,IAAK;AAAA,IACL,IAAAC,IAAK;AAAA,IACL,YAAAC,IAAa;AAAA,IACb,UAAAC;AAAA,IACA,cAAAC;AAAA,IACA,gBAAAC;AAAA,IACA,OAAAC;AAAA,IACA,YAAAC,IAAa;AAAA;AAAA,IAEb,YAAAC,IAAa;AAAA,IACb,WAAAC;AAAA,IACA,OAAAC;AAAA,IACA,GAAGC;AAAA,EACP,IAAMZ,GACE;AAAA,IACJ,IAAI;AAAA,IACJ,UAAAa;AAAA,EACJ,IAAMD,GACE;AAAA,IACJ,cAAAE;AAAA,IACA,SAAAC;AAAA,IACA,WAAAC;AAAA,EACJ,IAAMC,EAAQjB,CAAK;AACjB,SAAoBkB,gBAAAA,EAAK,OAAO;AAAA,IAC9B,KAAKd;AAAA,IACL,GAAGH;AAAA,IACH,GAAGC;AAAA,IACH,UAAUW;AAAA,IACV,OAAOf;AAAA,IACP,UAAUgB,EAAa,SAAS,IAAiBI,gBAAAA,EAAK,QAAQ;AAAA,MAC5D,KAAKb;AAAA,MACL,WAAWW;AAAA,MACX,GAAGJ;AAAA,MACH,YAAYT;AAAA,MACZ,UAAUW,EAAa,IAAI,CAACK,GAAMC,MAAuBF,gBAAAA,EAAK,SAAS;AAAA,QACrE;AAAA,QACA,IAAIE,MAAU,IAAIL,IAAUP;AAAA,QAC5B,UAAUW,EAAK,MAAM,KAAK,GAAG;AAAA,MACrC,GAASC,CAAK,CAAC;AAAA,IACf,CAAK,IAAI;AAAA,EACT,CAAG;AACH;","x_google_ignoreList":[0]}

package/dist/visualization.es290.js

@@ -1,12 +1,9 @@
-import { MeasureLayout as o } from "./visualization.es476.js";
-import { HTMLProjectionNode as t } from "./visualization.es467.js";
-const a = {
-  layout: {
-    ProjectionNode: t,
-    MeasureLayout: o
-  }
-};
+const i = (e) => e !== null;
+function c(e, { repeat: n, repeatType: l = "loop" }, o, r = 1) {
+  const t = e.filter(i), s = r < 0 || n && l !== "loop" && n % 2 === 1 ? 0 : t.length - 1;
+  return !s || o === void 0 ? t[s] : o;
+}
 export {
-  a as layout
+  c as getFinalKeyframe
 };
 //# sourceMappingURL=visualization.es290.js.map

package/dist/visualization.es290.js.map

@@ -1 +1 @@
-{"version":3,"file":"visualization.es290.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/layout.mjs"],"sourcesContent":["import { HTMLProjectionNode } from 'motion-dom';\nimport { MeasureLayout } from './layout/MeasureLayout.mjs';\n\nconst layout = {\n    layout: {\n        ProjectionNode: HTMLProjectionNode,\n        MeasureLayout,\n    },\n};\n\nexport { layout };\n//# sourceMappingURL=layout.mjs.map\n"],"names":["layout","HTMLProjectionNode","MeasureLayout"],"mappings":";;AAGK,MAACA,IAAS;AAAA,EACX,QAAQ;AAAA,IACJ,gBAAgBC;AAAA,IAChB,eAAAC;AAAA,EACR;AACA;","x_google_ignoreList":[0]}
+{"version":3,"file":"visualization.es290.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]}