animejs 4.4.0 → 4.5.0

package/dist/modules/adapters/three/object3d.js

@@ -0,0 +1,212 @@
+/**
+ * Anime.js - adapters - ESM
+ * @version v4.5.0
+ * @license MIT
+ * @copyright 2026 - Julian Garnier
+ */
+
+import { Object3D, Color, SRGBColorSpace } from 'three';
+import { radToDeg, degToRad } from '../../utils/number.js';
+import { threeAdapter } from './adapter.js';
+import { readScalar, PATH_DIRECT, writeScalar, readColorAt, writeColorAt, readColorHex, COLOR_NORM, applySkewOrigin } from './helpers.js';
+
+/**
+ * `Object3D` adapter. Maps flat properties (position, rotation, scale, opacity, color, visible, light / audio / camera specifics) onto the matching three.js fields, and auto-detects material props (direct / uniform / TSL `UniformNode`) on the target's `material` at tween creation.
+ */
+
+
+const colorTarget = (t) => t.isLight ? t : t.material;
+
+// Per-mesh skew and transformOrigin state, stored under a private symbol so we add one hidden property instead of polluting the Object3D surface with seven underscored fields.
+const skewSymbol = Symbol('animejs.skewOrigin');
+
+// Fallback opacity storage for Object3D targets without a material such as Groups or CSS2DObjects.
+// Without it reads always return the default 1, so reverse-direction tweens between two non-default values collapse to a no-op delta and the visibility flip never fires on the way back.
+const opacitySymbol = Symbol('animejs.opacity');
+
+/**
+ * Sets `o.visible` based on opacity and current scale. If `opacity` is omitted, reads it from `o.material` (defaults to `1` when no material is present).
+ *
+ * @param {Object3D & { material?: import('three').Material | import('three').Material[] }} o
+ * @param {number} [opacity]
+ */
+function setVisibility(o, opacity) {
+  if (opacity === undefined) {
+    if (o.material) {
+      opacity = readScalar(o.material, 'opacity', PATH_DIRECT, 1);
+    } else {
+      const v = o[opacitySymbol];
+      opacity = v === undefined ? 1 : v;
+    }
+  }
+  const s = o.scale;
+  o.visible = !!(opacity && s.x && s.y && s.z);
+}
+
+/**
+ * Installs a per-mesh `updateMatrix` override on first skew / transformOrigin write. The override calls the original three.js compose, then patches the result with `applySkewOrigin` whenever any axis is non-zero. Idempotent.
+ *
+ * @param {any} mesh
+ * @return {{ skewX: number, skewY: number, skewZ: number, originX: number, originY: number, originZ: number }}
+ */
+function installSkewMatrix(mesh) {
+  let s = mesh[skewSymbol];
+  if (s) return s;
+  s = mesh[skewSymbol] = { skewX: 0, skewY: 0, skewZ: 0, originX: 0, originY: 0, originZ: 0 };
+  const original = mesh.updateMatrix;
+  mesh.updateMatrix = function () {
+    original.call(this);
+    const st = this[skewSymbol];
+    if (st.skewX !== 0 || st.skewY !== 0 || st.skewZ !== 0 || st.originX !== 0 || st.originY !== 0 || st.originZ !== 0) {
+      applySkewOrigin(this.matrix.elements, st.skewX, st.skewY, st.skewZ, st.originX, st.originY, st.originZ);
+    }
+  };
+  return s;
+}
+
+const threeObject3D = threeAdapter.registerTargetAdapter((t) => t instanceof Object3D);
+
+// Position
+threeObject3D.registerProperty('x', (t) => t.position.x, (t, v) => { t.position.x = v; });
+threeObject3D.registerProperty('y', (t) => t.position.y, (t, v) => { t.position.y = v; });
+threeObject3D.registerProperty('z', (t) => t.position.z, (t, v) => { t.position.z = v; });
+
+// Rotation in degrees
+threeObject3D.registerProperty('rotateX', (t) => radToDeg(t.rotation.x), (t, v) => { t.rotation.x = degToRad(v); });
+threeObject3D.registerProperty('rotateY', (t) => radToDeg(t.rotation.y), (t, v) => { t.rotation.y = degToRad(v); });
+threeObject3D.registerProperty('rotateZ', (t) => radToDeg(t.rotation.z), (t, v) => { t.rotation.z = degToRad(v); });
+
+// Scale per-axis and uniform
+threeObject3D.registerProperty('scaleX', (t) => t.scale.x, (t, v) => { t.scale.x = v; setVisibility(t); });
+threeObject3D.registerProperty('scaleY', (t) => t.scale.y, (t, v) => { t.scale.y = v; setVisibility(t); });
+threeObject3D.registerProperty('scaleZ', (t) => t.scale.z, (t, v) => { t.scale.z = v; setVisibility(t); });
+threeObject3D.registerProperty('scale',
+  (t) => t.scale.x,
+  (t, v) => {
+    t.scale.x = v; t.scale.y = v; t.scale.z = v;
+    setVisibility(t);
+  },
+);
+
+// Material
+threeObject3D.registerProperty('visible', (t) => t.visible, (t, v) => { t.visible = !!v; });
+threeObject3D.registerProperty('opacity',
+  (t) => {
+    if (t.material) return readScalar(t.material, 'opacity', PATH_DIRECT, 1);
+    const v = t[opacitySymbol];
+    return v === undefined ? 1 : v;
+  },
+  (t, v) => {
+    if (t.material) writeScalar(t.material, 'opacity', v, PATH_DIRECT);
+    else t[opacitySymbol] = v;
+    setVisibility(t, v);
+  },
+  (t) => !t.isLight,
+);
+threeObject3D.registerProperty('color',
+  (t) => readColorAt(colorTarget(t), 'color', PATH_DIRECT),
+  (t, _, tw) => writeColorAt(colorTarget(t), 'color', tw._numbers, PATH_DIRECT),
+);
+
+// HemisphereLight
+threeObject3D.registerProperty('groundColor',
+  (t) => readColorAt(t, 'groundColor', PATH_DIRECT),
+  (t, _, tw) => writeColorAt(t, 'groundColor', tw._numbers, PATH_DIRECT),
+  (t) => !!t.groundColor,
+);
+
+// Scene background, lazily initializes scene background to a Color on first write so the user does not have to set one upfront.
+threeObject3D.registerProperty('background',
+  (t) => {
+    const bg = /** @type {any} */(t).background;
+    return bg && bg.isColor ? readColorHex(bg) : '#000000';
+  },
+  (t, _, tw) => {
+    const scene = /** @type {any} */(t);
+    let bg = scene.background;
+    if (!bg || !bg.isColor) {
+      bg = new Color();
+      scene.background = bg;
+    }
+    const ns = tw._numbers;
+    bg.setRGB(ns[0] * COLOR_NORM, ns[1] * COLOR_NORM, ns[2] * COLOR_NORM, SRGBColorSpace);
+  },
+  (t) => !!t.isScene,
+);
+
+// Method-bridged props for Audio and PerspectiveCamera focalLength, read via getXxx and write via setXxx.
+const registerMethodProp = (apiName, getter, setter, gate) => {
+  threeObject3D.registerProperty(apiName,
+    (t) => t[getter](),
+    (t, v) => { t[setter](v); },
+    (t) => !!t[gate],
+  );
+};
+registerMethodProp('volume', 'getVolume', 'setVolume', 'setVolume');
+// PositionalAudio
+registerMethodProp('refDistance', 'getRefDistance', 'setRefDistance', 'setRefDistance');
+registerMethodProp('rolloffFactor', 'getRolloffFactor', 'setRolloffFactor', 'setRefDistance');
+registerMethodProp('maxDistance', 'getMaxDistance', 'setMaxDistance', 'setRefDistance');
+// PerspectiveCamera
+registerMethodProp('focalLength', 'getFocalLength', 'setFocalLength', 'setFocalLength');
+
+// Camera projection-update props, setter writes the value then calls updateProjectionMatrix.
+const registerCameraProp = (apiName, gate) => {
+  threeObject3D.registerProperty(apiName,
+    (t) => t[apiName],
+    (t, v) => { t[apiName] = v; t.updateProjectionMatrix(); },
+    gate,
+  );
+};
+const isPersp = (t) => !!t.isPerspectiveCamera;
+const isOrtho = (t) => !!t.isOrthographicCamera;
+registerCameraProp('fov', isPersp);
+registerCameraProp('aspect', isPersp);
+registerCameraProp('left', isOrtho);
+registerCameraProp('right', isOrtho);
+registerCameraProp('top', isOrtho);
+registerCameraProp('bottom', isOrtho);
+
+// Skew in degrees and transform-origin in object-space.
+// Patches mesh updateMatrix on first write so the standard PRS compose is followed by an in-place skew and origin shift.
+// Reads default to 0 for meshes that have never been written.
+/**
+ * @param {String} apiName
+ * @param {String} key
+ */
+const registerSkewProp = (apiName, key) => {
+  threeObject3D.registerProperty(apiName,
+    (t) => { const s = /** @type {any} */(t)[skewSymbol]; return s ? s[key] : 0; },
+    (t, v) => { installSkewMatrix(t)[key] = v; },
+  );
+};
+registerSkewProp('skewX', 'skewX');
+registerSkewProp('skewY', 'skewY');
+registerSkewProp('skewZ', 'skewZ');
+registerSkewProp('transformOriginX', 'originX');
+registerSkewProp('transformOriginY', 'originY');
+registerSkewProp('transformOriginZ', 'originZ');
+
+// Shorthand 3-token string x y z or 2-string from-to array routed via the engine COMPLEX path.
+// The setter reads tween _numbers for the per-frame lerped triplet.
+threeObject3D.registerProperty('transformOrigin',
+  (t) => {
+    const s = /** @type {any} */(t)[skewSymbol];
+    return s ? `${s.originX} ${s.originY} ${s.originZ}` : '0 0 0';
+  },
+  (t, _, tw) => {
+    const s = installSkewMatrix(t);
+    const ns = tw._numbers;
+    s.originX = ns[0];
+    s.originY = ns[1];
+    s.originZ = ns[2];
+  },
+);
+
+// Shared by both camera types.
+const isCamera = (t) => !!t.isPerspectiveCamera || !!t.isOrthographicCamera;
+registerCameraProp('near', isCamera);
+registerCameraProp('far', isCamera);
+registerCameraProp('zoom', isCamera);
+
+// Auto-detection for material props on meshes and direct Vector / Color fields on the target is provided by the shared resolvers in resolvers.js.

package/dist/modules/adapters/three/resolvers.cjs

@@ -0,0 +1,105 @@
+/**
+ * Anime.js - adapters - CJS
+ * @version v4.5.0
+ * @license MIT
+ * @copyright 2026 - Julian Garnier
+ */
+
+'use strict';
+
+var adapter = require('./adapter.cjs');
+var number = require('../../utils/number.cjs');
+var helpers = require('./helpers.cjs');
+
+/**
+ * Global property resolvers for three.js targets. Auto-detect `Color`-typed properties, `Vector2/3/4` axis components, shader uniforms, and TSL `UniformNode` slots on any three.js object. For mesh-like targets, a second resolver walks to `target.material` and runs the same detection there.
+ */
+
+
+const identity = (t) => t;
+const getMaterial = (t) => t.material;
+
+const directColorCache = [{}, {}, {}];
+const directScalarCache = [{}, {}, {}];
+const directVectorCache = [{}, {}, {}];
+
+const materialColorCache = [{}, {}, {}];
+const materialScalarCache = [{}, {}, {}];
+const materialVectorCache = [{}, {}, {}];
+
+const buildEntry = (name, d, getHost, colorCaches, scalarCaches, vectorCaches) => {
+  const path = d.path;
+  if (d.kind === helpers.KIND_COLOR) {
+    const cache = colorCaches[path];
+    return cache[name] || (cache[name] = {
+      get: (t) => helpers.readColorAt(getHost(t), name, path),
+      set: (t, _, tw) => helpers.writeColorAt(getHost(t), name, tw._numbers, path),
+    });
+  }
+  if (d.kind === helpers.KIND_SCALAR) {
+    const cache = scalarCaches[path];
+    return cache[name] || (cache[name] = {
+      get: (t) => helpers.readScalar(getHost(t), name, path),
+      set: (t, v) => helpers.writeScalar(getHost(t), name, v, path),
+    });
+  }
+  // KIND_VECTOR
+  const base = d.base;
+  const axis = d.axis;
+  const cache = vectorCaches[path];
+  return cache[name] || (cache[name] = {
+    get: (t) => helpers.readVectorAt(getHost(t), base, axis, path),
+    set: (t, v) => helpers.writeVectorAt(getHost(t), base, axis, v, path),
+  });
+};
+
+// Detect direct Color, Vector axis, uniforms, and UniformNode slots on the target.
+// Numeric or boolean direct fields fall through to the engine OBJECT path.
+adapter.threeAdapter.registerPropertyResolver((target, name) => {
+  const d = helpers.classifyTargetProp(target, name);
+  if (!d) return null;
+  if (d.kind === helpers.KIND_SCALAR && d.path === helpers.PATH_DIRECT) return null;
+  return buildEntry(name, d, identity, directColorCache, directScalarCache, directVectorCache);
+});
+
+// Walk to target.material for meshes and other Object3D subclasses with a material field.
+// Skip when the target already exposes the name directly so a mesh-level mapping wins.
+adapter.threeAdapter.registerPropertyResolver((target, name) => {
+  if (target[name] !== undefined) return null;
+  const m = target.material;
+  if (!m) return null;
+  const first = Array.isArray(m) ? m[0] : m;
+  if (!first) return null;
+  const d = helpers.classifyTargetProp(first, name);
+  if (!d) return null;
+  return buildEntry(name, d, getMaterial, materialColorCache, materialScalarCache, materialVectorCache);
+});
+
+// Convert angle-named scalar fields between degrees and radians so users animate in degrees on any three.js target.
+// Object3D Euler rotation is excluded because Euler is not a number, the rotateX/Y/Z mappings handle it.
+const ANGLE_NAMES = { rotation: 1, angle: 1 };
+const angleEntries = {};
+adapter.threeAdapter.registerPropertyResolver((target, name) => {
+  if (!ANGLE_NAMES[name]) return null;
+  if (typeof target[name] !== 'number') return null;
+  return angleEntries[name] || (angleEntries[name] = {
+    get: (t) => number.radToDeg(t[name]),
+    set: (t, v) => { t[name] = number.degToRad(v); },
+  });
+});
+
+// Decompose Euler-typed angle fields to axis components in degrees, like rotationX, rotationY, rotationZ when rotation is an Euler.
+// Object3D mappings win because static adapter props beat resolvers, so this only catches non-Object3D targets with an Euler rotation field.
+const eulerAxisEntries = {};
+adapter.threeAdapter.registerPropertyResolver((target, name) => {
+  const axis = helpers.AXIS_MAP[name[name.length - 1]];
+  if (!axis) return null;
+  const base = name.slice(0, -1);
+  if (!ANGLE_NAMES[base]) return null;
+  const v = target[base];
+  if (!v || !v.isEuler) return null;
+  return eulerAxisEntries[name] || (eulerAxisEntries[name] = {
+    get: (t) => number.radToDeg(t[base][axis]),
+    set: (t, v) => { t[base][axis] = number.degToRad(v); },
+  });
+});

package/dist/modules/adapters/three/resolvers.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/modules/adapters/three/resolvers.js

@@ -0,0 +1,103 @@
+/**
+ * Anime.js - adapters - ESM
+ * @version v4.5.0
+ * @license MIT
+ * @copyright 2026 - Julian Garnier
+ */
+
+import { threeAdapter } from './adapter.js';
+import { radToDeg, degToRad } from '../../utils/number.js';
+import { classifyTargetProp, KIND_SCALAR, PATH_DIRECT, AXIS_MAP, KIND_COLOR, writeColorAt, readColorAt, writeScalar, readScalar, writeVectorAt, readVectorAt } from './helpers.js';
+
+/**
+ * Global property resolvers for three.js targets. Auto-detect `Color`-typed properties, `Vector2/3/4` axis components, shader uniforms, and TSL `UniformNode` slots on any three.js object. For mesh-like targets, a second resolver walks to `target.material` and runs the same detection there.
+ */
+
+
+const identity = (t) => t;
+const getMaterial = (t) => t.material;
+
+const directColorCache = [{}, {}, {}];
+const directScalarCache = [{}, {}, {}];
+const directVectorCache = [{}, {}, {}];
+
+const materialColorCache = [{}, {}, {}];
+const materialScalarCache = [{}, {}, {}];
+const materialVectorCache = [{}, {}, {}];
+
+const buildEntry = (name, d, getHost, colorCaches, scalarCaches, vectorCaches) => {
+  const path = d.path;
+  if (d.kind === KIND_COLOR) {
+    const cache = colorCaches[path];
+    return cache[name] || (cache[name] = {
+      get: (t) => readColorAt(getHost(t), name, path),
+      set: (t, _, tw) => writeColorAt(getHost(t), name, tw._numbers, path),
+    });
+  }
+  if (d.kind === KIND_SCALAR) {
+    const cache = scalarCaches[path];
+    return cache[name] || (cache[name] = {
+      get: (t) => readScalar(getHost(t), name, path),
+      set: (t, v) => writeScalar(getHost(t), name, v, path),
+    });
+  }
+  // KIND_VECTOR
+  const base = d.base;
+  const axis = d.axis;
+  const cache = vectorCaches[path];
+  return cache[name] || (cache[name] = {
+    get: (t) => readVectorAt(getHost(t), base, axis, path),
+    set: (t, v) => writeVectorAt(getHost(t), base, axis, v, path),
+  });
+};
+
+// Detect direct Color, Vector axis, uniforms, and UniformNode slots on the target.
+// Numeric or boolean direct fields fall through to the engine OBJECT path.
+threeAdapter.registerPropertyResolver((target, name) => {
+  const d = classifyTargetProp(target, name);
+  if (!d) return null;
+  if (d.kind === KIND_SCALAR && d.path === PATH_DIRECT) return null;
+  return buildEntry(name, d, identity, directColorCache, directScalarCache, directVectorCache);
+});
+
+// Walk to target.material for meshes and other Object3D subclasses with a material field.
+// Skip when the target already exposes the name directly so a mesh-level mapping wins.
+threeAdapter.registerPropertyResolver((target, name) => {
+  if (target[name] !== undefined) return null;
+  const m = target.material;
+  if (!m) return null;
+  const first = Array.isArray(m) ? m[0] : m;
+  if (!first) return null;
+  const d = classifyTargetProp(first, name);
+  if (!d) return null;
+  return buildEntry(name, d, getMaterial, materialColorCache, materialScalarCache, materialVectorCache);
+});
+
+// Convert angle-named scalar fields between degrees and radians so users animate in degrees on any three.js target.
+// Object3D Euler rotation is excluded because Euler is not a number, the rotateX/Y/Z mappings handle it.
+const ANGLE_NAMES = { rotation: 1, angle: 1 };
+const angleEntries = {};
+threeAdapter.registerPropertyResolver((target, name) => {
+  if (!ANGLE_NAMES[name]) return null;
+  if (typeof target[name] !== 'number') return null;
+  return angleEntries[name] || (angleEntries[name] = {
+    get: (t) => radToDeg(t[name]),
+    set: (t, v) => { t[name] = degToRad(v); },
+  });
+});
+
+// Decompose Euler-typed angle fields to axis components in degrees, like rotationX, rotationY, rotationZ when rotation is an Euler.
+// Object3D mappings win because static adapter props beat resolvers, so this only catches non-Object3D targets with an Euler rotation field.
+const eulerAxisEntries = {};
+threeAdapter.registerPropertyResolver((target, name) => {
+  const axis = AXIS_MAP[name[name.length - 1]];
+  if (!axis) return null;
+  const base = name.slice(0, -1);
+  if (!ANGLE_NAMES[base]) return null;
+  const v = target[base];
+  if (!v || !v.isEuler) return null;
+  return eulerAxisEntries[name] || (eulerAxisEntries[name] = {
+    get: (t) => radToDeg(t[base][axis]),
+    set: (t, v) => { t[base][axis] = degToRad(v); },
+  });
+});

package/dist/modules/adapters/three/uniform.cjs

@@ -0,0 +1,41 @@
+/**
+ * Anime.js - adapters - CJS
+ * @version v4.5.0
+ * @license MIT
+ * @copyright 2026 - Julian Garnier
+ */
+
+'use strict';
+
+var three = require('three');
+var adapter = require('./adapter.cjs');
+var helpers = require('./helpers.cjs');
+
+/**
+ * Bare `UniformNode` adapter. Auto-detects `UniformNode` instances and exposes their `.value` for animation. Scalars and booleans animate via `value`, `Color` uniforms via `color`, and `Vector2/3/4` uniforms via `x` / `y` / `z` / `w` axes.
+ *
+ *   import 'animejs/bindings/three';
+ *   import { uniform } from 'three/tsl';
+ *   animate(uniform(0),              { value: 1 });
+ *   animate(uniform(new Color()),    { color: '#0f0' });
+ *   animate(uniform(new Vector3()),  { x: 1, y: 0.5 });
+ *
+ * `UniformNode` slots assigned to `NodeMaterial` (`material.colorNode`, `material.offsetNode`, ...) are auto-detected by the shared resolvers in `resolvers.js`. Non-uniform nodes (`mix`, `add`, computed expressions), `Matrix3/4` and `Texture` valued uniforms, and `UniformArrayNode` / `BufferNode` are out of scope and fall through to the engine's direct property path.
+ */
+
+
+const uniformNode = adapter.threeAdapter.registerTargetAdapter((t) => !!(t && t.isUniformNode));
+
+// Scalar and bool uniforms animate via the engine OBJECT fallthrough on value, no adapter prop needed since the engine writes uniform value natively.
+uniformNode.registerProperty('color',
+  (t) => helpers.readColorHex(t.value),
+  (t, _, tw) => {
+    const ns = tw._numbers;
+    t.value.setRGB(ns[0] * helpers.COLOR_NORM, ns[1] * helpers.COLOR_NORM, ns[2] * helpers.COLOR_NORM, three.SRGBColorSpace);
+  },
+  (t) => !!(t.value && t.value.isColor),
+);
+uniformNode.registerProperty('x', (t) => t.value.x, (t, v) => { t.value.x = v; }, (t) => helpers.isVectorWith(t.value, 'x'));
+uniformNode.registerProperty('y', (t) => t.value.y, (t, v) => { t.value.y = v; }, (t) => helpers.isVectorWith(t.value, 'y'));
+uniformNode.registerProperty('z', (t) => t.value.z, (t, v) => { t.value.z = v; }, (t) => helpers.isVectorWith(t.value, 'z'));
+uniformNode.registerProperty('w', (t) => t.value.w, (t, v) => { t.value.w = v; }, (t) => helpers.isVectorWith(t.value, 'w'));

package/dist/modules/adapters/three/uniform.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/modules/adapters/three/uniform.js

@@ -0,0 +1,39 @@
+/**
+ * Anime.js - adapters - ESM
+ * @version v4.5.0
+ * @license MIT
+ * @copyright 2026 - Julian Garnier
+ */
+
+import { SRGBColorSpace } from 'three';
+import { threeAdapter } from './adapter.js';
+import { readColorHex, COLOR_NORM, isVectorWith } from './helpers.js';
+
+/**
+ * Bare `UniformNode` adapter. Auto-detects `UniformNode` instances and exposes their `.value` for animation. Scalars and booleans animate via `value`, `Color` uniforms via `color`, and `Vector2/3/4` uniforms via `x` / `y` / `z` / `w` axes.
+ *
+ *   import 'animejs/bindings/three';
+ *   import { uniform } from 'three/tsl';
+ *   animate(uniform(0),              { value: 1 });
+ *   animate(uniform(new Color()),    { color: '#0f0' });
+ *   animate(uniform(new Vector3()),  { x: 1, y: 0.5 });
+ *
+ * `UniformNode` slots assigned to `NodeMaterial` (`material.colorNode`, `material.offsetNode`, ...) are auto-detected by the shared resolvers in `resolvers.js`. Non-uniform nodes (`mix`, `add`, computed expressions), `Matrix3/4` and `Texture` valued uniforms, and `UniformArrayNode` / `BufferNode` are out of scope and fall through to the engine's direct property path.
+ */
+
+
+const uniformNode = threeAdapter.registerTargetAdapter((t) => !!(t && t.isUniformNode));
+
+// Scalar and bool uniforms animate via the engine OBJECT fallthrough on value, no adapter prop needed since the engine writes uniform value natively.
+uniformNode.registerProperty('color',
+  (t) => readColorHex(t.value),
+  (t, _, tw) => {
+    const ns = tw._numbers;
+    t.value.setRGB(ns[0] * COLOR_NORM, ns[1] * COLOR_NORM, ns[2] * COLOR_NORM, SRGBColorSpace);
+  },
+  (t) => !!(t.value && t.value.isColor),
+);
+uniformNode.registerProperty('x', (t) => t.value.x, (t, v) => { t.value.x = v; }, (t) => isVectorWith(t.value, 'x'));
+uniformNode.registerProperty('y', (t) => t.value.y, (t, v) => { t.value.y = v; }, (t) => isVectorWith(t.value, 'y'));
+uniformNode.registerProperty('z', (t) => t.value.z, (t, v) => { t.value.z = v; }, (t) => isVectorWith(t.value, 'z'));
+uniformNode.registerProperty('w', (t) => t.value.w, (t, v) => { t.value.w = v; }, (t) => isVectorWith(t.value, 'w'));

package/dist/modules/animatable/animatable.cjs

@@ -1,6 +1,6 @@
 /**
  * Anime.js - animatable - CJS
- * @version v4.4.0
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -60,6 +60,7 @@ class Animatable {
     const callbacksAnimationParams = { v: 1, autoplay: false };
     const properties = {};
     this.targets = [];
+    /** @type {Record<String, JSAnimation>} */
     this.animations = {};
     /** @type {JSAnimation|null} */
     this.callbacks = null;

package/dist/modules/animatable/animatable.d.ts

@@ -16,7 +16,8 @@ export class Animatable {
      */
     constructor(targets: TargetsParam, parameters: AnimatableParams);
     targets: (HTMLElement | SVGElement | import("../types/index.js").JSTarget)[];
-    animations: {};
+    /** @type {Record<String, JSAnimation>} */
+    animations: Record<string, JSAnimation>;
     /** @type {JSAnimation|null} */
     callbacks: JSAnimation | null;
     revert(): this;

package/dist/modules/animatable/animatable.js

@@ -1,6 +1,6 @@
 /**
  * Anime.js - animatable - ESM
- * @version v4.4.0
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -58,6 +58,7 @@ class Animatable {
     const callbacksAnimationParams = { v: 1, autoplay: false };
     const properties = {};
     this.targets = [];
+    /** @type {Record<String, JSAnimation>} */
     this.animations = {};
     /** @type {JSAnimation|null} */
     this.callbacks = null;

package/dist/modules/animatable/index.cjs

@@ -1,6 +1,6 @@
 /**
  * Anime.js - animatable - CJS
- * @version v4.4.0
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */

package/dist/modules/animatable/index.js

@@ -1,6 +1,6 @@
 /**
  * Anime.js - animatable - ESM
- * @version v4.4.0
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */

package/dist/modules/animation/additive.cjs

@@ -1,6 +1,6 @@
 /**
  * Anime.js - animation - CJS
- * @version v4.4.0
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */

package/dist/modules/animation/additive.js

@@ -1,6 +1,6 @@
 /**
  * Anime.js - animation - ESM
- * @version v4.4.0
+ * @version v4.5.0
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */