@realsee/dnalogel 3.81.13 → 4.0.0-webgpu.3

package/dist/internal/animation-D9rPUNWJ.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation-D9rPUNWJ.js","names":["isBrowser","win","doc","tweenTypes","valueTypes","tickModes","compositionTypes","isRegisteredTargetSymbol","isDomSymbol","isSvgSymbol","transformsSymbol","proxyTargetSymbol","minValue","maxValue","K","emptyArray","shortTransforms","map","validTransforms","transformsFragmentStrings","a","v","noop","noopModifier","validRgbHslRgx","hexTestRgx","rgbExecRgx","rgbaExecRgx","hslExecRgx","hslaExecRgx","digitWithExponentRgx","unitsExecRgx","lowerCaseRgx","relativeValuesExecRgx","cssVariableMatchRgx","defaults","scope","globals","globalVersions","toLowerCase","str","stringStartsWith","sub","now","isArr","isObj","isNum","isStr","isFnc","isUnd","isNil","isSvg","isHex","isRgb","isHsl","isCol","isKey","svgCssReservedProperties","isValidSVGAttribute","propertyName","el","elParentNode","parseNumber","pow","sqrt","sin","cos","abs","floor","asin","PI","_round","clamp","min","max","round","decimalLength","p","lerp","factor","end","start","clampInfinity","normalizeTime","cloneArray","mergeObjects","merged","o1","o2","o1p","forEachChildren","next","parent","adjustedNextProp","nextProp","reverse","prevProp","currentNext","callback","removeChild","prev","child","addChild","sortMethod","parseInlineTransforms","inlineTransforms","target","cachedTransforms","pos","len","fullTranslateValue","nameStart","name","depth","valueStart","c1","c2","c","valueEnd","propName","animationInlineStyles","cached","buildTransformString","i","l","key","val","props","next2","adapters","resolveAdapterEntry","al","tas","j","m","ta","entry","rs","rgbToRgba","rgba","rgbValue","hexToRgba","hexLength","hexValue","isShort","hue2rgb","t","q","hslToRgba","hsla","hslValue","h","s","r","g","b","convertColorStringValuesToRgbaArray","colorString","setValue","targetValue","defaultValue","resolveCssVar","match","value","computed","getFunctionValue","store","index","targets","prevTween","func","getTweenType","prop","getCSSValue","inlineStyles","getOriginalAnimatableValue","type","tweenType","adapterProp","getRelativeValue","operator","x","y","createDecomposedValueTargetObject","decomposeRawValue","rawValue","targetObject","num","unitMatch","matchedNumbers","decomposeTweenValue","tween","decomposedOriginalValue","composeComplexValue","mod","fn","tn","ts","n","progress","precision","render","tickable","duration","completed","iterationDuration","iterationCount","_currentIteration","_loopDelay","_reversed","_alternate","_hasChildren","tickableDelay","tickablePrevAbsoluteTime","tickableEndTime","tickableAbsoluteTime","time","tickablePrevTime","tickableCurrentTime","deltaTime","isCurrentTimeAboveZero","isCurrentTimeEqualOrAboveDuration","isSetter","forcedTick","tickMode","isOdd","iterationElapsedTime","hasRendered","period","currentIteration","isReversed","_ease","iterationTime","isRunningBackwards","muteCallbacks","forcedRender","absoluteTime","tweenTarget","tweenStyle","tweenTargetTransforms","tweenTargetTransformsProperties","tweenTransformsNeedUpdate","tweenComposition","tweenCurrentTime","tweenChangeDuration","tweenAbsEndTime","tweenNextRep","tweenPrevRep","tweenHasComposition","tweenPrevRepEndTime","tweenPrevRepIsCrossParent","tweenNextRepTakeover","tweenNewTime","tweenProgress","tweenModifier","tweenValueType","tweenIsObject","tweenIsNumber","tweenPrecision","number","ns","omt","fr","fg","fb","tr","tg","tb","internalRender","tweenProperty","tick","tl","tlIsRunningBackwards","tlChildrenTime","tlCildrenTickTime","tlChildrenHasRendered","tlChildrenHaveCompleted","tlIterationDuration","childDuration","childStartTime","childEndTime","childTime","childTickMode","propertyNamesCache","sanitizePropertyName","cachedPropertyName","lowerCaseName","revertValues","renderable","inlineStylesOnly","animation","originalInlinedValue","tweenHadNoInlineValue","src","dst","targetStyle","Clock","initTime","frameRate","fps","frameDuration","pbr","playbackRate","elapsed","scaled","delta","additive","addAdditiveAnimation","lookups","propertyAnimation","tweens","lookupTween","valueType","additiveValues","additiveValue","engineTickMethod","engineCancelMethod","Engine","engineSpeed","engineFps","activeTickable","nextTickable","tickEngine","killEngine","speed","secondsScale","isSecond","unit","newScale","scaleFactor","engine","getTweenSiblings","lookupMap","lookup","targetLookup","property","addTweenSortMethod","overrideTween","composeTween","tweenCompositionType","tweenAbsStartTime","siblings","prevSibling","prevParent","prevAbsEndTime","prevPrevSibling","absoluteUpdateStartTime","prevChangeStartTime","updatedPrevChangeDuration","tweenParentTL","pausePrevParentAnimation","prevParentTL","pausePrevParentTL","additiveTweenSiblings","additiveAnimation","toNumber","toNumbers","removeTweenSliblings","tweenReplaceSiblings","addTweensLookup","addTargetProps","shouldClean","resetTimerProperties","timer","reviveTimer","timerId","sortByPriority","Timer","parameters","timerInitTime","timerDefaults","timerDelay","delay","timerDuration","timerLoop","loop","timerLoopDelay","loopDelay","timerIterationCount","offsetPosition","parentPosition","id","onBegin","onBeforeUpdate","onUpdate","onLoop","onPause","onComplete","autoplay","reversed","alternate","priority","paused","softReset","timeScale","isPaused","count","iterations","currentDuration","normlizedDuration","newDuration","ap","then","onResolve","getNodeList","parseTargets","flattened","parsed","item","nodeList","jl","subItem","isDuplicate","k","kl","registerTargets","parsedTargetsArray","parsedTargetsLength","isSvgType","angleUnitsMap","\"deg\"","\"rad\"","\"turn\"","convertedValuesCache","convertValueUnit","currentUnit","decomposedValue","currentNumber","cachedKey","force","convertedValue","tempEl","parentNode","parentEl","elStyle","currentUnitWidth","none","easeInPower","easeTypes","easeIn","halfPI","doublePI","easeInFunctions","pow2","overshoot","amplitude","e","eases","list","easeType","easesLookups","parseEaseString","string","parsedFn","split","deprecated","parseEase","ease","fromTargetObject","toTargetObject","inlineStylesStore","toFunctionStore","fromFunctionStore","keyframesTargetArray","fastSetValuesArray","keyObjectTarget","tweenId","JSAnimationId","keyframes","generateKeyframes","properties","propertyNames","newKey","keyValue","totalDuration","offset","propArray","length","prevKey","keyObj","durProgress","prevEase","currentEase","JSAnimation","parsedTargets","targetsLength","kfParams","params","animDefaults","animEase","animPlaybackEase","playbackEase","parsedAnimPlaybackEase","hasSpring","tEasing","tDuration","tDelay","tModifier","modifier","tComposition","composition","absoluteOffsetTime","iterationDelay","animationAnimationLength","shouldTriggerRender","targetIndex","ti","allTargets","lastTransformGroupIndex","lastTransformGroupLength","propValue","isPropValueArray","fastSet","arrayLength","isNotObjectValue","firstTweenChangeStartTime","lastTweenChangeEndTime","tweenIndex","keyframe","computedComposition","tailTween","prevSiblingTween","computedToValue","tweenToValue","tweenFromValue","easeToParse","easeFunctionResult","keyEasing","tweenEasing","tweenDuration","tweenDelay","hasFromvalue","hasToValue","isFromToArray","isFromToValue","tweenUpdateStartLocal","tweenStartTime","absoluteStartTime","nextSibling","originalValue","complexValue","notComplexValue","unitValue","notUnitValue","colorValue","notColorValue","valueToConvert","longestValue","shortestValue","tweenUpdateDuration","inlineValue","tweenSetter","fromD","toD","toS","vt","d","additiveTween","onRender","toFunc","fromFunc","animate"],"sources":["../../../node_modules/animejs/dist/modules/core/consts.js","../../../node_modules/animejs/dist/modules/core/globals.js","../../../node_modules/animejs/dist/modules/core/helpers.js","../../../node_modules/animejs/dist/modules/core/transforms.js","../../../node_modules/animejs/dist/modules/adapters/registry.js","../../../node_modules/animejs/dist/modules/core/colors.js","../../../node_modules/animejs/dist/modules/core/values.js","../../../node_modules/animejs/dist/modules/core/render.js","../../../node_modules/animejs/dist/modules/core/styles.js","../../../node_modules/animejs/dist/modules/core/clock.js","../../../node_modules/animejs/dist/modules/animation/additive.js","../../../node_modules/animejs/dist/modules/engine/engine.js","../../../node_modules/animejs/dist/modules/animation/composition.js","../../../node_modules/animejs/dist/modules/timer/timer.js","../../../node_modules/animejs/dist/modules/core/targets.js","../../../node_modules/animejs/dist/modules/core/units.js","../../../node_modules/animejs/dist/modules/easings/none.js","../../../node_modules/animejs/dist/modules/easings/eases/parser.js","../../../node_modules/animejs/dist/modules/animation/animation.js"],"sourcesContent":["/**\n * Anime.js - core - ESM\n * @version v4.5.0\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\n// Environments\n\n// TODO: Do we need to check if we're running inside a worker ?\nconst isBrowser = typeof window !== 'undefined';\n\n/** @typedef {Window & {AnimeJS: Array}|null} AnimeJSWindow\n\n/** @type {AnimeJSWindow} */\nconst win = isBrowser ? /** @type {AnimeJSWindow} */(/** @type {unknown} */(window)) : null;\n\n/** @type {Document|null} */\nconst doc = isBrowser ? document : null;\n\n// Enums\n\n/** @enum {Number} */\nconst tweenTypes = {\n  OBJECT: 0,\n  ATTRIBUTE: 1,\n  CSS: 2,\n  TRANSFORM: 3,\n  CSS_VAR: 4,\n};\n\n/** @enum {Number} */\nconst valueTypes = {\n  NUMBER: 0,\n  UNIT: 1,\n  COLOR: 2,\n  COMPLEX: 3,\n};\n\n/** @enum {Number} */\nconst tickModes = {\n  NONE: 0,\n  AUTO: 1,\n  FORCE: 2,\n};\n\n/** @enum {Number} */\nconst compositionTypes = {\n  replace: 0,\n  none: 1,\n  blend: 2,\n};\n\n// Cache symbols\n\nconst isRegisteredTargetSymbol = Symbol();\nconst isDomSymbol = Symbol();\nconst isSvgSymbol = Symbol();\nconst transformsSymbol = Symbol();\nconst proxyTargetSymbol = Symbol();\n\n// Numbers\n\nconst minValue = 1e-11;\nconst maxValue = 1e12;\nconst K = 1e3;\nconst maxFps = 240;\n\n// Strings\n\nconst emptyString = '';\nconst cssVarPrefix = 'var(';\n\n// Arrays\n\n// 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.\nconst emptyArray = [];\n\nconst shortTransforms = /*#__PURE__*/ (() => {\n  const map = new Map();\n  map.set('x', 'translateX');\n  map.set('y', 'translateY');\n  map.set('z', 'translateZ');\n  return map;\n})();\n\nconst validTransforms = [\n  'perspective',\n  'translateX',\n  'translateY',\n  'translateZ',\n  'rotate',\n  'rotateX',\n  'rotateY',\n  'rotateZ',\n  'scale',\n  'scaleX',\n  'scaleY',\n  'scaleZ',\n  'skew',\n  'skewX',\n  'skewY',\n];\n\nconst transformsFragmentStrings = /*#__PURE__*/ validTransforms.reduce((a, v) => ({...a, [v]: v + '('}), {});\n\n// Functions\n\n/** @return {void} */\nconst noop = () => {};\n\n/**\n * @template T\n * @param  {T} v\n * @return {T}\n */\nconst noopModifier = v => v;\n\n// Regex\n\nconst validRgbHslRgx = /\\)\\s*[-.\\d]/;\nconst hexTestRgx = /(^#([\\da-f]{3}){1,2}$)|(^#([\\da-f]{4}){1,2}$)/i;\nconst rgbExecRgx = /rgb\\(\\s*(\\d+)\\s*,\\s*(\\d+)\\s*,\\s*(\\d+)\\s*\\)/i;\nconst rgbaExecRgx = /rgba\\(\\s*(\\d+)\\s*,\\s*(\\d+)\\s*,\\s*(\\d+)\\s*,\\s*(-?\\d+|-?\\d*.\\d+)\\s*\\)/i;\nconst hslExecRgx = /hsl\\(\\s*(-?\\d+|-?\\d*.\\d+)\\s*,\\s*(-?\\d+|-?\\d*.\\d+)%\\s*,\\s*(-?\\d+|-?\\d*.\\d+)%\\s*\\)/i;\nconst hslaExecRgx = /hsla\\(\\s*(-?\\d+|-?\\d*.\\d+)\\s*,\\s*(-?\\d+|-?\\d*.\\d+)%\\s*,\\s*(-?\\d+|-?\\d*.\\d+)%\\s*,\\s*(-?\\d+|-?\\d*.\\d+)\\s*\\)/i;\n// export const digitWithExponentRgx = /[-+]?\\d*\\.?\\d+(?:[eE][-+]?\\d+)?/g;\nconst digitWithExponentRgx = /[-+]?\\d*\\.?\\d+(?:e[-+]?\\d)?/gi;\n// export const unitsExecRgx = /^([-+]?\\d*\\.?\\d+(?:[eE][-+]?\\d+)?)+([a-z]+|%)$/i;\nconst unitsExecRgx = /^([-+]?\\d*\\.?\\d+(?:e[-+]?\\d+)?)([a-z]+|%)$/i;\nconst lowerCaseRgx = /([a-z])([A-Z])/g;\nconst relativeValuesExecRgx = /(\\*=|\\+=|-=)/;\nconst cssVariableMatchRgx = /var\\(\\s*(--[\\w-]+)(?:\\s*,\\s*([^)]+))?\\s*\\)/;\n\nexport { K, compositionTypes, cssVarPrefix, cssVariableMatchRgx, digitWithExponentRgx, doc, emptyArray, emptyString, hexTestRgx, hslExecRgx, hslaExecRgx, isBrowser, isDomSymbol, isRegisteredTargetSymbol, isSvgSymbol, lowerCaseRgx, maxFps, maxValue, minValue, noop, noopModifier, proxyTargetSymbol, relativeValuesExecRgx, rgbExecRgx, rgbaExecRgx, shortTransforms, tickModes, transformsFragmentStrings, transformsSymbol, tweenTypes, unitsExecRgx, validRgbHslRgx, validTransforms, valueTypes, win };\n","/**\n * Anime.js - core - ESM\n * @version v4.5.0\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { isBrowser, win, noop, noopModifier, compositionTypes, K, maxFps, doc } from './consts.js';\n\n/**\n * @import {\n *   DefaultsParams,\n *   DOMTarget,\n * } from '../types/index.js'\n *\n * @import {\n *   Scope,\n * } from '../scope/index.js'\n*/\n\n/**\n * @typedef {Object} EditorGlobals\n * @property {boolean} showPanel\n * @property {Function} addAnimation\n * @property {Function} addSet\n * @property {Function} addTimeline\n * @property {Function} addTimelineChild\n * @property {Function} addTimelineLabel\n * @property {Function} addTimelineCall\n * @property {Function} addTimelineSync\n * @property {Function} resolveStagger\n * @property {Object|null} _head\n * @property {Object|null} _tail\n */\n\n/** @type {DefaultsParams} */\nconst defaults = {\n  id: null,\n  keyframes: null,\n  playbackEase: null,\n  playbackRate: 1,\n  frameRate: maxFps,\n  loop: 0,\n  reversed: false,\n  alternate: false,\n  autoplay: true,\n  persist: false,\n  duration: K,\n  delay: 0,\n  loopDelay: 0,\n  ease: 'out(2)',\n  composition: compositionTypes.replace,\n  modifier: noopModifier,\n  onBegin: noop,\n  onBeforeUpdate: noop,\n  onUpdate: noop,\n  onLoop: noop,\n  onPause: noop,\n  onComplete: noop,\n  onRender: noop,\n};\n\nconst scope = {\n  /** @type {Scope} */\n  current: null,\n  /** @type {Document|DOMTarget} */\n  root: doc,\n};\n\nconst globals = {\n  /** @type {DefaultsParams} */\n  defaults,\n  /** @type {Number} */\n  precision: 4,\n  /** @type {Number} equals 1 in ms mode, 0.001 in s mode */\n  timeScale: 1,\n  /** @type {Number} */\n  tickThreshold: 200,\n  /** @type {EditorGlobals|null} */\n  editor: null,\n};\n\nconst globalVersions = { version: '4.5.0', engine: null };\n\nif (isBrowser) {\n  if (!win.AnimeJS) win.AnimeJS = [];\n  win.AnimeJS.push(globalVersions);\n}\n\nexport { defaults, globalVersions, globals, scope };\n","/**\n * Anime.js - core - ESM\n * @version v4.5.0\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { isBrowser, maxValue, minValue, hexTestRgx, lowerCaseRgx, validRgbHslRgx } from './consts.js';\nimport { globals } from './globals.js';\n\n/**\n * @import {\n *   Target,\n *   DOMTarget,\n * } from '../types/index.js'\n*/\n\n// Strings\n\n/**\n * @param  {String} str\n * @return {String}\n */\nconst toLowerCase = str => str.replace(lowerCaseRgx, '$1-$2').toLowerCase();\n\n/**\n * Prioritize this method instead of regex when possible\n * @param  {String} str\n * @param  {String} sub\n * @return {Boolean}\n */\nconst stringStartsWith = (str, sub) => str.indexOf(sub) === 0;\n\n// Note: Date.now is used instead of performance.now since it is precise enough for timings calculations, performs slightly faster and works in Node.js environement.\nconst now = Date.now;\n\n// Types checkers\n\nconst isArr = Array.isArray;\n/**@param {any} a @return {a is Record<String, any>} */\nconst isObj = a => a && a.constructor === Object;\n/**@param {any} a @return {a is Number} */\nconst isNum = a => typeof a === 'number' && !isNaN(a);\n/**@param {any} a @return {a is String} */\nconst isStr = a => typeof a === 'string';\n/**@param {any} a @return {a is Function} */\nconst isFnc = a => typeof a === 'function';\n/**@param {any} a @return {a is undefined} */\nconst isUnd = a => typeof a === 'undefined';\n/**@param {any} a @return {a is null | undefined} */\nconst isNil = a => isUnd(a) || a === null;\n/**@param {any} a @return {a is SVGElement} */\nconst isSvg = a => isBrowser && a instanceof SVGElement;\n/**@param {any} a @return {Boolean} */\nconst isHex = a => hexTestRgx.test(a);\n/**@param {any} a @return {Boolean} */\nconst isRgb = a => stringStartsWith(a, 'rgb');\n/**@param {any} a @return {Boolean} */\nconst isHsl = a => stringStartsWith(a, 'hsl');\n/**@param {any} a @return {Boolean} */ // Make sure boxShadow syntax like 'rgb(255, 0, 0) 0px 0px 6px 0px' is not a valid color type\nconst isCol = a => isHex(a) || ((isRgb(a) || isHsl(a)) && (a[a.length - 1] === ')' || !validRgbHslRgx.test(a)));\n/**@param {any} a @return {Boolean} */\nconst isKey = a => !globals.defaults.hasOwnProperty(a);\n\n// SVG\n\n// Consider the following as CSS animation\n// CSS opacity animation has better default values (opacity: 1 instead of 0))\n// rotate is more commonly intended to be used as a transform\nconst svgCssReservedProperties = ['opacity', 'rotate', 'overflow', 'color'];\n\n/**\n * @param  {Target} el\n * @param  {String} propertyName\n * @return {Boolean}\n */\nconst isValidSVGAttribute = (el, propertyName) => {\n  if (svgCssReservedProperties.includes(propertyName)) return false;\n  if (el.getAttribute(propertyName) || propertyName in el) {\n    if (propertyName === 'scale') { // Scale\n      const elParentNode = /** @type {SVGGeometryElement} */(/** @type {DOMTarget} */(el).parentNode);\n      // Only consider scale as a valid SVG attribute on filter element\n      return elParentNode && elParentNode.tagName === 'filter';\n    }\n    return true;\n  }\n};\n\n// Number\n\n/**\n * @param  {Number|String} str\n * @return {Number}\n */\nconst parseNumber = str => isStr(str) ?\n  parseFloat(/** @type {String} */(str)) :\n  /** @type {Number} */(str);\n\n// Math\n\nconst pow = Math.pow;\nconst sqrt = Math.sqrt;\nconst sin = Math.sin;\nconst cos = Math.cos;\nconst abs = Math.abs;\nconst exp = Math.exp;\nconst ceil = Math.ceil;\nconst floor = Math.floor;\nconst asin = Math.asin;\nconst max = Math.max;\nconst atan2 = Math.atan2;\nconst PI = Math.PI;\nconst _round = Math.round;\n\n/**\n * Clamps a value between min and max bounds\n *\n * @param  {Number} v - Value to clamp\n * @param  {Number} min - Minimum boundary\n * @param  {Number} max - Maximum boundary\n * @return {Number}\n */\nconst clamp = (v, min, max) => v < min ? min : v > max ? max : v;\n\n/**\n * Rounds a number to specified decimal places\n *\n * @param  {Number} v - Value to round\n * @param  {Number} decimalLength - Number of decimal places\n * @return {Number}\n */\n const round = (v, decimalLength) => {\n   if (decimalLength < 0) return v;\n   if (!decimalLength) return _round(v);\n   const p = 10 ** decimalLength;\n   return _round(v * p) / p;\n };\n\n/**\n * Snaps a value to nearest increment or array value\n *\n * @param  {Number} v - Value to snap\n * @param  {Number|Array<Number>} increment - Step size or array of snap points\n * @return {Number}\n */\nconst snap = (v, increment) => isArr(increment) ? increment.reduce((closest, cv) => (abs(cv - v) < abs(closest - v) ? cv : closest)) : increment ? _round(v / increment) * increment : v;\n\n/**\n * Linear interpolation between two values\n *\n * @param  {Number} start - Starting value\n * @param  {Number} end - Ending value\n * @param  {Number} factor - Interpolation factor in the range [0, 1]\n * @return {Number} The interpolated value\n */\nconst lerp = (start, end, factor) => factor === 1 ? end : factor === 0 ? start : start + (end - start) * factor;\n\n/**\n * Replaces infinity with maximum safe value\n *\n * @param  {Number} v - Value to check\n * @return {Number}\n */\nconst clampInfinity = v => v === Infinity ? maxValue : v === -Infinity ? -maxValue : v;\n\n/**\n * Normalizes time value with minimum threshold\n *\n * @param  {Number} v - Time value to normalize\n * @return {Number}\n */\nconst normalizeTime = v => v <= minValue ? minValue : clampInfinity(round(v, 11));\n\n// Arrays\n\n/**\n * @template T\n * @param    {T[]} a\n * @return   {T[]}\n */\nconst cloneArray = a => isArr(a) ? [ ...a ] : a;\n\n// Objects\n\n/**\n * @template T\n * @template U\n * @param    {T} o1\n * @param    {U} o2\n * @return   {T & U}\n */\nconst mergeObjects = (o1, o2) => {\n  const merged = /** @type {T & U} */({ ...o1 });\n  for (let p in o2) {\n    const o1p = /** @type {T & U} */(o1)[p];\n    merged[p] = isUnd(o1p) ? /** @type {T & U} */(o2)[p] : o1p;\n  }  return merged;\n};\n\n// Linked lists\n\n/**\n * @param  {Object} parent\n * @param  {Function} callback\n * @param  {Boolean} [reverse]\n * @param  {String} [prevProp]\n * @param  {String} [nextProp]\n * @return {void}\n */\nconst forEachChildren = (parent, callback, reverse, prevProp = '_prev', nextProp = '_next') => {\n  let next = parent._head;\n  let adjustedNextProp = nextProp;\n  if (reverse) {\n    next = parent._tail;\n    adjustedNextProp = prevProp;\n  }\n  while (next) {\n    const currentNext = next[adjustedNextProp];\n    callback(next);\n    next = currentNext;\n  }\n};\n\n/**\n * @param  {Object} parent\n * @param  {Object} child\n * @param  {String} [prevProp]\n * @param  {String} [nextProp]\n * @return {void}\n */\nconst removeChild = (parent, child, prevProp = '_prev', nextProp = '_next') => {\n  const prev = child[prevProp];\n  const next = child[nextProp];\n  prev ? prev[nextProp] = next : parent._head = next;\n  next ? next[prevProp] = prev : parent._tail = prev;\n  child[prevProp] = null;\n  child[nextProp] = null;\n};\n\n/**\n * @param  {Object} parent\n * @param  {Object} child\n * @param  {Function} [sortMethod]\n * @param  {String} prevProp\n * @param  {String} nextProp\n * @return {void}\n */\nconst addChild = (parent, child, sortMethod, prevProp = '_prev', nextProp = '_next') => {\n  let prev = parent._tail;\n  while (prev && sortMethod && sortMethod(prev, child)) prev = prev[prevProp];\n  const next = prev ? prev[nextProp] : parent._head;\n  prev ? prev[nextProp] = child : parent._head = child;\n  next ? next[prevProp] = child : parent._tail = child;\n  child[prevProp] = prev;\n  child[nextProp] = next;\n};\n\nexport { PI, _round, abs, addChild, asin, atan2, ceil, clamp, clampInfinity, cloneArray, cos, exp, floor, forEachChildren, isArr, isCol, isFnc, isHex, isHsl, isKey, isNil, isNum, isObj, isRgb, isStr, isSvg, isUnd, isValidSVGAttribute, lerp, max, mergeObjects, normalizeTime, now, parseNumber, pow, removeChild, round, sin, snap, sqrt, stringStartsWith, toLowerCase };\n","/**\n * Anime.js - core - ESM\n * @version v4.5.0\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { transformsFragmentStrings, emptyString, validTransforms, transformsSymbol } from './consts.js';\nimport { isUnd, stringStartsWith } from './helpers.js';\n\n/**\n* @import {\n*   DOMTarget,\n* } from '../types/index.js'\n*/\n\n/**\n * @param  {DOMTarget} target\n * @param  {String} propName\n * @param  {Object} animationInlineStyles\n * @return {String}\n */\nconst parseInlineTransforms = (target, propName, animationInlineStyles) => {\n  const inlineTransforms = target.style.transform;\n  if (inlineTransforms) {\n    const cachedTransforms = target[transformsSymbol];\n    let pos = 0;\n    const len = inlineTransforms.length;\n    let fullTranslateValue;\n    while (pos < len) {\n      // Skip whitespace\n      while (pos < len && inlineTransforms.charCodeAt(pos) === 32) pos++;\n      if (pos >= len) break;\n      // Read function name\n      const nameStart = pos;\n      while (pos < len && inlineTransforms.charCodeAt(pos) !== 40) pos++;\n      if (pos >= len) break;\n      const name = inlineTransforms.substring(nameStart, pos);\n      // Scan to closing paren, recording top-level comma positions\n      let depth = 1;\n      const valueStart = pos + 1;\n      let c1 = -1, c2 = -1;\n      pos++;\n      while (pos < len && depth > 0) {\n        const c = inlineTransforms.charCodeAt(pos);\n        if (c === 40) depth++;\n        else if (c === 41) depth--;\n        else if (c === 44 && depth === 1) {\n          if (c1 === -1) c1 = pos;\n          else if (c2 === -1) c2 = pos;\n        }\n        pos++;\n      }\n      const valueEnd = pos - 1;\n      // Decompose multi-arg functions into individual axis properties\n      if (name === 'translate' || name === 'translate3d') {\n        if (c1 === -1) {\n          cachedTransforms.translateX = inlineTransforms.substring(valueStart, valueEnd).trim();\n        } else {\n          cachedTransforms.translateX = inlineTransforms.substring(valueStart, c1).trim();\n          if (c2 === -1) {\n            cachedTransforms.translateY = inlineTransforms.substring(c1 + 1, valueEnd).trim();\n          } else {\n            cachedTransforms.translateY = inlineTransforms.substring(c1 + 1, c2).trim();\n            cachedTransforms.translateZ = inlineTransforms.substring(c2 + 1, valueEnd).trim();\n          }\n        }\n        fullTranslateValue = inlineTransforms.substring(valueStart, valueEnd);\n      } else if (name === 'scale' || name === 'scale3d') {\n        if (c1 === -1) {\n          cachedTransforms.scale = inlineTransforms.substring(valueStart, valueEnd).trim();\n        } else {\n          cachedTransforms.scaleX = inlineTransforms.substring(valueStart, c1).trim();\n          if (c2 === -1) {\n            cachedTransforms.scaleY = inlineTransforms.substring(c1 + 1, valueEnd).trim();\n          } else {\n            cachedTransforms.scaleY = inlineTransforms.substring(c1 + 1, c2).trim();\n            cachedTransforms.scaleZ = inlineTransforms.substring(c2 + 1, valueEnd).trim();\n          }\n        }\n      } else {\n        cachedTransforms[name] = inlineTransforms.substring(valueStart, valueEnd);\n      }\n    }\n    // Resolve the requested property from the cache\n    if (propName === 'translate3d' && fullTranslateValue) {\n      if (animationInlineStyles) animationInlineStyles[propName] = fullTranslateValue;\n      return fullTranslateValue;\n    }\n    const cached = cachedTransforms[propName];\n    if (!isUnd(cached)) {\n      if (animationInlineStyles) animationInlineStyles[propName] = cached;\n      return cached;\n    }\n  }\n  return propName === 'translate3d' ? '0px, 0px, 0px' :\n    propName === 'rotate3d' ? '0, 0, 0, 0deg' :\n    stringStartsWith(propName, 'scale') ? '1' :\n    stringStartsWith(propName, 'rotate') || stringStartsWith(propName, 'skew') ? '0deg' : '0px';\n};\n\n/**\n * Builds a CSS transform string from the target's cached transform properties.\n * Iterates validTransforms in order (perspective > translate > rotate > scale > skew > matrix).\n * When adjacent axis properties are all present, emits a shorter shorthand (translateX + translateY -> translate(x, y))\n * The index is advanced past consumed properties so they are not emitted twice.\n * Properties without a grouping partner (e.g. translateY alone, scaleZ alone) emit individually.\n *\n * @param  {Record<String, String>} props\n * @return {String}\n */\nconst buildTransformString = (props) => {\n  let str = emptyString;\n  for (let i = 0, l = validTransforms.length; i < l; i++) {\n    const key = validTransforms[i];\n    const val = props[key];\n    if (val !== undefined) {\n      // Group translateX with adjacent translateY / translateZ\n      if (key === 'translateX') {\n        const next = props.translateY;\n        if (next !== undefined) {\n          const next2 = props.translateZ;\n          if (next2 !== undefined) {\n            str += `translate3d(${val},${next},${next2}) `;\n            i += 2;\n          } else {\n            str += `translate(${val},${next}) `;\n            i += 1;\n          }\n          continue;\n        }\n      }\n      // Group scaleX with adjacent scaleY / scaleZ (only when standalone scale is absent)\n      if (key === 'scaleX' && props.scale === undefined) {\n        const next = props.scaleY;\n        if (next !== undefined) {\n          const next2 = props.scaleZ;\n          if (next2 !== undefined) {\n            str += `scale3d(${val},${next},${next2}) `;\n            i += 2;\n          } else {\n            str += `scale(${val},${next}) `;\n            i += 1;\n          }\n          continue;\n        }\n      }\n      // All other properties: emit individually using pre-built fragment string\n      str += `${transformsFragmentStrings[key]}${val}) `;\n    }\n    // Preserve non-animatable rotate3d in correct position (after rotateZ, before scale)\n    if (key === 'rotateZ') {\n      if (props.rotate3d !== undefined) str += `rotate3d(${props.rotate3d}) `;\n    }\n  }\n  // Preserve non-animatable matrix/matrix3d from inline styles\n  if (props.matrix !== undefined) str += `matrix(${props.matrix}) `;\n  if (props.matrix3d !== undefined) str += `matrix3d(${props.matrix3d}) `;\n  return str;\n};\n\nexport { buildTransformString, parseInlineTransforms };\n","/**\n * Anime.js - adapters - ESM\n * @version v4.5.0\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\n/**\n * 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.\n *\n *   import { registerAdapter } from 'animejs/adapters';\n *\n *   const myAdapter = registerAdapter();\n *   const widget = myAdapter.registerTargetAdapter((t) => t instanceof MyWidget);\n *   widget.registerProperty('value',\n *     (t) => t.getValue(),\n *     (target, value) => target.setValue(value),\n *   );\n *\n * 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.\n *\n * 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.\n */\n\n/**\n * @typedef TargetAdapterEntry\n * @property {(t: any) => any} get\n * @property {(target: any, value: number, tween: any) => void} set\n * @property {(t: any) => boolean} [gate]\n */\n\nconst alwaysTrue = () => true;\n\nclass TargetAdapter {\n  /**\n   * @param {(t: any) => boolean} detect\n   */\n  constructor(detect) {\n    this.detect = detect;\n    /** @type {Record<string, TargetAdapterEntry>} */\n    this.props = {};\n  }\n\n  /**\n   * 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.\n   *\n   * @param {string} name\n   * @param {(t: any) => any} getter\n   * @param {(target: any, value: number, tween: any) => void} setter\n   * @param {(t: any) => boolean} [gate]\n   */\n  registerProperty(name, getter, setter, gate) {\n    this.props[name] = {\n      get: getter,\n      set: setter,\n      gate: gate || alwaysTrue,\n    };\n  }\n}\n\nclass Adapter {\n  /**\n   * @param {((t: any) => boolean) | null} [detect]\n   *   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.\n   */\n  constructor(detect) {\n    /** @type {((t: any) => boolean) | null} */\n    this.detect = detect || null;\n    /** @type {TargetAdapter[]} */\n    this.targetAdapters = [];\n    /** @type {((target: any, name: string) => TargetAdapterEntry | null)[]} */\n    this.propertyResolvers = [];\n  }\n\n  /**\n   * Creates and registers a `TargetAdapter` scoped to this Adapter.\n   *\n   * @param {(t: any) => boolean} detect\n   * @return {TargetAdapter}\n   */\n  registerTargetAdapter(detect) {\n    const ta = new TargetAdapter(detect);\n    this.targetAdapters.push(ta);\n    return ta;\n  }\n\n  /**\n   * 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.).\n   *\n   * @param {(target: any, name: string) => TargetAdapterEntry | null} resolver\n   */\n  registerPropertyResolver(resolver) {\n    if (this.propertyResolvers.indexOf(resolver) === -1) this.propertyResolvers.push(resolver);\n  }\n}\n\nconst adapters = /** @type {Adapter[]} */([]);\n\n/**\n * 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.\n *\n * @param {(t: any) => boolean} [detect]\n * @return {Adapter}\n */\nfunction registerAdapter(detect) {\n  const a = new Adapter(detect);\n  adapters.push(a);\n  return a;\n}\n\n/**\n * Internal resolution. Tries every Adapter's target adapters first (in registration order, first match wins), then every Adapter's property resolvers.\n *\n * @param {any} target\n * @param {string} name\n * @return {TargetAdapterEntry | null}\n */\nfunction resolveAdapterEntry(target, name) {\n  if (!target) return null;\n  const al = adapters.length;\n  outer: for (let i = 0; i < al; i++) {\n    const a = adapters[i];\n    if (a.detect && !a.detect(target)) continue;\n    const tas = a.targetAdapters;\n    for (let j = 0, m = tas.length; j < m; j++) {\n      const ta = tas[j];\n      if (ta.detect(target)) {\n        const entry = ta.props[name];\n        if (entry && (!entry.gate || entry.gate(target))) return entry;\n        break outer;\n      }\n    }\n  }\n  for (let i = 0; i < al; i++) {\n    const a = adapters[i];\n    if (a.detect && !a.detect(target)) continue;\n    const rs = a.propertyResolvers;\n    for (let j = 0, m = rs.length; j < m; j++) {\n      const entry = rs[j](target, name);\n      if (entry) return entry;\n    }\n  }\n  return null;\n}\n\nexport { registerAdapter, resolveAdapterEntry };\n","/**\n * Anime.js - core - ESM\n * @version v4.5.0\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { rgbExecRgx, rgbaExecRgx, hslExecRgx, hslaExecRgx } from './consts.js';\nimport { isRgb, isHex, isHsl, isUnd, round } from './helpers.js';\n\n/**\n * @import {\n *   ColorArray,\n * } from '../types/index.js'\n*/\n\n/**\n * RGB / RGBA Color value string -> RGBA values array\n * @param  {String} rgbValue\n * @return {ColorArray}\n */\nconst rgbToRgba = rgbValue => {\n  const rgba = rgbExecRgx.exec(rgbValue) || rgbaExecRgx.exec(rgbValue);\n  const a = !isUnd(rgba[4]) ? +rgba[4] : 1;\n  return [\n    +rgba[1],\n    +rgba[2],\n    +rgba[3],\n    a\n  ]\n};\n\n/**\n * HEX3 / HEX3A / HEX6 / HEX6A Color value string -> RGBA values array\n * @param  {String} hexValue\n * @return {ColorArray}\n */\nconst hexToRgba = hexValue => {\n  const hexLength = hexValue.length;\n  const isShort = hexLength === 4 || hexLength === 5;\n  return [\n    +('0x' + hexValue[1] + hexValue[isShort ? 1 : 2]),\n    +('0x' + hexValue[isShort ? 2 : 3] + hexValue[isShort ? 2 : 4]),\n    +('0x' + hexValue[isShort ? 3 : 5] + hexValue[isShort ? 3 : 6]),\n    ((hexLength === 5 || hexLength === 9) ? +(+('0x' + hexValue[isShort ? 4 : 7] + hexValue[isShort ? 4 : 8]) / 255).toFixed(3) : 1)\n  ]\n};\n\n/**\n * @param  {Number} p\n * @param  {Number} q\n * @param  {Number} t\n * @return {Number}\n */\nconst hue2rgb = (p, q, t) => {\n  if (t < 0) t += 1;\n  if (t > 1) t -= 1;\n  return t < 1 / 6 ? p + (q - p) * 6 * t :\n         t < 1 / 2 ? q :\n         t < 2 / 3 ? p + (q - p) * (2 / 3 - t) * 6 :\n         p;\n};\n\n/**\n * HSL / HSLA Color value string -> RGBA values array\n * @param  {String} hslValue\n * @return {ColorArray}\n */\nconst hslToRgba = hslValue => {\n  const hsla = hslExecRgx.exec(hslValue) || hslaExecRgx.exec(hslValue);\n  const h = +hsla[1] / 360;\n  const s = +hsla[2] / 100;\n  const l = +hsla[3] / 100;\n  const a = !isUnd(hsla[4]) ? +hsla[4] : 1;\n  let r, g, b;\n  if (s === 0) {\n    r = g = b = l;\n  } else {\n    const q = l < .5 ? l * (1 + s) : l + s - l * s;\n    const p = 2 * l - q;\n    r = round(hue2rgb(p, q, h + 1 / 3) * 255, 0);\n    g = round(hue2rgb(p, q, h) * 255, 0);\n    b = round(hue2rgb(p, q, h - 1 / 3) * 255, 0);\n  }\n  return [r, g, b, a];\n};\n\n/**\n * All in one color converter that converts a color string value into an array of RGBA values\n * @param  {String} colorString\n * @return {ColorArray}\n */\nconst convertColorStringValuesToRgbaArray = colorString => {\n  return isRgb(colorString) ? rgbToRgba(colorString) :\n         isHex(colorString) ? hexToRgba(colorString) :\n         isHsl(colorString) ? hslToRgba(colorString) :\n         [0, 0, 0, 1];\n};\n\nexport { convertColorStringValuesToRgbaArray };\n","/**\n * Anime.js - core - ESM\n * @version v4.5.0\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { valueTypes, unitsExecRgx, digitWithExponentRgx, tweenTypes, isDomSymbol, isSvgSymbol, validTransforms, shortTransforms, proxyTargetSymbol, cssVariableMatchRgx, emptyString, cssVarPrefix } from './consts.js';\nimport { isUnd, isCol, isValidSVGAttribute, stringStartsWith, isFnc, isStr, round, lerp, cloneArray } from './helpers.js';\nimport { parseInlineTransforms } from './transforms.js';\nimport { resolveAdapterEntry } from '../adapters/registry.js';\nimport { convertColorStringValuesToRgbaArray } from './colors.js';\n\n/**\n* @import {\n*   Target,\n*   DOMTarget,\n*   Tween,\n*   TweenPropValue,\n*   TweenDecomposedValue,\n*   TargetsArray,\n* } from '../types/index.js'\n*/\n\n/**\n * @template T, D\n * @param {T|undefined} targetValue\n * @param {D} defaultValue\n * @return {T|D}\n */\nconst setValue = (targetValue, defaultValue) => {\n  return isUnd(targetValue) ? defaultValue : targetValue;\n};\n\n/**\n * 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.\n *\n * @param  {String} value\n * @param  {Target} target\n * @return {String|Number}\n */\nconst resolveCssVar = (value, target) => {\n  const match = value.match(cssVariableMatchRgx);\n  const el = target[isDomSymbol] ? target : document.documentElement;\n  let computed = getComputedStyle(/** @type {HTMLElement} */(el))?.getPropertyValue(match[1]);\n  if ((!computed || computed.trim() === emptyString) && match[2]) computed = match[2].trim();\n  return computed || 0;\n};\n\n/**\n * @param  {TweenPropValue} value\n * @param  {Target} target\n * @param  {Number} index\n * @param  {TargetsArray} targets\n * @param  {Object|null} store\n * @param  {Tween|null} prevTween\n * @return {any}\n */\nconst getFunctionValue = (value, target, index, targets, store, prevTween) => {\n  if (isFnc(value)) {\n    if (!store) {\n      const computed = /** @type {Function} */(value)(target, index, targets, prevTween);\n      // Fallback to 0 if the function returns undefined, NaN, null, false or 0\n      return !isNaN(+computed) ? +computed : computed || 0;\n    }\n    const func = () => {\n      const computed = /** @type {Function} */(value)(target, index, targets, prevTween);\n      return !isNaN(+computed) ? +computed : computed || 0;\n    };\n    store.func = func;\n    return func();\n  }\n  if (isStr(value) && stringStartsWith(value, cssVarPrefix)) {\n    if (!store) return resolveCssVar(/** @type {String} */(value), target);\n    const func = () => resolveCssVar(/** @type {String} */(value), target);\n    store.func = func;\n    return func();\n  }\n  return value;\n};\n\n/**\n * @param  {Target} target\n * @param  {String} prop\n * @return {tweenTypes}\n */\nconst getTweenType = (target, prop) => {\n  return !target[isDomSymbol] ? tweenTypes.OBJECT :\n    // Handle SVG attributes\n    target[isSvgSymbol] && isValidSVGAttribute(target, prop) ? tweenTypes.ATTRIBUTE :\n    // Handle CSS Transform properties differently than CSS to allow individual animations\n    validTransforms.includes(prop) || shortTransforms.get(prop) ? tweenTypes.TRANSFORM :\n    // CSS variables\n    stringStartsWith(prop, '--') ? tweenTypes.CSS_VAR :\n    // All other CSS properties\n    prop in /** @type {DOMTarget} */(target).style ? tweenTypes.CSS :\n    // Handle other DOM Attributes\n    prop in target ? tweenTypes.OBJECT :\n    tweenTypes.ATTRIBUTE;\n};\n\n/**\n * @param  {DOMTarget} target\n * @param  {String} propName\n * @param  {Object} animationInlineStyles\n * @return {String}\n */\nconst getCSSValue = (target, propName, animationInlineStyles) => {\n  const inlineStyles = target.style[propName];\n  if (inlineStyles && animationInlineStyles) {\n    animationInlineStyles[propName] = inlineStyles;\n  }\n  const value = inlineStyles || getComputedStyle(target[proxyTargetSymbol] || target).getPropertyValue(propName);\n  return value === 'auto' ? '0' : value;\n};\n\n/**\n * @param {Target} target\n * @param {String} propName\n * @param {tweenTypes} [tweenType]\n * @param {Object|void} [animationInlineStyles]\n * @return {String|Number}\n */\nconst getOriginalAnimatableValue = (target, propName, tweenType, animationInlineStyles) => {\n  const type = !isUnd(tweenType) ? tweenType : getTweenType(target, propName);\n  const adapterProp = resolveAdapterEntry(target, propName);\n  if (adapterProp) {\n    const value = adapterProp.get(target);\n    if (value && animationInlineStyles) animationInlineStyles[propName] = value;\n    return value == null ? 0 : value;\n  }\n  if (type === tweenTypes.OBJECT) {\n    const value = target[propName];\n    if (value && animationInlineStyles) animationInlineStyles[propName] = value;\n    return value || 0;\n  }\n  if (type === tweenTypes.ATTRIBUTE) {\n    const value = /** @type {DOMTarget} */(target).getAttribute(propName);\n    if (value && animationInlineStyles) animationInlineStyles[propName] = value;\n    return value;\n  }\n  return type === tweenTypes.TRANSFORM ? parseInlineTransforms(/** @type {DOMTarget} */(target), propName, animationInlineStyles) :\n         type === tweenTypes.CSS_VAR ? getCSSValue(/** @type {DOMTarget} */(target), propName, animationInlineStyles).trimStart() :\n         getCSSValue(/** @type {DOMTarget} */(target), propName, animationInlineStyles);\n};\n\n/**\n * @param  {Number} x\n * @param  {Number} y\n * @param  {String} operator\n * @return {Number}\n */\nconst getRelativeValue = (x, y, operator) => {\n  return operator === '-' ? x - y :\n         operator === '+' ? x + y :\n         x * y;\n};\n\n/** @return {TweenDecomposedValue} */\nconst createDecomposedValueTargetObject = () => {\n  return {\n    /** @type {valueTypes} */\n    t: valueTypes.NUMBER,\n    n: 0,\n    u: null,\n    o: null,\n    d: null,\n    s: null,\n  }\n};\n\n/**\n * @param  {String|Number|Object} rawValue\n * @param  {TweenDecomposedValue} targetObject\n * @return {TweenDecomposedValue}\n */\nconst decomposeRawValue = (rawValue, targetObject) => {\n  /** @type {valueTypes} */\n  targetObject.t = valueTypes.NUMBER;\n  targetObject.n = 0;\n  targetObject.u = null;\n  targetObject.o = null;\n  targetObject.d = null;\n  targetObject.s = null;\n  if (!rawValue) return targetObject;\n  const num = +rawValue;\n  if (!isNaN(num)) {\n    // It's a number\n    targetObject.n = num;\n    return targetObject;\n  }\n  // let str = /** @type {String} */(rawValue).trim();\n  let str = /** @type {String} */(rawValue);\n  // Parsing operators (+=, -=, *=) manually is much faster than using regex here\n  if (str[1] === '=') {\n    targetObject.o = str[0];\n    str = str.slice(2);\n  }\n  // Skip exec regex if the value type is complex or color to avoid long regex backtracking\n  const unitMatch = str.includes(' ') ? false : unitsExecRgx.exec(str);\n  if (unitMatch) {\n    // Has a number and a unit\n    targetObject.t = valueTypes.UNIT;\n    targetObject.n = +unitMatch[1];\n    targetObject.u = unitMatch[2];\n    return targetObject;\n  } else if (targetObject.o) {\n    // Has an operator (+=, -=, *=)\n    targetObject.n = +str;\n    return targetObject;\n  } else if (isCol(str)) {\n    // Color string\n    targetObject.t = valueTypes.COLOR;\n    targetObject.d = convertColorStringValuesToRgbaArray(str);\n    return targetObject;\n  } else {\n    // Is a more complex string (generally svg coords, calc() or filters CSS values)\n    const matchedNumbers = str.match(digitWithExponentRgx);\n    targetObject.t = valueTypes.COMPLEX;\n    targetObject.d = matchedNumbers ? matchedNumbers.map(Number) : [];\n    targetObject.s = str.split(digitWithExponentRgx) || [];\n    return targetObject;\n  }\n};\n\n/**\n * @param  {Tween} tween\n * @param  {TweenDecomposedValue} targetObject\n * @return {TweenDecomposedValue}\n */\nconst decomposeTweenValue = (tween, targetObject) => {\n  targetObject.t = tween._valueType;\n  targetObject.n = tween._toNumber;\n  targetObject.u = tween._unit;\n  targetObject.o = null;\n  targetObject.d = cloneArray(tween._toNumbers);\n  targetObject.s = cloneArray(tween._strings);\n  return targetObject;\n};\n\nconst decomposedOriginalValue = createDecomposedValueTargetObject();\n\n/**\n * @param  {Tween} tween\n * @param  {Number} progress\n * @param  {Number} precision\n * @return {String}\n */\nconst composeComplexValue = (tween, progress, precision) => {\n  const mod = tween._modifier;\n  const fn = tween._fromNumbers;\n  const tn = tween._toNumbers;\n  const ts = tween._strings;\n  let v = ts[0];\n  for (let j = 0, l = tn.length; j < l; j++) {\n    const n = /** @type {Number} */(mod(round(lerp(fn[j], tn[j], progress), precision)));\n    const s = ts[j + 1];\n    v += `${s ? n + s : n}`;\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.\n    // Potential optimization, skip the write when nothing reads it: if (hasComposition || tween._setter) tween._numbers[j] = n;\n    tween._numbers[j] = n;\n  }\n  return v;\n};\n\nexport { composeComplexValue, createDecomposedValueTargetObject, decomposeRawValue, decomposeTweenValue, decomposedOriginalValue, getFunctionValue, getOriginalAnimatableValue, getRelativeValue, getTweenType, setValue };\n","/**\n * Anime.js - core - ESM\n * @version v4.5.0\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { globals } from './globals.js';\nimport { minValue, tickModes, valueTypes, compositionTypes, tweenTypes, transformsSymbol } from './consts.js';\nimport { forEachChildren, round, now, clamp, lerp } from './helpers.js';\nimport { buildTransformString } from './transforms.js';\nimport { composeComplexValue } from './values.js';\n\n/**\n * @import {\n *   Tickable,\n *   Renderable,\n *   CallbackArgument,\n *   Tween,\n *   DOMTarget,\n * } from '../types/index.js'\n*/\n\n/**\n * @import {\n *   JSAnimation,\n * } from '../animation/animation.js'\n*/\n\n/**\n * @import {\n *   Timeline,\n * } from '../timeline/timeline.js'\n*/\n\n/**\n * @param  {Tickable} tickable\n * @param  {Number} time\n * @param  {Number} muteCallbacks\n * @param  {Number} internalRender\n * @param  {tickModes} tickMode\n * @return {Number}\n */\nconst render = (tickable, time, muteCallbacks, internalRender, tickMode) => {\n\n  const parent = tickable.parent;\n  const duration = tickable.duration;\n  const completed = tickable.completed;\n  const iterationDuration = tickable.iterationDuration;\n  const iterationCount = tickable.iterationCount;\n  const _currentIteration = tickable._currentIteration;\n  const _loopDelay = tickable._loopDelay;\n  const _reversed = tickable._reversed;\n  const _alternate = tickable._alternate;\n  const _hasChildren = tickable._hasChildren;\n  const tickableDelay = tickable._delay;\n  const tickablePrevAbsoluteTime = tickable._currentTime; // TODO: rename ._currentTime to ._absoluteCurrentTime\n  const tickableEndTime = tickableDelay + iterationDuration;\n  const tickableAbsoluteTime = time - tickableDelay;\n  const tickablePrevTime = clamp(tickablePrevAbsoluteTime, -tickableDelay, duration);\n  const tickableCurrentTime = clamp(tickableAbsoluteTime, -tickableDelay, duration);\n  const deltaTime = tickableAbsoluteTime - tickablePrevAbsoluteTime;\n  const isCurrentTimeAboveZero = tickableCurrentTime > 0;\n  const isCurrentTimeEqualOrAboveDuration = tickableCurrentTime >= duration;\n  const isSetter = duration <= minValue;\n  const forcedTick = tickMode === tickModes.FORCE;\n\n  let isOdd = 0;\n  let iterationElapsedTime = tickableAbsoluteTime;\n  // Render checks\n  // Used to also check if the children have rendered in order to trigger the onRender callback on the parent timer\n  let hasRendered = 0;\n\n  // Execute the \"expensive\" iterations calculations only when necessary\n  if (iterationCount > 1) {\n    // bitwise NOT operator seems to be generally faster than Math.floor() across browsers\n    const period = iterationDuration + (isCurrentTimeEqualOrAboveDuration ? 0 : _loopDelay);\n    const currentIteration = ~~(tickableCurrentTime / period);\n    tickable._currentIteration = clamp(currentIteration, 0, iterationCount);\n    // Prevent the iteration count to go above the max iterations when reaching the end of the animation\n    if (isCurrentTimeEqualOrAboveDuration) tickable._currentIteration--;\n    isOdd = tickable._currentIteration % 2;\n    // 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.\n    iterationElapsedTime = tickableCurrentTime - currentIteration * period || 0;\n  }\n\n  // Checks if exactly one of _reversed and (_alternate && isOdd) is true\n  const isReversed = _reversed ^ (_alternate && isOdd);\n  const _ease = /** @type {Renderable} */(tickable)._ease;\n  let iterationTime = isCurrentTimeEqualOrAboveDuration ? isReversed ? 0 : duration : isReversed ? iterationDuration - iterationElapsedTime : iterationElapsedTime;\n  if (_ease) iterationTime = iterationDuration * _ease(iterationTime / iterationDuration) || 0;\n  const isRunningBackwards = (parent ? parent.backwards : tickableAbsoluteTime < tickablePrevAbsoluteTime) ? !isReversed : !!isReversed;\n\n  tickable._currentTime = tickableAbsoluteTime;\n  tickable._iterationTime = iterationTime;\n  tickable.backwards = isRunningBackwards;\n\n  if (isCurrentTimeAboveZero && !tickable.began) {\n    tickable.began = true;\n    if (!muteCallbacks && !(parent && (isRunningBackwards || !parent.began))) {\n      tickable.onBegin(/** @type {CallbackArgument} */(tickable));\n    }\n  } else if (tickableAbsoluteTime <= 0) {\n    tickable.began = false;\n  }\n\n  // Only triggers onLoop for tickable without children, otherwise call the the onLoop callback in the tick function\n  // Make sure to trigger the onLoop before rendering to allow .refresh() to pickup the current values\n  if (!muteCallbacks && !_hasChildren && isCurrentTimeAboveZero && tickable._currentIteration !== _currentIteration) {\n    tickable.onLoop(/** @type {CallbackArgument} */(tickable));\n  }\n\n  if (\n    forcedTick ||\n    tickMode === tickModes.AUTO && (\n      // Timeline children render from their offset instead of their delay so the gap left by a truncated sibling is covered on seek.\n      time >= (parent && tickableDelay > 0 ? 0 : tickableDelay) && time <= tickableEndTime || // Normal render\n      time <= tickableDelay && tickablePrevTime > tickableDelay || // Playhead is before the animation start time so make sure the animation is at its initial state\n      time >= tickableEndTime && tickablePrevTime !== duration // Playhead is after the animation end time so make sure the animation is at its end state\n    ) ||\n    iterationTime >= tickableEndTime && tickablePrevTime !== duration ||\n    // 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.\n    iterationTime <= tickableDelay && tickablePrevTime > 0 && !isCurrentTimeEqualOrAboveDuration ||\n    time <= tickablePrevTime && tickablePrevTime === duration && completed || // Force a render if a seek occurs on an completed animation\n    isCurrentTimeEqualOrAboveDuration && !completed && isSetter // This prevents 0 duration tickables to be skipped\n  ) {\n\n    if (isCurrentTimeAboveZero) {\n      // Trigger onUpdate callback before rendering\n      tickable.computeDeltaTime(tickablePrevTime);\n      if (!muteCallbacks) tickable.onBeforeUpdate(/** @type {CallbackArgument} */(tickable));\n    }\n\n    // Start tweens rendering\n    if (!_hasChildren) {\n\n      // Time has jumped more than globals.tickThreshold so consider this tick manual\n      const forcedRender = forcedTick || (isRunningBackwards ? deltaTime * -1 : deltaTime) >= globals.tickThreshold;\n      // Round to match the precision of tween._absoluteStartTime so equal-time boundary checks compare cleanly without floating point drift from the unrounded _offset.\n      const absoluteTime = round(tickable._offset + (parent ? parent._offset : 0) + tickableDelay + iterationTime, 12);\n\n      // Only Animation can have tweens, Timer returns undefined\n      let tween = /** @type {Tween} */(/** @type {JSAnimation} */(tickable)._head);\n      let tweenTarget;\n      let tweenStyle;\n      let tweenTargetTransforms;\n      let tweenTargetTransformsProperties;\n      let tweenTransformsNeedUpdate = 0;\n\n      while (tween) {\n\n        const tweenComposition = tween._composition;\n        const tweenCurrentTime = tween._currentTime;\n        const tweenChangeDuration = tween._changeDuration;\n        const tweenAbsEndTime = tween._absoluteStartTime + tween._changeDuration;\n        const tweenNextRep = tween._nextRep;\n        const tweenPrevRep = tween._prevRep;\n        const tweenHasComposition = tweenComposition !== compositionTypes.none;\n        // The previous sibling stops writing at its truncated end, so this tween takes over the hold from that point.\n        const tweenPrevRepEndTime = tweenPrevRep ? tweenPrevRep._absoluteStartTime + tweenPrevRep._changeDuration : 0;\n        const tweenPrevRepIsCrossParent = tweenPrevRep && tweenPrevRep.parent !== tween.parent;\n        // Same parent keyframes take over at their own start, end plus delay equals the next start by construction.\n        // Cross parent siblings take over at their update start.\n        // Negative delay siblings take over at their own start instead.\n        const tweenNextRepTakeover = !tweenNextRep || tweenNextRep._isOverridden ? tweenAbsEndTime :\n          tweenNextRep.parent === tween.parent ? tweenAbsEndTime + tweenNextRep._delay :\n          tweenNextRep._absoluteStartTime < tweenNextRep._absoluteUpdateStartTime ? tweenNextRep._absoluteStartTime : tweenNextRep._absoluteUpdateStartTime;\n\n        if ((forcedRender || (\n            // 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.\n            (tweenCurrentTime !== tweenChangeDuration || absoluteTime <= tweenNextRepTakeover ||\n            (tweenPrevRep && !tweenPrevRepIsCrossParent && (!tweenNextRep || tweenNextRep.parent !== tween.parent))) &&\n            // A cross parent tween re-renders its from value from the previous sibling truncated end so the handoff gap holds.\n            // 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.\n            (tweenCurrentTime !== 0 || absoluteTime >= tween._absoluteStartTime ||\n            (tweenPrevRepIsCrossParent && !tween._hasFromValue && !tweenPrevRep._isOverridden && absoluteTime >= tweenPrevRepEndTime) ||\n            (tweenNextRep && !tweenNextRep._isOverridden && tweenNextRep.parent === tween.parent && tweenNextRep._currentTime !== 0 && iterationTime < tweenNextRep._startTime))\n          )) &&\n          // 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.\n          (!tweenPrevRep || tweenPrevRepIsCrossParent || iterationTime >= tween._startTime) &&\n          (!tweenHasComposition || (\n            !tween._isOverridden &&\n            (!tween._isOverlapped || absoluteTime <= tweenAbsEndTime) &&\n            // The next sibling owns the value past its takeover point, so yielding there keeps writes single owner in both directions.\n            (!tweenNextRep || tweenNextRep._isOverridden || absoluteTime <= tweenNextRepTakeover) &&\n            // The previous sibling owns the value up to its truncated end.\n            // Cross parent tweens take over the hold from that point, explicit from values wait for their own start.\n            (!tweenPrevRep || (tweenPrevRep._isOverridden || (!tweenPrevRepIsCrossParent ?\n              absoluteTime >= tweenPrevRepEndTime + tween._delay :\n              absoluteTime >= tween._absoluteStartTime || (!tween._hasFromValue && absoluteTime >= tweenPrevRepEndTime))))\n          ))\n        ) {\n\n          const tweenNewTime = tween._currentTime = clamp(iterationTime - tween._startTime, 0, tweenChangeDuration);\n          const tweenProgress = tween._ease(tweenNewTime / tween._updateDuration);\n          const tweenModifier = tween._modifier;\n          const tweenValueType = tween._valueType;\n          const tweenType = tween._tweenType;\n          const tweenIsObject = tweenType === tweenTypes.OBJECT;\n          const tweenIsNumber = tweenValueType === valueTypes.NUMBER;\n          // 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.\n          const tweenPrecision = (tweenIsNumber && tweenIsObject) || tweenProgress === 0 || tweenProgress === 1 ? -1 : globals.precision;\n\n          // Recompose tween value\n          /** @type {String|Number} */\n          let value;\n          /** @type {Number} */\n          let number;\n\n          if (tweenIsNumber) {\n            value = number = /** @type {Number} */(tweenModifier(round(lerp(tween._fromNumber, tween._toNumber,  tweenProgress), tweenPrecision )));\n          } else if (tweenValueType === valueTypes.UNIT) {\n            // Rounding the values speed up string composition\n            number = /** @type {Number} */(tweenModifier(round(lerp(tween._fromNumber, tween._toNumber,  tweenProgress), tweenPrecision)));\n            value = `${number}${tween._unit}`;\n          } else if (tweenValueType === valueTypes.COLOR) {\n            const ns = tween._numbers;\n            const fn = tween._fromNumbers;\n            const tn = tween._toNumbers;\n            const omt = 1 - tweenProgress;\n            const fr = fn[0], fg = fn[1], fb = fn[2];\n            const tr = tn[0], tg = tn[1], tb = tn[2];\n            // RGB channels lerp in pseudo-linear space (square inputs, sqrt result) to approximate gamma-correct blending.\n            // See https://developer.nvidia.com/gpugems/gpugems3/part-iv-image-effects/chapter-24-importance-being-linear.\n            ns[0] = /** @type {Number} */(tweenModifier(Math.sqrt(fr * fr * omt + tr * tr * tweenProgress)));\n            ns[1] = /** @type {Number} */(tweenModifier(Math.sqrt(fg * fg * omt + tg * tg * tweenProgress)));\n            ns[2] = /** @type {Number} */(tweenModifier(Math.sqrt(fb * fb * omt + tb * tb * tweenProgress)));\n            ns[3] = /** @type {Number} */(tweenModifier(lerp(fn[3], tn[3], tweenProgress)));\n            // The rgba string is built only for the dispatch path or the internalRender composition tick (setters handles the color comp)\n            if (!tween._setter || internalRender) {\n              value = `rgba(${round(ns[0], 0)},${round(ns[1], 0)},${round(ns[2], 0)},${ns[3]})`;\n            }\n          } else if (tweenValueType === valueTypes.COMPLEX) {\n            value = composeComplexValue(tween, tweenProgress, tweenPrecision);\n          }\n\n          // For additive tweens and Animatables\n          if (tweenHasComposition) {\n            tween._number = number;\n          }\n\n          if (!internalRender && tweenComposition !== compositionTypes.blend) {\n\n            const tweenProperty = tween.property;\n            tweenTarget = tween.target;\n\n            if (tween._setter) {\n              tween._setter(tweenTarget, number, tween);\n            } else if (tweenIsObject) {\n              tweenTarget[tweenProperty] = value;\n            } else if (tweenType === tweenTypes.ATTRIBUTE) {\n              /** @type {DOMTarget} */(tweenTarget).setAttribute(tweenProperty, /** @type {String} */(value));\n            } else {\n              tweenStyle = /** @type {DOMTarget} */(tweenTarget).style;\n              if (tweenType === tweenTypes.TRANSFORM) {\n                if (tweenTarget !== tweenTargetTransforms) {\n                  tweenTargetTransforms = tweenTarget;\n                  // NOTE: Referencing the cachedTransforms in the tween property directly can be a little bit faster but appears to increase memory usage.\n                  tweenTargetTransformsProperties = tweenTarget[transformsSymbol];\n                }\n                tweenTargetTransformsProperties[tweenProperty] = value;\n                tweenTransformsNeedUpdate = 1;\n              } else if (tweenType === tweenTypes.CSS) {\n                tweenStyle[tweenProperty] = value;\n              } else if (tweenType === tweenTypes.CSS_VAR) {\n                tweenStyle.setProperty(tweenProperty,/** @type {String} */(value));\n              }\n            }\n\n            if (isCurrentTimeAboveZero) hasRendered = 1;\n\n          } else {\n            // Used for composing timeline tweens without having to do a real render\n            tween._value = value;\n          }\n\n        } else if (tweenCurrentTime && tweenPrevRep && !tweenPrevRepIsCrossParent && iterationTime < tween._startTime) {\n          // Mark the keyframe as reverted when the playhead moves before its start, the previous keyframe owns the from revert and writes it once.\n          tween._currentTime = 0;\n        }\n\n        if (tweenTransformsNeedUpdate && tween._renderTransforms) {\n          tweenStyle.transform = buildTransformString(tweenTargetTransformsProperties);\n          tweenTransformsNeedUpdate = 0;\n        }\n\n        tween = tween._next;\n      }\n\n      if (!muteCallbacks && hasRendered) {\n        /** @type {JSAnimation} */(tickable).onRender(/** @type {JSAnimation} */(tickable));\n      }\n    }\n\n    if (!muteCallbacks && isCurrentTimeAboveZero) {\n      tickable.onUpdate(/** @type {CallbackArgument} */(tickable));\n    }\n\n  }\n\n  // End tweens rendering\n\n  // Handle setters on timeline differently and allow re-trigering the onComplete callback when seeking backwards\n  if (parent && isSetter) {\n    if (!muteCallbacks && (\n      // (tickableAbsoluteTime > 0 instead) of (tickableAbsoluteTime >= duration) to prevent floating point precision issues\n      // see: https://github.com/juliangarnier/anime/issues/1088\n      (parent.began && !isRunningBackwards && tickableAbsoluteTime > 0 && !completed) ||\n      (isRunningBackwards && tickableAbsoluteTime <= minValue && completed)\n    )) {\n      tickable.onComplete(/** @type {CallbackArgument} */(tickable));\n      tickable.completed = !isRunningBackwards;\n    }\n  // If currentTime is both above 0 and at least equals to duration, handles normal onComplete or infinite loops\n  } else if (isCurrentTimeAboveZero && isCurrentTimeEqualOrAboveDuration) {\n    if (iterationCount === Infinity) {\n      // Offset the tickable _startTime with its duration to reset _currentTime to 0 and continue the infinite timer\n      tickable._startTime += tickable.duration;\n    } else if (tickable._currentIteration >= iterationCount - 1) {\n      // By setting paused to true, we tell the engine loop to not render this tickable and removes it from the list on the next tick\n      tickable.paused = true;\n      if (!completed && !_hasChildren) {\n        // If the tickable has children, triggers onComplete() only when all children have completed in the tick function\n        tickable.completed = true;\n        if (!muteCallbacks && !(parent && (isRunningBackwards || !parent.began))) {\n          tickable.onComplete(/** @type {CallbackArgument} */(tickable));\n          tickable._resolve(/** @type {CallbackArgument} */(tickable));\n        }\n      }\n    }\n  // Otherwise set the completed flag to false\n  } else {\n    tickable.completed = false;\n  }\n\n  // NOTE: hasRendered * direction (negative for backwards) this way we can remove the tickable.backwards property completly ?\n  return hasRendered;\n};\n\n/**\n * @param  {Tickable} tickable\n * @param  {Number} time\n * @param  {Number} muteCallbacks\n * @param  {Number} internalRender\n * @param  {Number} tickMode\n * @return {void}\n */\nconst tick = (tickable, time, muteCallbacks, internalRender, tickMode) => {\n  const _currentIteration = tickable._currentIteration;\n  render(tickable, time, muteCallbacks, internalRender, tickMode);\n  if (tickable._hasChildren) {\n    const tl = /** @type {Timeline} */(tickable);\n    const tlIsRunningBackwards = tl.backwards;\n    const tlChildrenTime = internalRender ? time : tl._iterationTime;\n    const tlCildrenTickTime = now();\n\n    let tlChildrenHasRendered = 0;\n    let tlChildrenHaveCompleted = true;\n\n    // If the timeline has looped forward, we need to manually triggers children skipped callbacks\n    if (!internalRender && tl._currentIteration !== _currentIteration) {\n      const tlIterationDuration = tl.iterationDuration;\n      forEachChildren(tl, (/** @type {JSAnimation} */child) => {\n        if (!tlIsRunningBackwards) {\n          // Force an internal render to trigger the callbacks if the child has not completed on loop\n          if (!child.completed && !child.backwards && child._currentTime < child.iterationDuration) {\n            render(child, tlIterationDuration, muteCallbacks, 1, tickModes.FORCE);\n          }\n          // Reset their began and completed flags to allow retrigering callbacks on the next iteration\n          child.began = false;\n          child.completed = false;\n        } else {\n          const childDuration = child.duration;\n          const childStartTime = child._offset + child._delay;\n          const childEndTime = childStartTime + childDuration;\n          // Triggers the onComplete callback on reverse for children on the edges of the timeline\n          if (!muteCallbacks && childDuration <= minValue && (!childStartTime || childEndTime === tlIterationDuration)) {\n            child.onComplete(child);\n          }\n        }\n      });\n      if (!muteCallbacks) tl.onLoop(/** @type {CallbackArgument} */(tl));\n    }\n\n    forEachChildren(tl, (/** @type {JSAnimation} */child) => {\n      const childTime = round((tlChildrenTime - child._offset) * child._speed, 12); // Rounding is needed when using seconds\n      // 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.\n      if (tlIsRunningBackwards && childTime > child._delay + child.duration) return;\n      const childTickMode = child._fps < tl._fps ? child.requestTick(tlCildrenTickTime) : tickMode;\n      tlChildrenHasRendered += render(child, childTime, muteCallbacks, internalRender, childTickMode);\n      if (!child.completed && tlChildrenHaveCompleted) tlChildrenHaveCompleted = false;\n    }, tlIsRunningBackwards);\n\n    // Renders on timeline are triggered by its children so it needs to be set after rendering the children\n    if (!muteCallbacks && tlChildrenHasRendered) tl.onRender(/** @type {CallbackArgument} */(tl));\n    // Triggers the timeline onComplete() once all chindren all completed and the current time has reached the end\n    if ((tlChildrenHaveCompleted || tlIsRunningBackwards) && tl._currentTime >= tl.duration) {\n      // Make sure the paused flag is false in case it has been skipped in the render function\n      tl.paused = true;\n      if (!tl.completed) {\n        tl.completed = true;\n        if (!muteCallbacks) {\n          tl.onComplete(/** @type {CallbackArgument} */(tl));\n          tl._resolve(/** @type {CallbackArgument} */(tl));\n        }\n      }\n    }\n  }\n};\n\nexport { render, tick };\n","/**\n * Anime.js - core - ESM\n * @version v4.5.0\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { tweenTypes, isDomSymbol, transformsSymbol, emptyString, shortTransforms } from './consts.js';\nimport { forEachChildren, toLowerCase, isNil, isSvg } from './helpers.js';\nimport { buildTransformString } from './transforms.js';\nimport { decomposeRawValue, decomposedOriginalValue } from './values.js';\n\n/**\n * @import {\n *   JSAnimation,\n * } from '../animation/animation.js'\n*/\n\n/**\n* @import {\n*   Target,\n*   DOMTarget,\n*   Renderable,\n*   Tween,\n* } from '../types/index.js'\n*/\n\nconst propertyNamesCache = {};\n\n/**\n * @param  {String} propertyName\n * @param  {Target} target\n * @param  {tweenTypes} tweenType\n * @return {String}\n */\nconst sanitizePropertyName = (propertyName, target, tweenType) => {\n  if (tweenType === tweenTypes.TRANSFORM) {\n    const t = shortTransforms.get(propertyName);\n    return t ? t : propertyName;\n  } else if (\n    tweenType === tweenTypes.CSS ||\n    // Handle special cases where properties like \"strokeDashoffset\" needs to be set as \"stroke-dashoffset\"\n    // but properties like \"baseFrequency\" should stay in lowerCamelCase\n    (tweenType === tweenTypes.ATTRIBUTE && (isSvg(target) && propertyName in /** @type {DOMTarget} */(target).style))\n  ) {\n    const cachedPropertyName = propertyNamesCache[propertyName];\n    if (cachedPropertyName) {\n      return cachedPropertyName;\n    } else {\n      const lowerCaseName = propertyName ? toLowerCase(propertyName) : propertyName;\n      propertyNamesCache[propertyName] = lowerCaseName;\n      return lowerCaseName;\n    }\n  } else {\n    return propertyName;\n  }\n};\n\n/**\n * @template {Renderable} T\n * @param {T} renderable\n * @param {Boolean} [inlineStylesOnly]\n * @return {T}\n */\nconst revertValues = (renderable, inlineStylesOnly = false) => {\n  // Allow revertValues() to be called on timelines\n  if (renderable._hasChildren) {\n    forEachChildren(renderable, (/** @type {Renderable} */child) => revertValues(child, inlineStylesOnly), true);\n  } else {\n    const animation = /** @type {JSAnimation} */(renderable);\n    animation.pause();\n    forEachChildren(animation, (/** @type {Tween} */tween) => {\n      const tweenProperty = tween.property;\n      const tweenTarget = tween.target;\n      const tweenType = tween._tweenType;\n      const originalInlinedValue = tween._inlineValue;\n      const tweenHadNoInlineValue = isNil(originalInlinedValue) || originalInlinedValue === emptyString;\n      if (tween._setter) {\n        if (!inlineStylesOnly && !tweenHadNoInlineValue) {\n          // 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.\n          decomposeRawValue(originalInlinedValue, decomposedOriginalValue);\n          if (decomposedOriginalValue.d) {\n            const src = decomposedOriginalValue.d;\n            const dst = tween._numbers;\n            for (let i = 0, l = src.length; i < l; i++) dst[i] = src[i];\n          } else {\n            tween._number = decomposedOriginalValue.n;\n          }\n          tween._setter(tween.target, tween._number, tween);\n        }\n      } else if (tweenType === tweenTypes.OBJECT) {\n        if (!inlineStylesOnly && !tweenHadNoInlineValue) {\n          tweenTarget[tweenProperty] = originalInlinedValue;\n        }\n      } else if (tweenTarget[isDomSymbol]) {\n        if (tweenType === tweenTypes.ATTRIBUTE) {\n          if (!inlineStylesOnly) {\n            if (tweenHadNoInlineValue) {\n              /** @type {DOMTarget} */(tweenTarget).removeAttribute(tweenProperty);\n            } else {\n              /** @type {DOMTarget} */(tweenTarget).setAttribute(tweenProperty, /** @type {String} */(originalInlinedValue));\n            }\n          }\n        } else {\n          const targetStyle = /** @type {DOMTarget} */(tweenTarget).style;\n          if (tweenType === tweenTypes.TRANSFORM) {\n            const cachedTransforms = tweenTarget[transformsSymbol];\n            if (tweenHadNoInlineValue) {\n              delete cachedTransforms[tweenProperty];\n            } else {\n              cachedTransforms[tweenProperty] = originalInlinedValue;\n            }\n            if (tween._renderTransforms) {\n              if (!Object.keys(cachedTransforms).length) {\n                targetStyle.removeProperty('transform');\n              } else {\n                targetStyle.transform = buildTransformString(cachedTransforms);\n              }\n            }\n          } else {\n            if (tweenHadNoInlineValue) {\n              targetStyle.removeProperty(toLowerCase(tweenProperty));\n            } else {\n              targetStyle[tweenProperty] = originalInlinedValue;\n            }\n          }\n        }\n      }\n      if (tweenTarget[isDomSymbol] && animation._tail === tween) {\n        animation.targets.forEach(t => {\n          if (t.getAttribute && t.getAttribute('style') === emptyString) {\n            t.removeAttribute('style');\n          }        });\n      }\n    });\n  }\n  return renderable;\n};\n\n/**\n * @template {Renderable} T\n * @param {T} renderable\n * @return {T}\n */\nconst cleanInlineStyles = renderable => revertValues(renderable, true);\n\nexport { cleanInlineStyles, revertValues, sanitizePropertyName };\n","/**\n * Anime.js - core - ESM\n * @version v4.5.0\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { K, maxFps, minValue, tickModes } from './consts.js';\nimport { defaults } from './globals.js';\n\n/**\n * @import {\n *   Tickable,\n *   Tween,\n * } from '../types/index.js'\n*/\n\n/*\n * Base class to control framerate and playback rate.\n * Inherited by Engine, Timer, Animation and Timeline.\n */\nclass Clock {\n\n  /** @param {Number} [initTime] */\n  constructor(initTime = 0) {\n    /** @type {Number} */\n    this.deltaTime = 0;\n    /** @type {Number} */\n    this._currentTime = initTime;\n    /** @type {Number} */\n    this._lastTickTime = initTime;\n    /** @type {Number} */\n    this._startTime = initTime;\n    /** @type {Number} */\n    this._lastTime = initTime;\n    /** @type {Number} */\n    this._frameDuration = K / maxFps;\n    /** @type {Number} */\n    this._fps = maxFps;\n    /** @type {Number} */\n    this._speed = 1;\n    /** @type {Boolean} */\n    this._hasChildren = false;\n    /** @type {Tickable|Tween} */\n    this._head = null;\n    /** @type {Tickable|Tween} */\n    this._tail = null;\n  }\n\n  get fps() {\n    return this._fps;\n  }\n\n  set fps(frameRate) {\n    const fr = +frameRate;\n    const fps = fr < minValue ? minValue : fr;\n    const frameDuration = K / fps;\n    if (fps > defaults.frameRate) defaults.frameRate = fps;\n    this._fps = fps;\n    this._frameDuration = frameDuration;\n  }\n\n  get speed() {\n    return this._speed;\n  }\n\n  set speed(playbackRate) {\n    const pbr = +playbackRate;\n    this._speed = pbr < minValue ? minValue : pbr;\n  }\n\n  /**\n   * @param  {Number} time\n   * @return {tickModes}\n   */\n  requestTick(time) {\n    const frameDuration = this._frameDuration;\n    const elapsed = time - this._lastTickTime;\n    const scaled = frameDuration * .25;\n    const tolerance = scaled < 4 ? scaled : 4;\n    // Tolerance prevents dropping frames that arrive a bit early due to RAF jitter\n    // typically <= ~25% of frame duration and capped at 4ms so it doesn't dominate at high fps.\n    // e.g. at 60fps (frameDuration=16.667ms) a frame arriving after 15ms:\n    // - without tolerance: 15 < 16.667 -> skip\n    // - with tolerance: 15 + 4 >= 16.667 -> tick\n    if (elapsed + tolerance < frameDuration) return tickModes.NONE;\n    this._lastTickTime = elapsed >= frameDuration ? time - (elapsed % frameDuration) : time;\n    return tickModes.AUTO;\n  }\n\n  /**\n   * @param  {Number} time\n   * @return {Number}\n   */\n  computeDeltaTime(time) {\n    const delta = time - this._lastTime;\n    this.deltaTime = delta;\n    this._lastTime = time;\n    return delta;\n  }\n\n}\n\nexport { Clock };\n","/**\n * Anime.js - animation - ESM\n * @version v4.5.0\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { noop, minValue, valueTypes, tickModes } from '../core/consts.js';\nimport { cloneArray } from '../core/helpers.js';\nimport { render } from '../core/render.js';\n\nconst additive = {\n  animation: null,\n  update: noop,\n};\n\n/**\n * @import {\n *   Tween,\n *   TweenAdditiveLookups,\n * } from '../types/index.js'\n */\n\n/**\n * @typedef AdditiveAnimation\n * @property {Number} duration\n * @property {Number} _offset\n * @property {Number} _delay\n * @property {Tween} _head\n * @property {Tween} _tail\n */\n\n/**\n * @param  {TweenAdditiveLookups} lookups\n * @return {AdditiveAnimation}\n */\nconst addAdditiveAnimation = lookups => {\n  let animation = additive.animation;\n  if (!animation) {\n    animation = {\n      duration: minValue,\n      computeDeltaTime: noop,\n      _offset: 0,\n      _delay: 0,\n      _head: null,\n      _tail: null,\n    };\n    additive.animation = animation;\n    additive.update = () => {\n      lookups.forEach(propertyAnimation => {\n        for (let propertyName in propertyAnimation) {\n          const tweens = propertyAnimation[propertyName];\n          const lookupTween = tweens._head;\n          if (lookupTween) {\n            const valueType = lookupTween._valueType;\n            const additiveValues = valueType === valueTypes.COMPLEX || valueType === valueTypes.COLOR ? cloneArray(lookupTween._fromNumbers) : null;\n            let additiveValue = lookupTween._fromNumber;\n            let tween = tweens._tail;\n            while (tween && tween !== lookupTween) {\n              if (additiveValues) {\n                for (let i = 0, l = tween._numbers.length; i < l; i++) additiveValues[i] += tween._numbers[i];\n              } else {\n                additiveValue += tween._number;\n              }\n              tween = tween._prevAdd;\n            }\n            lookupTween._toNumber = additiveValue;\n            lookupTween._toNumbers = additiveValues;\n          }\n        }\n      });\n      // TODO: Avoid polymorphism here, idealy the additive animation should be a regular animation with a higher priority in the render loop\n      render(animation, 1, 1, 0, tickModes.FORCE);\n    };\n  }\n  return animation;\n};\n\nexport { addAdditiveAnimation, additive };\n","/**\n * Anime.js - engine - ESM\n * @version v4.5.0\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { globalVersions, defaults, globals } from '../core/globals.js';\nimport { isBrowser, doc, tickModes, K } from '../core/consts.js';\nimport { now, removeChild, forEachChildren } from '../core/helpers.js';\nimport { Clock } from '../core/clock.js';\nimport { tick } from '../core/render.js';\nimport { additive } from '../animation/additive.js';\n\n/**\n * @import {\n *   DefaultsParams,\n * } from '../types/index.js'\n*/\n\n/**\n * @import {\n *   Tickable,\n * } from '../types/index.js'\n*/\n\nconst engineTickMethod = /*#__PURE__*/ (() => isBrowser ? requestAnimationFrame : setImmediate)();\nconst engineCancelMethod = /*#__PURE__*/ (() => isBrowser ? cancelAnimationFrame : clearImmediate)();\n\nclass Engine extends Clock {\n\n  /** @param {Number} [initTime] */\n  constructor(initTime) {\n    super(initTime);\n    this.useDefaultMainLoop = true;\n    this.pauseOnDocumentHidden = true;\n    /** @type {DefaultsParams} */\n    this.defaults = defaults;\n    // this.paused = isBrowser && doc.hidden ? true  : false;\n    this.paused = true;\n    /** @type {Number|NodeJS.Immediate} */\n    this.reqId = 0;\n  }\n\n  update() {\n    const time = this._currentTime = now();\n    if (this.requestTick(time)) {\n      this.computeDeltaTime(time);\n      const engineSpeed = this._speed;\n      const engineFps = this._fps;\n      let activeTickable = /** @type {Tickable} */(this._head);\n      while (activeTickable) {\n        const nextTickable = activeTickable._next;\n        if (!activeTickable.paused) {\n          tick(\n            activeTickable,\n            (time - activeTickable._startTime) * activeTickable._speed * engineSpeed,\n            0, // !muteCallbacks\n            0, // !internalRender\n            activeTickable._fps < engineFps ? activeTickable.requestTick(time) : tickModes.AUTO\n          );\n        } else {\n          removeChild(this, activeTickable);\n          this._hasChildren = !!this._tail;\n          activeTickable._running = false;\n          if (activeTickable.completed && !activeTickable._cancelled) {\n            activeTickable.cancel();\n          }\n        }\n        activeTickable = nextTickable;\n      }\n      additive.update();\n    }\n  }\n\n  wake() {\n    if (this.useDefaultMainLoop && !this.reqId) {\n      // Imediatly request a tick to update engine._lastTickTime and get accurate offsetPosition calculation in timer.js\n      this.requestTick(now());\n      this.reqId = engineTickMethod(tickEngine);\n    }\n    return this;\n  }\n\n  pause() {\n    if (!this.reqId) return;\n    this.paused = true;\n    return killEngine();\n  }\n\n  resume() {\n    if (!this.paused) return;\n    this.paused = false;\n    forEachChildren(this, (/** @type {Tickable} */child) => child.resetTime());\n    return this.wake();\n  }\n\n  // Getter and setter for speed\n  get speed() {\n    return this._speed * (globals.timeScale === 1 ? 1 : K);\n  }\n\n  set speed(playbackRate) {\n    const speed = playbackRate * globals.timeScale;\n    if (this._speed === speed) return;\n    this._speed = speed;\n    forEachChildren(this, (/** @type {Tickable} */child) => child.speed = child._speed);\n  }\n\n  // Getter and setter for timeUnit\n  get timeUnit() {\n    return globals.timeScale === 1 ? 'ms' : 's';\n  }\n\n  set timeUnit(unit) {\n    const secondsScale = 0.001;\n    const isSecond = unit === 's';\n    const newScale = isSecond ? secondsScale : 1;\n    if (globals.timeScale !== newScale) {\n      globals.timeScale = newScale;\n      globals.tickThreshold = 200 * newScale;\n      const scaleFactor = isSecond ? secondsScale : K;\n      /** @type {Number} */\n      (this.defaults.duration) *= scaleFactor;\n      this._speed *= scaleFactor;\n    }\n  }\n\n  // Getter and setter for precision\n  get precision() {\n    return globals.precision;\n  }\n\n  set precision(precision) {\n    globals.precision = precision;\n  }\n\n}\n\nconst engine = /*#__PURE__*/(() => {\n  const engine = new Engine(now());\n  if (isBrowser) {\n    globalVersions.engine = engine;\n    doc.addEventListener('visibilitychange', () => {\n      if (!engine.pauseOnDocumentHidden) return;\n      doc.hidden ? engine.pause() : engine.resume();\n    });\n  }\n  return engine;\n})();\n\n\nconst tickEngine = () => {\n  if (engine._head) {\n    engine.reqId = engineTickMethod(tickEngine);\n    engine.update();\n  } else {\n    engine.reqId = 0;\n  }\n};\n\nconst killEngine = () => {\n  engineCancelMethod(/** @type {NodeJS.Immediate & Number} */(engine.reqId));\n  engine.reqId = 0;\n  return engine;\n};\n\nexport { engine };\n","/**\n * Anime.js - animation - ESM\n * @version v4.5.0\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { compositionTypes, minValue, tweenTypes } from '../core/consts.js';\nimport { forEachChildren, removeChild, isUnd, addChild, round, cloneArray } from '../core/helpers.js';\nimport { sanitizePropertyName } from '../core/styles.js';\nimport { engine } from '../engine/engine.js';\nimport { additive, addAdditiveAnimation } from './additive.js';\n\n/**\n * @import {\n *   TweenReplaceLookups,\n *   TweenAdditiveLookups,\n *   TweenPropertySiblings,\n *   Tween,\n *   Target,\n *   TargetsArray,\n *   Renderable,\n * } from '../types/index.js'\n *\n * @import {\n *   JSAnimation,\n * } from '../animation/animation.js'\n*/\n\nconst lookups = {\n  /** @type {TweenReplaceLookups} */\n  _rep: new WeakMap(),\n  /** @type {TweenAdditiveLookups} */\n  _add: new Map(),\n};\n\n/**\n * @param  {Target} target\n * @param  {String} property\n * @param  {String} lookup\n * @return {TweenPropertySiblings}\n */\nconst getTweenSiblings = (target, property, lookup = '_rep') => {\n  const lookupMap = lookups[lookup];\n  let targetLookup = lookupMap.get(target);\n  if (!targetLookup) {\n    targetLookup = {};\n    lookupMap.set(target, targetLookup);\n  }\n  return targetLookup[property] ? targetLookup[property] : targetLookup[property] = {\n    _head: null,\n    _tail: null,\n  }\n};\n\n/**\n * @param  {Tween} p\n * @param  {Tween} c\n * @return {Number|Boolean}\n */\nconst addTweenSortMethod = (p, c) => {\n  return p._isOverridden || p._absoluteStartTime > c._absoluteStartTime;\n};\n\n/**\n * @param {Tween} tween\n */\nconst overrideTween = tween => {\n  tween._isOverlapped = 1;\n  tween._isOverridden = 1;\n  tween._changeDuration = minValue;\n  tween._currentTime = minValue;\n};\n\n/**\n * @param  {Tween} tween\n * @param  {TweenPropertySiblings} siblings\n * @return {Tween}\n */\nconst composeTween = (tween, siblings) => {\n\n  const tweenCompositionType = tween._composition;\n\n  // Handle replaced tweens\n\n  if (tweenCompositionType === compositionTypes.replace) {\n\n    const tweenAbsStartTime = tween._absoluteStartTime;\n\n    addChild(siblings, tween, addTweenSortMethod, '_prevRep', '_nextRep');\n\n    const prevSibling = tween._prevRep;\n\n    // Update the previous siblings for composition replace tweens\n\n    if (prevSibling) {\n\n      const prevParent = prevSibling.parent;\n      const prevAbsEndTime = prevSibling._absoluteEndTime;\n\n      // Handle looped animations tween\n\n      if (\n        // Check if the previous tween is from a different animation\n        tween.parent.id !== prevParent.id &&\n        // Check if the animation has loops\n        prevParent.iterationCount> 1 &&\n        // Check if _absoluteChangeEndTime of last loop overlaps the current tween\n        prevAbsEndTime + (prevParent.duration - prevParent.iterationDuration) > tweenAbsStartTime\n      ) {\n\n        // TODO: Find a way to only override the iterations overlapping with the tween\n        overrideTween(prevSibling);\n\n        let prevPrevSibling = prevSibling._prevRep;\n\n        // If the tween was part of a set of keyframes, override its siblings\n        while (prevPrevSibling && prevPrevSibling.parent.id === prevParent.id) {\n          overrideTween(prevPrevSibling);\n          prevPrevSibling = prevPrevSibling._prevRep;\n        }\n\n      }\n\n      // 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.\n      const absoluteUpdateStartTime = tween._absoluteUpdateStartTime;\n\n      if (prevAbsEndTime > absoluteUpdateStartTime) {\n\n        const prevChangeStartTime = prevSibling._startTime;\n        const prevTLOffset = prevAbsEndTime - (prevChangeStartTime + prevSibling._updateDuration);\n        // Rounding is necessary here to minimize floating point errors when working in seconds\n        const updatedPrevChangeDuration = round(absoluteUpdateStartTime - prevTLOffset - prevChangeStartTime, 12);\n\n        prevSibling._changeDuration = updatedPrevChangeDuration;\n        prevSibling._currentTime = updatedPrevChangeDuration;\n        prevSibling._isOverlapped = 1;\n\n        // Override the previous tween if its new _changeDuration is lower than minValue\n        // TODO: See if it's even neceseeary to test against minValue, checking for 0 might be enough\n        if (updatedPrevChangeDuration < minValue) {\n          overrideTween(prevSibling);\n        }\n      }\n\n      // Skip the cancel cascade when both tweens share the same parent timeline, a timeline cannot replace itself.\n      const tweenParentTL = tween.parent.parent;\n      if (!tweenParentTL || tweenParentTL !== prevParent.parent) {\n\n        let pausePrevParentAnimation = true;\n\n        forEachChildren(prevParent, (/** @type Tween */t) => {\n          if (!t._isOverlapped) pausePrevParentAnimation = false;\n        });\n\n        if (pausePrevParentAnimation) {\n          const prevParentTL = prevParent.parent;\n          if (prevParentTL) {\n            let pausePrevParentTL = true;\n            forEachChildren(prevParentTL, (/** @type JSAnimation */a) => {\n              if (a !== prevParent) {\n                forEachChildren(a, (/** @type Tween */t) => {\n                  if (!t._isOverlapped) pausePrevParentTL = false;\n                });\n              }\n            });\n            if (pausePrevParentTL) {\n              prevParentTL.cancel();\n            }\n          } else {\n            prevParent.cancel();\n            // Previously, calling .cancel() on a timeline child would affect the render order of other children\n            // Worked around this by marking it as .completed and using .pause() for safe removal in the engine loop\n            // This is no longer needed since timeline tween composition is now handled separately\n            // Keeping this here for reference\n            // prevParent.completed = true;\n            // prevParent.pause();\n          }\n        }\n\n      }\n\n    }\n\n    // let nextSibling = tween._nextRep;\n\n    // // All the next siblings are automatically overridden\n\n    // if (nextSibling && nextSibling._absoluteStartTime >= tweenAbsStartTime) {\n    //   while (nextSibling) {\n    //     overrideTween(nextSibling);\n    //     nextSibling = nextSibling._nextRep;\n    //   }\n    // }\n\n    // if (nextSibling && nextSibling._absoluteStartTime < tweenAbsStartTime) {\n    //   while (nextSibling) {\n    //     overrideTween(nextSibling);\n    //     console.log(tween.id, nextSibling.id);\n    //     nextSibling = nextSibling._nextRep;\n    //   }\n    // }\n\n  // Handle additive tweens composition\n\n  } else if (tweenCompositionType === compositionTypes.blend) {\n\n    const additiveTweenSiblings = getTweenSiblings(tween.target, tween.property, '_add');\n    const additiveAnimation = addAdditiveAnimation(lookups._add);\n\n    let lookupTween = additiveTweenSiblings._head;\n\n    if (!lookupTween) {\n      lookupTween = { ...tween };\n      lookupTween._composition = compositionTypes.replace;\n      lookupTween._updateDuration = minValue;\n      lookupTween._startTime = 0;\n      lookupTween._numbers = cloneArray(tween._fromNumbers);\n      lookupTween._number = 0;\n      lookupTween._next = null;\n      lookupTween._prev = null;\n      addChild(additiveTweenSiblings, lookupTween);\n      addChild(additiveAnimation, lookupTween);\n    }\n\n    // Convert the values of TO to FROM and set TO to 0\n\n    const toNumber = tween._toNumber;\n    tween._fromNumber = lookupTween._fromNumber - toNumber;\n    tween._toNumber = 0;\n    tween._numbers = cloneArray(tween._fromNumbers);\n    tween._number = 0;\n    lookupTween._fromNumber = toNumber;\n\n    if (tween._toNumbers.length) {\n      const toNumbers = cloneArray(tween._toNumbers);\n      toNumbers.forEach((value, i) => {\n        tween._fromNumbers[i] = lookupTween._fromNumbers[i] - value;\n        tween._toNumbers[i] = 0;\n      });\n      lookupTween._fromNumbers = toNumbers;\n    }\n\n    addChild(additiveTweenSiblings, tween, null, '_prevAdd', '_nextAdd');\n\n  }\n\n  return tween;\n\n};\n\n/**\n * @param  {Tween} tween\n * @return {Tween}\n */\nconst removeTweenSliblings = tween => {\n  const tweenComposition = tween._composition;\n  if (tweenComposition !== compositionTypes.none) {\n    const tweenTarget = tween.target;\n    const tweenProperty = tween.property;\n    const replaceTweensLookup = lookups._rep;\n    const replaceTargetProps = replaceTweensLookup.get(tweenTarget);\n    const tweenReplaceSiblings = replaceTargetProps[tweenProperty];\n    removeChild(tweenReplaceSiblings, tween, '_prevRep', '_nextRep');\n    if (tweenComposition === compositionTypes.blend) {\n      const addTweensLookup = lookups._add;\n      const addTargetProps = addTweensLookup.get(tweenTarget);\n      if (!addTargetProps) return;\n      const additiveTweenSiblings = addTargetProps[tweenProperty];\n      const additiveAnimation = additive.animation;\n      removeChild(additiveTweenSiblings, tween, '_prevAdd', '_nextAdd');\n      // If only one tween is left in the additive lookup, it's the tween lookup\n      const lookupTween = additiveTweenSiblings._head;\n      if (lookupTween && lookupTween === additiveTweenSiblings._tail) {\n        removeChild(additiveTweenSiblings, lookupTween, '_prevAdd', '_nextAdd');\n        removeChild(additiveAnimation, lookupTween);\n        let shouldClean = true;\n        for (let prop in addTargetProps) {\n          if (addTargetProps[prop]._head) {\n            shouldClean = false;\n            break;\n          }\n        }\n        if (shouldClean) {\n          addTweensLookup.delete(tweenTarget);\n        }\n      }\n    }\n  }\n  return tween;\n};\n\n/**\n * @param  {TargetsArray} targetsArray\n * @param  {JSAnimation} animation\n * @param  {String} [propertyName]\n * @return {Boolean}\n */\nconst removeTargetsFromJSAnimation = (targetsArray, animation, propertyName) => {\n  let tweensMatchesTargets = false;\n  forEachChildren(animation, (/**@type {Tween} */tween) => {\n    const tweenTarget = tween.target;\n    if (targetsArray.includes(tweenTarget)) {\n      const tweenName = tween.property;\n      const tweenType = tween._tweenType;\n      const normalizePropName = sanitizePropertyName(propertyName, tweenTarget, tweenType);\n      if (!normalizePropName || normalizePropName && normalizePropName === tweenName) {\n        // Make sure to flag the previous CSS transform tween to renderTransform\n        if (tween.parent._tail === tween &&\n            tween._tweenType === tweenTypes.TRANSFORM &&\n            tween._prev &&\n            tween._prev._tweenType === tweenTypes.TRANSFORM\n        ) {\n          tween._prev._renderTransforms = 1;\n        }\n        // Removes the tween from the selected animation\n        removeChild(animation, tween);\n        // Detach the tween from its siblings to make sure blended tweens are correctlly removed\n        removeTweenSliblings(tween);\n        tweensMatchesTargets = true;\n      }\n    }\n  }, true);\n  return tweensMatchesTargets;\n};\n\n/**\n * @param  {TargetsArray} targetsArray\n * @param  {Renderable} [renderable]\n * @param  {String} [propertyName]\n */\nconst removeTargetsFromRenderable = (targetsArray, renderable, propertyName) => {\n  const parent = /** @type {Renderable|typeof engine} **/(renderable ? renderable : engine);\n  let removeMatches;\n  if (parent._hasChildren) {\n    let iterationDuration = 0;\n    forEachChildren(parent, (/** @type {Renderable} */child) => {\n      if (!child._hasChildren) {\n        removeMatches = removeTargetsFromJSAnimation(targetsArray, /** @type {JSAnimation} */(child), propertyName);\n        // Remove the child from its parent if no tweens and no children left after the removal\n        if (removeMatches && !child._head) {\n          child.cancel();\n          removeChild(parent, child);\n        } else {\n          // Calculate the new iterationDuration value to handle onComplete with last child in render()\n          const childTLOffset = child._offset + child._delay;\n          const childDur = childTLOffset + child.duration;\n          if (childDur > iterationDuration) {\n            iterationDuration = childDur;\n          }\n        }\n      }\n      // Make sure to also remove engine's children targets\n      // NOTE: Avoid recursion?\n      if (child._head) {\n        removeTargetsFromRenderable(targetsArray, child, propertyName);\n      } else {\n        child._hasChildren = false;\n      }\n    }, true);\n    // Update iterationDuration value to handle onComplete with last child in render()\n    if (!isUnd(/** @type {Renderable} */(parent).iterationDuration)) {\n      /** @type {Renderable} */(parent).iterationDuration = iterationDuration;\n    }\n  } else {\n    removeMatches = removeTargetsFromJSAnimation(\n      targetsArray,\n      /** @type {JSAnimation} */(parent),\n      propertyName\n    );\n  }\n  if (removeMatches && !parent._head) {\n    parent._hasChildren = false;\n    // Cancel the parent if there are no tweens and no children left after the removal\n    // We have to check if the .cancel() method exist to handle cases where the parent is the engine itself\n    if (/** @type {Renderable} */(parent).cancel) /** @type {Renderable} */(parent).cancel();\n  }\n};\n\nexport { composeTween, getTweenSiblings, overrideTween, removeTargetsFromRenderable, removeTweenSliblings };\n","/**\n * Anime.js - timer - ESM\n * @version v4.5.0\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { minValue, noop, maxValue, compositionTypes, tickModes } from '../core/consts.js';\nimport { isFnc, isUnd, now, clampInfinity, clamp, round, forEachChildren, addChild, normalizeTime, floor } from '../core/helpers.js';\nimport { globals, scope } from '../core/globals.js';\nimport { setValue } from '../core/values.js';\nimport { tick } from '../core/render.js';\nimport { removeTweenSliblings, composeTween, getTweenSiblings } from '../animation/composition.js';\nimport { Clock } from '../core/clock.js';\nimport { engine } from '../engine/engine.js';\n\n/**\n * @import {\n *   Callback,\n *   TimerParams,\n *   Renderable,\n *   Tween,\n * } from '../types/index.js'\n*/\n\n/**\n * @import {\n *   ScrollObserver,\n * } from '../events/scroll.js'\n*/\n\n/**\n * @import {\n *   Timeline,\n * } from '../timeline/timeline.js'\n*/\n\n/**\n * @param  {Timer} timer\n * @return {Timer}\n */\nconst resetTimerProperties = timer => {\n  timer.paused = true;\n  timer.began = false;\n  timer.completed = false;\n  return timer;\n};\n\n/**\n * @param  {Timer} timer\n * @return {Timer}\n */\nconst reviveTimer = timer => {\n  if (!timer._cancelled) return timer;\n  if (timer._hasChildren) {\n    forEachChildren(timer, reviveTimer);\n  } else {\n    forEachChildren(timer, (/** @type {Tween} tween */tween) => {\n      if (tween._composition !== compositionTypes.none) {\n        composeTween(tween, getTweenSiblings(tween.target, tween.property));\n      }\n    });\n  }\n  timer._cancelled = 0;\n  return timer;\n};\n\nlet timerId = 0;\n\n/** @param {Timer} prev @param {Timer} child */\nconst sortByPriority = (prev, child) => prev._priority > child._priority;\n\n/**\n * Base class used to create Timers, Animations and Timelines\n */\nclass Timer extends Clock {\n  /**\n   * @param {TimerParams} [parameters]\n   * @param {Timeline} [parent]\n   * @param {Number} [parentPosition]\n   */\n  constructor(parameters = {}, parent = null, parentPosition = 0) {\n\n    super(0);\n\n    ++timerId;\n\n    const {\n      id,\n      delay,\n      duration,\n      reversed,\n      alternate,\n      loop,\n      loopDelay,\n      autoplay,\n      frameRate,\n      playbackRate,\n      priority,\n      onComplete,\n      onLoop,\n      onPause,\n      onBegin,\n      onBeforeUpdate,\n      onUpdate,\n    } = parameters;\n\n    if (scope.current) scope.current.register(this);\n\n    const timerInitTime = parent ? 0 : engine._lastTickTime;\n    const timerDefaults = parent ? parent.defaults : globals.defaults;\n    const timerDelay = /** @type {Number} */(isFnc(delay) || isUnd(delay) ? timerDefaults.delay : +delay);\n    const timerDuration = isFnc(duration) || isUnd(duration) ? Infinity : +duration;\n    const timerLoop = setValue(loop, timerDefaults.loop);\n    const timerLoopDelay = setValue(loopDelay, timerDefaults.loopDelay);\n    let timerIterationCount = timerLoop === true ||\n                              timerLoop === Infinity ||\n                              /** @type {Number} */(timerLoop) < 0 ? Infinity :\n                              /** @type {Number} */(timerLoop) + 1;\n\n    let offsetPosition = 0;\n\n    if (parent) {\n      offsetPosition = parentPosition;\n    } else {\n      // Make sure to tick the engine once if not currently running to get up to date engine._lastTickTime\n      // to avoid big gaps with the following offsetPosition calculation\n      if (!engine.reqId) engine.requestTick(now());\n      // Make sure to scale the offset position with globals.timeScale to properly handle seconds unit\n      offsetPosition = (engine._lastTickTime - engine._startTime) * globals.timeScale;\n    }\n\n    // Timer's parameters\n    /** @type {String|Number} */\n    this.id = !isUnd(id) ? id : timerId;\n    /** @type {Timeline} */\n    this.parent = parent;\n    // Total duration of the timer\n    this.duration = clampInfinity(((timerDuration + timerLoopDelay) * timerIterationCount) - timerLoopDelay) || minValue;\n    /** @type {Boolean} */\n    this.backwards = false;\n    /** @type {Boolean} */\n    this.paused = true;\n    /** @type {Boolean} */\n    this.began = false;\n    /** @type {Boolean} */\n    this.completed = false;\n    /** @type {Callback<this>} */\n    this.onBegin = onBegin || timerDefaults.onBegin;\n    /** @type {Callback<this>} */\n    this.onBeforeUpdate = onBeforeUpdate || timerDefaults.onBeforeUpdate;\n    /** @type {Callback<this>} */\n    this.onUpdate = onUpdate || timerDefaults.onUpdate;\n    /** @type {Callback<this>} */\n    this.onLoop = onLoop || timerDefaults.onLoop;\n    /** @type {Callback<this>} */\n    this.onPause = onPause || timerDefaults.onPause;\n    /** @type {Callback<this>} */\n    this.onComplete = onComplete || timerDefaults.onComplete;\n    /** @type {Number} */\n    this.iterationDuration = timerDuration; // Duration of one loop\n    /** @type {Number} */\n    this.iterationCount = timerIterationCount; // Number of loops\n    /** @type {Boolean|ScrollObserver} */\n    this._autoplay = parent ? false : setValue(autoplay, timerDefaults.autoplay);\n    /** @type {Number} */\n    this._offset = offsetPosition;\n    /** @type {Number} */\n    this._delay = timerDelay;\n    /** @type {Number} */\n    this._loopDelay = timerLoopDelay;\n    /** @type {Number} */\n    this._iterationTime = 0;\n    /** @type {Number} */\n    this._currentIteration = 0; // Current loop index\n    /** @type {Function} */\n    this._resolve = noop; // Used by .then()\n    /** @type {Boolean} */\n    this._running = false;\n    /** @type {Number} */\n    this._reversed = +setValue(reversed, timerDefaults.reversed);\n    /** @type {Number} */\n    this._reverse = this._reversed;\n    /** @type {Number} */\n    this._cancelled = 0;\n    /** @type {Boolean} */\n    this._alternate = setValue(alternate, timerDefaults.alternate);\n    /** @type {Renderable} */\n    this._prev = null;\n    /** @type {Renderable} */\n    this._next = null;\n\n    // Clock's parameters\n    /** @type {Number} */\n    this._lastTickTime = timerInitTime;\n    /** @type {Number} */\n    this._startTime = timerInitTime;\n    /** @type {Number} */\n    this._lastTime = timerInitTime;\n    /** @type {Number} */\n    this._fps = setValue(frameRate, timerDefaults.frameRate);\n    /** @type {Number} */\n    this._speed = setValue(playbackRate, timerDefaults.playbackRate);\n    /** @type {Number} */\n    this._priority = +setValue(priority, 1);\n  }\n\n  get cancelled() {\n    return !!this._cancelled;\n  }\n\n  set cancelled(cancelled) {\n    cancelled ? this.cancel() : this.reset(true).play();\n  }\n\n  get currentTime() {\n    return clamp(round(this._currentTime, globals.precision), -this._delay, this.duration);\n  }\n\n  set currentTime(time) {\n    const paused = this.paused;\n    // Pausing the timer is necessary to avoid time jumps on a running instance\n    this.pause().seek(+time);\n    if (!paused) this.resume();\n  }\n\n  get iterationCurrentTime() {\n    return clamp(round(this._iterationTime, globals.precision), 0, this.iterationDuration);\n  }\n\n  set iterationCurrentTime(time) {\n    this.currentTime = (this.iterationDuration * this._currentIteration) + time;\n  }\n\n  get progress() {\n    return clamp(round(this._currentTime / this.duration, 10), 0, 1);\n  }\n\n  set progress(progress) {\n    this.currentTime = this.duration * progress;\n  }\n\n  get iterationProgress() {\n    return clamp(round(this._iterationTime / this.iterationDuration, 10), 0, 1);\n  }\n\n  set iterationProgress(progress) {\n    const iterationDuration = this.iterationDuration;\n    this.currentTime = (iterationDuration * this._currentIteration) + (iterationDuration * progress);\n  }\n\n  get currentIteration() {\n    return this._currentIteration;\n  }\n\n  set currentIteration(iterationCount) {\n    this.currentTime = (this.iterationDuration * clamp(+iterationCount, 0, this.iterationCount - 1));\n  }\n\n  get reversed() {\n    return !!this._reversed;\n  }\n\n  set reversed(reverse) {\n    reverse ? this.reverse() : this.play();\n  }\n\n  get speed() {\n    return super.speed;\n  }\n\n  set speed(playbackRate) {\n    super.speed = playbackRate;\n    this.resetTime();\n  }\n\n  /**\n   * @param  {Boolean} [softReset]\n   * @return {this}\n   */\n  reset(softReset = false) {\n    // If cancelled, revive the timer before rendering in order to have propertly composed tweens siblings\n    reviveTimer(this);\n    if (this._reversed && !this._reverse) this.reversed = false;\n    // Rendering before updating the completed flag to prevent skips and to make sure the properties are not overridden\n    // Setting the iterationTime at the end to force the rendering to happend backwards, otherwise calling .reset() on Timelines might not render children in the right order\n    // NOTE: This is only required for Timelines and might be better to move to the Timeline class?\n    this._iterationTime = this.iterationDuration;\n    // Set tickMode to tickModes.FORCE to force rendering\n    tick(this, 0, 1, ~~softReset, tickModes.FORCE);\n    // Reset timer properties after revive / render to make sure the props are not updated again\n    resetTimerProperties(this);\n    // Also reset children properties\n    if (this._hasChildren) {\n      forEachChildren(this, resetTimerProperties);\n    }\n    return this;\n  }\n\n  /**\n   * @param  {Boolean} internalRender\n   * @return {this}\n   */\n  init(internalRender = false) {\n    this.fps = this._fps;\n    this.speed = this._speed;\n    // Manually calling .init() on timelines should render all children intial state\n    // Forces all children to render once then render to 0 when reseted\n    if (!internalRender && this._hasChildren) {\n      tick(this, this.duration, 1, ~~internalRender, tickModes.FORCE);\n    }\n    this.reset(internalRender);\n    // Make sure to set autoplay to false to child timers so it doesn't attempt to autoplay / link\n    const autoplay = this._autoplay;\n    if (autoplay === true) {\n      this.resume();\n    } else if (autoplay && !isUnd(/** @type {ScrollObserver} */(autoplay).linked)) {\n      /** @type {ScrollObserver} */(autoplay).link(this);\n    }\n    return this;\n  }\n\n  /** @return {this} */\n  resetTime() {\n    const timeScale = 1 / (this._speed * engine._speed);\n    // TODO: See if we can safely use engine._lastTickTime here\n    // if (!engine.reqId) engine.requestTick(now())\n    // this._startTime = engine._lastTickTime - (this._currentTime + this._delay) * timeScale;\n    this._startTime = now() - (this._currentTime + this._delay) * timeScale;\n    return this;\n  }\n\n  /** @return {this} */\n  pause() {\n    if (this.paused) return this;\n    this.paused = true;\n    this.onPause(this);\n    return this;\n  }\n\n  /** @return {this} */\n  resume() {\n    if (!this.paused) return this;\n    this.paused = false;\n    // We can safely imediatly render a timer that has no duration and no children\n    if (this.duration <= minValue && !this._hasChildren) {\n      tick(this, minValue, 0, 0, tickModes.FORCE);\n    } else {\n      if (!this._running) {\n        addChild(engine, this, sortByPriority);\n        engine._hasChildren = true;\n        this._running = true;\n      }\n      this.resetTime();\n      // Forces the timer to advance by at least one frame when the next tick occurs\n      this._startTime -= 12;\n      engine.wake();\n    }\n    return this;\n  }\n\n  /** @return {this} */\n  restart() {\n    return this.reset().resume();\n  }\n\n  /**\n   * @param  {Number} time\n   * @param  {Boolean|Number} [muteCallbacks]\n   * @param  {Boolean|Number} [internalRender]\n   * @return {this}\n   */\n  seek(time, muteCallbacks = 0, internalRender = 0) {\n    // Recompose the tween siblings in case the timer has been cancelled\n    reviveTimer(this);\n    // If you seek a completed animation, otherwise the next play will starts at 0\n    this.completed = false;\n    const isPaused = this.paused;\n    this.paused = true;\n    // timer, time, muteCallbacks, internalRender, tickMode\n    tick(this, time + this._delay, ~~muteCallbacks, ~~internalRender, tickModes.AUTO);\n    return isPaused ? this : this.resume();\n  }\n\n  /** @return {this} */\n  alternate() {\n    const reversed = this._reversed;\n    const count = this.iterationCount;\n    const duration = this.iterationDuration;\n    // Calculate the maximum iterations possible given the iteration duration\n    const iterations = count === Infinity ? floor(maxValue / duration) : count;\n    this._reversed = +(this._alternate && !(iterations % 2) ? reversed : !reversed);\n    if (count === Infinity) {\n      // Handle infinite loops to loop on themself\n      this.iterationProgress = this._reversed ? 1 - this.iterationProgress : this.iterationProgress;\n    } else {\n      this.seek((duration * iterations) - this._currentTime);\n    }\n    this.resetTime();\n    return this;\n  }\n\n  /** @return {this} */\n  play() {\n    if (this._reversed) this.alternate();\n    return this.resume();\n  }\n\n  /** @return {this} */\n  reverse() {\n    if (!this._reversed) this.alternate();\n    return this.resume();\n  }\n\n  // TODO: Move all the animation / tweens / children related code to Animation / Timeline\n\n  /** @return {this} */\n  cancel() {\n    if (this._hasChildren) {\n      forEachChildren(this, (/** @type {Renderable} */child) => child.cancel(), true);\n    } else {\n      forEachChildren(this, removeTweenSliblings);\n    }\n    this._cancelled = 1;\n    // Pausing the timer removes it from the engine\n    return this.pause();\n  }\n\n  /**\n   * @param  {Number} newDuration\n   * @return {this}\n   */\n  stretch(newDuration) {\n    const currentDuration = this.duration;\n    const normlizedDuration = normalizeTime(newDuration);\n    if (currentDuration === normlizedDuration) return this;\n    const timeScale = newDuration / currentDuration;\n    const isSetter = newDuration <= minValue;\n    this.duration = isSetter ? minValue : normlizedDuration;\n    this.iterationDuration = isSetter ? minValue : normalizeTime(this.iterationDuration * timeScale);\n    this._offset *= timeScale;\n    this._delay *= timeScale;\n    this._loopDelay *= timeScale;\n    return this;\n  }\n\n /**\n   * Cancels the timer by seeking it back to 0 and reverting the attached scroller if necessary\n   * @return {this}\n   */\n  revert() {\n    tick(this, 0, 1, 0, tickModes.AUTO);\n    const ap = /** @type {ScrollObserver} */(this._autoplay);\n    if (ap && ap.linked && ap.linked === this) ap.revert();\n    return this.cancel();\n  }\n\n /**\n   * Imediatly completes the timer, cancels it and triggers the onComplete callback\n   * @param  {Boolean|Number} [muteCallbacks]\n   * @return {this}\n   */\n  complete(muteCallbacks = 0) {\n    return this.seek(this.duration, muteCallbacks).cancel();\n  }\n\n  /**\n   * @typedef {this & {then: null}} ResolvedTimer\n   */\n\n  /**\n   * @param  {Callback<ResolvedTimer>} [callback]\n   * @return Promise<this>\n   */\n  then(callback = noop) {\n    const then = this.then;\n    const onResolve = () => {\n      // this.then = null prevents infinite recursion if returned by an async function\n      // https://github.com/juliangarnierorg/anime-beta/issues/26\n      this.then = null;\n      callback(/** @type {ResolvedTimer} */(this));\n      this.then = then;\n      this._resolve = noop;\n    };\n    return new Promise(r => {\n      this._resolve = () => r(onResolve());\n      // Make sure to resolve imediatly if the timer has already completed\n      if (this.completed) this._resolve();\n      return this;\n    });\n  }\n\n}\n\n/**\n * @param {TimerParams} [parameters]\n * @return {Timer}\n */\nconst createTimer = parameters => new Timer(parameters, null, 0).init();\n\nexport { Timer, createTimer };\n","/**\n * Anime.js - core - ESM\n * @version v4.5.0\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { scope } from './globals.js';\nimport { isRegisteredTargetSymbol, isDomSymbol, isSvgSymbol, transformsSymbol, isBrowser } from './consts.js';\nimport { isSvg, isNil, isArr, isStr } from './helpers.js';\n\n/**\n* @import {\n*   DOMTarget,\n*   DOMTargetsParam,\n*   JSTargetsArray,\n*   TargetsParam,\n*   JSTargetsParam,\n*   TargetsArray,\n*   DOMTargetsArray,\n* } from '../types/index.js'\n*/\n\n/**\n * @param  {DOMTargetsParam|TargetsParam} v\n * @return {NodeList|HTMLCollection}\n */\nfunction getNodeList(v) {\n  const n = isStr(v) ? scope.root.querySelectorAll(v) : v;\n  if (n instanceof NodeList || n instanceof HTMLCollection) return n;\n}\n\n/**\n * @overload\n * @param  {DOMTargetsParam} targets\n * @return {DOMTargetsArray}\n *\n * @overload\n * @param  {JSTargetsParam} targets\n * @return {JSTargetsArray}\n *\n * @overload\n * @param  {TargetsParam} targets\n * @return {TargetsArray}\n *\n * @param  {DOMTargetsParam|JSTargetsParam|TargetsParam} targets\n */\nfunction parseTargets(targets) {\n  if (isNil(targets)) return /** @type {TargetsArray} */([]);\n  if (!isBrowser) return /** @type {JSTargetsArray} */(isArr(targets) && targets.flat(Infinity) || [targets]);\n  if (isArr(targets)) {\n    const flattened = targets.flat(Infinity);\n    /** @type {TargetsArray} */\n    const parsed = [];\n    for (let i = 0, l = flattened.length; i < l; i++) {\n      const item = flattened[i];\n      if (!isNil(item)) {\n        const nodeList = getNodeList(item);\n        if (nodeList) {\n          for (let j = 0, jl = nodeList.length; j < jl; j++) {\n            const subItem = nodeList[j];\n            if (!isNil(subItem)) {\n              let isDuplicate = false;\n              for (let k = 0, kl = parsed.length; k < kl; k++) {\n                if (parsed[k] === subItem) {\n                  isDuplicate = true;\n                  break;\n                }\n              }\n              if (!isDuplicate) {\n                parsed.push(subItem);\n              }\n            }\n          }\n        } else {\n          let isDuplicate = false;\n          for (let j = 0, jl = parsed.length; j < jl; j++) {\n            if (parsed[j] === item) {\n              isDuplicate = true;\n              break;\n            }\n          }\n          if (!isDuplicate) {\n            parsed.push(item);\n          }\n        }\n      }\n    }\n    return parsed;\n  }\n  const nodeList = getNodeList(targets);\n  if (nodeList) return /** @type {DOMTargetsArray} */(Array.from(nodeList));\n  return /** @type {TargetsArray} */([targets]);\n}\n\n/**\n * @overload\n * @param  {DOMTargetsParam} targets\n * @return {DOMTargetsArray}\n *\n * @overload\n * @param  {JSTargetsParam} targets\n * @return {JSTargetsArray}\n *\n * @overload\n * @param  {TargetsParam} targets\n * @return {TargetsArray}\n *\n * @param  {DOMTargetsParam|JSTargetsParam|TargetsParam} targets\n */\nfunction registerTargets(targets) {\n  const parsedTargetsArray = parseTargets(targets);\n  const parsedTargetsLength = parsedTargetsArray.length;\n  for (let i = 0; i < parsedTargetsLength; i++) {\n    const target = parsedTargetsArray[i];\n    if (!target[isRegisteredTargetSymbol]) {\n      target[isRegisteredTargetSymbol] = true;\n      const isSvgType = isSvg(target);\n      const isDom = /** @type {DOMTarget} */(target).nodeType || isSvgType;\n      if (isDom) {\n        target[isDomSymbol] = true;\n        target[isSvgSymbol] = isSvgType;\n        target[transformsSymbol] = {};\n      }\n    }\n  }\n  return parsedTargetsArray;\n}\n\nexport { getNodeList, parseTargets, registerTargets };\n","/**\n * Anime.js - core - ESM\n * @version v4.5.0\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { valueTypes, doc } from './consts.js';\nimport { isUnd, PI } from './helpers.js';\n\nconst angleUnitsMap = { 'deg': 1, 'rad': 180 / PI, 'turn': 360 };\nconst convertedValuesCache = {};\n\n/**\n* @import {\n*   DOMTarget,\n*   TweenDecomposedValue,\n* } from '../types/index.js'\n*/\n\n/**\n * @param  {DOMTarget} el\n * @param  {TweenDecomposedValue} decomposedValue\n * @param  {String} unit\n * @param  {Boolean} [force]\n * @return {TweenDecomposedValue}\n */\nconst convertValueUnit = (el, decomposedValue, unit, force = false) => {\n  const currentUnit = decomposedValue.u;\n  const currentNumber = decomposedValue.n;\n  if (decomposedValue.t === valueTypes.UNIT && currentUnit === unit) { // TODO: Check if checking against the same unit string is necessary\n    return decomposedValue;\n  }\n  const cachedKey = currentNumber + currentUnit + unit;\n  const cached = convertedValuesCache[cachedKey];\n  if (!isUnd(cached) && !force) {\n    decomposedValue.n = cached;\n  } else {\n    let convertedValue;\n    if (currentUnit in angleUnitsMap) {\n      convertedValue = currentNumber * angleUnitsMap[currentUnit] / angleUnitsMap[unit];\n    } else {\n      const baseline = 100;\n      const tempEl = /** @type {DOMTarget} */(el.cloneNode());\n      const parentNode = el.parentNode;\n      const parentEl = (parentNode && (parentNode !== doc)) ? parentNode : doc.body;\n      parentEl.appendChild(tempEl);\n      const elStyle = tempEl.style;\n      elStyle.width = baseline + currentUnit;\n      const currentUnitWidth = /** @type {HTMLElement} */(tempEl).offsetWidth || baseline;\n      elStyle.width = baseline + unit;\n      const newUnitWidth = /** @type {HTMLElement} */(tempEl).offsetWidth || baseline;\n      const factor = currentUnitWidth / newUnitWidth;\n      parentEl.removeChild(tempEl);\n      convertedValue = factor * currentNumber;\n    }\n    decomposedValue.n = convertedValue;\n    convertedValuesCache[cachedKey] = convertedValue;\n  }\n  decomposedValue.t === valueTypes.UNIT;\n  decomposedValue.u = unit;\n  return decomposedValue;\n};\n\nexport { convertValueUnit };\n","/**\n * Anime.js - easings - ESM\n * @version v4.5.0\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\n/**\n * @import {\n *   EasingFunction,\n * } from '../types/index.js'\n*/\n\n/** @type {EasingFunction} */\nconst none = t => t;\n\nexport { none };\n","/**\n * Anime.js - easings - ESM\n * @version v4.5.0\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { emptyString, minValue } from '../../core/consts.js';\nimport { pow, sin, sqrt, cos, isStr, stringStartsWith, isFnc, clamp, asin, PI } from '../../core/helpers.js';\nimport { none } from '../none.js';\n\n/**\n * @import {\n *   EasingFunction,\n *   EasingFunctionWithParams,\n *   EasingParam,\n *   BackEasing,\n *   ElasticEasing,\n *   PowerEasing,\n * } from '../../types/index.js'\n*/\n\n\n/** @type {PowerEasing} */\nconst easeInPower = (p = 1.68) => t => pow(t, +p);\n\n/**\n * @callback EaseType\n * @param {EasingFunction} Ease\n * @return {EasingFunction}\n */\n\n/** @type {Record<String, EaseType>} */\nconst easeTypes = {\n  in: easeIn => t => easeIn(t),\n  out: easeIn => t => 1 - easeIn(1 - t),\n  inOut: easeIn => t => t < .5 ? easeIn(t * 2) / 2 : 1 - easeIn(t * -2 + 2) / 2,\n  outIn: easeIn => t => t < .5 ? (1 - easeIn(1 - t * 2)) / 2 : (easeIn(t * 2 - 1) + 1) / 2,\n};\n\n/**\n * Easing functions adapted and simplified from https://robertpenner.com/easing/\n * (c) 2001 Robert Penner\n */\n\nconst halfPI = PI / 2;\nconst doublePI = PI * 2;\n\n/** @type {Record<String, EasingFunctionWithParams|EasingFunction>} */\nconst easeInFunctions = {\n  [emptyString]: easeInPower,\n  Quad: easeInPower(2),\n  Cubic: easeInPower(3),\n  Quart: easeInPower(4),\n  Quint: easeInPower(5),\n  /** @type {EasingFunction} */\n  Sine: t => 1 - cos(t * halfPI),\n  /** @type {EasingFunction} */\n  Circ: t => 1 - sqrt(1 - t * t),\n  /** @type {EasingFunction} */\n  Expo: t => t ? pow(2, 10 * t - 10) : 0,\n  /** @type {EasingFunction} */\n  Bounce: t => {\n    let pow2, b = 4;\n    while (t < ((pow2 = pow(2, --b)) - 1) / 11);\n    return 1 / pow(4, 3 - b) - 7.5625 * pow((pow2 * 3 - 2) / 22 - t, 2);\n  },\n  /** @type {BackEasing} */\n  Back: (overshoot = 1.7) => t => (+overshoot + 1) * t * t * t - +overshoot * t * t,\n  /** @type {ElasticEasing} */\n  Elastic: (amplitude = 1, period = .3) => {\n    const a = clamp(+amplitude, 1, 10);\n    const p = clamp(+period, minValue, 2);\n    const s = (p / doublePI) * asin(1 / a);\n    const e = doublePI / p;\n    return t => t === 0 || t === 1 ? t : -a * pow(2, -10 * (1 - t)) * sin(((1 - t) - s) * e);\n  }\n};\n\n/**\n * @typedef  {Object} EasesFunctions\n * @property {EasingFunction} linear\n * @property {EasingFunction} none\n * @property {PowerEasing} in\n * @property {PowerEasing} out\n * @property {PowerEasing} inOut\n * @property {PowerEasing} outIn\n * @property {EasingFunction} inQuad\n * @property {EasingFunction} outQuad\n * @property {EasingFunction} inOutQuad\n * @property {EasingFunction} outInQuad\n * @property {EasingFunction} inCubic\n * @property {EasingFunction} outCubic\n * @property {EasingFunction} inOutCubic\n * @property {EasingFunction} outInCubic\n * @property {EasingFunction} inQuart\n * @property {EasingFunction} outQuart\n * @property {EasingFunction} inOutQuart\n * @property {EasingFunction} outInQuart\n * @property {EasingFunction} inQuint\n * @property {EasingFunction} outQuint\n * @property {EasingFunction} inOutQuint\n * @property {EasingFunction} outInQuint\n * @property {EasingFunction} inSine\n * @property {EasingFunction} outSine\n * @property {EasingFunction} inOutSine\n * @property {EasingFunction} outInSine\n * @property {EasingFunction} inCirc\n * @property {EasingFunction} outCirc\n * @property {EasingFunction} inOutCirc\n * @property {EasingFunction} outInCirc\n * @property {EasingFunction} inExpo\n * @property {EasingFunction} outExpo\n * @property {EasingFunction} inOutExpo\n * @property {EasingFunction} outInExpo\n * @property {EasingFunction} inBounce\n * @property {EasingFunction} outBounce\n * @property {EasingFunction} inOutBounce\n * @property {EasingFunction} outInBounce\n * @property {BackEasing} inBack\n * @property {BackEasing} outBack\n * @property {BackEasing} inOutBack\n * @property {BackEasing} outInBack\n * @property {ElasticEasing} inElastic\n * @property {ElasticEasing} outElastic\n * @property {ElasticEasing} inOutElastic\n * @property {ElasticEasing} outInElastic\n */\n\nconst eases = (/*#__PURE__ */ (() => {\n  const list = { linear: none, none: none };\n  for (let type in easeTypes) {\n    for (let name in easeInFunctions) {\n      const easeIn = easeInFunctions[name];\n      const easeType = easeTypes[type];\n      list[type + name] = /** @type {EasingFunctionWithParams|EasingFunction} */(\n        name === emptyString || name === 'Back' || name === 'Elastic' ?\n        (a, b) => easeType(/** @type {EasingFunctionWithParams} */(easeIn)(a, b)) :\n        easeType(/** @type {EasingFunction} */(easeIn))\n      );\n    }\n  }\n  return /** @type {EasesFunctions} */(list);\n})());\n\n/** @type {Record<String, EasingFunction>} */\nconst easesLookups = { linear: none, none: none };\n\n/**\n * @param  {String} string\n * @return {EasingFunction}\n */\nconst parseEaseString = (string) => {\n  if (easesLookups[string]) return easesLookups[string];\n  if (string.indexOf('(') <= -1) {\n    const hasParams = easeTypes[string] || string.includes('Back') || string.includes('Elastic');\n    const parsedFn = /** @type {EasingFunction} */(hasParams ? /** @type {EasingFunctionWithParams} */(eases[string])() : eases[string]);\n    return parsedFn ? easesLookups[string] = parsedFn : none;\n  } else {\n    const split = string.slice(0, -1).split('(');\n    const parsedFn = /** @type {EasingFunctionWithParams} */(eases[split[0]]);\n    return parsedFn ? easesLookups[string] = parsedFn(...split[1].split(',')) : none;\n  }\n};\n\nconst deprecated = ['steps(', 'irregular(', 'linear(', 'cubicBezier('];\n\n/**\n * @param  {EasingParam} ease\n * @return {EasingFunction}\n */\nconst parseEase = ease => {\n  if (isStr(ease)) {\n    for (let i = 0, l = deprecated.length; i < l; i++) {\n      if (stringStartsWith(ease, deprecated[i])) {\n        console.warn(`String syntax for \\`ease: \"${ease}\"\\` has been removed from the core and replaced by importing and passing the easing function directly: \\`ease: ${ease}\\``);\n        return none;\n      }\n    }\n  }\n  const easeFunc = isFnc(ease) ? ease : isStr(ease) ? parseEaseString(/** @type {String} */(ease)) : none;\n  return easeFunc;\n};\n\nexport { easeInPower, easeTypes, eases, parseEase, parseEaseString };\n","/**\n * Anime.js - animation - ESM\n * @version v4.5.0\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { K, compositionTypes, valueTypes, emptyArray, minValue, isDomSymbol, tweenTypes } from '../core/consts.js';\nimport { mergeObjects, isUnd, isKey, isObj, cloneArray, isNil, round, addChild, forEachChildren, clampInfinity, normalizeTime, isArr, isNum, isFnc, isStr } from '../core/helpers.js';\nimport { globals } from '../core/globals.js';\nimport { registerTargets } from '../core/targets.js';\nimport { resolveAdapterEntry } from '../adapters/registry.js';\nimport { setValue, getTweenType, getFunctionValue, decomposeRawValue, getOriginalAnimatableValue, createDecomposedValueTargetObject, decomposedOriginalValue, getRelativeValue, composeComplexValue, decomposeTweenValue } from '../core/values.js';\nimport { sanitizePropertyName, revertValues } from '../core/styles.js';\nimport { convertValueUnit } from '../core/units.js';\nimport { parseEase } from '../easings/eases/parser.js';\nimport { Timer } from '../timer/timer.js';\nimport { getTweenSiblings, overrideTween, composeTween } from './composition.js';\nimport { additive } from './additive.js';\n\n/**\n * @import {\n *   Tween,\n *   TweenKeyValue,\n *   TweenParamsOptions,\n *   TweenValues,\n *   DurationKeyframes,\n *   PercentageKeyframes,\n *   AnimationParams,\n *   TweenPropValue,\n *   ArraySyntaxValue,\n *   TargetsParam,\n *   TimerParams,\n *   TweenParamValue,\n *   DOMTarget,\n *   TargetsArray,\n *   Callback,\n *   EasingFunction,\n * } from '../types/index.js'\n *\n * @import {\n *   Timeline,\n * } from '../timeline/timeline.js'\n *\n * @import {\n *   Spring,\n * } from '../easings/spring/index.js'\n */\n\n// Defines decomposed values target objects only once and mutate their properties later to avoid GC\n// TODO: Maybe move the objects creation to values.js and use the decompose function to create the base object\nconst fromTargetObject = createDecomposedValueTargetObject();\nconst toTargetObject = createDecomposedValueTargetObject();\nconst inlineStylesStore = {};\nconst toFunctionStore = { func: null };\nconst fromFunctionStore = { func: null };\nconst keyframesTargetArray = [null];\nconst fastSetValuesArray = [null, null];\n/** @type {TweenKeyValue} */\nconst keyObjectTarget = { to: null };\n\nlet tweenId = 0;\nlet JSAnimationId = 0;\nlet keyframes;\n/** @type {TweenParamsOptions & TweenValues} */\nlet key;\n\n/**\n * @param {DurationKeyframes | PercentageKeyframes} keyframes\n * @param {AnimationParams} parameters\n * @return {AnimationParams}\n */\nconst generateKeyframes = (keyframes, parameters) => {\n  /** @type {AnimationParams} */\n  const properties = {};\n  if (isArr(keyframes)) {\n    const propertyNames = [].concat(.../** @type {DurationKeyframes} */(keyframes).map(key => Object.keys(key))).filter(isKey);\n    for (let i = 0, l = propertyNames.length; i < l; i++) {\n      const propName = propertyNames[i];\n      const propArray = /** @type {DurationKeyframes} */(keyframes).map(key => {\n        /** @type {TweenKeyValue} */\n        const newKey = {};\n        for (let p in key) {\n          const keyValue = /** @type {TweenPropValue} */(key[p]);\n          if (isKey(p)) {\n            if (p === propName) {\n              newKey.to = keyValue;\n            }\n          } else {\n            newKey[p] = keyValue;\n          }\n        }\n        return newKey;\n      });\n      properties[propName] = /** @type {ArraySyntaxValue} */(propArray);\n    }\n\n  } else {\n    const totalDuration = /** @type {Number} */(setValue(parameters.duration, globals.defaults.duration));\n    const keys = Object.keys(keyframes)\n    .map(key => { return {o: parseFloat(key) / 100, p: keyframes[key]} })\n    .sort((a, b) => a.o - b.o);\n    keys.forEach(key => {\n      const offset = key.o;\n      const prop = key.p;\n      for (let name in prop) {\n        if (isKey(name)) {\n          let propArray = /** @type {Array} */(properties[name]);\n          if (!propArray) propArray = properties[name] = [];\n          const duration = offset * totalDuration;\n          let length = propArray.length;\n          let prevKey = propArray[length - 1];\n          const keyObj = { to: prop[name] };\n          let durProgress = 0;\n          for (let i = 0; i < length; i++) {\n            durProgress += propArray[i].duration;\n          }\n          if (length === 1) {\n            keyObj.from = prevKey.to;\n          }\n          if (prop.ease) {\n            keyObj.ease = prop.ease;\n          }\n          keyObj.duration = duration - (length ? durProgress : 0);\n          propArray.push(keyObj);\n        }\n      }\n      return key;\n    });\n\n    for (let name in properties) {\n      const propArray = /** @type {Array} */(properties[name]);\n      let prevEase;\n      // let durProgress = 0\n      for (let i = 0, l = propArray.length; i < l; i++) {\n        const prop = propArray[i];\n        // Emulate WAPPI easing parameter position\n        const currentEase = prop.ease;\n        prop.ease = prevEase ? prevEase : undefined;\n        prevEase = currentEase;\n        // durProgress += prop.duration;\n        // if (i === l - 1 && durProgress !== totalDuration) {\n        //   propArray.push({ from: prop.to, ease: prop.ease, duration: totalDuration - durProgress })\n        // }\n      }\n      if (!propArray[0].duration) {\n        propArray.shift();\n      }\n    }\n\n  }\n\n  return properties;\n};\n\nclass JSAnimation extends Timer {\n  /**\n   * @param {TargetsParam} targets\n   * @param {AnimationParams} parameters\n   * @param {Timeline} [parent]\n   * @param {Number} [parentPosition]\n   * @param {Boolean} [fastSet=false]\n   * @param {Number} [index=0]\n   * @param {TargetsArray} [allTargets]\n   */\n  constructor(\n    targets,\n    parameters,\n    parent,\n    parentPosition,\n    fastSet = false,\n    index = 0,\n    allTargets\n  ) {\n\n    super(/** @type {TimerParams & AnimationParams} */(parameters), parent, parentPosition);\n\n    /** @type {Tween} */\n    this._head;\n    /** @type {Tween} */\n    this._tail;\n\n    ++JSAnimationId;\n\n    const parsedTargets = registerTargets(targets);\n    const targetsLength = parsedTargets.length;\n\n    // If the parameters object contains a \"keyframes\" property, convert all the keyframes values to regular properties\n\n    const kfParams = /** @type {AnimationParams} */(parameters).keyframes;\n    const params = /** @type {AnimationParams} */(kfParams ? mergeObjects(generateKeyframes(/** @type {DurationKeyframes} */(kfParams), parameters), parameters) : parameters);\n\n    const {\n      id,\n      delay,\n      duration,\n      ease,\n      playbackEase,\n      modifier,\n      composition,\n      onRender,\n    } = params;\n\n    const animDefaults = parent ? parent.defaults : globals.defaults;\n    const animEase = setValue(ease, animDefaults.ease);\n    const animPlaybackEase = setValue(playbackEase, animDefaults.playbackEase);\n    const parsedAnimPlaybackEase = animPlaybackEase ? parseEase(animPlaybackEase) : null;\n    const hasSpring = !isUnd(/** @type {Spring} */(animEase).ease);\n    const tEasing = hasSpring ? /** @type {Spring} */(animEase).ease : setValue(ease, parsedAnimPlaybackEase ? 'linear' : animDefaults.ease);\n    const tDuration = hasSpring ? /** @type {Spring} */(animEase).settlingDuration : setValue(duration, animDefaults.duration);\n    const tDelay = setValue(delay, animDefaults.delay);\n    const tModifier = modifier || animDefaults.modifier;\n    // If no composition is defined and the targets length is high (>= 1000) set the composition to 'none' (0) for faster tween creation\n    const tComposition = isUnd(composition) && targetsLength >= K ? compositionTypes.none : !isUnd(composition) ? composition : animDefaults.composition;\n    // const absoluteOffsetTime = this._offset;\n    const absoluteOffsetTime = this._offset + (parent ? parent._offset : 0);\n    // This allows targeting the current animation in the spring onComplete callback\n    if (hasSpring) /** @type {Spring} */(animEase).parent = this;\n\n    let iterationDuration = NaN;\n    let iterationDelay = NaN;\n    let animationAnimationLength = 0;\n    let shouldTriggerRender = 0;\n\n    for (let targetIndex = 0; targetIndex < targetsLength; targetIndex++) {\n\n      const target = parsedTargets[targetIndex];\n      const ti = index || targetIndex;\n      const tl = allTargets || parsedTargets;\n\n      let lastTransformGroupIndex = NaN;\n      let lastTransformGroupLength = NaN;\n\n      for (let p in params) {\n\n        if (isKey(p)) {\n\n          const tweenType = getTweenType(target, p);\n          const adapterProp = resolveAdapterEntry(target, p);\n\n          const propName = sanitizePropertyName(p, target, tweenType);\n\n          let propValue = params[p];\n\n          const isPropValueArray = isArr(propValue);\n\n          if (fastSet && !isPropValueArray) {\n            fastSetValuesArray[0] = propValue;\n            fastSetValuesArray[1] = propValue;\n            propValue = fastSetValuesArray;\n          }\n\n          // TODO: Allow nested keyframes inside ObjectValue value (prop: { to: [.5, 1, .75, 2, 3] })\n          // Normalize property values to valid keyframe syntax:\n          // [x, y] to [{to: [x, y]}] or {to: x} to [{to: x}] or keep keys syntax [{}, {}, {}...]\n          // const keyframes = isArr(propValue) ? propValue.length === 2 && !isObj(propValue[0]) ? [{ to: propValue }] : propValue : [propValue];\n          if (isPropValueArray) {\n            const arrayLength = /** @type {Array} */(propValue).length;\n            const isNotObjectValue = !isObj(propValue[0]);\n            // Convert [x, y] to [{to: [x, y]}]\n            if (arrayLength === 2 && isNotObjectValue) {\n              keyObjectTarget.to = /** @type {TweenParamValue} */(/** @type {unknown} */(propValue));\n              keyframesTargetArray[0] = keyObjectTarget;\n              keyframes = keyframesTargetArray;\n            // Convert [x, y, z] to [[x, y], z]\n            } else if (arrayLength > 2 && isNotObjectValue) {\n              keyframes = [];\n              /** @type {Array.<Number>} */(propValue).forEach((v, i) => {\n                if (!i) {\n                  fastSetValuesArray[0] = v;\n                } else if (i === 1) {\n                  fastSetValuesArray[1] = v;\n                  keyframes.push(fastSetValuesArray);\n                } else {\n                  keyframes.push(v);\n                }\n              });\n            } else {\n              keyframes = /** @type {Array.<TweenKeyValue>} */(propValue);\n            }\n          } else {\n            keyframesTargetArray[0] = propValue;\n            keyframes = keyframesTargetArray;\n          }\n\n          let siblings = null;\n          let prevTween = null;\n          let firstTweenChangeStartTime = NaN;\n          let lastTweenChangeEndTime = 0;\n          let tweenIndex = 0;\n\n          for (let l = keyframes.length; tweenIndex < l; tweenIndex++) {\n\n            const keyframe = keyframes[tweenIndex];\n\n            if (isObj(keyframe)) {\n              key = keyframe;\n            } else {\n              keyObjectTarget.to = /** @type {TweenParamValue} */(keyframe);\n              key = keyObjectTarget;\n            }\n\n            toFunctionStore.func = null;\n            fromFunctionStore.func = null;\n\n            const computedComposition = getFunctionValue(setValue(key.composition, tComposition), target, ti, tl, null, null);\n            const tweenComposition = isNum(computedComposition) ? computedComposition : compositionTypes[computedComposition];\n            if (!siblings && tweenComposition !== compositionTypes.none) siblings = getTweenSiblings(target, propName);\n            // Timelines pass the last sibling tween if it belongs to the same timeline\n            // Standalone animations only pass prevTween when the property has multiple keyframes\n            const tailTween = siblings ? siblings._tail : null;\n            const prevSiblingTween = parent && tailTween && tailTween.parent.parent === parent ? tailTween : prevTween;\n            const computedToValue = getFunctionValue(key.to, target, ti, tl, toFunctionStore, prevSiblingTween);\n\n            let tweenToValue;\n            // Allows function based values to return an object syntax value ({to: v})\n            if (isObj(computedToValue) && !isUnd(computedToValue.to)) {\n              key = computedToValue;\n              tweenToValue = computedToValue.to;\n            } else {\n              tweenToValue = computedToValue;\n            }\n            const tweenFromValue = getFunctionValue(key.from, target, ti, tl, fromFunctionStore, prevSiblingTween);\n            const easeToParse = key.ease || tEasing;\n\n            const easeFunctionResult = getFunctionValue(easeToParse, target, ti, tl, null, prevSiblingTween);\n            const keyEasing = isFnc(easeFunctionResult) || isStr(easeFunctionResult) ? easeFunctionResult : easeToParse;\n\n            const hasSpring = !isUnd(keyEasing) && !isUnd(/** @type {Spring} */(keyEasing).ease);\n            const tweenEasing = hasSpring ? /** @type {Spring} */(keyEasing).ease : keyEasing;\n            // Calculate default individual keyframe duration by dividing the tl of keyframes\n            const tweenDuration = hasSpring ? /** @type {Spring} */(keyEasing).settlingDuration : getFunctionValue(setValue(key.duration, (l > 1 ? getFunctionValue(tDuration, target, ti, tl, null, prevSiblingTween) / l : tDuration)), target, ti, tl, null, prevSiblingTween);\n            // Default delay value should only be applied to the first tween\n            const tweenDelay = getFunctionValue(setValue(key.delay, (!tweenIndex ? tDelay : 0)), target, ti, tl, null, prevSiblingTween);\n            // Modifiers are treated differently and don't accept function based value to prevent having to pass a function wrapper\n            const tweenModifier = key.modifier || tModifier;\n            const hasFromvalue = !isUnd(tweenFromValue);\n            const hasToValue = !isUnd(tweenToValue);\n            const isFromToArray = isArr(tweenToValue);\n            const isFromToValue = isFromToArray || (hasFromvalue && hasToValue);\n            // 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.\n            const tweenUpdateStartLocal = prevTween ? lastTweenChangeEndTime : 0;\n            const tweenStartTime = prevTween ? lastTweenChangeEndTime + tweenDelay : tweenDelay;\n            // Rounding is necessary here to minimize floating point errors when working in seconds\n            const absoluteStartTime = round(absoluteOffsetTime + tweenStartTime, 12);\n            // Match the rounding pattern of prevSibling._absoluteEndTime so the composition overlap check compares cleanly when keyframes touch at a boundary.\n            const absoluteUpdateStartTime = round(absoluteOffsetTime + tweenUpdateStartLocal, 12);\n\n            // Force a onRender callback if the animation contains at least one from value and autoplay is set to false\n            if (!shouldTriggerRender && (hasFromvalue || isFromToArray)) shouldTriggerRender = 1;\n\n            let prevSibling = prevTween;\n\n            if (tweenComposition !== compositionTypes.none) {\n              let nextSibling = siblings._head;\n              // 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.\n              while (nextSibling && nextSibling._absoluteStartTime <= absoluteStartTime) {\n                if (!nextSibling._isOverridden) prevSibling = nextSibling;\n                nextSibling = nextSibling._nextRep;\n                // Overrides all the next siblings if the next sibling starts at the same time of after as the new tween start time\n                if (nextSibling && nextSibling._absoluteStartTime >= absoluteStartTime) {\n                  while (nextSibling) {\n                    overrideTween(nextSibling);\n                    // This will ends both the current while loop and the upper one once all the next sibllings have been overriden\n                    nextSibling = nextSibling._nextRep;\n                  }\n                }\n              }\n            }\n\n            // Decompose values\n            if (isFromToValue) {\n              decomposeRawValue(isFromToArray ? getFunctionValue(tweenToValue[0], target, ti, tl, fromFunctionStore, prevSiblingTween) : tweenFromValue, fromTargetObject);\n              decomposeRawValue(isFromToArray ? getFunctionValue(tweenToValue[1], target, ti, tl, toFunctionStore, prevSiblingTween) : tweenToValue, toTargetObject);\n              // Needed to force an inline style registration\n              const originalValue = getOriginalAnimatableValue(target, propName, tweenType, inlineStylesStore);\n              if (fromTargetObject.t === valueTypes.NUMBER) {\n                if (prevSibling) {\n                  if (prevSibling._valueType === valueTypes.UNIT) {\n                    fromTargetObject.t = valueTypes.UNIT;\n                    fromTargetObject.u = prevSibling._unit;\n                  }\n                } else {\n                  decomposeRawValue(\n                    originalValue,\n                    decomposedOriginalValue\n                  );\n                  if (decomposedOriginalValue.t === valueTypes.UNIT) {\n                    fromTargetObject.t = valueTypes.UNIT;\n                    fromTargetObject.u = decomposedOriginalValue.u;\n                  }\n                }\n              }\n            } else {\n              if (hasToValue) {\n                decomposeRawValue(tweenToValue, toTargetObject);\n              } else {\n                if (prevTween) {\n                  decomposeTweenValue(prevTween, toTargetObject);\n                } else {\n                  // 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\n                  decomposeRawValue(parent && prevSibling && prevSibling.parent.parent === parent ? prevSibling._value :\n                  getOriginalAnimatableValue(target, propName, tweenType, inlineStylesStore), toTargetObject);\n                }\n              }\n              if (hasFromvalue) {\n                decomposeRawValue(tweenFromValue, fromTargetObject);\n              } else {\n                if (prevTween) {\n                  decomposeTweenValue(prevTween, fromTargetObject);\n                } else {\n                  // 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\n                  decomposeRawValue(parent && prevSibling && prevSibling.parent.parent === parent ? prevSibling._value :\n                  getOriginalAnimatableValue(target, propName, tweenType, inlineStylesStore), fromTargetObject);\n                }\n              }\n            }\n\n            // Apply operators\n            if (fromTargetObject.o) {\n              fromTargetObject.n = getRelativeValue(\n                !prevSibling ? decomposeRawValue(\n                  getOriginalAnimatableValue(target, propName, tweenType, inlineStylesStore),\n                  decomposedOriginalValue\n                ).n : prevSibling._toNumber,\n                fromTargetObject.n,\n                fromTargetObject.o\n              );\n            }\n\n            if (toTargetObject.o) {\n              toTargetObject.n = getRelativeValue(fromTargetObject.n, toTargetObject.n, toTargetObject.o);\n            }\n\n            // Values omogenisation in cases of type difference between \"from\" and \"to\"\n            if (fromTargetObject.t !== toTargetObject.t) {\n              if (fromTargetObject.t === valueTypes.COMPLEX || toTargetObject.t === valueTypes.COMPLEX) {\n                const complexValue = fromTargetObject.t === valueTypes.COMPLEX ? fromTargetObject : toTargetObject;\n                const notComplexValue = fromTargetObject.t === valueTypes.COMPLEX ? toTargetObject : fromTargetObject;\n                notComplexValue.t = valueTypes.COMPLEX;\n                notComplexValue.s = cloneArray(complexValue.s);\n                notComplexValue.d = complexValue.d.map(() => notComplexValue.n);\n              } else if (fromTargetObject.t === valueTypes.UNIT || toTargetObject.t === valueTypes.UNIT) {\n                const unitValue = fromTargetObject.t === valueTypes.UNIT ? fromTargetObject : toTargetObject;\n                const notUnitValue = fromTargetObject.t === valueTypes.UNIT ? toTargetObject : fromTargetObject;\n                notUnitValue.t = valueTypes.UNIT;\n                notUnitValue.u = unitValue.u;\n              } else if (fromTargetObject.t === valueTypes.COLOR || toTargetObject.t === valueTypes.COLOR) {\n                const colorValue = fromTargetObject.t === valueTypes.COLOR ? fromTargetObject : toTargetObject;\n                const notColorValue = fromTargetObject.t === valueTypes.COLOR ? toTargetObject : fromTargetObject;\n                notColorValue.t = valueTypes.COLOR;\n                notColorValue.d = colorValue.d.map(() => 0);\n              }\n            }\n\n            // Unit conversion\n            if (fromTargetObject.u !== toTargetObject.u) {\n              let valueToConvert = toTargetObject.u ? fromTargetObject : toTargetObject;\n              valueToConvert = convertValueUnit(/** @type {DOMTarget} */(target), valueToConvert, toTargetObject.u ? toTargetObject.u : fromTargetObject.u, false);\n              // TODO:\n              // convertValueUnit(target, to.u ? from : to, to.u ? to.u : from.u);\n            }\n\n            // Fill in non existing complex values\n            if (toTargetObject.d && fromTargetObject.d && (toTargetObject.d.length !== fromTargetObject.d.length)) {\n              const longestValue = fromTargetObject.d.length > toTargetObject.d.length ? fromTargetObject : toTargetObject;\n              const shortestValue = longestValue === fromTargetObject ? toTargetObject : fromTargetObject;\n              // TODO: Check if n should be used instead of 0 for default complex values\n              shortestValue.d = longestValue.d.map((/** @type {Number} */_, /** @type {Number} */i) => isUnd(shortestValue.d[i]) ? 0 : shortestValue.d[i]);\n              shortestValue.s = cloneArray(longestValue.s);\n            }\n\n            // Tween factory\n\n            // Rounding is necessary here to minimize floating point errors when working in seconds\n            const tweenUpdateDuration = round(+tweenDuration || minValue, 12);\n\n            // Copy the value of the iniline style if it exist and imediatly nullify it to prevents false positive on other targets\n            let inlineValue = inlineStylesStore[propName];\n            if (!isNil(inlineValue)) inlineStylesStore[propName] = null;\n\n            // Resolve the adapter setter once so render skips the lookup per frame.\n            const tweenSetter = adapterProp ? adapterProp.set : null;\n\n            // Rounding is necessary here to minimize floating point errors when working in seconds\n            lastTweenChangeEndTime = round(tweenStartTime + tweenUpdateDuration, 12);\n\n            const fromD = fromTargetObject.d;\n            const toD = toTargetObject.d;\n            const toS = toTargetObject.s;\n\n            /** @type {Tween} */\n            const tween = {\n              parent: this,\n              id: tweenId++,\n              property: propName,\n              target: target,\n              _value: null,\n              _toFunc: toFunctionStore.func,\n              _fromFunc: fromFunctionStore.func,\n              _ease: parseEase(tweenEasing),\n              _fromNumbers: fromD ? cloneArray(fromD) : emptyArray,\n              _toNumbers: toD ? cloneArray(toD) : emptyArray,\n              _strings: toS ? cloneArray(toS) : emptyArray,\n              _fromNumber: fromTargetObject.n,\n              _toNumber: toTargetObject.n,\n              _numbers: fromD ? cloneArray(fromD) : emptyArray, // For additive tween and animatables\n              _number: fromTargetObject.n, // For additive tween and animatables\n              _unit: toTargetObject.u,\n              _modifier: tweenModifier,\n              _currentTime: 0,\n              _startTime: tweenStartTime,\n              _delay: +tweenDelay,\n              _updateDuration: tweenUpdateDuration,\n              _changeDuration: tweenUpdateDuration,\n              _absoluteStartTime: absoluteStartTime,\n              _absoluteUpdateStartTime: absoluteUpdateStartTime,\n              _absoluteEndTime: round(absoluteOffsetTime + lastTweenChangeEndTime, 12),\n              _hasFromValue: hasFromvalue || isFromToArray ? 1 : 0,\n              // NOTE: Investigate bit packing to stores ENUM / BOOL\n              _tweenType: tweenType,\n              _setter: tweenSetter,\n              _valueType: toTargetObject.t,\n              _composition: tweenComposition,\n              _isOverlapped: 0,\n              _isOverridden: 0,\n              _renderTransforms: 0,\n              _inlineValue: inlineValue,\n              _prevRep: null, // For replaced tween\n              _nextRep: null, // For replaced tween\n              _prevAdd: null, // For additive tween\n              _nextAdd: null, // For additive tween\n              _prev: null,\n              _next: null,\n            };\n\n            if (tweenComposition !== compositionTypes.none) {\n              composeTween(tween, siblings);\n            }\n\n            // Pre-compute the tween end value for function-based value chaining (ie morphTo / scrambleText in keyframe arrays and timelines)\n            const vt = tween._valueType;\n            if (vt === valueTypes.COMPLEX) {\n              tween._value = composeComplexValue(tween, 1, -1);\n            } else if (vt === valueTypes.UNIT) {\n              tween._value = `${tweenModifier(tween._toNumber)}${tween._unit}`;\n            } else if (vt === valueTypes.COLOR) {\n              const d = toTargetObject.d;\n              tween._value = `rgba(${round(d[0], 0)},${round(d[1], 0)},${round(d[2], 0)},${d[3]})`;\n            } else {\n              tween._value = tweenModifier(tween._toNumber);\n            }\n\n            if (isNaN(firstTweenChangeStartTime)) {\n              firstTweenChangeStartTime = tween._startTime;\n            }\n\n            prevTween = tween;\n            animationAnimationLength++;\n\n            addChild(this, tween);\n\n          }\n\n          // Update animation timings with the added tweens properties\n\n          if (isNaN(iterationDelay) || firstTweenChangeStartTime < iterationDelay) {\n            iterationDelay = firstTweenChangeStartTime;\n          }\n\n          if (isNaN(iterationDuration) || lastTweenChangeEndTime > iterationDuration) {\n            iterationDuration = lastTweenChangeEndTime;\n          }\n\n          // TODO: Find a way to inline tween._renderTransforms = 1 here\n          if (tweenType === tweenTypes.TRANSFORM) {\n            lastTransformGroupIndex = animationAnimationLength - tweenIndex;\n            lastTransformGroupLength = animationAnimationLength;\n          }\n\n        }\n\n      }\n\n      // Set _renderTransforms to last transform property to correctly render the transforms list\n      if (!isNaN(lastTransformGroupIndex)) {\n        let i = 0;\n        forEachChildren(this, (/** @type {Tween} */tween) => {\n          if (i >= lastTransformGroupIndex && i < lastTransformGroupLength) {\n            tween._renderTransforms = 1;\n            if (tween._composition === compositionTypes.blend) {\n              forEachChildren(additive.animation, (/** @type {Tween} */additiveTween) => {\n                if (additiveTween.id === tween.id) {\n                  additiveTween._renderTransforms = 1;\n                }\n              });\n            }\n          }\n          i++;\n        });\n      }\n\n    }\n\n    if (!targetsLength) {\n      console.warn(`No target found. Make sure the element you're trying to animate is accessible before creating your animation.`);\n    }\n\n    if (iterationDelay) {\n      forEachChildren(this, (/** @type {Tween} */tween) => {\n        // If (startTime - delay) equals 0, this means the tween is at the begining of the animation so we need to trim the delay too\n        if (!(tween._startTime - tween._delay)) {\n          tween._delay -= iterationDelay;\n        }\n        tween._startTime -= iterationDelay;\n      });\n      iterationDuration -= iterationDelay;\n    } else {\n      iterationDelay = 0;\n    }\n\n    // Prevents iterationDuration to be NaN if no valid animatable props have been provided\n    // Prevents _iterationCount to be NaN if no valid animatable props have been provided\n    if (!iterationDuration) {\n      iterationDuration = minValue;\n      this.iterationCount = 0;\n    }\n    /** @type {TargetsArray} */\n    this.targets = parsedTargets;\n    /** @type {String|Number} */\n    this.id = !isUnd(id) ? id : JSAnimationId;\n    /** @type {Number} */\n    this.duration = iterationDuration === minValue ? minValue : clampInfinity(((iterationDuration + this._loopDelay) * this.iterationCount) - this._loopDelay) || minValue;\n    /** @type {Callback<this>} */\n    this.onRender = onRender || animDefaults.onRender;\n    /** @type {EasingFunction} */\n    this._ease = parsedAnimPlaybackEase;\n    /** @type {Number} */\n    this._delay = iterationDelay;\n    // NOTE: I'm keeping delay values separated from offsets in timelines because delays can override previous tweens and it could be confusing to debug a timeline with overridden tweens and no associated visible delays.\n    // this._delay = parent ? 0 : iterationDelay;\n    // this._offset += parent ? iterationDelay : 0;\n    /** @type {Number} */\n    this.iterationDuration = iterationDuration;\n\n    if (!this._autoplay && shouldTriggerRender) this.onRender(this);\n  }\n\n  /**\n   * @param  {Number} newDuration\n   * @return {this}\n   */\n  stretch(newDuration) {\n    const currentDuration = this.duration;\n    if (currentDuration === normalizeTime(newDuration)) return this;\n    const timeScale = newDuration / currentDuration;\n    // NOTE: Find a better way to handle the stretch of an animation after stretch = 0\n    forEachChildren(this, (/** @type {Tween} */tween) => {\n      // Rounding is necessary here to minimize floating point errors\n      tween._updateDuration = normalizeTime(tween._updateDuration * timeScale);\n      tween._changeDuration = normalizeTime(tween._changeDuration * timeScale);\n      tween._currentTime *= timeScale;\n      tween._delay *= timeScale;\n      tween._startTime *= timeScale;\n      tween._absoluteStartTime *= timeScale;\n      tween._absoluteUpdateStartTime *= timeScale;\n      tween._absoluteEndTime *= timeScale;\n    });\n    return super.stretch(newDuration);\n  }\n\n  /**\n   * @return {this}\n   */\n  refresh() {\n    forEachChildren(this, (/** @type {Tween} */tween) => {\n      const toFunc = tween._toFunc;\n      const fromFunc = tween._fromFunc;\n      if (toFunc || fromFunc) {\n        if (fromFunc) {\n          decomposeRawValue(fromFunc(), fromTargetObject);\n          if (fromTargetObject.u !== tween._unit && tween.target[isDomSymbol]) {\n            convertValueUnit(/** @type {DOMTarget} */(tween.target), fromTargetObject, tween._unit, true);\n          }\n          tween._fromNumbers = cloneArray(fromTargetObject.d);\n          tween._fromNumber = fromTargetObject.n;\n        } else if (toFunc) {\n          // When only toFunc exists, get from value from target\n          decomposeRawValue(getOriginalAnimatableValue(tween.target, tween.property, tween._tweenType), decomposedOriginalValue);\n          tween._fromNumbers = cloneArray(decomposedOriginalValue.d);\n          tween._fromNumber = decomposedOriginalValue.n;\n        }\n        if (toFunc) {\n          decomposeRawValue(toFunc(), toTargetObject);\n          tween._toNumbers = cloneArray(toTargetObject.d);\n          tween._strings = cloneArray(toTargetObject.s);\n          // Make sure to apply relative operators https://github.com/juliangarnier/anime/issues/1025\n          tween._toNumber = toTargetObject.o ? getRelativeValue(tween._fromNumber, toTargetObject.n, toTargetObject.o) : toTargetObject.n;\n        }\n      }\n    });\n    // This forces setter animations to render once\n    if (this.duration === minValue) this.restart();\n    return this;\n  }\n\n  /**\n   * Cancel the animation and revert all the values affected by this animation to their original state\n   * @return {this}\n   */\n  revert() {\n    super.revert();\n    return revertValues(this);\n  }\n\n  /**\n   * @typedef {this & {then: null}} ResolvedJSAnimation\n   */\n\n  /**\n   * @param  {Callback<ResolvedJSAnimation>} [callback]\n   * @return Promise<this>\n   */\n  then(callback) {\n    return super.then(callback);\n  }\n\n}\n\n/**\n * @param {TargetsParam} targets\n * @param {AnimationParams} parameters\n * @return {JSAnimation}\n */\nconst animate = (targets, parameters) => {\n  if (globals.editor) {\n    return globals.editor.addAnimation(targets, parameters);\n  } else {\n    return new JSAnimation(targets, parameters, null, 0, false).init();\n  }\n};\n\nexport { JSAnimation, animate };\n"],"ignoreList":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18],"mappings":"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"}