funnel-gfx-wc 0.1.239 → 0.1.241

package/dist/cjs/funnel-app.cjs.entry.js

@@ -471,7 +471,7 @@ var consts = {};
 
 /**
  * Anime.js - core - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -548,6 +548,11 @@ function requireConsts () {
 	const emptyString = '';
 	const cssVarPrefix = 'var(';
 
+	// Arrays
+
+	// Shared sentinel for tween slots that don't hold array data. Never mutated, only read; COMPLEX and COLOR tweens always replace the slot before writing.
+	const emptyArray = [];
+
 	const shortTransforms = /*#__PURE__*/ (() => {
 	  const map = new Map();
 	  map.set('x', 'translateX');
@@ -581,6 +586,13 @@ function requireConsts () {
 	/** @return {void} */
 	const noop = () => {};
 
+	/**
+	 * @template T
+	 * @param  {T} v
+	 * @return {T}
+	 */
+	const noopModifier = v => v;
+
 	// Regex
 
 	const validRgbHslRgx = /\)\s*[-.\d]/;
@@ -603,6 +615,7 @@ function requireConsts () {
 	consts.cssVariableMatchRgx = cssVariableMatchRgx;
 	consts.digitWithExponentRgx = digitWithExponentRgx;
 	consts.doc = doc;
+	consts.emptyArray = emptyArray;
 	consts.emptyString = emptyString;
 	consts.hexTestRgx = hexTestRgx;
 	consts.hslExecRgx = hslExecRgx;
@@ -616,6 +629,7 @@ function requireConsts () {
 	consts.maxValue = maxValue;
 	consts.minValue = minValue;
 	consts.noop = noop;
+	consts.noopModifier = noopModifier;
 	consts.proxyTargetSymbol = proxyTargetSymbol;
 	consts.relativeValuesExecRgx = relativeValuesExecRgx;
 	consts.rgbExecRgx = rgbExecRgx;
@@ -639,7 +653,7 @@ var globals = {};
 
 /**
  * Anime.js - core - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -666,10 +680,13 @@ function requireGlobals () {
 	/**
 	 * @typedef {Object} EditorGlobals
 	 * @property {boolean} showPanel
-	 * @property {boolean} synced
 	 * @property {Function} addAnimation
+	 * @property {Function} addSet
 	 * @property {Function} addTimeline
 	 * @property {Function} addTimelineChild
+	 * @property {Function} addTimelineLabel
+	 * @property {Function} addTimelineCall
+	 * @property {Function} addTimelineSync
 	 * @property {Function} resolveStagger
 	 * @property {Object|null} _head
 	 * @property {Object|null} _tail
@@ -692,7 +709,7 @@ function requireGlobals () {
 	  loopDelay: 0,
 	  ease: 'out(2)',
 	  composition: consts.compositionTypes.replace,
-	  modifier: v => v,
+	  modifier: consts.noopModifier,
 	  onBegin: consts.noop,
 	  onBeforeUpdate: consts.noop,
 	  onUpdate: consts.noop,
@@ -722,7 +739,7 @@ function requireGlobals () {
 	  editor: null,
 	};
 
-	const globalVersions = { version: '4.4.1', engine: null };
+	const globalVersions = { version: '4.5.0', engine: null };
 
 	if (consts.isBrowser) {
 	  if (!consts.win.AnimeJS) consts.win.AnimeJS = [];
@@ -738,7 +755,7 @@ function requireGlobals () {
 
 /**
  * Anime.js - core - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -897,7 +914,7 @@ function requireHelpers$1 () {
 	 * @param  {Number} factor - Interpolation factor in the range [0, 1]
 	 * @return {Number} The interpolated value
 	 */
-	const lerp = (start, end, factor) => start + (end - start) * factor;
+	const lerp = (start, end, factor) => factor === 1 ? end : factor === 0 ? start : start + (end - start) * factor;
 
 	/**
 	 * Replaces infinity with maximum safe value
@@ -1050,7 +1067,7 @@ var transforms = {};
 
 /**
  * Anime.js - core - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -1220,11 +1237,169 @@ function requireTransforms () {
 	return transforms;
 }
 
+var registry = {};
+
+/**
+ * Anime.js - adapters - CJS
+ * @version v4.5.0
+ * @license MIT
+ * @copyright 2026 - Julian Garnier
+ */
+
+var hasRequiredRegistry;
+
+function requireRegistry () {
+	if (hasRequiredRegistry) return registry;
+	hasRequiredRegistry = 1;
+
+	/**
+	 * Anime.js adapter API. Each library or class group that wants to extend `animate()` and `utils.set()` calls `registerAdapter()` to create its own `Adapter`. The returned `Adapter` exposes `registerTargetAdapter(detect)` for per-class detection and `registerPropertyResolver(fn)` for global Color / Vector / pattern-based fallbacks.
+	 *
+	 *   import { registerAdapter } from 'animejs/adapters';
+	 *
+	 *   const myAdapter = registerAdapter();
+	 *   const widget = myAdapter.registerTargetAdapter((t) => t instanceof MyWidget);
+	 *   widget.registerProperty('value',
+	 *     (t) => t.getValue(),
+	 *     (target, value) => target.setValue(value),
+	 *   );
+	 *
+	 * For scalar tweens, `value` is the interpolated number. For color and complex tweens it is `undefined`; read `tween._numbers` instead. `gate(target)` scopes the prop to a subset of matching targets.
+	 *
+	 * Resolution order: every Adapter's target adapters in registration order (first match wins) then every Adapter's property resolvers (first non-null wins) then engine direct property path.
+	 */
+
+	/**
+	 * @typedef TargetAdapterEntry
+	 * @property {(t: any) => any} get
+	 * @property {(target: any, value: number, tween: any) => void} set
+	 * @property {(t: any) => boolean} [gate]
+	 */
+
+	const alwaysTrue = () => true;
+
+	class TargetAdapter {
+	  /**
+	   * @param {(t: any) => boolean} detect
+	   */
+	  constructor(detect) {
+	    this.detect = detect;
+	    /** @type {Record<string, TargetAdapterEntry>} */
+	    this.props = {};
+	  }
+
+	  /**
+	   * Registers a property the adapter handles. `setter` receives `(target, value, tween)`. For color and complex tweens `value` is `undefined`, read `tween._numbers` instead. `gate(target)` scopes the prop to a subset of matching targets.
+	   *
+	   * @param {string} name
+	   * @param {(t: any) => any} getter
+	   * @param {(target: any, value: number, tween: any) => void} setter
+	   * @param {(t: any) => boolean} [gate]
+	   */
+	  registerProperty(name, getter, setter, gate) {
+	    this.props[name] = {
+	      get: getter,
+	      set: setter,
+	      gate: gate || alwaysTrue,
+	    };
+	  }
+	}
+
+	class Adapter {
+	  /**
+	   * @param {((t: any) => boolean) | null} [detect]
+	   *   Optional gate. When provided, every lookup against this Adapter's target adapters and resolvers is skipped if `detect(target)` returns falsy. Lets the Adapter as a whole short-circuit on unrelated targets.
+	   */
+	  constructor(detect) {
+	    /** @type {((t: any) => boolean) | null} */
+	    this.detect = detect || null;
+	    /** @type {TargetAdapter[]} */
+	    this.targetAdapters = [];
+	    /** @type {((target: any, name: string) => TargetAdapterEntry | null)[]} */
+	    this.propertyResolvers = [];
+	  }
+
+	  /**
+	   * Creates and registers a `TargetAdapter` scoped to this Adapter.
+	   *
+	   * @param {(t: any) => boolean} detect
+	   * @return {TargetAdapter}
+	   */
+	  registerTargetAdapter(detect) {
+	    const ta = new TargetAdapter(detect);
+	    this.targetAdapters.push(ta);
+	    return ta;
+	  }
+
+	  /**
+	   * Registers a property resolver scoped to this Adapter. Resolvers are functions invoked at tween creation when no target adapter has claimed the name; the function returns an entry for names it handles or `null` to defer. Use for runtime-matched patterns (Color / Vector axis detection, name-prefix conventions, etc.).
+	   *
+	   * @param {(target: any, name: string) => TargetAdapterEntry | null} resolver
+	   */
+	  registerPropertyResolver(resolver) {
+	    if (this.propertyResolvers.indexOf(resolver) === -1) this.propertyResolvers.push(resolver);
+	  }
+	}
+
+	const adapters = /** @type {Adapter[]} */([]);
+
+	/**
+	 * Creates and registers an Adapter. Each library extending `animate()` calls this once and uses the returned Adapter to wire up its target adapters and property resolvers. The optional `detect` short-circuits all lookups against the Adapter when the target is unrelated.
+	 *
+	 * @param {(t: any) => boolean} [detect]
+	 * @return {Adapter}
+	 */
+	function registerAdapter(detect) {
+	  const a = new Adapter(detect);
+	  adapters.push(a);
+	  return a;
+	}
+
+	/**
+	 * Internal resolution. Tries every Adapter's target adapters first (in registration order, first match wins), then every Adapter's property resolvers.
+	 *
+	 * @param {any} target
+	 * @param {string} name
+	 * @return {TargetAdapterEntry | null}
+	 */
+	function resolveAdapterEntry(target, name) {
+	  if (!target) return null;
+	  const al = adapters.length;
+	  outer: for (let i = 0; i < al; i++) {
+	    const a = adapters[i];
+	    if (a.detect && !a.detect(target)) continue;
+	    const tas = a.targetAdapters;
+	    for (let j = 0, m = tas.length; j < m; j++) {
+	      const ta = tas[j];
+	      if (ta.detect(target)) {
+	        const entry = ta.props[name];
+	        if (entry && (!entry.gate || entry.gate(target))) return entry;
+	        break outer;
+	      }
+	    }
+	  }
+	  for (let i = 0; i < al; i++) {
+	    const a = adapters[i];
+	    if (a.detect && !a.detect(target)) continue;
+	    const rs = a.propertyResolvers;
+	    for (let j = 0, m = rs.length; j < m; j++) {
+	      const entry = rs[j](target, name);
+	      if (entry) return entry;
+	    }
+	  }
+	  return null;
+	}
+
+	registry.registerAdapter = registerAdapter;
+	registry.resolveAdapterEntry = resolveAdapterEntry;
+	return registry;
+}
+
 var colors = {};
 
 /**
  * Anime.js - core - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -1333,7 +1508,7 @@ function requireColors () {
 
 /**
  * Anime.js - core - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -1347,6 +1522,7 @@ function requireValues () {
 	var consts = /*@__PURE__*/ requireConsts();
 	var helpers = /*@__PURE__*/ requireHelpers$1();
 	var transforms = /*@__PURE__*/ requireTransforms();
+	var registry = requireRegistry();
 	var colors = /*@__PURE__*/ requireColors();
 
 	/**
@@ -1370,6 +1546,21 @@ function requireValues () {
 	  return helpers.isUnd(targetValue) ? defaultValue : targetValue;
 	};
 
+	/**
+	 * Resolve against the target when it's a DOM element, otherwise fall back to :root so non-DOM targets like three.js meshes and custom adapters still pick up CSS variables defined on the document.
+	 *
+	 * @param  {String} value
+	 * @param  {Target} target
+	 * @return {String|Number}
+	 */
+	const resolveCssVar = (value, target) => {
+	  const match = value.match(consts.cssVariableMatchRgx);
+	  const el = target[consts.isDomSymbol] ? target : document.documentElement;
+	  let computed = getComputedStyle(/** @type {HTMLElement} */(el))?.getPropertyValue(match[1]);
+	  if ((!computed || computed.trim() === consts.emptyString) && match[2]) computed = match[2].trim();
+	  return computed || 0;
+	};
+
 	/**
 	 * @param  {TweenPropValue} value
 	 * @param  {Target} target
@@ -1380,30 +1571,26 @@ function requireValues () {
 	 * @return {any}
 	 */
 	const getFunctionValue = (value, target, index, targets, store, prevTween) => {
-	  let func;
 	  if (helpers.isFnc(value)) {
-	    func = () => {
+	    if (!store) {
+	      const computed = /** @type {Function} */(value)(target, index, targets, prevTween);
+	      // Fallback to 0 if the function returns undefined, NaN, null, false or 0
+	      return !isNaN(+computed) ? +computed : computed || 0;
+	    }
+	    const func = () => {
 	      const computed = /** @type {Function} */(value)(target, index, targets, prevTween);
-	      // Fallback to 0 if the function returns undefined / NaN / null / false / 0
 	      return !isNaN(+computed) ? +computed : computed || 0;
 	    };
-	  } else if (helpers.isStr(value) && helpers.stringStartsWith(value, consts.cssVarPrefix)) {
-	    func = () => {
-	      const match = value.match(consts.cssVariableMatchRgx);
-	      const cssVarName = match[1];
-	      const fallbackValue = match[2];
-	      let computed = getComputedStyle(/** @type {HTMLElement} */(target))?.getPropertyValue(cssVarName);
-	      // Use fallback if CSS variable is not set or empty
-	      if ((!computed || computed.trim() === consts.emptyString) && fallbackValue) {
-	        computed = fallbackValue.trim();
-	      }
-	      return computed || 0;
-	    };
-	  } else {
-	    return value;
+	    store.func = func;
+	    return func();
 	  }
-	  if (store) store.func = func;
-	  return func();
+	  if (helpers.isStr(value) && helpers.stringStartsWith(value, consts.cssVarPrefix)) {
+	    if (!store) return resolveCssVar(/** @type {String} */(value), target);
+	    const func = () => resolveCssVar(/** @type {String} */(value), target);
+	    store.func = func;
+	    return func();
+	  }
+	  return value;
 	};
 
 	/**
@@ -1450,6 +1637,12 @@ function requireValues () {
 	 */
 	const getOriginalAnimatableValue = (target, propName, tweenType, animationInlineStyles) => {
 	  const type = !helpers.isUnd(tweenType) ? tweenType : getTweenType(target, propName);
+	  const adapterProp = registry.resolveAdapterEntry(target, propName);
+	  if (adapterProp) {
+	    const value = adapterProp.get(target);
+	    if (value && animationInlineStyles) animationInlineStyles[propName] = value;
+	    return value == null ? 0 : value;
+	  }
 	  if (type === consts.tweenTypes.OBJECT) {
 	    const value = target[propName];
 	    if (value && animationInlineStyles) animationInlineStyles[propName] = value;
@@ -1491,7 +1684,7 @@ function requireValues () {
 	};
 
 	/**
-	 * @param  {String|Number} rawValue
+	 * @param  {String|Number|Object} rawValue
 	 * @param  {TweenDecomposedValue} targetObject
 	 * @return {TweenDecomposedValue}
 	 */
@@ -1509,39 +1702,38 @@ function requireValues () {
 	    // It's a number
 	    targetObject.n = num;
 	    return targetObject;
+	  }
+	  // let str = /** @type {String} */(rawValue).trim();
+	  let str = /** @type {String} */(rawValue);
+	  // Parsing operators (+=, -=, *=) manually is much faster than using regex here
+	  if (str[1] === '=') {
+	    targetObject.o = str[0];
+	    str = str.slice(2);
+	  }
+	  // Skip exec regex if the value type is complex or color to avoid long regex backtracking
+	  const unitMatch = str.includes(' ') ? false : consts.unitsExecRgx.exec(str);
+	  if (unitMatch) {
+	    // Has a number and a unit
+	    targetObject.t = consts.valueTypes.UNIT;
+	    targetObject.n = +unitMatch[1];
+	    targetObject.u = unitMatch[2];
+	    return targetObject;
+	  } else if (targetObject.o) {
+	    // Has an operator (+=, -=, *=)
+	    targetObject.n = +str;
+	    return targetObject;
+	  } else if (helpers.isCol(str)) {
+	    // Color string
+	    targetObject.t = consts.valueTypes.COLOR;
+	    targetObject.d = colors.convertColorStringValuesToRgbaArray(str);
+	    return targetObject;
 	  } else {
-	    // let str = /** @type {String} */(rawValue).trim();
-	    let str = /** @type {String} */(rawValue);
-	    // Parsing operators (+=, -=, *=) manually is much faster than using regex here
-	    if (str[1] === '=') {
-	      targetObject.o = str[0];
-	      str = str.slice(2);
-	    }
-	    // Skip exec regex if the value type is complex or color to avoid long regex backtracking
-	    const unitMatch = str.includes(' ') ? false : consts.unitsExecRgx.exec(str);
-	    if (unitMatch) {
-	      // Has a number and a unit
-	      targetObject.t = consts.valueTypes.UNIT;
-	      targetObject.n = +unitMatch[1];
-	      targetObject.u = unitMatch[2];
-	      return targetObject;
-	    } else if (targetObject.o) {
-	      // Has an operator (+=, -=, *=)
-	      targetObject.n = +str;
-	      return targetObject;
-	    } else if (helpers.isCol(str)) {
-	      // Is a color
-	      targetObject.t = consts.valueTypes.COLOR;
-	      targetObject.d = colors.convertColorStringValuesToRgbaArray(str);
-	      return targetObject;
-	    } else {
-	      // Is a more complex string (generally svg coords, calc() or filters CSS values)
-	      const matchedNumbers = str.match(consts.digitWithExponentRgx);
-	      targetObject.t = consts.valueTypes.COMPLEX;
-	      targetObject.d = matchedNumbers ? matchedNumbers.map(Number) : [];
-	      targetObject.s = str.split(consts.digitWithExponentRgx) || [];
-	      return targetObject;
-	    }
+	    // Is a more complex string (generally svg coords, calc() or filters CSS values)
+	    const matchedNumbers = str.match(consts.digitWithExponentRgx);
+	    targetObject.t = consts.valueTypes.COMPLEX;
+	    targetObject.d = matchedNumbers ? matchedNumbers.map(Number) : [];
+	    targetObject.s = str.split(consts.digitWithExponentRgx) || [];
+	    return targetObject;
 	  }
 	};
 
@@ -1562,30 +1754,6 @@ function requireValues () {
 
 	const decomposedOriginalValue = createDecomposedValueTargetObject();
 
-	/**
-	 * @param  {Tween} tween
-	 * @param  {Number} progress
-	 * @param  {Number} precision
-	 * @return {String}
-	 */
-	const composeColorValue = (tween, progress, precision) => {
-	  const mod = tween._modifier;
-	  const fn = tween._fromNumbers;
-	  const tn = tween._toNumbers;
-	  const r = helpers.round(helpers.clamp(/** @type {Number} */(mod(helpers.lerp(fn[0], tn[0], progress))), 0, 255), 0);
-	  const g = helpers.round(helpers.clamp(/** @type {Number} */(mod(helpers.lerp(fn[1], tn[1], progress))), 0, 255), 0);
-	  const b = helpers.round(helpers.clamp(/** @type {Number} */(mod(helpers.lerp(fn[2], tn[2], progress))), 0, 255), 0);
-	  const a = helpers.clamp(/** @type {Number} */(mod(helpers.round(helpers.lerp(fn[3], tn[3], progress), precision))), 0, 1);
-	  if (tween._composition !== consts.compositionTypes.none) {
-	    const ns = tween._numbers;
-	    ns[0] = r;
-	    ns[1] = g;
-	    ns[2] = b;
-	    ns[3] = a;
-	  }
-	  return `rgba(${r},${g},${b},${a})`;
-	};
-
 	/**
 	 * @param  {Tween} tween
 	 * @param  {Number} progress
@@ -1597,20 +1765,18 @@ function requireValues () {
 	  const fn = tween._fromNumbers;
 	  const tn = tween._toNumbers;
 	  const ts = tween._strings;
-	  const hasComposition = tween._composition !== consts.compositionTypes.none;
 	  let v = ts[0];
 	  for (let j = 0, l = tn.length; j < l; j++) {
 	    const n = /** @type {Number} */(mod(helpers.round(helpers.lerp(fn[j], tn[j], progress), precision)));
 	    const s = ts[j + 1];
 	    v += `${s ? n + s : n}`;
-	    if (hasComposition) {
-	      tween._numbers[j] = n;
-	    }
+	    // Keep _numbers fresh for every tween, not only composed ones, so a non-composition setter that reads the lerped triplet such as three transformOrigin still animates.
+	    // Potential optimization, skip the write when nothing reads it: if (hasComposition || tween._setter) tween._numbers[j] = n;
+	    tween._numbers[j] = n;
 	  }
 	  return v;
 	};
 
-	values.composeColorValue = composeColorValue;
 	values.composeComplexValue = composeComplexValue;
 	values.createDecomposedValueTargetObject = createDecomposedValueTargetObject;
 	values.decomposeRawValue = decomposeRawValue;
@@ -1628,7 +1794,7 @@ var render = {};
 
 /**
  * Anime.js - core - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -1708,12 +1874,14 @@ function requireRender () {
 	  // Execute the "expensive" iterations calculations only when necessary
 	  if (iterationCount > 1) {
 	    // bitwise NOT operator seems to be generally faster than Math.floor() across browsers
-	    const currentIteration = ~~(tickableCurrentTime / (iterationDuration + (isCurrentTimeEqualOrAboveDuration ? 0 : _loopDelay)));
+	    const period = iterationDuration + (isCurrentTimeEqualOrAboveDuration ? 0 : _loopDelay);
+	    const currentIteration = ~~(tickableCurrentTime / period);
 	    tickable._currentIteration = helpers.clamp(currentIteration, 0, iterationCount);
 	    // Prevent the iteration count to go above the max iterations when reaching the end of the animation
 	    if (isCurrentTimeEqualOrAboveDuration) tickable._currentIteration--;
 	    isOdd = tickable._currentIteration % 2;
-	    iterationElapsedTime = tickableCurrentTime % (iterationDuration + _loopDelay) || 0;
+	    // Derive elapsed from the same `~~` truncation that gave currentIteration. Using `% period` here can disagree with `~~(/period)` under float drift at iteration boundaries and write the wrong end of the tween for one frame.
+	    iterationElapsedTime = tickableCurrentTime - currentIteration * period || 0;
 	  }
 
 	  // Checks if exactly one of _reversed and (_alternate && isOdd) is true
@@ -1745,12 +1913,14 @@ function requireRender () {
 	  if (
 	    forcedTick ||
 	    tickMode === consts.tickModes.AUTO && (
-	      time >= tickableDelay && time <= tickableEndTime || // Normal render
+	      // Timeline children render from their offset instead of their delay so the gap left by a truncated sibling is covered on seek.
+	      time >= (parent && tickableDelay > 0 ? 0 : tickableDelay) && time <= tickableEndTime || // Normal render
 	      time <= tickableDelay && tickablePrevTime > tickableDelay || // Playhead is before the animation start time so make sure the animation is at its initial state
 	      time >= tickableEndTime && tickablePrevTime !== duration // Playhead is after the animation end time so make sure the animation is at its end state
 	    ) ||
 	    iterationTime >= tickableEndTime && tickablePrevTime !== duration ||
-	    iterationTime <= tickableDelay && tickablePrevTime > 0 ||
+	    // iterationTime is per-iteration, compared to the delay to catch a backward seek into a looped iteration's delay region. Exclude the final settled end, where iterationTime clamps to duration and would falsely match the delay region when the delay exceeds the duration.
+	    iterationTime <= tickableDelay && tickablePrevTime > 0 && !isCurrentTimeEqualOrAboveDuration ||
 	    time <= tickablePrevTime && tickablePrevTime === duration && completed || // Force a render if a seek occurs on an completed animation
 	    isCurrentTimeEqualOrAboveDuration && !completed && isSetter // This prevents 0 duration tickables to be skipped
 	  ) {
@@ -1766,7 +1936,8 @@ function requireRender () {
 
 	      // Time has jumped more than globals.tickThreshold so consider this tick manual
 	      const forcedRender = forcedTick || (isRunningBackwards ? deltaTime * -1 : deltaTime) >= globals.globals.tickThreshold;
-	      const absoluteTime = tickable._offset + (parent ? parent._offset : 0) + tickableDelay + iterationTime;
+	      // Round to match the precision of tween._absoluteStartTime so equal-time boundary checks compare cleanly without floating point drift from the unrounded _offset.
+	      const absoluteTime = helpers.round(tickable._offset + (parent ? parent._offset : 0) + tickableDelay + iterationTime, 12);
 
 	      // Only Animation can have tweens, Timer returns undefined
 	      let tween = /** @type {Tween} */(/** @type {JSAnimation} */(tickable)._head);
@@ -1785,15 +1956,38 @@ function requireRender () {
 	        const tweenNextRep = tween._nextRep;
 	        const tweenPrevRep = tween._prevRep;
 	        const tweenHasComposition = tweenComposition !== consts.compositionTypes.none;
+	        // The previous sibling stops writing at its truncated end, so this tween takes over the hold from that point.
+	        const tweenPrevRepEndTime = tweenPrevRep ? tweenPrevRep._absoluteStartTime + tweenPrevRep._changeDuration : 0;
+	        const tweenPrevRepIsCrossParent = tweenPrevRep && tweenPrevRep.parent !== tween.parent;
+	        // Same parent keyframes take over at their own start, end plus delay equals the next start by construction.
+	        // Cross parent siblings take over at their update start.
+	        // Negative delay siblings take over at their own start instead.
+	        const tweenNextRepTakeover = !tweenNextRep || tweenNextRep._isOverridden ? tweenAbsEndTime :
+	          tweenNextRep.parent === tween.parent ? tweenAbsEndTime + tweenNextRep._delay :
+	          tweenNextRep._absoluteStartTime < tweenNextRep._absoluteUpdateStartTime ? tweenNextRep._absoluteStartTime : tweenNextRep._absoluteUpdateStartTime;
 
 	        if ((forcedRender || (
-	            (tweenCurrentTime !== tweenChangeDuration || absoluteTime <= tweenAbsEndTime + (tweenNextRep ? tweenNextRep._delay : 0)) &&
-	            (tweenCurrentTime !== 0 || absoluteTime >= tween._absoluteStartTime)
-	          )) && (!tweenHasComposition || (
+	            // Tail keyframes always re-evaluate the gate so an earlier keyframe cannot leave the target stale by writing past its own range after a backward seek.
+	            (tweenCurrentTime !== tweenChangeDuration || absoluteTime <= tweenNextRepTakeover ||
+	            (tweenPrevRep && !tweenPrevRepIsCrossParent && (!tweenNextRep || tweenNextRep.parent !== tween.parent))) &&
+	            // A cross parent tween re-renders its from value from the previous sibling truncated end so the handoff gap holds.
+	            // A keyframe re-renders its from revert while the next keyframe time is stale so a backward jump over its range cannot leave the next value in place.
+	            (tweenCurrentTime !== 0 || absoluteTime >= tween._absoluteStartTime ||
+	            (tweenPrevRepIsCrossParent && !tween._hasFromValue && !tweenPrevRep._isOverridden && absoluteTime >= tweenPrevRepEndTime) ||
+	            (tweenNextRep && !tweenNextRep._isOverridden && tweenNextRep.parent === tween.parent && tweenNextRep._currentTime !== 0 && iterationTime < tweenNextRep._startTime))
+	          )) &&
+	          // Non-first keyframes wait until the iteration reaches their own start before rendering, so the previous keyframe can handle the from-revert when scrubbed backward past this tween's range.
+	          (!tweenPrevRep || tweenPrevRepIsCrossParent || iterationTime >= tween._startTime) &&
+	          (!tweenHasComposition || (
 	            !tween._isOverridden &&
 	            (!tween._isOverlapped || absoluteTime <= tweenAbsEndTime) &&
-	            (!tweenNextRep || (tweenNextRep._isOverridden || absoluteTime <= tweenNextRep._absoluteStartTime)) &&
-	            (!tweenPrevRep || (tweenPrevRep._isOverridden || (absoluteTime >= (tweenPrevRep._absoluteStartTime + tweenPrevRep._changeDuration) + tween._delay)))
+	            // The next sibling owns the value past its takeover point, so yielding there keeps writes single owner in both directions.
+	            (!tweenNextRep || tweenNextRep._isOverridden || absoluteTime <= tweenNextRepTakeover) &&
+	            // The previous sibling owns the value up to its truncated end.
+	            // Cross parent tweens take over the hold from that point, explicit from values wait for their own start.
+	            (!tweenPrevRep || (tweenPrevRep._isOverridden || (!tweenPrevRepIsCrossParent ?
+	              absoluteTime >= tweenPrevRepEndTime + tween._delay :
+	              absoluteTime >= tween._absoluteStartTime || (!tween._hasFromValue && absoluteTime >= tweenPrevRepEndTime))))
 	          ))
 	        ) {
 
@@ -1804,7 +1998,7 @@ function requireRender () {
 	          const tweenType = tween._tweenType;
 	          const tweenIsObject = tweenType === consts.tweenTypes.OBJECT;
 	          const tweenIsNumber = tweenValueType === consts.valueTypes.NUMBER;
-	          // Only round the in-between frames values if the final value is a string
+	          // Only round the in-between frames values if the final value is a string. Object targets consume raw numbers, so rounding is dead work there.
 	          const tweenPrecision = (tweenIsNumber && tweenIsObject) || tweenProgress === 0 || tweenProgress === 1 ? -1 : globals.globals.precision;
 
 	          // Recompose tween value
@@ -1820,7 +2014,22 @@ function requireRender () {
 	            number = /** @type {Number} */(tweenModifier(helpers.round(helpers.lerp(tween._fromNumber, tween._toNumber,  tweenProgress), tweenPrecision)));
 	            value = `${number}${tween._unit}`;
 	          } else if (tweenValueType === consts.valueTypes.COLOR) {
-	            value = values.composeColorValue(tween, tweenProgress, tweenPrecision);
+	            const ns = tween._numbers;
+	            const fn = tween._fromNumbers;
+	            const tn = tween._toNumbers;
+	            const omt = 1 - tweenProgress;
+	            const fr = fn[0], fg = fn[1], fb = fn[2];
+	            const tr = tn[0], tg = tn[1], tb = tn[2];
+	            // RGB channels lerp in pseudo-linear space (square inputs, sqrt result) to approximate gamma-correct blending.
+	            // See https://developer.nvidia.com/gpugems/gpugems3/part-iv-image-effects/chapter-24-importance-being-linear.
+	            ns[0] = /** @type {Number} */(tweenModifier(Math.sqrt(fr * fr * omt + tr * tr * tweenProgress)));
+	            ns[1] = /** @type {Number} */(tweenModifier(Math.sqrt(fg * fg * omt + tg * tg * tweenProgress)));
+	            ns[2] = /** @type {Number} */(tweenModifier(Math.sqrt(fb * fb * omt + tb * tb * tweenProgress)));
+	            ns[3] = /** @type {Number} */(tweenModifier(helpers.lerp(fn[3], tn[3], tweenProgress)));
+	            // The rgba string is built only for the dispatch path or the internalRender composition tick (setters handles the color comp)
+	            if (!tween._setter || internalRender) {
+	              value = `rgba(${helpers.round(ns[0], 0)},${helpers.round(ns[1], 0)},${helpers.round(ns[2], 0)},${ns[3]})`;
+	            }
 	          } else if (tweenValueType === consts.valueTypes.COMPLEX) {
 	            value = values.composeComplexValue(tween, tweenProgress, tweenPrecision);
 	          }
@@ -1835,7 +2044,9 @@ function requireRender () {
 	            const tweenProperty = tween.property;
 	            tweenTarget = tween.target;
 
-	            if (tweenIsObject) {
+	            if (tween._setter) {
+	              tween._setter(tweenTarget, number, tween);
+	            } else if (tweenIsObject) {
 	              tweenTarget[tweenProperty] = value;
 	            } else if (tweenType === consts.tweenTypes.ATTRIBUTE) {
 	              /** @type {DOMTarget} */(tweenTarget).setAttribute(tweenProperty, /** @type {String} */(value));
@@ -1863,6 +2074,9 @@ function requireRender () {
 	            tween._value = value;
 	          }
 
+	        } else if (tweenCurrentTime && tweenPrevRep && !tweenPrevRepIsCrossParent && iterationTime < tween._startTime) {
+	          // Mark the keyframe as reverted when the playhead moves before its start, the previous keyframe owns the from revert and writes it once.
+	          tween._currentTime = 0;
 	        }
 
 	        if (tweenTransformsNeedUpdate && tween._renderTransforms) {
@@ -1970,6 +2184,8 @@ function requireRender () {
 
 	    helpers.forEachChildren(tl, (/** @type {JSAnimation} */child) => {
 	      const childTime = helpers.round((tlChildrenTime - child._offset) * child._speed, 12); // Rounding is needed when using seconds
+	      // Skip past-end siblings on backward iteration so their progress=1 to-values don't render last and overwrite the active sibling's write. Compare against _delay + duration so children with a normalized delay are not skipped while still inside their active range.
+	      if (tlIsRunningBackwards && childTime > child._delay + child.duration) return;
 	      const childTickMode = child._fps < tl._fps ? child.requestTick(tlCildrenTickTime) : tickMode;
 	      tlChildrenHasRendered += render$1(child, childTime, muteCallbacks, internalRender, childTickMode);
 	      if (!child.completed && tlChildrenHaveCompleted) tlChildrenHaveCompleted = false;
@@ -2003,7 +2219,7 @@ var styles = {};
 
 /**
  * Anime.js - core - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -2017,6 +2233,7 @@ function requireStyles () {
 	var consts = /*@__PURE__*/ requireConsts();
 	var helpers = /*@__PURE__*/ requireHelpers$1();
 	var transforms = /*@__PURE__*/ requireTransforms();
+	var values = /*@__PURE__*/ requireValues();
 
 	/**
 	 * @import {
@@ -2083,7 +2300,20 @@ function requireStyles () {
 	      const tweenType = tween._tweenType;
 	      const originalInlinedValue = tween._inlineValue;
 	      const tweenHadNoInlineValue = helpers.isNil(originalInlinedValue) || originalInlinedValue === consts.emptyString;
-	      if (tweenType === consts.tweenTypes.OBJECT) {
+	      if (tween._setter) {
+	        if (!inlineStylesOnly && !tweenHadNoInlineValue) {
+	          // Re-seed the original value to the _number / _numbers props so the setter can write the original state instead of re-applying the current frame.
+	          values.decomposeRawValue(originalInlinedValue, values.decomposedOriginalValue);
+	          if (values.decomposedOriginalValue.d) {
+	            const src = values.decomposedOriginalValue.d;
+	            const dst = tween._numbers;
+	            for (let i = 0, l = src.length; i < l; i++) dst[i] = src[i];
+	          } else {
+	            tween._number = values.decomposedOriginalValue.n;
+	          }
+	          tween._setter(tween.target, tween._number, tween);
+	        }
+	      } else if (tweenType === consts.tweenTypes.OBJECT) {
 	        if (!inlineStylesOnly && !tweenHadNoInlineValue) {
 	          tweenTarget[tweenProperty] = originalInlinedValue;
 	        }
@@ -2151,7 +2381,7 @@ var clock = {};
 
 /**
  * Anime.js - core - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -2191,8 +2421,6 @@ function requireClock () {
 	    /** @type {Number} */
 	    this._lastTime = initTime;
 	    /** @type {Number} */
-	    this._scheduledTime = 0;
-	    /** @type {Number} */
 	    this._frameDuration = consts.K / consts.maxFps;
 	    /** @type {Number} */
 	    this._fps = consts.maxFps;
@@ -2211,14 +2439,12 @@ function requireClock () {
 	  }
 
 	  set fps(frameRate) {
-	    const previousFrameDuration = this._frameDuration;
 	    const fr = +frameRate;
 	    const fps = fr < consts.minValue ? consts.minValue : fr;
 	    const frameDuration = consts.K / fps;
 	    if (fps > globals.defaults.frameRate) globals.defaults.frameRate = fps;
 	    this._fps = fps;
 	    this._frameDuration = frameDuration;
-	    this._scheduledTime += frameDuration - previousFrameDuration;
 	  }
 
 	  get speed() {
@@ -2235,17 +2461,17 @@ function requireClock () {
 	   * @return {tickModes}
 	   */
 	  requestTick(time) {
-	    const scheduledTime = this._scheduledTime;
-	    this._lastTickTime = time;
-	    // If the current time is lower than the scheduled time
-	    // this means not enough time has passed to hit one frameDuration
-	    // so skip that frame
-	    if (time < scheduledTime) return consts.tickModes.NONE;
 	    const frameDuration = this._frameDuration;
-	    const frameDelta = time - scheduledTime;
-	    // Ensures that _scheduledTime progresses in steps of at least 1 frameDuration.
-	    // Skips ahead if the actual elapsed time is higher.
-	    this._scheduledTime += frameDelta < frameDuration ? frameDuration : frameDelta;
+	    const elapsed = time - this._lastTickTime;
+	    const scaled = frameDuration * .25;
+	    const tolerance = scaled < 4 ? scaled : 4;
+	    // Tolerance prevents dropping frames that arrive a bit early due to RAF jitter
+	    // typically <= ~25% of frame duration and capped at 4ms so it doesn't dominate at high fps.
+	    // e.g. at 60fps (frameDuration=16.667ms) a frame arriving after 15ms:
+	    // - without tolerance: 15 < 16.667 -> skip
+	    // - with tolerance: 15 + 4 >= 16.667 -> tick
+	    if (elapsed + tolerance < frameDuration) return consts.tickModes.NONE;
+	    this._lastTickTime = elapsed >= frameDuration ? time - (elapsed % frameDuration) : time;
 	    return consts.tickModes.AUTO;
 	  }
 
@@ -2270,7 +2496,7 @@ var additive = {};
 
 /**
  * Anime.js - animation - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -2359,7 +2585,7 @@ function requireAdditive () {
 
 /**
  * Anime.js - engine - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -2466,7 +2692,9 @@ function requireEngine () {
 	  }
 
 	  set speed(playbackRate) {
-	    this._speed = playbackRate * globals.globals.timeScale;
+	    const speed = playbackRate * globals.globals.timeScale;
+	    if (this._speed === speed) return;
+	    this._speed = speed;
 	    helpers.forEachChildren(this, (/** @type {Tickable} */child) => child.speed = child._speed);
 	  }
 
@@ -2534,7 +2762,7 @@ function requireEngine () {
 
 /**
  * Anime.js - animation - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -2636,7 +2864,7 @@ function requireComposition$1 () {
 	    if (prevSibling) {
 
 	      const prevParent = prevSibling.parent;
-	      const prevAbsEndTime = prevSibling._absoluteStartTime + prevSibling._changeDuration;
+	      const prevAbsEndTime = prevSibling._absoluteEndTime;
 
 	      // Handle looped animations tween
 
@@ -2662,7 +2890,8 @@ function requireComposition$1 () {
 
 	      }
 
-	      const absoluteUpdateStartTime = tweenAbsStartTime - tween._delay;
+	      // Read the precision-matched update-start instead of subtracting tween._delay live so sequential keyframes touching at a boundary don't trigger a phantom overlap from float drift.
+	      const absoluteUpdateStartTime = tween._absoluteUpdateStartTime;
 
 	      if (prevAbsEndTime > absoluteUpdateStartTime) {
 
@@ -2682,37 +2911,41 @@ function requireComposition$1 () {
 	        }
 	      }
 
-	      // Pause (and cancel) the parent if it only contains overlapped tweens
+	      // Skip the cancel cascade when both tweens share the same parent timeline, a timeline cannot replace itself.
+	      const tweenParentTL = tween.parent.parent;
+	      if (!tweenParentTL || tweenParentTL !== prevParent.parent) {
 
-	      let pausePrevParentAnimation = true;
+	        let pausePrevParentAnimation = true;
 
-	      helpers.forEachChildren(prevParent, (/** @type Tween */t) => {
-	        if (!t._isOverlapped) pausePrevParentAnimation = false;
-	      });
+	        helpers.forEachChildren(prevParent, (/** @type Tween */t) => {
+	          if (!t._isOverlapped) pausePrevParentAnimation = false;
+	        });
 
-	      if (pausePrevParentAnimation) {
-	        const prevParentTL = prevParent.parent;
-	        if (prevParentTL) {
-	          let pausePrevParentTL = true;
-	          helpers.forEachChildren(prevParentTL, (/** @type JSAnimation */a) => {
-	            if (a !== prevParent) {
-	              helpers.forEachChildren(a, (/** @type Tween */t) => {
-	                if (!t._isOverlapped) pausePrevParentTL = false;
-	              });
+	        if (pausePrevParentAnimation) {
+	          const prevParentTL = prevParent.parent;
+	          if (prevParentTL) {
+	            let pausePrevParentTL = true;
+	            helpers.forEachChildren(prevParentTL, (/** @type JSAnimation */a) => {
+	              if (a !== prevParent) {
+	                helpers.forEachChildren(a, (/** @type Tween */t) => {
+	                  if (!t._isOverlapped) pausePrevParentTL = false;
+	                });
+	              }
+	            });
+	            if (pausePrevParentTL) {
+	              prevParentTL.cancel();
 	            }
-	          });
-	          if (pausePrevParentTL) {
-	            prevParentTL.cancel();
+	          } else {
+	            prevParent.cancel();
+	            // Previously, calling .cancel() on a timeline child would affect the render order of other children
+	            // Worked around this by marking it as .completed and using .pause() for safe removal in the engine loop
+	            // This is no longer needed since timeline tween composition is now handled separately
+	            // Keeping this here for reference
+	            // prevParent.completed = true;
+	            // prevParent.pause();
 	          }
-	        } else {
-	          prevParent.cancel();
-	          // Previously, calling .cancel() on a timeline child would affect the render order of other children
-	          // Worked around this by marking it as .completed and using .pause() for safe removal in the engine loop
-	          // This is no longer needed since timeline tween composition is now handled separately
-	          // Keeping this here for reference
-	          // prevParent.completed = true;
-	          // prevParent.pause();
 	        }
+
 	      }
 
 	    }
@@ -2767,14 +3000,12 @@ function requireComposition$1 () {
 	    tween._number = 0;
 	    lookupTween._fromNumber = toNumber;
 
-	    if (tween._toNumbers) {
+	    if (tween._toNumbers.length) {
 	      const toNumbers = helpers.cloneArray(tween._toNumbers);
-	      if (toNumbers) {
-	        toNumbers.forEach((value, i) => {
-	          tween._fromNumbers[i] = lookupTween._fromNumbers[i] - value;
-	          tween._toNumbers[i] = 0;
-	        });
-	      }
+	      toNumbers.forEach((value, i) => {
+	        tween._fromNumbers[i] = lookupTween._fromNumbers[i] - value;
+	        tween._toNumbers[i] = 0;
+	      });
 	      lookupTween._fromNumbers = toNumbers;
 	    }
 
@@ -2924,7 +3155,7 @@ function requireComposition$1 () {
 
 /**
  * Anime.js - timer - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -3439,7 +3670,7 @@ var targets = {};
 
 /**
  * Anime.js - core - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -3556,18 +3787,16 @@ function requireTargets () {
 	function registerTargets(targets) {
 	  const parsedTargetsArray = parseTargets(targets);
 	  const parsedTargetsLength = parsedTargetsArray.length;
-	  if (parsedTargetsLength) {
-	    for (let i = 0; i < parsedTargetsLength; i++) {
-	      const target = parsedTargetsArray[i];
-	      if (!target[consts.isRegisteredTargetSymbol]) {
-	        target[consts.isRegisteredTargetSymbol] = true;
-	        const isSvgType = helpers.isSvg(target);
-	        const isDom = /** @type {DOMTarget} */(target).nodeType || isSvgType;
-	        if (isDom) {
-	          target[consts.isDomSymbol] = true;
-	          target[consts.isSvgSymbol] = isSvgType;
-	          target[consts.transformsSymbol] = {};
-	        }
+	  for (let i = 0; i < parsedTargetsLength; i++) {
+	    const target = parsedTargetsArray[i];
+	    if (!target[consts.isRegisteredTargetSymbol]) {
+	      target[consts.isRegisteredTargetSymbol] = true;
+	      const isSvgType = helpers.isSvg(target);
+	      const isDom = /** @type {DOMTarget} */(target).nodeType || isSvgType;
+	      if (isDom) {
+	        target[consts.isDomSymbol] = true;
+	        target[consts.isSvgSymbol] = isSvgType;
+	        target[consts.transformsSymbol] = {};
 	      }
 	    }
 	  }
@@ -3584,7 +3813,7 @@ var units = {};
 
 /**
  * Anime.js - core - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -3661,7 +3890,7 @@ var none = {};
 
 /**
  * Anime.js - easings - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -3687,7 +3916,7 @@ function requireNone () {
 
 /**
  * Anime.js - easings - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -3772,8 +4001,8 @@ function requireParser () {
 
 	/**
 	 * @typedef  {Object} EasesFunctions
-	 * @property {typeof none} linear
-	 * @property {typeof none} none
+	 * @property {EasingFunction} linear
+	 * @property {EasingFunction} none
 	 * @property {PowerEasing} in
 	 * @property {PowerEasing} out
 	 * @property {PowerEasing} inOut
@@ -3885,7 +4114,7 @@ function requireParser () {
 
 /**
  * Anime.js - animation - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -3900,6 +4129,7 @@ function requireAnimation () {
 	var helpers = /*@__PURE__*/ requireHelpers$1();
 	var globals = /*@__PURE__*/ requireGlobals();
 	var targets = /*@__PURE__*/ requireTargets();
+	var registry = requireRegistry();
 	var values = /*@__PURE__*/ requireValues();
 	var styles = /*@__PURE__*/ requireStyles();
 	var units = /*@__PURE__*/ requireUnits();
@@ -4121,6 +4351,7 @@ function requireAnimation () {
 	        if (helpers.isKey(p)) {
 
 	          const tweenType = values.getTweenType(target, p);
+	          const adapterProp = registry.resolveAdapterEntry(target, p);
 
 	          const propName = styles.sanitizePropertyName(p, target, tweenType);
 
@@ -4204,7 +4435,7 @@ function requireAnimation () {
 	            } else {
 	              tweenToValue = computedToValue;
 	            }
-	            const tweenFromValue = values.getFunctionValue(key.from, target, ti, tl, null, prevSiblingTween);
+	            const tweenFromValue = values.getFunctionValue(key.from, target, ti, tl, fromFunctionStore, prevSiblingTween);
 	            const easeToParse = key.ease || tEasing;
 
 	            const easeFunctionResult = values.getFunctionValue(easeToParse, target, ti, tl, null, prevSiblingTween);
@@ -4222,9 +4453,13 @@ function requireAnimation () {
 	            const hasToValue = !helpers.isUnd(tweenToValue);
 	            const isFromToArray = helpers.isArr(tweenToValue);
 	            const isFromToValue = isFromToArray || (hasFromvalue && hasToValue);
+	            // Capture the update-start in local time, the previous sibling's end for keyframes after the first, zero for the first keyframe. Used to derive a precision-matched _absoluteUpdateStartTime below.
+	            const tweenUpdateStartLocal = prevTween ? lastTweenChangeEndTime : 0;
 	            const tweenStartTime = prevTween ? lastTweenChangeEndTime + tweenDelay : tweenDelay;
 	            // Rounding is necessary here to minimize floating point errors when working in seconds
 	            const absoluteStartTime = helpers.round(absoluteOffsetTime + tweenStartTime, 12);
+	            // Match the rounding pattern of prevSibling._absoluteEndTime so the composition overlap check compares cleanly when keyframes touch at a boundary.
+	            const absoluteUpdateStartTime = helpers.round(absoluteOffsetTime + tweenUpdateStartLocal, 12);
 
 	            // Force a onRender callback if the animation contains at least one from value and autoplay is set to false
 	            if (!shouldTriggerRender && (hasFromvalue || isFromToArray)) shouldTriggerRender = 1;
@@ -4233,9 +4468,9 @@ function requireAnimation () {
 
 	            if (tweenComposition !== consts.compositionTypes.none) {
 	              let nextSibling = siblings._head;
-	              // Iterate trough all the next siblings until we find a sibling with an equal or inferior start time
-	              while (nextSibling && !nextSibling._isOverridden && nextSibling._absoluteStartTime <= absoluteStartTime) {
-	                prevSibling = nextSibling;
+	              // Walk prior siblings up to the new tween, skipping overridden ones so the chain resolves to the latest live value instead of stopping at the first override.
+	              while (nextSibling && nextSibling._absoluteStartTime <= absoluteStartTime) {
+	                if (!nextSibling._isOverridden) prevSibling = nextSibling;
 	                nextSibling = nextSibling._nextRep;
 	                // Overrides all the next siblings if the next sibling starts at the same time of after as the new tween start time
 	                if (nextSibling && nextSibling._absoluteStartTime >= absoluteStartTime) {
@@ -4289,8 +4524,8 @@ function requireAnimation () {
 	                if (prevTween) {
 	                  values.decomposeTweenValue(prevTween, fromTargetObject);
 	                } else {
-	                  values.decomposeRawValue(parent && prevSibling && prevSibling.parent.parent === parent ? prevSibling._value :
 	                  // No need to get and parse the original value if the tween is part of a timeline and has a previous sibling part of the same timeline
+	                  values.decomposeRawValue(parent && prevSibling && prevSibling.parent.parent === parent ? prevSibling._value :
 	                  values.getOriginalAnimatableValue(target, propName, tweenType, inlineStylesStore), fromTargetObject);
 	                }
 	              }
@@ -4329,8 +4564,7 @@ function requireAnimation () {
 	                const colorValue = fromTargetObject.t === consts.valueTypes.COLOR ? fromTargetObject : toTargetObject;
 	                const notColorValue = fromTargetObject.t === consts.valueTypes.COLOR ? toTargetObject : fromTargetObject;
 	                notColorValue.t = consts.valueTypes.COLOR;
-	                notColorValue.s = colorValue.s;
-	                notColorValue.d = [0, 0, 0, 1];
+	                notColorValue.d = colorValue.d.map(() => 0);
 	              }
 	            }
 
@@ -4360,6 +4594,16 @@ function requireAnimation () {
 	            let inlineValue = inlineStylesStore[propName];
 	            if (!helpers.isNil(inlineValue)) inlineStylesStore[propName] = null;
 
+	            // Resolve the adapter setter once so render skips the lookup per frame.
+	            const tweenSetter = adapterProp ? adapterProp.set : null;
+
+	            // Rounding is necessary here to minimize floating point errors when working in seconds
+	            lastTweenChangeEndTime = helpers.round(tweenStartTime + tweenUpdateDuration, 12);
+
+	            const fromD = fromTargetObject.d;
+	            const toD = toTargetObject.d;
+	            const toS = toTargetObject.s;
+
 	            /** @type {Tween} */
 	            const tween = {
 	              parent: this,
@@ -4370,12 +4614,12 @@ function requireAnimation () {
 	              _toFunc: toFunctionStore.func,
 	              _fromFunc: fromFunctionStore.func,
 	              _ease: parser.parseEase(tweenEasing),
-	              _fromNumbers: helpers.cloneArray(fromTargetObject.d),
-	              _toNumbers: helpers.cloneArray(toTargetObject.d),
-	              _strings: helpers.cloneArray(toTargetObject.s),
+	              _fromNumbers: fromD ? helpers.cloneArray(fromD) : consts.emptyArray,
+	              _toNumbers: toD ? helpers.cloneArray(toD) : consts.emptyArray,
+	              _strings: toS ? helpers.cloneArray(toS) : consts.emptyArray,
 	              _fromNumber: fromTargetObject.n,
 	              _toNumber: toTargetObject.n,
-	              _numbers: helpers.cloneArray(fromTargetObject.d), // For additive tween and animatables
+	              _numbers: fromD ? helpers.cloneArray(fromD) : consts.emptyArray, // For additive tween and animatables
 	              _number: fromTargetObject.n, // For additive tween and animatables
 	              _unit: toTargetObject.u,
 	              _modifier: tweenModifier,
@@ -4385,8 +4629,12 @@ function requireAnimation () {
 	              _updateDuration: tweenUpdateDuration,
 	              _changeDuration: tweenUpdateDuration,
 	              _absoluteStartTime: absoluteStartTime,
+	              _absoluteUpdateStartTime: absoluteUpdateStartTime,
+	              _absoluteEndTime: helpers.round(absoluteOffsetTime + lastTweenChangeEndTime, 12),
+	              _hasFromValue: hasFromvalue || isFromToArray ? 1 : 0,
 	              // NOTE: Investigate bit packing to stores ENUM / BOOL
 	              _tweenType: tweenType,
+	              _setter: tweenSetter,
 	              _valueType: toTargetObject.t,
 	              _composition: tweenComposition,
 	              _isOverlapped: 0,
@@ -4409,10 +4657,11 @@ function requireAnimation () {
 	            const vt = tween._valueType;
 	            if (vt === consts.valueTypes.COMPLEX) {
 	              tween._value = values.composeComplexValue(tween, 1, -1);
-	            } else if (vt === consts.valueTypes.COLOR) {
-	              tween._value = values.composeColorValue(tween, 1, -1);
 	            } else if (vt === consts.valueTypes.UNIT) {
 	              tween._value = `${tweenModifier(tween._toNumber)}${tween._unit}`;
+	            } else if (vt === consts.valueTypes.COLOR) {
+	              const d = toTargetObject.d;
+	              tween._value = `rgba(${helpers.round(d[0], 0)},${helpers.round(d[1], 0)},${helpers.round(d[2], 0)},${d[3]})`;
 	            } else {
 	              tween._value = tweenModifier(tween._toNumber);
 	            }
@@ -4420,8 +4669,7 @@ function requireAnimation () {
 	            if (isNaN(firstTweenChangeStartTime)) {
 	              firstTweenChangeStartTime = tween._startTime;
 	            }
-	            // Rounding is necessary here to minimize floating point errors when working in seconds
-	            lastTweenChangeEndTime = helpers.round(tweenStartTime + tweenUpdateDuration, 12);
+
 	            prevTween = tween;
 	            animationAnimationLength++;
 
@@ -4527,8 +4775,11 @@ function requireAnimation () {
 	      tween._updateDuration = helpers.normalizeTime(tween._updateDuration * timeScale);
 	      tween._changeDuration = helpers.normalizeTime(tween._changeDuration * timeScale);
 	      tween._currentTime *= timeScale;
+	      tween._delay *= timeScale;
 	      tween._startTime *= timeScale;
 	      tween._absoluteStartTime *= timeScale;
+	      tween._absoluteUpdateStartTime *= timeScale;
+	      tween._absoluteEndTime *= timeScale;
 	    });
 	    return super.stretch(newDuration);
 	  }
@@ -4615,7 +4866,7 @@ var position = {};
 
 /**
  * Anime.js - timeline - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -4694,7 +4945,7 @@ function requirePosition () {
 
 /**
  * Anime.js - timeline - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -4732,6 +4983,7 @@ function requireTimeline () {
 	 *   TimelinePosition,
 	 *   StaggerFunction,
 	 *   TargetsArray,
+	 *   TweakRegister,
 	 * } from '../types/index.js'
 	*/
 
@@ -4741,8 +4993,6 @@ function requireTimeline () {
 	 * } from '../waapi/waapi.js'
 	*/
 
-	/** @import {TweakRegister} from 'tweaks' */
-
 	/**
 	 * @param {Timeline} tl
 	 * @return {Number}
@@ -4935,13 +5185,21 @@ function requireTimeline () {
 	    if (!helpers.isUnd(synced) && !helpers.isUnd(/** @type {WAAPIAnimation} */(synced).persist)) {
 	      /** @type {WAAPIAnimation} */(synced).persist = true;
 	    }
-	    return this.add(synced, { currentTime: [0, duration], duration, delay: 0, ease: 'linear', playbackEase: 'linear' }, position);
+	    const editor = globals.globals.editor;
+	    const childHook = editor && editor.addTimelineChild;
+	    if (editor && editor.addTimelineSync) {
+	      position = editor.addTimelineSync(synced, position, this.id);
+	      editor.addTimelineChild = null; // Suppress the per-child hook for the internal .add, sync already registered.
+	    }
+	    const result = this.add(synced, { currentTime: [0, duration], duration, delay: 0, ease: 'linear', playbackEase: 'linear' }, position);
+	    if (editor) editor.addTimelineChild = childHook;
+	    return result;
 	  }
 
 	  /**
 	   * @param  {TargetsParam} targets
 	   * @param  {AnimationParams} parameters
-	   * @param  {TimelinePosition} [position]
+	   * @param  {TimelinePosition|StaggerFunction<Number|String>|TweakRegister} [position]
 	   * @return {this}
 	   */
 	  set(targets, parameters, position) {
@@ -4958,6 +5216,7 @@ function requireTimeline () {
 	   */
 	  call(callback, position) {
 	    if (helpers.isUnd(callback) || callback && !helpers.isFnc(callback)) return this;
+	    if (globals.globals.editor && globals.globals.editor.addTimelineCall) position = globals.globals.editor.addTimelineCall(callback, position, this.id);
 	    return this.add({ duration: 0, delay: 0, onComplete: () => callback(this) }, position);
 	  }
 
@@ -4969,6 +5228,7 @@ function requireTimeline () {
 	   */
 	  label(labelName, position$1) {
 	    if (helpers.isUnd(labelName) || labelName && !helpers.isStr(labelName)) return this;
+	    if (globals.globals.editor && globals.globals.editor.addTimelineLabel) position$1 = globals.globals.editor.addTimelineLabel(labelName, position$1, this.id);
 	    this.labels[labelName] = position.parseTimelinePosition(this, position$1);
 	    return this;
 	  }
@@ -5049,7 +5309,7 @@ var animatable = {};
 
 /**
  * Anime.js - animatable - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -5113,6 +5373,7 @@ function requireAnimatable () {
 	    const callbacksAnimationParams = { v: 1, autoplay: false };
 	    const properties = {};
 	    this.targets = [];
+	    /** @type {Record<String, JSAnimation>} */
 	    this.animations = {};
 	    /** @type {JSAnimation|null} */
 	    this.callbacks = null;
@@ -5210,7 +5471,7 @@ var number = {};
 
 /**
  * Anime.js - utils - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -5316,7 +5577,7 @@ var spring = {};
 
 /**
  * Anime.js - easings - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -5582,7 +5843,7 @@ var composition = {};
 
 /**
  * Anime.js - waapi - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -5684,7 +5945,7 @@ function requireComposition () {
 
 /**
  * Anime.js - utils - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -5781,6 +6042,9 @@ function requireTarget () {
 	 */
 	const set = (targets, parameters) => {
 	  if (helpers.isUnd(parameters)) return;
+	  if (globals.globals.editor && globals.globals.editor.addSet) {
+	    return globals.globals.editor.addSet(targets, parameters);
+	  }
 	  parameters.duration = consts.minValue;
 	  // Do not overrides currently active tweens by default
 	  parameters.composition = values.setValue(parameters.composition, consts.compositionTypes.none);
@@ -5821,7 +6085,7 @@ function requireTarget () {
 
 /**
  * Anime.js - draggable - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -7071,7 +7335,7 @@ var time = {};
 
 /**
  * Anime.js - utils - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -7103,13 +7367,14 @@ function requireTime () {
 	};
 
 	/**
-	 * @param  {(...args: any[]) => Tickable | ((...args: any[]) => void) | void} constructor
-	 * @return {(...args: any[]) => Tickable | ((...args: any[]) => void)}
+	 * @template {Tickable | ((...args: any[]) => void) | void} T
+	 * @param  {(...args: any[]) => T} constructor
+	 * @return {(...args: any[]) => T extends void ? () => void : T}
 	 */
 	const keepTime = constructor => {
 	  /** @type {Tickable} */
 	  let tracked;
-	  return (...args) => {
+	  return /** @type {(...args: any[]) => T extends void ? () => void : T} */(/** @type {*} */((...args) => {
 	    let currentIteration, currentIterationProgress, reversed, alternate, startTime;
 	    if (tracked) {
 	      currentIteration = tracked.currentIteration;
@@ -7127,7 +7392,7 @@ function requireTime () {
 	      /** @type {Tickable} */(tracked)._startTime = startTime;
 	    }
 	    return cleanup || consts.noop;
-	  }
+	  }));
 	};
 
 	time.keepTime = keepTime;
@@ -7137,7 +7402,7 @@ function requireTime () {
 
 /**
  * Anime.js - scope - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -7400,7 +7665,7 @@ var scroll = {};
 
 /**
  * Anime.js - events - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -7620,12 +7885,14 @@ function requireScroll () {
 
 	  refreshScrollObservers() {
 	    helpers.forEachChildren(this, (/** @type {ScrollObserver} */child) => {
+	      if (!child.ready) return;
 	      if (child._debug) {
 	        child.removeDebug();
 	      }
 	    });
 	    this.updateBounds();
 	    helpers.forEachChildren(this, (/** @type {ScrollObserver} */child) => {
+	      if (!child.ready) return;
 	      child.refresh();
 	      child.onResize(child);
 	      if (child._debug) {
@@ -8359,7 +8626,7 @@ var cubicBezier = {};
 
 /**
  * Anime.js - easings - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -8432,7 +8699,7 @@ var steps = {};
 
 /**
  * Anime.js - easings - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -8471,7 +8738,7 @@ var linear = {};
 
 /**
  * Anime.js - easings - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -8539,7 +8806,7 @@ var irregular = {};
 
 /**
  * Anime.js - easings - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -8587,7 +8854,7 @@ function requireIrregular () {
 
 /**
  * Anime.js - easings - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -8624,7 +8891,7 @@ var waapi = {};
 
 /**
  * Anime.js - waapi - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -9138,7 +9405,7 @@ function requireWaapi () {
 
 /**
  * Anime.js - layout - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -10745,7 +11012,7 @@ var chainable = {};
 
 /**
  * Anime.js - utils - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -10947,7 +11214,7 @@ var random = {};
 
 /**
  * Anime.js - utils - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -11014,11 +11281,12 @@ function requireRandom () {
 	 * Adapted from https://bost.ocks.org/mike/shuffle/
 	 *
 	 * @param  {Array} items - The array to shuffle (will be modified in-place)
+	 * @param  {RandomNumberGenerator} [rnd] - Optional RNG matching the random() signature (defaults to random)
 	 * @return {Array} The same array reference, now shuffled
 	 */
-	const shuffle = items => {
+	const shuffle = (items, rnd = random$1) => {
 	  let m = items.length, t, i;
-	  while (m) { i = random$1(0, --m); t = items[m]; items[m] = items[i]; items[i] = t; }
+	  while (m) { i = rnd(0, --m); t = items[m]; items[m] = items[i]; items[i] = t; }
 	  return items;
 	};
 
@@ -11033,7 +11301,7 @@ var stagger = {};
 
 /**
  * Anime.js - utils - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -11103,6 +11371,7 @@ function requireStagger () {
 	  let values$1 = [];
 	  let maxValue = 0;
 	  let cachedOffset;
+	  let jitterSamples = null;
 	  const from = params.from;
 	  const reversed = params.reversed;
 	  const ease = params.ease;
@@ -11124,27 +11393,42 @@ function requireStagger () {
 	  const val2 = isRange ? helpers.parseNumber(val[1]) : 0;
 	  const unitMatch = consts.unitsExecRgx.exec((isRange ? val[1] : val) + consts.emptyString);
 	  const start = params.start || 0 + (isRange ? val1 : 0);
+	  const seed = params.seed;
+	  const hasSeed = !helpers.isUnd(seed) && seed !== false;
+	  const rng = hasSeed ? random.createSeededRandom(seed === true ? 0 : /** @type {Number} */(seed)) : random.random;
+	  const jitter = params.jitter;
+	  const hasJitter = !helpers.isUnd(jitter);
+	  const jitterIsArr = helpers.isArr(jitter);
+	  const jitterStart = jitterIsArr ? /** @type {[Number,Number]} */(jitter)[0] : /** @type {Number} */(jitter) || 0;
+	  const jitterEnd = jitterIsArr ? /** @type {[Number,Number]} */(jitter)[1] : /** @type {Number} */(jitter) || 0;
 	  let fromIndex = fromFirst ? 0 : helpers.isNum(from) ? from : 0;
 	  return (target, i, t, _, tl) => {
 	    const [ registeredTarget ] = targets.registerTargets(target);
 	    const total = helpers.isUnd(customTotal) ? t.length : customTotal;
 	    const customIndex = !helpers.isUnd(useProp) ? helpers.isFnc(useProp) ? useProp(registeredTarget, i, total) : values.getOriginalAnimatableValue(registeredTarget, useProp) : false;
-	    const staggerIndex = helpers.isNum(customIndex) || helpers.isStr(customIndex) && helpers.isNum(+customIndex) ? +customIndex : i;
+	    const customIdx = helpers.isNum(customIndex) || helpers.isStr(customIndex) && helpers.isNum(+customIndex) ? +customIndex : i;
+	    // Fall back to the natural index when the resolved value lands outside [0, total) so values[staggerIndex] never reads undefined.
+	    const staggerIndex = customIdx >= 0 && customIdx < total ? customIdx : i;
 	    if (fromCenter) fromIndex = (total - 1) / 2;
 	    if (fromLast) fromIndex = total - 1;
 	    if (!values$1.length) {
 	      if (autoGrid) {
 	        let hasPositions = true;
+	        let has3D = false;
 	        let minPosX = Infinity;
 	        let minPosY = Infinity;
+	        let minPosZ = Infinity;
 	        let maxPosX = -Infinity;
 	        let maxPosY = -Infinity;
+	        let maxPosZ = -Infinity;
 	        const pxArr = [];
 	        const pyArr = [];
+	        const pzArr = [];
 	        for (let index = 0; index < total; index++) {
 	          const el = t[index];
 	          let px = 0;
 	          let py = 0;
+	          let pz = 0;
 	          let found = false;
 	          if (el && helpers.isFnc(el.getBoundingClientRect)) {
 	            const rect = el.getBoundingClientRect();
@@ -11156,6 +11440,10 @@ function requireStagger () {
 	            if (obj && helpers.isNum(obj.x) && helpers.isNum(obj.y)) {
 	              px = obj.x;
 	              py = obj.y;
+	              if (helpers.isNum(obj.z)) {
+	                pz = obj.z;
+	                has3D = true;
+	              }
 	              found = true;
 	            }
 	          }
@@ -11165,42 +11453,52 @@ function requireStagger () {
 	          }
 	          pxArr.push(px);
 	          pyArr.push(py);
+	          pzArr.push(pz);
 	          if (px < minPosX) minPosX = px;
 	          if (py < minPosY) minPosY = py;
+	          if (pz < minPosZ) minPosZ = pz;
 	          if (px > maxPosX) maxPosX = px;
 	          if (py > maxPosY) maxPosY = py;
+	          if (pz > maxPosZ) maxPosZ = pz;
 	        }
 	        if (hasPositions) {
 	          let fX = pxArr[0];
 	          let fY = pyArr[0];
+	          let fZ = pzArr[0];
 	          if (fromArr) {
 	            fX = minPosX + from[0] * (maxPosX - minPosX);
 	            fY = minPosY + from[1] * (maxPosY - minPosY);
+	            fZ = has3D ? minPosZ + (from.length >= 3 ? from[2] : 0.5) * (maxPosZ - minPosZ) : 0;
 	          } else if (fromCenter) {
 	            fX = (minPosX + maxPosX) / 2;
 	            fY = (minPosY + maxPosY) / 2;
+	            fZ = (minPosZ + maxPosZ) / 2;
 	          } else if (fromLast) {
 	            fX = pxArr[total - 1];
 	            fY = pyArr[total - 1];
+	            fZ = pzArr[total - 1];
 	          } else if (helpers.isNum(from)) {
 	            fX = pxArr[from];
 	            fY = pyArr[from];
+	            fZ = pzArr[from];
 	          }
 	          for (let index = 0; index < total; index++) {
 	            const distanceX = fX - pxArr[index];
 	            const distanceY = fY - pyArr[index];
-	            let value = helpers.sqrt(distanceX * distanceX + distanceY * distanceY);
+	            const distanceZ = fZ - pzArr[index];
+	            let value = helpers.sqrt(distanceX * distanceX + distanceY * distanceY + (has3D ? distanceZ * distanceZ : 0));
 	            if (axis === 'x') value = -distanceX;
 	            if (axis === 'y') value = -distanceY;
+	            if (axis === 'z') value = -distanceZ;
 	            values$1.push(value);
 	          }
 	          let minDist = Infinity;
-	          for (let index = 0, l = values$1.length; index < l; index++) {
+	          for (let index = 0; index < total; index++) {
 	            const absVal = helpers.abs(values$1[index]);
 	            if (absVal > 0 && absVal < minDist) minDist = absVal;
 	          }
 	          if (minDist > 0 && minDist < Infinity) {
-	            for (let index = 0, l = values$1.length; index < l; index++) {
+	            for (let index = 0; index < total; index++) {
 	              values$1[index] = values$1[index] / minDist;
 	            }
 	          }
@@ -11214,32 +11512,51 @@ function requireStagger () {
 	          if (!grid) {
 	            values$1.push(helpers.abs(fromIndex - index));
 	          } else {
-	            let fromX, fromY;
+	            const dims = grid.length;
+	            const wh = grid[0] * grid[1];
+	            let fromX, fromY, fromZ;
 	            if (fromArr) {
 	              fromX = from[0] * (grid[0] - 1);
 	              fromY = from[1] * (grid[1] - 1);
+	              fromZ = dims === 3 ? (from.length >= 3 ? from[2] : 0.5) * (grid[2] - 1) : 0;
 	            } else if (fromCenter) {
 	              fromX = (grid[0] - 1) / 2;
 	              fromY = (grid[1] - 1) / 2;
+	              fromZ = dims === 3 ? (grid[2] - 1) / 2 : 0;
 	            } else {
 	              fromX = fromIndex % grid[0];
-	              fromY = helpers.floor(fromIndex / grid[0]);
+	              fromY = helpers.floor(fromIndex / grid[0]) % grid[1];
+	              fromZ = dims === 3 ? helpers.floor(fromIndex / wh) : 0;
 	            }
 	            const toX = index % grid[0];
-	            const toY = helpers.floor(index / grid[0]);
+	            const toY = helpers.floor(index / grid[0]) % grid[1];
+	            const toZ = dims === 3 ? helpers.floor(index / wh) : 0;
 	            const distanceX = fromX - toX;
 	            const distanceY = fromY - toY;
-	            let value = helpers.sqrt(distanceX * distanceX + distanceY * distanceY);
+	            const distanceZ = fromZ - toZ;
+	            let value = helpers.sqrt(distanceX * distanceX + distanceY * distanceY + (dims === 3 ? distanceZ * distanceZ : 0));
 	            if (axis === 'x') value = -distanceX;
 	            if (axis === 'y') value = -distanceY;
+	            if (axis === 'z') value = -distanceZ;
 	            values$1.push(value);
 	          }
 	        }
 	      }
-	      maxValue = helpers.max(...values$1);
-	      if (staggerEase) values$1 = values$1.map(val => staggerEase(val / maxValue) * maxValue);
-	      if (reversed) values$1 = values$1.map(val => axis ? (val < 0) ? val * -1 : -val : helpers.abs(maxValue - val));
-	      if (fromRandom) values$1 = random.shuffle(values$1);
+	      maxValue = values$1[0];
+	      for (let k = 1; k < total; k++) if (values$1[k] > maxValue) maxValue = values$1[k];
+	      if (staggerEase || reversed) {
+	        for (let k = 0; k < total; k++) {
+	          let v = values$1[k];
+	          if (staggerEase) v = staggerEase(v / maxValue) * maxValue;
+	          if (reversed) v = axis ? -v : helpers.abs(maxValue - v);
+	          values$1[k] = v;
+	        }
+	      }
+	      if (hasJitter) {
+	        jitterSamples = new Array(total);
+	        for (let k = 0; k < total; k++) jitterSamples[k] = rng(-1, 1, 4);
+	      }
+	      if (fromRandom) values$1 = random.shuffle(values$1, rng);
 	    }
 	    const spacing = isRange ? (val2 - val1) / maxValue : val1;
 	    if (helpers.isUnd(cachedOffset)) {
@@ -11247,6 +11564,11 @@ function requireStagger () {
 	    }
 	    /** @type {String|Number} */
 	    let output = cachedOffset + ((spacing * helpers.round(values$1[staggerIndex], 2)) || 0);
+	    if (hasJitter) {
+	      const progress = maxValue ? values$1[staggerIndex] / maxValue : 0;
+	      const mag = jitterStart + (jitterEnd - jitterStart) * progress;
+	      output = /** @type {Number} */(output) + jitterSamples[staggerIndex] * mag;
+	    }
 	    if (params.modifier) output = params.modifier(/** @type {Number} */(output));
 	    if (unitMatch) output = `${output}${unitMatch[2]}`;
 	    return output;
@@ -11259,7 +11581,7 @@ function requireStagger () {
 
 /**
  * Anime.js - utils - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -11319,7 +11641,7 @@ var helpers = {};
 
 /**
  * Anime.js - svg - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -11356,7 +11678,7 @@ function requireHelpers () {
 
 /**
  * Anime.js - svg - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -11455,7 +11777,7 @@ var drawable = {};
 
 /**
  * Anime.js - svg - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -11583,7 +11905,7 @@ var morphto = {};
 
 /**
  * Anime.js - svg - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -11655,7 +11977,7 @@ function requireMorphto () {
 
 /**
  * Anime.js - svg - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -11684,7 +12006,7 @@ var split = {};
 
 /**
  * Anime.js - text - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -11806,6 +12128,7 @@ function requireSplit () {
 	 */
 	const generateTemplate = (type, params = {}) => {
 	  let template = ``;
+	  if (!params) params = {};
 	  const classString = helpers.isStr(params.class) ? ` class="${params.class}"` : '';
 	  const cloneType = values.setValue(params.clone, false);
 	  const wrapType = values.setValue(params.wrap, false);
@@ -12195,7 +12518,7 @@ var scramble = {};
 
 /**
  * Anime.js - text - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -12219,6 +12542,16 @@ function requireScramble () {
 	 * } from '../types/index.js'
 	*/
 
+	/**
+	 * @typedef {Object} ScrambleTextTween
+	 * @property {Number} from
+	 * @property {Number} to
+	 * @property {Number} duration
+	 * @property {Number} delay
+	 * @property {String} ease
+	 * @property {(v: Number) => String} modifier
+	 */
+
 	/**
 	 * '-' is the range operator; place it at the start or end of the string to use it as a literal (e.g. '-abc' or 'abc-')
 	 * @param {String} str
@@ -12256,7 +12589,7 @@ function requireScramble () {
 	 * progressively revealing the original text.
 	 *
 	 * @param {ScrambleTextParams} [params]
-	 * @return {FunctionValue}
+	 * @return {FunctionValue<ScrambleTextTween>}
 	 */
 	const scrambleText = (params = {}) => {
 	  if (!params) params = {};
@@ -12474,7 +12807,7 @@ function requireScramble () {
 
 /**
  * Anime.js - text - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -12499,7 +12832,7 @@ function requireText () {
 
 /**
  * Anime.js - CJS
- * @version v4.4.1
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */