{"version":3,"sources":["jsdelivr-header.js","/npm/animejs@4.3.6/dist/modules/core/consts.js","/npm/animejs@4.3.6/dist/modules/core/globals.js","/npm/animejs@4.3.6/dist/modules/core/helpers.js","/npm/animejs@4.3.6/dist/modules/core/colors.js","/npm/animejs@4.3.6/dist/modules/core/values.js","/npm/animejs@4.3.6/dist/modules/core/transforms.js","/npm/animejs@4.3.6/dist/modules/core/render.js","/npm/animejs@4.3.6/dist/modules/core/styles.js","/npm/animejs@4.3.6/dist/modules/core/clock.js","/npm/animejs@4.3.6/dist/modules/animation/additive.js","/npm/animejs@4.3.6/dist/modules/engine/engine.js","/npm/animejs@4.3.6/dist/modules/animation/composition.js","/npm/animejs@4.3.6/dist/modules/timer/timer.js","/npm/animejs@4.3.6/dist/modules/core/targets.js","/npm/animejs@4.3.6/dist/modules/core/units.js","/npm/animejs@4.3.6/dist/modules/easings/none.js","/npm/animejs@4.3.6/dist/modules/easings/eases/parser.js","/npm/animejs@4.3.6/dist/modules/animation/animation.js","/npm/animejs@4.3.6/dist/modules/timeline/position.js","/npm/animejs@4.3.6/dist/modules/timeline/timeline.js","/npm/animejs@4.3.6/dist/modules/animatable/animatable.js","/npm/animejs@4.3.6/dist/modules/utils/number.js","/npm/animejs@4.3.6/dist/modules/easings/spring/index.js","/npm/animejs@4.3.6/dist/modules/waapi/composition.js","/npm/animejs@4.3.6/dist/modules/utils/target.js","/npm/animejs@4.3.6/dist/modules/draggable/draggable.js","/npm/animejs@4.3.6/dist/modules/utils/time.js","/npm/animejs@4.3.6/dist/modules/scope/scope.js","/npm/animejs@4.3.6/dist/modules/events/scroll.js","/npm/animejs@4.3.6/dist/modules/easings/cubic-bezier/index.js","/npm/animejs@4.3.6/dist/modules/easings/steps/index.js","/npm/animejs@4.3.6/dist/modules/easings/linear/index.js","/npm/animejs@4.3.6/dist/modules/easings/irregular/index.js","/npm/animejs@4.3.6/dist/modules/waapi/waapi.js","/npm/animejs@4.3.6/dist/modules/layout/layout.js","/npm/animejs@4.3.6/dist/modules/utils/chainable.js","/npm/animejs@4.3.6/dist/modules/utils/random.js","/npm/animejs@4.3.6/dist/modules/utils/stagger.js","/npm/animejs@4.3.6/dist/modules/svg/helpers.js","/npm/animejs@4.3.6/dist/modules/svg/motionpath.js","/npm/animejs@4.3.6/dist/modules/svg/drawable.js","/npm/animejs@4.3.6/dist/modules/svg/morphto.js","/npm/animejs@4.3.6/dist/modules/text/split.js"],"names":[],"mappings":"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","file":"/npm/animejs@4.3.6/dist/modules/index.js/+esm","sourceRoot":"","sourcesContent":["/**\n * Bundled by jsDelivr using Rollup v2.79.2 and Terser v5.39.0.\n * Original file: /npm/animejs@4.3.6/dist/modules/index.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","/**\n * Anime.js - core - ESM\n * @version v4.3.6\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} & {AnimeJSDevTools: any}|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 morphPointsSymbol = 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\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  '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  'matrix',\n  'matrix3d',\n  'perspective',\n];\n\nconst transformsFragmentStrings = /*#__PURE__*/ validTransforms.reduce((a, v) => ({...a, [v]: v + '('}), {});\n\n// Functions\n\n/** @return {void} */\nconst noop = () => {};\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 transformsExecRgx = /(\\w+)(\\([^)]+\\)+)/g; // Match inline transforms with cacl() values, returns the value wrapped in ()\nconst relativeValuesExecRgx = /(\\*=|\\+=|-=)/;\nconst cssVariableMatchRgx = /var\\(\\s*(--[\\w-]+)(?:\\s*,\\s*([^)]+))?\\s*\\)/;\n\nexport { K, compositionTypes, cssVarPrefix, cssVariableMatchRgx, digitWithExponentRgx, doc, emptyString, hexTestRgx, hslExecRgx, hslaExecRgx, isBrowser, isDomSymbol, isRegisteredTargetSymbol, isSvgSymbol, lowerCaseRgx, maxFps, maxValue, minValue, morphPointsSymbol, noop, proxyTargetSymbol, relativeValuesExecRgx, rgbExecRgx, rgbaExecRgx, shortTransforms, tickModes, transformsExecRgx, transformsFragmentStrings, transformsSymbol, tweenTypes, unitsExecRgx, validRgbHslRgx, validTransforms, valueTypes, win };\n","/**\n * Anime.js - core - ESM\n * @version v4.3.6\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { isBrowser, win, noop, maxFps, K, compositionTypes, 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/** @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: v => v,\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};\n\nconst devTools = isBrowser && win.AnimeJSDevTools;\n\nconst globalVersions = { version: '4.3.6', engine: null };\n\nif (isBrowser) {\n  if (!win.AnimeJS) win.AnimeJS = [];\n  win.AnimeJS.push(globalVersions);\n}\n\nexport { defaults, devTools, globalVersions, globals, scope };\n","/**\n * Anime.js - core - ESM\n * @version v4.3.6\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\nconst powCache = {};\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 */\nconst round = (v, decimalLength) => {\n  if (decimalLength < 0) return v;\n  if (!decimalLength) return _round(v);\n  let p = powCache[decimalLength];\n  if (!p) p = powCache[decimalLength] = 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) => 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.3.6\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.3.6\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { tweenTypes, isDomSymbol, isSvgSymbol, validTransforms, shortTransforms, valueTypes, unitsExecRgx, digitWithExponentRgx, proxyTargetSymbol, cssVarPrefix, cssVariableMatchRgx, emptyString } from './consts.js';\nimport { isUnd, isValidSVGAttribute, stringStartsWith, isCol, isFnc, isStr, cloneArray } from './helpers.js';\nimport { parseInlineTransforms } from './transforms.js';\nimport { convertColorStringValuesToRgbaArray } from './colors.js';\n\n/**\n* @import {\n*   Target,\n*   DOMTarget,\n*   Tween,\n*   TweenPropValue,\n*   TweenDecomposedValue,\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 * @param  {TweenPropValue} value\n * @param  {Target} target\n * @param  {Number} index\n * @param  {Number} total\n * @param  {Object} [store]\n * @return {any}\n */\nconst getFunctionValue = (value, target, index, total, store) => {\n  let func;\n  if (isFnc(value)) {\n    func = () => {\n      const computed = /** @type {Function} */(value)(target, index, total);\n      // Fallback to 0 if the function returns undefined / NaN / null / false / 0\n      return !isNaN(+computed) ? +computed : computed || 0;\n    };\n  } else if (isStr(value) && stringStartsWith(value, cssVarPrefix)) {\n    func = () => {\n      const match = value.match(cssVariableMatchRgx);\n      const cssVarName = match[1];\n      const fallbackValue = match[2];\n      let computed = getComputedStyle(/** @type {HTMLElement} */(target))?.getPropertyValue(cssVarName);\n      // Use fallback if CSS variable is not set or empty\n      if ((!computed || computed.trim() === emptyString) && fallbackValue) {\n        computed = fallbackValue.trim();\n      }\n      return computed || 0;\n    };\n  } else {\n    return value;\n  }\n  if (store) store.func = func;\n  return func();\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  return type === tweenTypes.OBJECT ? target[propName] || 0 :\n         type === tweenTypes.ATTRIBUTE ? /** @type {DOMTarget} */(target).getAttribute(propName) :\n         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} 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  } else {\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      // Is a color\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/**\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\nexport { createDecomposedValueTargetObject, decomposeRawValue, decomposeTweenValue, decomposedOriginalValue, getFunctionValue, getOriginalAnimatableValue, getRelativeValue, getTweenType, setValue };\n","/**\n * Anime.js - core - ESM\n * @version v4.3.6\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { transformsSymbol, transformsExecRgx } 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  let inlinedStylesPropertyValue;\n  if (inlineTransforms) {\n    const cachedTransforms = target[transformsSymbol];\n    let t; while (t = transformsExecRgx.exec(inlineTransforms)) {\n      const inlinePropertyName = t[1];\n      // const inlinePropertyValue = t[2];\n      const inlinePropertyValue = t[2].slice(1, -1);\n      cachedTransforms[inlinePropertyName] = inlinePropertyValue;\n      if (inlinePropertyName === propName) {\n        inlinedStylesPropertyValue = inlinePropertyValue;\n        // Store the new parsed inline styles if animationInlineStyles is provided\n        if (animationInlineStyles) {\n          animationInlineStyles[propName] = inlinePropertyValue;\n        }\n      }\n    }\n  }\n  return inlineTransforms && !isUnd(inlinedStylesPropertyValue) ? inlinedStylesPropertyValue :\n    stringStartsWith(propName, 'scale') ? '1' :\n    stringStartsWith(propName, 'rotate') || stringStartsWith(propName, 'skew') ? '0deg' : '0px';\n};\n\nexport { parseInlineTransforms };\n","/**\n * Anime.js - core - ESM\n * @version v4.3.6\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { globals } from './globals.js';\nimport { minValue, tickModes, valueTypes, compositionTypes, tweenTypes, transformsSymbol, transformsFragmentStrings, emptyString } from './consts.js';\nimport { forEachChildren, round, now, clamp, lerp } from './helpers.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\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 currentIteration = ~~(tickableCurrentTime / (iterationDuration + (isCurrentTimeEqualOrAboveDuration ? 0 : _loopDelay)));\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    iterationElapsedTime = tickableCurrentTime % (iterationDuration + _loopDelay) || 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      time >= 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 <= tickableDelay && tickablePrevTime > 0 ||\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      const absoluteTime = tickable._offset + (parent ? parent._offset : 0) + tickableDelay + iterationTime;\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\n        if ((forcedRender || (\n            (tweenCurrentTime !== tweenChangeDuration || absoluteTime <= tweenAbsEndTime + (tweenNextRep ? tweenNextRep._delay : 0)) &&\n            (tweenCurrentTime !== 0 || absoluteTime >= tween._absoluteStartTime)\n          )) && (!tweenHasComposition || (\n            !tween._isOverridden &&\n            (!tween._isOverlapped || absoluteTime <= tweenAbsEndTime) &&\n            (!tweenNextRep || (tweenNextRep._isOverridden || absoluteTime <= tweenNextRep._absoluteStartTime)) &&\n            (!tweenPrevRep || (tweenPrevRep._isOverridden || (absoluteTime >= (tweenPrevRep._absoluteStartTime + tweenPrevRep._changeDuration) + tween._delay)))\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\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 fn = tween._fromNumbers;\n            const tn = tween._toNumbers;\n            const r = round(clamp(/** @type {Number} */(tweenModifier(lerp(fn[0], tn[0], tweenProgress))), 0, 255), 0);\n            const g = round(clamp(/** @type {Number} */(tweenModifier(lerp(fn[1], tn[1], tweenProgress))), 0, 255), 0);\n            const b = round(clamp(/** @type {Number} */(tweenModifier(lerp(fn[2], tn[2], tweenProgress))), 0, 255), 0);\n            const a = clamp(/** @type {Number} */(tweenModifier(round(lerp(fn[3], tn[3], tweenProgress), tweenPrecision))), 0, 1);\n            value = `rgba(${r},${g},${b},${a})`;\n            if (tweenHasComposition) {\n              const ns = tween._numbers;\n              ns[0] = r;\n              ns[1] = g;\n              ns[2] = b;\n              ns[3] = a;\n            }\n          } else if (tweenValueType === valueTypes.COMPLEX) {\n            value = tween._strings[0];\n            for (let j = 0, l = tween._toNumbers.length; j < l; j++) {\n              const n = /** @type {Number} */(tweenModifier(round(lerp(tween._fromNumbers[j], tween._toNumbers[j], tweenProgress), tweenPrecision)));\n              const s = tween._strings[j + 1];\n              value += `${s ? n + s : n}`;\n              if (tweenHasComposition) {\n                tween._numbers[j] = n;\n              }\n            }\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 (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        }\n\n        // NOTE: Possible improvement: Use translate(x,y) / translate3d(x,y,z) syntax\n        // to reduce memory usage on string composition\n        if (tweenTransformsNeedUpdate && tween._renderTransforms) {\n          let str = emptyString;\n          for (let key in tweenTargetTransformsProperties) {\n            str += `${transformsFragmentStrings[key]}${tweenTargetTransformsProperties[key]}) `;\n          }\n          tweenStyle.transform = str;\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      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\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.3.6\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { tweenTypes, shortTransforms, isDomSymbol, transformsSymbol, transformsFragmentStrings, emptyString } from './consts.js';\nimport { forEachChildren, isSvg, toLowerCase, isNil } from './helpers.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 * @return {T}\n */\nconst cleanInlineStyles = renderable => {\n  // Allow cleanInlineStyles() to be called on timelines\n  if (renderable._hasChildren) {\n    forEachChildren(renderable, cleanInlineStyles, 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      if (tweenTarget[isDomSymbol]) {\n        const targetStyle = /** @type {DOMTarget} */(tweenTarget).style;\n        const originalInlinedValue = tween._inlineValue;\n        const tweenHadNoInlineValue = isNil(originalInlinedValue) || originalInlinedValue === emptyString;\n        if (tween._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              let str = emptyString;\n              for (let key in cachedTransforms) {\n                str += transformsFragmentStrings[key] + cachedTransforms[key] + ') ';\n              }\n              targetStyle.transform = str;\n            }\n          }\n        } else {\n          if (tweenHadNoInlineValue) {\n            targetStyle.removeProperty(toLowerCase(tweenProperty));\n          } else {\n            targetStyle[tweenProperty] = originalInlinedValue;\n          }\n        }\n        if (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  }\n  return renderable;\n};\n\nexport { cleanInlineStyles, sanitizePropertyName };\n","/**\n * Anime.js - core - ESM\n * @version v4.3.6\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._scheduledTime = 0;\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 previousFrameDuration = this._frameDuration;\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    this._scheduledTime += frameDuration - previousFrameDuration;\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 scheduledTime = this._scheduledTime;\n    this._lastTickTime = time;\n    // If the current time is lower than the scheduled time\n    // this means not enough time has passed to hit one frameDuration\n    // so skip that frame\n    if (time < scheduledTime) return tickModes.NONE;\n    const frameDuration = this._frameDuration;\n    const frameDelta = time - scheduledTime;\n    // Ensures that _scheduledTime progresses in steps of at least 1 frameDuration.\n    // Skips ahead if the actual elapsed time is higher.\n    this._scheduledTime += frameDelta < frameDuration ? frameDuration : frameDelta;\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.3.6\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.3.6\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    this._speed = playbackRate * globals.timeScale;\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.3.6\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { minValue, compositionTypes, 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 { addAdditiveAnimation, additive } 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._absoluteStartTime + prevSibling._changeDuration;\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      const absoluteUpdateStartTime = tweenAbsStartTime - tween._delay;\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      // Pause (and cancel) the parent if it only contains overlapped tweens\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    // 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) {\n      const toNumbers = cloneArray(tween._toNumbers);\n      if (toNumbers) {\n        toNumbers.forEach((value, i) => {\n          tween._fromNumbers[i] = lookupTween._fromNumbers[i] - value;\n          tween._toNumbers[i] = 0;\n        });\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.3.6\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, devTools, 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/**\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      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    if (devTools) {\n      const isInfinite = timerIterationCount === Infinity;\n      const registered = devTools.register(this, parameters, isInfinite);\n      if (registered && isInfinite) {\n        const minIterations = alternate ? 2 : 1;\n        const iterations = parent ? devTools.maxNestedInfiniteLoops : devTools.maxInfiniteLoops;\n        timerIterationCount = Math.max(iterations, minIterations);\n      }\n    }\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  }\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);\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.3.6\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  if (parsedTargetsLength) {\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  }\n  return parsedTargetsArray;\n}\n\nexport { getNodeList, parseTargets, registerTargets };\n","/**\n * Anime.js - core - ESM\n * @version v4.3.6\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.3.6\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.3.6\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 {typeof none} linear\n * @property {typeof none} 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.3.6\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { K, compositionTypes, valueTypes, minValue, tweenTypes, isDomSymbol } from '../core/consts.js';\nimport { mergeObjects, isUnd, isKey, isObj, round, cloneArray, isNil, addChild, forEachChildren, clampInfinity, normalizeTime, isArr, isFnc, isStr, isNum } from '../core/helpers.js';\nimport { globals } from '../core/globals.js';\nimport { registerTargets } from '../core/targets.js';\nimport { setValue, getTweenType, getFunctionValue, decomposeRawValue, getOriginalAnimatableValue, createDecomposedValueTargetObject, decomposedOriginalValue, getRelativeValue, decomposeTweenValue } from '../core/values.js';\nimport { sanitizePropertyName, cleanInlineStyles } 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 {Number} [length=0]\n   */\n  constructor(\n    targets,\n    parameters,\n    parent,\n    parentPosition,\n    fastSet = false,\n    index = 0,\n    length = 0\n  ) {\n\n    super(/** @type {TimerParams & AnimationParams} */(parameters), parent, parentPosition);\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 = length || targetsLength;\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\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 computedToValue = getFunctionValue(key.to, target, ti, tl, toFunctionStore);\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);\n            const easeToParse = key.ease || tEasing;\n\n            const easeFunctionResult = getFunctionValue(easeToParse, target, ti, tl);\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) / l : tDuration)), target, ti, tl);\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);\n            const computedComposition = getFunctionValue(setValue(key.composition, tComposition), target, ti, tl);\n            const tweenComposition = isNum(computedComposition) ? computedComposition : compositionTypes[computedComposition];\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            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\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              if (!siblings) siblings = getTweenSiblings(target, propName);\n              let nextSibling = siblings._head;\n              // Iterate trough all the next siblings until we find a sibling with an equal or inferior start time\n              while (nextSibling && !nextSibling._isOverridden && nextSibling._absoluteStartTime <= absoluteStartTime) {\n                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) : tweenFromValue, fromTargetObject);\n              decomposeRawValue(isFromToArray ? getFunctionValue(tweenToValue[1], target, ti, tl, toFunctionStore) : 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                  decomposeRawValue(parent && prevSibling && prevSibling.parent.parent === parent ? prevSibling._value :\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                  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.s = colorValue.s;\n                notColorValue.d = [0, 0, 0, 1];\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            /** @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: cloneArray(fromTargetObject.d),\n              _toNumbers: cloneArray(toTargetObject.d),\n              _strings: cloneArray(toTargetObject.s),\n              _fromNumber: fromTargetObject.n,\n              _toNumber: toTargetObject.n,\n              _numbers: cloneArray(fromTargetObject.d), // 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              // NOTE: Investigate bit packing to stores ENUM / BOOL\n              _tweenType: tweenType,\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            if (isNaN(firstTweenChangeStartTime)) {\n              firstTweenChangeStartTime = tween._startTime;\n            }\n            // Rounding is necessary here to minimize floating point errors when working in seconds\n            lastTweenChangeEndTime = round(tweenStartTime + tweenUpdateDuration, 12);\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._startTime *= timeScale;\n      tween._absoluteStartTime *= 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 cleanInlineStyles(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) => new JSAnimation(targets, parameters, null, 0, false).init();\n\nexport { JSAnimation, animate };\n","/**\n * Anime.js - timeline - ESM\n * @version v4.3.6\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { relativeValuesExecRgx, minValue } from '../core/consts.js';\nimport { isUnd, isNum, stringStartsWith, isNil } from '../core/helpers.js';\nimport { getRelativeValue } from '../core/values.js';\n\n/**\n * @import {\n *   Tickable,\n *   TimelinePosition,\n * } from '../types/index.js'\n*/\n\n/**\n * @import {\n *   Timeline,\n * } from './timeline.js'\n*/\n\n/**\n * Timeline's children offsets positions parser\n * @param  {Timeline} timeline\n * @param  {String} timePosition\n * @return {Number}\n */\nconst getPrevChildOffset = (timeline, timePosition) => {\n  if (stringStartsWith(timePosition, '<')) {\n    const goToPrevAnimationOffset = timePosition[1] === '<';\n    const prevAnimation = /** @type {Tickable} */(timeline._tail);\n    const prevOffset = prevAnimation ? prevAnimation._offset + prevAnimation._delay : 0;\n    return goToPrevAnimationOffset ? prevOffset : prevOffset + prevAnimation.duration;\n  }\n};\n\n/**\n * @param  {Timeline} timeline\n * @param  {TimelinePosition} [timePosition]\n * @return {Number}\n */\nconst parseTimelinePosition = (timeline, timePosition) => {\n  let tlDuration = timeline.iterationDuration;\n  if (tlDuration === minValue) tlDuration = 0;\n  if (isUnd(timePosition)) return tlDuration;\n  if (isNum(+timePosition)) return +timePosition;\n  const timePosStr = /** @type {String} */(timePosition);\n  const tlLabels = timeline ? timeline.labels : null;\n  const hasLabels = !isNil(tlLabels);\n  const prevOffset = getPrevChildOffset(timeline, timePosStr);\n  const hasSibling = !isUnd(prevOffset);\n  const matchedRelativeOperator = relativeValuesExecRgx.exec(timePosStr);\n  if (matchedRelativeOperator) {\n    const fullOperator = matchedRelativeOperator[0];\n    const split = timePosStr.split(fullOperator);\n    const labelOffset = hasLabels && split[0] ? tlLabels[split[0]] : tlDuration;\n    const parsedOffset = hasSibling ? prevOffset : hasLabels ? labelOffset : tlDuration;\n    const parsedNumericalOffset = +split[1];\n    return getRelativeValue(parsedOffset, parsedNumericalOffset, fullOperator[0]);\n  } else {\n    return hasSibling ? prevOffset :\n           hasLabels ? !isUnd(tlLabels[timePosStr]) ? tlLabels[timePosStr] :\n           tlDuration : tlDuration;\n  }\n};\n\nexport { parseTimelinePosition };\n","/**\n * Anime.js - timeline - ESM\n * @version v4.3.6\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { globals } from '../core/globals.js';\nimport { minValue, compositionTypes, tickModes } from '../core/consts.js';\nimport { isUnd, mergeObjects, isObj, isFnc, isStr, normalizeTime, forEachChildren, isNum, addChild, clampInfinity } from '../core/helpers.js';\nimport { setValue } from '../core/values.js';\nimport { parseTargets } from '../core/targets.js';\nimport { tick } from '../core/render.js';\nimport { cleanInlineStyles } from '../core/styles.js';\nimport { removeTargetsFromRenderable } from '../animation/composition.js';\nimport { JSAnimation } from '../animation/animation.js';\nimport { Timer } from '../timer/timer.js';\nimport { parseEase } from '../easings/eases/parser.js';\nimport { parseTimelinePosition } from './position.js';\n\n/**\n * @import {\n *   TargetsParam,\n *   Callback,\n *   Tickable,\n *   TimerParams,\n *   AnimationParams,\n *   Target,\n *   Renderable,\n *   TimelineParams,\n *   DefaultsParams,\n *   TimelinePosition,\n *   StaggerFunction,\n * } from '../types/index.js'\n*/\n\n/**\n * @import {\n *   WAAPIAnimation,\n * } from '../waapi/waapi.js'\n*/\n\n/**\n * @param {Timeline} tl\n * @return {Number}\n */\nfunction getTimelineTotalDuration(tl) {\n  return clampInfinity(((tl.iterationDuration + tl._loopDelay) * tl.iterationCount) - tl._loopDelay) || minValue;\n}\n\n/**\n * @overload\n * @param  {TimerParams} childParams\n * @param  {Timeline} tl\n * @param  {Number} timePosition\n * @return {Timeline}\n *\n * @overload\n * @param  {AnimationParams} childParams\n * @param  {Timeline} tl\n * @param  {Number} timePosition\n * @param  {TargetsParam} targets\n * @param  {Number} [index]\n * @param  {Number} [length]\n * @return {Timeline}\n *\n * @param  {TimerParams|AnimationParams} childParams\n * @param  {Timeline} tl\n * @param  {Number} timePosition\n * @param  {TargetsParam} [targets]\n * @param  {Number} [index]\n * @param  {Number} [length]\n */\nfunction addTlChild(childParams, tl, timePosition, targets, index, length) {\n  const isSetter = isNum(childParams.duration) && /** @type {Number} */(childParams.duration) <= minValue;\n  // Offset the tl position with -minValue for 0 duration animations or .set() calls in order to align their end value with the defined position\n  const adjustedPosition = isSetter ? timePosition - minValue : timePosition;\n  if (tl.composition) tick(tl, adjustedPosition, 1, 1, tickModes.AUTO);\n  const tlChild = targets ?\n    new JSAnimation(targets,/** @type {AnimationParams} */(childParams), tl, adjustedPosition, false, index, length) :\n    new Timer(/** @type {TimerParams} */(childParams), tl, adjustedPosition);\n  if (tl.composition) tlChild.init(true);\n  // TODO: Might be better to insert at a position relative to startTime?\n  addChild(tl, tlChild);\n  forEachChildren(tl, (/** @type {Renderable} */child) => {\n    const childTLOffset = child._offset + child._delay;\n    const childDur = childTLOffset + child.duration;\n    if (childDur > tl.iterationDuration) tl.iterationDuration = childDur;\n  });\n  tl.duration = getTimelineTotalDuration(tl);\n  return tl;\n}\n\nlet TLId = 0;\n\nclass Timeline extends Timer {\n\n  /**\n   * @param {TimelineParams} [parameters]\n   */\n  constructor(parameters = {}) {\n    super(/** @type {TimerParams&TimelineParams} */(parameters), null, 0);\n    ++TLId;\n    /** @type {String|Number} */\n    this.id = !isUnd(parameters.id) ? parameters.id : TLId;\n    /** @type {Number} */\n    this.duration = 0; // TL duration starts at 0 and grows when adding children\n    /** @type {Record<String, Number>} */\n    this.labels = {};\n    const defaultsParams = parameters.defaults;\n    const globalDefaults = globals.defaults;\n    /** @type {DefaultsParams} */\n    this.defaults = defaultsParams ? mergeObjects(defaultsParams, globalDefaults) : globalDefaults;\n    /** @type {Boolean} */\n    this.composition = setValue(parameters.composition, true);\n    /** @type {Callback<this>} */\n    this.onRender = parameters.onRender || globalDefaults.onRender;\n    const tlPlaybackEase = setValue(parameters.playbackEase, globalDefaults.playbackEase);\n    this._ease = tlPlaybackEase ? parseEase(tlPlaybackEase) : null;\n    /** @type {Number} */\n    this.iterationDuration = 0;\n  }\n\n  /**\n   * @overload\n   * @param {TargetsParam} a1\n   * @param {AnimationParams} a2\n   * @param {TimelinePosition|StaggerFunction<Number|String>} [a3]\n   * @return {this}\n   *\n   * @overload\n   * @param {TimerParams} a1\n   * @param {TimelinePosition} [a2]\n   * @return {this}\n   *\n   * @param {TargetsParam|TimerParams} a1\n   * @param {TimelinePosition|AnimationParams} a2\n   * @param {TimelinePosition|StaggerFunction<Number|String>} [a3]\n   */\n  add(a1, a2, a3) {\n    const isAnim = isObj(a2);\n    const isTimer = isObj(a1);\n    if (isAnim || isTimer) {\n      this._hasChildren = true;\n      if (isAnim) {\n        const childParams = /** @type {AnimationParams} */(a2);\n        // Check for function for children stagger positions\n        if (isFnc(a3)) {\n          const staggeredPosition = a3;\n          const parsedTargetsArray = parseTargets(/** @type {TargetsParam} */(a1));\n          // Store initial duration before adding new children that will change the duration\n          const tlDuration = this.duration;\n          // Store initial _iterationDuration before adding new children that will change the duration\n          const tlIterationDuration = this.iterationDuration;\n          // Store the original id in order to add specific indexes to the new animations ids\n          const id = childParams.id;\n          let i = 0;\n          /** @type {Number} */\n          const parsedLength = (parsedTargetsArray.length);\n          parsedTargetsArray.forEach((/** @type {Target} */target) => {\n            // Create a new parameter object for each staggered children\n            const staggeredChildParams = { ...childParams };\n            // Reset the duration of the timeline iteration before each stagger to prevent wrong start value calculation\n            this.duration = tlDuration;\n            this.iterationDuration = tlIterationDuration;\n            if (!isUnd(id)) staggeredChildParams.id = id + '-' + i;\n            addTlChild(\n              staggeredChildParams,\n              this,\n              parseTimelinePosition(this, staggeredPosition(target, i, parsedLength, this)),\n              target,\n              i,\n              parsedLength\n            );\n            i++;\n          });\n        } else {\n          addTlChild(\n            childParams,\n            this,\n            parseTimelinePosition(this, a3),\n            /** @type {TargetsParam} */(a1),\n          );\n        }\n      } else {\n        // It's a Timer\n        addTlChild(\n          /** @type TimerParams */(a1),\n          this,\n          parseTimelinePosition(this,a2),\n        );\n      }\n      if (this.composition) this.init(true);\n      return this;\n    }\n  }\n\n  /**\n   * @overload\n   * @param {Tickable} [synced]\n   * @param {TimelinePosition} [position]\n   * @return {this}\n   *\n   * @overload\n   * @param {globalThis.Animation} [synced]\n   * @param {TimelinePosition} [position]\n   * @return {this}\n   *\n   * @overload\n   * @param {WAAPIAnimation} [synced]\n   * @param {TimelinePosition} [position]\n   * @return {this}\n   *\n   * @param {Tickable|WAAPIAnimation|globalThis.Animation} [synced]\n   * @param {TimelinePosition} [position]\n   */\n  sync(synced, position) {\n    if (isUnd(synced) || synced && isUnd(synced.pause)) return this;\n    synced.pause();\n    const duration = +(/** @type {globalThis.Animation} */(synced).effect ? /** @type {globalThis.Animation} */(synced).effect.getTiming().duration : /** @type {Tickable} */(synced).duration);\n    // Forces WAAPI Animation to persist; otherwise, they will stop syncing on finish.\n    if (!isUnd(synced) && !isUnd(/** @type {WAAPIAnimation} */(synced).persist)) {\n      /** @type {WAAPIAnimation} */(synced).persist = true;\n    }\n    return this.add(synced, { currentTime: [0, duration], duration, delay: 0, ease: 'linear', playbackEase: 'linear' }, position);\n  }\n\n  /**\n   * @param  {TargetsParam} targets\n   * @param  {AnimationParams} parameters\n   * @param  {TimelinePosition} [position]\n   * @return {this}\n   */\n  set(targets, parameters, position) {\n    if (isUnd(parameters)) return this;\n    parameters.duration = minValue;\n    parameters.composition = compositionTypes.replace;\n    return this.add(targets, parameters, position);\n  }\n\n  /**\n   * @param {Callback<Timer>} callback\n   * @param {TimelinePosition} [position]\n   * @return {this}\n   */\n  call(callback, position) {\n    if (isUnd(callback) || callback && !isFnc(callback)) return this;\n    return this.add({ duration: 0, delay: 0, onComplete: () => callback(this) }, position);\n  }\n\n  /**\n   * @param {String} labelName\n   * @param {TimelinePosition} [position]\n   * @return {this}\n   *\n   */\n  label(labelName, position) {\n    if (isUnd(labelName) || labelName && !isStr(labelName)) return this;\n    this.labels[labelName] = parseTimelinePosition(this, position);\n    return this;\n  }\n\n  /**\n   * @param  {TargetsParam} targets\n   * @param  {String} [propertyName]\n   * @return {this}\n   */\n  remove(targets, propertyName) {\n    removeTargetsFromRenderable(parseTargets(targets), this, propertyName);\n    return 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    const labels = this.labels;\n    forEachChildren(this, (/** @type {JSAnimation} */child) => child.stretch(child.duration * timeScale));\n    for (let labelName in labels) labels[labelName] *= timeScale;\n    return super.stretch(newDuration);\n  }\n\n  /**\n   * @return {this}\n   */\n  refresh() {\n    forEachChildren(this, (/** @type {JSAnimation|Timer} */child) => {\n      if (/** @type {JSAnimation} */(child).refresh) /** @type {JSAnimation} */(child).refresh();\n    });\n    return this;\n  }\n\n  /**\n   * @return {this}\n   */\n  revert() {\n    super.revert();\n    forEachChildren(this, (/** @type {JSAnimation|Timer} */child) => child.revert, true);\n    return cleanInlineStyles(this);\n  }\n\n  /**\n   * @typedef {this & {then: null}} ResolvedTimeline\n   */\n\n  /**\n   * @param  {Callback<ResolvedTimeline>} [callback]\n   * @return Promise<this>\n   */\n  then(callback) {\n    return super.then(callback);\n  }\n}\n\n/**\n * @param {TimelineParams} [parameters]\n * @return {Timeline}\n */\nconst createTimeline = parameters => new Timeline(parameters).init();\n\nexport { Timeline, createTimeline };\n","/**\n * Anime.js - animatable - ESM\n * @version v4.3.6\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { compositionTypes, noop } from '../core/consts.js';\nimport { scope } from '../core/globals.js';\nimport { isUnd, isKey, stringStartsWith, isObj, mergeObjects, forEachChildren, isStr, isArr } from '../core/helpers.js';\nimport { JSAnimation } from '../animation/animation.js';\nimport { parseEase } from '../easings/eases/parser.js';\n\n/**\n * @import {\n * TargetsParam,\n * AnimatableParams,\n * AnimationParams,\n * TweenParamsOptions,\n * Tween,\n * AnimatableProperty,\n * AnimatableObject,\n * } from '../types/index.js';\n */\n\nclass Animatable {\n  /**\n   * @param {TargetsParam} targets\n   * @param {AnimatableParams} parameters\n   */\n  constructor(targets, parameters) {\n    if (scope.current) scope.current.register(this);\n    const beginHandler = () => {\n      if (this.callbacks.completed) this.callbacks.reset();\n      this.callbacks.play();\n    };\n    const pauseHandler = () => {\n      if (this.callbacks.completed) return;\n      let paused = true;\n      for (let name in this.animations) {\n        const anim = this.animations[name];\n        if (!anim.paused && paused) {\n          paused = false;\n          break;\n        }\n      }\n      if (paused) {\n        this.callbacks.complete();\n      }\n    };\n    /** @type {AnimationParams} */\n    const globalParams = {\n      onBegin: beginHandler,\n      onComplete: pauseHandler,\n      onPause: pauseHandler,\n    };\n    /** @type {AnimationParams} */\n    const callbacksAnimationParams = { v: 1, autoplay: false };\n    const properties = {};\n    this.targets = [];\n    this.animations = {};\n    /** @type {JSAnimation|null} */\n    this.callbacks = null;\n    if (isUnd(targets) || isUnd(parameters)) return;\n    for (let propName in parameters) {\n      const paramValue = parameters[propName];\n      if (isKey(propName)) {\n        properties[propName] = paramValue;\n      } else if (stringStartsWith(propName, 'on')) {\n        callbacksAnimationParams[propName] = paramValue;\n      } else {\n        globalParams[propName] = paramValue;\n      }\n    }\n    this.callbacks = new JSAnimation({ v: 0 }, callbacksAnimationParams);\n    for (let propName in properties) {\n      const propValue = properties[propName];\n      const isObjValue = isObj(propValue);\n      /** @type {TweenParamsOptions} */\n      let propParams = {};\n      let to = '+=0';\n      if (isObjValue) {\n        const unit = propValue.unit;\n        if (isStr(unit)) to += unit;\n      } else {\n        propParams.duration = propValue;\n      }\n      propParams[propName] = isObjValue ? mergeObjects({ to }, propValue) : to;\n      const animParams = mergeObjects(globalParams, propParams);\n      animParams.composition = compositionTypes.replace;\n      animParams.autoplay = false;\n      const animation = this.animations[propName] = new JSAnimation(targets, animParams, null, 0, false).init();\n      if (!this.targets.length) this.targets.push(...animation.targets);\n      /** @type {AnimatableProperty} */\n      this[propName] = (to, duration, ease) => {\n        const tween = /** @type {Tween} */(animation._head);\n        if (isUnd(to) && tween) {\n          const numbers = tween._numbers;\n          if (numbers && numbers.length) {\n            return numbers;\n          } else {\n            return tween._modifier(tween._number);\n          }\n        } else {\n          forEachChildren(animation, (/** @type {Tween} */tween) => {\n            if (isArr(to)) {\n              for (let i = 0, l = /** @type {Array} */(to).length; i < l; i++) {\n                if (!isUnd(tween._numbers[i])) {\n                  tween._fromNumbers[i] = /** @type {Number} */(tween._modifier(tween._numbers[i]));\n                  tween._toNumbers[i] = to[i];\n                }\n              }\n            } else {\n              tween._fromNumber = /** @type {Number} */(tween._modifier(tween._number));\n              tween._toNumber = /** @type {Number} */(to);\n            }\n            if (!isUnd(ease)) tween._ease = parseEase(ease);\n            tween._currentTime = 0;\n          });\n          if (!isUnd(duration)) animation.stretch(duration);\n          animation.reset(true).resume();\n          return this;\n        }\n      };\n    }\n  }\n\n  revert() {\n    for (let propName in this.animations) {\n      this[propName] = noop;\n      this.animations[propName].revert();\n    }\n    this.animations = {};\n    this.targets.length = 0;\n    if (this.callbacks) this.callbacks.revert();\n    return this;\n  }\n}\n\n/**\n * @param {TargetsParam} targets\n * @param {AnimatableParams} parameters\n * @return {AnimatableObject}\n */\nconst createAnimatable = (targets, parameters) => /** @type {AnimatableObject} */ (new Animatable(targets, parameters));\n\nexport { Animatable, createAnimatable };\n","/**\n * Anime.js - utils - ESM\n * @version v4.3.6\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { lerp } from '../core/helpers.js';\nexport { clamp, round, snap } from '../core/helpers.js';\n\n/**\n * Rounds a number to fixed decimal places\n * @param  {Number|String} v - Value to round\n * @param  {Number} decimalLength - Number of decimal places\n * @return {String}\n */\nconst roundPad = (v, decimalLength) => (+v).toFixed(decimalLength);\n\n/**\n * Pads the start of a value with a string\n * @param  {Number} v - Value to pad\n * @param  {Number} totalLength - Target length\n * @param  {String} padString - String to pad with\n * @return {String}\n */\nconst padStart = (v, totalLength, padString) => `${v}`.padStart(totalLength, padString);\n\n/**\n * Pads the end of a value with a string\n * @param  {Number} v - Value to pad\n * @param  {Number} totalLength - Target length\n * @param  {String} padString - String to pad with\n * @return {String}\n */\nconst padEnd = (v, totalLength, padString) => `${v}`.padEnd(totalLength, padString);\n\n/**\n * Wraps a value within a range\n * @param  {Number} v - Value to wrap\n * @param  {Number} min - Minimum boundary\n * @param  {Number} max - Maximum boundary\n * @return {Number}\n */\nconst wrap = (v, min, max) => (((v - min) % (max - min) + (max - min)) % (max - min)) + min;\n\n/**\n * Maps a value from one range to another\n * @param  {Number} value - Input value\n * @param  {Number} inLow - Input range minimum\n * @param  {Number} inHigh - Input range maximum\n * @param  {Number} outLow - Output range minimum\n * @param  {Number} outHigh - Output range maximum\n * @return {Number}\n */\nconst mapRange = (value, inLow, inHigh, outLow, outHigh) => outLow + ((value - inLow) / (inHigh - inLow)) * (outHigh - outLow);\n\n/**\n * Converts degrees to radians\n * @param  {Number} degrees - Angle in degrees\n * @return {Number}\n */\nconst degToRad = degrees => degrees * Math.PI / 180;\n\n/**\n * Converts radians to degrees\n * @param  {Number} radians - Angle in radians\n * @return {Number}\n */\nconst radToDeg = radians => radians * 180 / Math.PI;\n\n/**\n * Frame rate independent damped lerp\n * Based on: https://www.rorydriscoll.com/2016/03/07/frame-rate-independent-damping-using-lerp/\n *\n * @param  {Number} start - Starting value\n * @param  {Number} end - Target value\n * @param  {Number} deltaTime - Delta time in ms\n * @param  {Number} factor - Interpolation factor in the range [0, 1]\n * @return {Number} The interpolated value\n */\nconst damp = (start, end, deltaTime, factor) => {\n  return !factor ? start : factor === 1 ? end : lerp(start, end, 1 - Math.exp(-factor * deltaTime * .1));\n};\n\nexport { damp, degToRad, lerp, mapRange, padEnd, padStart, radToDeg, roundPad, wrap };\n","/**\n * Anime.js - easings - ESM\n * @version v4.3.6\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { K, minValue, noop } from '../../core/consts.js';\nimport { globals } from '../../core/globals.js';\nimport { isUnd, clamp, pow, PI, round, sqrt, abs, exp, cos, sin } from '../../core/helpers.js';\nimport { setValue } from '../../core/values.js';\n\n/**\n * @import {\n *   JSAnimation,\n * } from '../../animation/animation.js'\n */\n\n/**\n * @import {\n *   EasingFunction,\n *   SpringParams,\n *   Callback,\n * } from '../../types/index.js'\n*/\n\n/*\n * Spring easing solver adapted from https://webkit.org/demos/spring/spring.js\n * (c) 2016 Webkit - Apple Inc\n */\n\nconst maxSpringParamValue = K * 10;\n\nclass Spring {\n  /**\n   * @param {SpringParams} [parameters]\n   */\n  constructor(parameters = {}) {\n    const hasBounceOrDuration = !isUnd(parameters.bounce) || !isUnd(parameters.duration);\n    this.timeStep = .02; // Interval fed to the solver to calculate duration\n    this.restThreshold = .0005; // Values below this threshold are considered resting position\n    this.restDuration = 200; // Duration in ms used to check if the spring is resting after reaching restThreshold\n    this.maxDuration = 60000; // The maximum allowed spring duration in ms (default 1 min)\n    this.maxRestSteps = this.restDuration / this.timeStep / K; // How many steps allowed after reaching restThreshold before stopping the duration calculation\n    this.maxIterations = this.maxDuration / this.timeStep / K; // Calculate the maximum iterations allowed based on maxDuration\n    this.bn = clamp(setValue(parameters.bounce, .5), -1, 1); // The bounce percentage between -1 and 1.\n    this.pd = clamp(setValue(parameters.duration, 628), 10 * globals.timeScale, maxSpringParamValue * globals.timeScale); // The perceived duration\n    this.m = clamp(setValue(parameters.mass, 1), 1, maxSpringParamValue);\n    this.s = clamp(setValue(parameters.stiffness, 100), minValue, maxSpringParamValue);\n    this.d = clamp(setValue(parameters.damping, 10), minValue, maxSpringParamValue);\n    this.v = clamp(setValue(parameters.velocity, 0), -maxSpringParamValue, maxSpringParamValue);\n    this.w0 = 0;\n    this.zeta = 0;\n    this.wd = 0;\n    this.b = 0;\n    this.completed = false;\n    this.solverDuration = 0;\n    this.settlingDuration = 0;\n    /** @type {JSAnimation} */\n    this.parent = null;\n    /** @type {Callback<JSAnimation>} */\n    this.onComplete = parameters.onComplete || noop;\n    if (hasBounceOrDuration) this.calculateSDFromBD();\n    this.compute();\n    /** @type {EasingFunction} */\n    this.ease = t => {\n      const currentTime = t * this.settlingDuration;\n      const completed = this.completed;\n      const perceivedTime = this.pd;\n      if (currentTime >= perceivedTime && !completed) {\n        this.completed = true;\n        this.onComplete(this.parent);\n      }\n      if (currentTime < perceivedTime && completed) {\n        this.completed = false;\n      }\n      return t === 0 || t === 1 ? t : this.solve(t * this.solverDuration);\n    };\n  }\n\n  /** @type {EasingFunction} */\n  solve(time) {\n    const { zeta, w0, wd, b } = this;\n    let t = time;\n    if (zeta < 1) {\n      // Underdamped\n      t = exp(-t * zeta * w0) * (1 * cos(wd * t) + b * sin(wd * t));\n    } else if (zeta === 1) {\n      // Critically damped\n      t = (1 + b * t) * exp(-t * w0);\n    } else {\n      // Overdamped\n      // Using exponential instead of cosh and sinh functions to prevent Infinity\n      // Original exp(-zeta * w0 * t) * (cosh(wd * t) + b * sinh(wd * t))\n      t = ((1 + b) * exp((-zeta * w0 + wd) * t) + (1 - b) * exp((-zeta * w0 - wd) * t)) / 2;\n    }\n    return 1 - t;\n  }\n\n  calculateSDFromBD() {\n    // Apple's SwiftUI perceived spring duration implementation https://developer.apple.com/videos/play/wwdc2023/10158/?time=1010\n    // Equations taken from Kevin Grajeda's article https://www.kvin.me/posts/effortless-ui-spring-animations\n    const pds = globals.timeScale === 1 ? this.pd / K : this.pd;\n    // Mass and velocity should be set to their default values\n    this.m = 1;\n    this.v = 0;\n    // Stiffness = (2π ÷ perceptualDuration)²\n    this.s = pow((2 * PI) / pds, 2);\n    if (this.bn >= 0) {\n      // For bounce ≥ 0 (critically damped to underdamped)\n      // damping = ((1 - bounce) × 4π) ÷ perceptualDuration\n      this.d = ((1 - this.bn) * 4 * PI) / pds;\n    } else {\n      // For bounce < 0 (overdamped)\n      // damping = 4π ÷ (perceptualDuration × (1 + bounce))\n      // Note: (1 + bounce) is positive since bounce is negative\n      this.d = (4 * PI) / (pds * (1 + this.bn));\n    }\n    this.s = round(clamp(this.s, minValue, maxSpringParamValue), 3);\n    this.d = round(clamp(this.d, minValue, 300), 3); // Clamping to 300 is needed to prevent insane values in the solver\n  }\n\n  calculateBDFromSD() {\n    // Calculate perceived duration and bounce from stiffness and damping\n    // Note: We assumes m = 1 and v = 0 for these calculations\n    const pds = (2 * PI) / sqrt(this.s);\n    this.pd = pds * (globals.timeScale === 1 ? K : 1);\n    const zeta = this.d / (2 * sqrt(this.s));\n    if (zeta <= 1) {\n      // Critically damped to underdamped\n      this.bn = 1 - (this.d * pds) / (4 * PI);\n    } else {\n      // Overdamped\n      this.bn = (4 * PI) / (this.d * pds) - 1;\n    }\n    this.bn = round(clamp(this.bn, -1, 1), 3);\n    this.pd = round(clamp(this.pd, 10 * globals.timeScale, maxSpringParamValue * globals.timeScale), 3);\n  }\n\n  compute() {\n    const { maxRestSteps, maxIterations, restThreshold, timeStep, m, d, s, v } = this;\n    const w0 = this.w0 = clamp(sqrt(s / m), minValue, K);\n    const bouncedZeta = this.zeta = d / (2 * sqrt(s * m));\n    // Calculate wd based on damping type\n    if (bouncedZeta < 1) {\n      // Underdamped\n      this.wd = w0 * sqrt(1 - bouncedZeta * bouncedZeta);\n      this.b = (bouncedZeta * w0 + -v) / this.wd;\n    } else if (bouncedZeta === 1) {\n      // Critically damped\n      this.wd = 0;\n      this.b = -v + w0;\n    } else {\n      // Overdamped\n      this.wd = w0 * sqrt(bouncedZeta * bouncedZeta - 1);\n      this.b = (bouncedZeta * w0 + -v) / this.wd;\n    }\n\n    let solverTime = 0;\n    let restSteps = 0;\n    let iterations = 0;\n    while (restSteps <= maxRestSteps && iterations <= maxIterations) {\n      if (abs(1 - this.solve(solverTime)) < restThreshold) {\n        restSteps++;\n      } else {\n        restSteps = 0;\n      }\n      this.solverDuration = solverTime;\n      solverTime += timeStep;\n      iterations++;\n    }\n    this.settlingDuration = round(this.solverDuration * K, 0) * globals.timeScale;\n  }\n\n  get bounce() {\n    return this.bn;\n  }\n\n  set bounce(v) {\n    this.bn = clamp(setValue(v, 1), -1, 1);\n    this.calculateSDFromBD();\n    this.compute();\n  }\n\n  get duration() {\n    return this.pd;\n  }\n\n  set duration(v) {\n    this.pd = clamp(setValue(v, 1), 10 * globals.timeScale, maxSpringParamValue * globals.timeScale);\n    this.calculateSDFromBD();\n    this.compute();\n  }\n\n  get stiffness() {\n    return this.s;\n  }\n\n  set stiffness(v) {\n    this.s = clamp(setValue(v, 100), minValue, maxSpringParamValue);\n    this.calculateBDFromSD();\n    this.compute();\n  }\n\n  get damping() {\n    return this.d;\n  }\n\n  set damping(v) {\n    this.d = clamp(setValue(v, 10), minValue, maxSpringParamValue);\n    this.calculateBDFromSD();\n    this.compute();\n  }\n\n  get mass() {\n    return this.m;\n  }\n\n  set mass(v) {\n    this.m = clamp(setValue(v, 1), 1, maxSpringParamValue);\n    this.compute();\n  }\n\n  get velocity() {\n    return this.v;\n  }\n\n  set velocity(v) {\n    this.v = clamp(setValue(v, 0), -maxSpringParamValue, maxSpringParamValue);\n    this.compute();\n  }\n}\n\n/**\n * @param {SpringParams} [parameters]\n * @returns {Spring}\n */\nconst spring = (parameters) => new Spring(parameters);\n\n/**\n * @deprecated createSpring() is deprecated use spring() instead\n *\n * @param {SpringParams} [parameters]\n * @returns {Spring}\n */\nconst createSpring = (parameters) => {\n  console.warn('createSpring() is deprecated use spring() instead');\n  return new Spring(parameters);\n};\n\nexport { Spring, createSpring, spring };\n","/**\n * Anime.js - waapi - ESM\n * @version v4.3.6\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { removeChild, addChild } from '../core/helpers.js';\n\n/**\n * @import {\n *   DOMTarget,\n * } from '../types/index.js'\n*/\n\n/**\n * @import {\n *   WAAPIAnimation,\n * } from '../waapi/waapi.js'\n*/\n\nconst WAAPIAnimationsLookups = {\n  _head: null,\n  _tail: null,\n};\n\n/**\n * @param {DOMTarget} $el\n * @param {String} [property]\n * @param {WAAPIAnimation} [parent]\n * @return {globalThis.Animation}\n */\nconst removeWAAPIAnimation = ($el, property, parent) => {\n  let nextLookup = WAAPIAnimationsLookups._head;\n  let anim;\n  while (nextLookup) {\n    const next = nextLookup._next;\n    const matchTarget = nextLookup.$el === $el;\n    const matchProperty = !property || nextLookup.property === property;\n    const matchParent = !parent || nextLookup.parent === parent;\n    if (matchTarget && matchProperty && matchParent) {\n      anim = nextLookup.animation;\n      try { anim.commitStyles(); } catch {}      anim.cancel();\n      removeChild(WAAPIAnimationsLookups, nextLookup);\n      const lookupParent = nextLookup.parent;\n      if (lookupParent) {\n        lookupParent._completed++;\n        if (lookupParent.animations.length === lookupParent._completed) {\n          lookupParent.completed = true;\n          lookupParent.paused = true;\n          if (!lookupParent.muteCallbacks) {\n            lookupParent.onComplete(lookupParent);\n            lookupParent._resolve(lookupParent);\n          }\n        }\n      }\n    }\n    nextLookup = next;\n  }\n  return anim;\n};\n\n/**\n * @param {WAAPIAnimation} parent\n * @param {DOMTarget} $el\n * @param {String} property\n * @param {PropertyIndexedKeyframes} keyframes\n * @param {KeyframeAnimationOptions} params\n * @retun {globalThis.Animation}\n */\nconst addWAAPIAnimation = (parent, $el, property, keyframes, params) => {\n  const animation = $el.animate(keyframes, params);\n  const animTotalDuration = params.delay + (+params.duration * params.iterations);\n  animation.playbackRate = parent._speed;\n  if (parent.paused) animation.pause();\n  if (parent.duration < animTotalDuration) {\n    parent.duration = animTotalDuration;\n    parent.controlAnimation = animation;\n  }\n  parent.animations.push(animation);\n  removeWAAPIAnimation($el, property);\n  addChild(WAAPIAnimationsLookups, { parent, animation, $el, property, _next: null, _prev: null });\n  const handleRemove = () => removeWAAPIAnimation($el, property, parent);\n  animation.oncancel = handleRemove;\n  animation.onremove = handleRemove;\n  if (!parent.persist) {\n    animation.onfinish = handleRemove;\n  }\n  return animation;\n};\n\nexport { addWAAPIAnimation, removeWAAPIAnimation };\n","/**\n * Anime.js - utils - ESM\n * @version v4.3.6\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { globals } from '../core/globals.js';\nimport { valueTypes, minValue, compositionTypes } from '../core/consts.js';\nimport { isUnd, round } from '../core/helpers.js';\nimport { registerTargets, parseTargets } from '../core/targets.js';\nimport { sanitizePropertyName } from '../core/styles.js';\nexport { cleanInlineStyles } from '../core/styles.js';\nimport { getTweenType, getOriginalAnimatableValue, decomposeRawValue, decomposedOriginalValue, setValue } from '../core/values.js';\nimport { convertValueUnit } from '../core/units.js';\nimport { removeWAAPIAnimation } from '../waapi/composition.js';\nimport { removeTargetsFromRenderable } from '../animation/composition.js';\nimport { JSAnimation } from '../animation/animation.js';\n\n/**\n * @import {\n *   Renderable,\n *   DOMTargetSelector,\n *   JSTargetsParam,\n *   DOMTargetsParam,\n *   TargetsParam,\n *   DOMTarget,\n *   AnimationParams,\n *   TargetsArray,\n * } from '../types/index.js'\n*/\n\n/**\n * @import {\n *   WAAPIAnimation\n * } from '../waapi/waapi.js'\n*/\n\n/**\n * @overload\n * @param  {DOMTargetSelector} targetSelector\n * @param  {String} propName\n * @return {String}\n *\n * @overload\n * @param  {JSTargetsParam} targetSelector\n * @param  {String} propName\n * @return {Number|String}\n *\n * @overload\n * @param  {DOMTargetsParam} targetSelector\n * @param  {String} propName\n * @param  {String} unit\n * @return {String}\n *\n * @overload\n * @param  {TargetsParam} targetSelector\n * @param  {String} propName\n * @param  {Boolean} unit\n * @return {Number}\n *\n * @param  {TargetsParam} targetSelector\n * @param  {String} propName\n * @param  {String|Boolean} [unit]\n */\nfunction get(targetSelector, propName, unit) {\n  const targets = registerTargets(targetSelector);\n  if (!targets.length) return;\n  const [ target ] = targets;\n  const tweenType = getTweenType(target, propName);\n  const normalizePropName = sanitizePropertyName(propName, target, tweenType);\n  let originalValue = getOriginalAnimatableValue(target, normalizePropName);\n  if (isUnd(unit)) {\n    return originalValue;\n  } else {\n    decomposeRawValue(originalValue, decomposedOriginalValue);\n    if (decomposedOriginalValue.t === valueTypes.NUMBER || decomposedOriginalValue.t === valueTypes.UNIT) {\n      if (unit === false) {\n        return decomposedOriginalValue.n;\n      } else {\n        const convertedValue = convertValueUnit(/** @type {DOMTarget} */(target), decomposedOriginalValue, /** @type {String} */(unit), false);\n        return `${round(convertedValue.n, globals.precision)}${convertedValue.u}`;\n      }\n    }\n  }\n}\n\n/**\n * @param  {TargetsParam} targets\n * @param  {AnimationParams} parameters\n * @return {JSAnimation}\n */\nconst set = (targets, parameters) => {\n  if (isUnd(parameters)) return;\n  parameters.duration = minValue;\n  // Do not overrides currently active tweens by default\n  parameters.composition = setValue(parameters.composition, compositionTypes.none);\n  // Skip init() and force rendering by playing the animation\n  return new JSAnimation(targets, parameters, null, 0, true).resume();\n};\n\n/**\n * @param  {TargetsParam} targets\n * @param  {Renderable|WAAPIAnimation} [renderable]\n * @param  {String} [propertyName]\n * @return {TargetsArray}\n */\nconst remove = (targets, renderable, propertyName) => {\n  const targetsArray = parseTargets(targets);\n  for (let i = 0, l = targetsArray.length; i < l; i++) {\n    removeWAAPIAnimation(\n      /** @type {DOMTarget}  */(targetsArray[i]),\n      propertyName,\n      renderable && /** @type {WAAPIAnimation} */(renderable).controlAnimation && /** @type {WAAPIAnimation} */(renderable),\n    );\n  }\n  removeTargetsFromRenderable(\n    targetsArray,\n    /** @type {Renderable} */(renderable),\n    propertyName\n  );\n  return targetsArray;\n};\n\nexport { registerTargets as $, get, remove, set };\n","/**\n * Anime.js - draggable - ESM\n * @version v4.3.6\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { globals, scope } from '../core/globals.js';\nimport { doc, win, noop, maxValue, compositionTypes } from '../core/consts.js';\nimport { parseTargets } from '../core/targets.js';\nimport { isUnd, isObj, isArr, now, atan2, round, max, snap, clamp, isNum, abs, sqrt, cos, sin, isFnc } from '../core/helpers.js';\nimport { setValue } from '../core/values.js';\nimport { mapRange } from '../utils/number.js';\nimport { Timer } from '../timer/timer.js';\nimport { JSAnimation } from '../animation/animation.js';\nimport { removeTargetsFromRenderable } from '../animation/composition.js';\nimport { Animatable } from '../animatable/animatable.js';\nimport { parseEase, eases } from '../easings/eases/parser.js';\nimport { spring } from '../easings/spring/index.js';\nimport { get, set } from '../utils/target.js';\n\n/**\n * @import {\n *   DOMTarget,\n *   DOMTargetSelector,\n *   DraggableCursorParams,\n *   DraggableDragThresholdParams,\n *   TargetsParam,\n *   DraggableParams,\n *   EasingFunction,\n *   Callback,\n *   AnimatableParams,\n *   DraggableAxisParam,\n *   AnimatableObject,\n *   EasingParam,\n * } from '../types/index.js'\n*/\n\n/**\n * @import {\n *   Spring,\n * } from '../easings/spring/index.js'\n*/\n\n/**\n * @param {Event} e\n */\nconst preventDefault = e => {\n  if (e.cancelable) e.preventDefault();\n};\n\nclass DOMProxy {\n  /** @param {Object} el */\n  constructor(el) {\n    this.el = el;\n    this.zIndex = 0;\n    this.parentElement = null;\n    this.classList = {\n      add: noop,\n      remove: noop,\n    };\n  }\n\n  get x() { return this.el.x || 0 };\n  set x(v) { this.el.x = v; };\n\n  get y() { return this.el.y || 0 };\n  set y(v) { this.el.y = v; };\n\n  get width() { return this.el.width || 0 };\n  set width(v) { this.el.width = v; };\n\n  get height() { return this.el.height || 0 };\n  set height(v) { this.el.height = v; };\n\n  getBoundingClientRect() {\n    return {\n      top: this.y,\n      right: this.x,\n      bottom: this.y + this.height,\n      left: this.x + this.width,\n    }\n  }\n}\n\nclass Transforms {\n  /**\n   * @param {DOMTarget|DOMProxy} $el\n   */\n  constructor($el) {\n    this.$el = $el;\n    this.inlineTransforms = [];\n    this.point = new DOMPoint();\n    this.inversedMatrix = this.getMatrix().inverse();\n  }\n\n  /**\n   * @param {Number} x\n   * @param {Number} y\n   * @return {DOMPoint}\n   */\n  normalizePoint(x, y) {\n    this.point.x = x;\n    this.point.y = y;\n    return this.point.matrixTransform(this.inversedMatrix);\n  }\n\n  /**\n   * @callback TraverseParentsCallback\n   * @param {DOMTarget} $el\n   * @param {Number} i\n   */\n\n  /**\n   * @param {TraverseParentsCallback} cb\n   */\n  traverseUp(cb) {\n    let $el = /** @type {DOMTarget|Document} */(this.$el.parentElement), i = 0;\n    while ($el && $el !== doc) {\n      cb(/** @type {DOMTarget} */($el), i);\n      $el = /** @type {DOMTarget} */($el.parentElement);\n      i++;\n    }\n  }\n\n  getMatrix() {\n    const matrix = new DOMMatrix();\n    this.traverseUp($el => {\n      const transformValue = getComputedStyle($el).transform;\n      if (transformValue) {\n        const elMatrix = new DOMMatrix(transformValue);\n        matrix.preMultiplySelf(elMatrix);\n      }\n    });\n    return matrix;\n  }\n\n  remove() {\n    this.traverseUp(($el, i) => {\n      this.inlineTransforms[i] = $el.style.transform;\n      $el.style.transform = 'none';\n    });\n  }\n\n  revert() {\n    this.traverseUp(($el, i) => {\n      const ct = this.inlineTransforms[i];\n      if (ct === '') {\n        $el.style.removeProperty('transform');\n      } else {\n        $el.style.transform = ct;\n      }\n    });\n  }\n}\n\n/**\n * @template {Array<Number>|DOMTargetSelector|String|Number|Boolean|Function|DraggableCursorParams|DraggableDragThresholdParams} T\n * @param {T | ((draggable: Draggable) => T)} value\n * @param {Draggable} draggable\n * @return {T}\n */\nconst parseDraggableFunctionParameter = (value, draggable) => value && isFnc(value) ? /** @type {Function} */(value)(draggable) : /** @type {T} */(value);\n\nlet zIndex = 0;\n\nclass Draggable {\n  /**\n   * @param {TargetsParam} target\n   * @param {DraggableParams} [parameters]\n   */\n  constructor(target, parameters = {}) {\n    if (!target) return;\n    if (scope.current) scope.current.register(this);\n    const paramX = parameters.x;\n    const paramY = parameters.y;\n    const trigger = parameters.trigger;\n    const modifier = parameters.modifier;\n    const ease = parameters.releaseEase;\n    const customEase = ease && parseEase(ease);\n    const hasSpring = !isUnd(ease) && !isUnd(/** @type {Spring} */(ease).ease);\n    const xProp = /** @type {String} */(isObj(paramX) && !isUnd(/** @type {Object} */(paramX).mapTo) ? /** @type {Object} */(paramX).mapTo : 'translateX');\n    const yProp = /** @type {String} */(isObj(paramY) && !isUnd(/** @type {Object} */(paramY).mapTo) ? /** @type {Object} */(paramY).mapTo : 'translateY');\n    const container = parseDraggableFunctionParameter(parameters.container, this);\n    this.containerArray = isArr(container) ? container : null;\n    this.$container = /** @type {HTMLElement} */(container && !this.containerArray ? parseTargets(/** @type {DOMTarget} */(container))[0] : doc.body);\n    this.useWin = this.$container === doc.body;\n    /** @type {Window | HTMLElement} */\n    this.$scrollContainer = this.useWin ? win : this.$container;\n    this.$target = /** @type {HTMLElement} */(isObj(target) ? new DOMProxy(target) : parseTargets(target)[0]);\n    this.$trigger = /** @type {HTMLElement} */(parseTargets(trigger ? trigger : target)[0]);\n    this.fixed = get(this.$target, 'position') === 'fixed';\n    // Refreshable parameters\n    this.isFinePointer = true;\n    /** @type {[Number, Number, Number, Number]} */\n    this.containerPadding = [0, 0, 0, 0];\n    /** @type {Number} */\n    this.containerFriction = 0;\n    /** @type {Number} */\n    this.releaseContainerFriction = 0;\n    /** @type {Number|Array<Number>} */\n    this.snapX = 0;\n    /** @type {Number|Array<Number>} */\n    this.snapY = 0;\n    /** @type {Number} */\n    this.scrollSpeed = 0;\n    /** @type {Number} */\n    this.scrollThreshold = 0;\n    /** @type {Number} */\n    this.dragSpeed = 0;\n    /** @type {Number} */\n    this.dragThreshold = 3;\n    /** @type {Number} */\n    this.maxVelocity = 0;\n    /** @type {Number} */\n    this.minVelocity = 0;\n    /** @type {Number} */\n    this.velocityMultiplier = 0;\n    /** @type {Boolean|DraggableCursorParams} */\n    this.cursor = false;\n    /** @type {Spring} */\n    this.releaseXSpring = hasSpring ? /** @type {Spring} */(ease) : spring({\n      mass: setValue(parameters.releaseMass, 1),\n      stiffness: setValue(parameters.releaseStiffness, 80),\n      damping: setValue(parameters.releaseDamping, 20),\n    });\n    /** @type {Spring} */\n    this.releaseYSpring = hasSpring ? /** @type {Spring} */(ease) : spring({\n      mass: setValue(parameters.releaseMass, 1),\n      stiffness: setValue(parameters.releaseStiffness, 80),\n      damping: setValue(parameters.releaseDamping, 20),\n    });\n    /** @type {EasingFunction} */\n    this.releaseEase = customEase || eases.outQuint;\n    /** @type {Boolean} */\n    this.hasReleaseSpring = hasSpring;\n    /** @type {Callback<this>} */\n    this.onGrab = parameters.onGrab || noop;\n    /** @type {Callback<this>} */\n    this.onDrag = parameters.onDrag || noop;\n    /** @type {Callback<this>} */\n    this.onRelease = parameters.onRelease || noop;\n    /** @type {Callback<this>} */\n    this.onUpdate = parameters.onUpdate || noop;\n    /** @type {Callback<this>} */\n    this.onSettle = parameters.onSettle || noop;\n    /** @type {Callback<this>} */\n    this.onSnap = parameters.onSnap || noop;\n    /** @type {Callback<this>} */\n    this.onResize = parameters.onResize || noop;\n    /** @type {Callback<this>} */\n    this.onAfterResize = parameters.onAfterResize || noop;\n    /** @type {[Number, Number]} */\n    this.disabled = [0, 0];\n    /** @type {AnimatableParams} */\n    const animatableParams = {};\n    if (modifier) animatableParams.modifier = modifier;\n    if (isUnd(paramX) || paramX === true) {\n      animatableParams[xProp] = 0;\n    } else if (isObj(paramX)) {\n      const paramXObject = /** @type {DraggableAxisParam} */(paramX);\n      const animatableXParams = {};\n      if (paramXObject.modifier) animatableXParams.modifier = paramXObject.modifier;\n      if (paramXObject.composition) animatableXParams.composition = paramXObject.composition;\n      animatableParams[xProp] = animatableXParams;\n    } else if (paramX === false) {\n      animatableParams[xProp] = 0;\n      this.disabled[0] = 1;\n    }\n    if (isUnd(paramY) || paramY === true) {\n      animatableParams[yProp] = 0;\n    } else if (isObj(paramY)) {\n      const paramYObject = /** @type {DraggableAxisParam} */(paramY);\n      const animatableYParams = {};\n      if (paramYObject.modifier) animatableYParams.modifier = paramYObject.modifier;\n      if (paramYObject.composition) animatableYParams.composition = paramYObject.composition;\n      animatableParams[yProp] = animatableYParams;\n    } else if (paramY === false) {\n      animatableParams[yProp] = 0;\n      this.disabled[1] = 1;\n    }\n    /** @type {AnimatableObject} */\n    this.animate = /** @type {AnimatableObject} */(new Animatable(this.$target, animatableParams));\n    // Internal props\n    this.xProp = xProp;\n    this.yProp = yProp;\n    this.destX = 0;\n    this.destY = 0;\n    this.deltaX = 0;\n    this.deltaY = 0;\n    this.scroll = {x: 0, y: 0};\n    /** @type {[Number, Number, Number, Number]} */\n    this.coords = [this.x, this.y, 0, 0]; // x, y, temp x, temp y\n    /** @type {[Number, Number]} */\n    this.snapped = [0, 0]; // x, y\n    /** @type {[Number, Number, Number, Number, Number, Number, Number, Number]} */\n    this.pointer = [0, 0, 0, 0, 0, 0, 0, 0]; // x1, y1, x2, y2, temp x1, temp y1, temp x2, temp y2\n    /** @type {[Number, Number]} */\n    this.scrollView = [0, 0]; // w, h\n    /** @type {[Number, Number, Number, Number]} */\n    this.dragArea = [0, 0, 0, 0]; // x, y, w, h\n    /** @type {[Number, Number, Number, Number]} */\n    this.containerBounds = [-maxValue, maxValue, maxValue, -maxValue]; // t, r, b, l\n    /** @type {[Number, Number, Number, Number]} */\n    this.scrollBounds = [0, 0, 0, 0]; // t, r, b, l\n    /** @type {[Number, Number, Number, Number]} */\n    this.targetBounds = [0, 0, 0, 0]; // t, r, b, l\n    /** @type {[Number, Number]} */\n    this.window = [0, 0]; // w, h\n    /** @type {[Number, Number, Number]} */\n    this.velocityStack = [0, 0, 0];\n    /** @type {Number} */\n    this.velocityStackIndex = 0;\n    /** @type {Number} */\n    this.velocityTime = now();\n    /** @type {Number} */\n    this.velocity = 0;\n    /** @type {Number} */\n    this.angle = 0;\n    /** @type {JSAnimation} */\n    this.cursorStyles = null;\n    /** @type {JSAnimation} */\n    this.triggerStyles = null;\n    /** @type {JSAnimation} */\n    this.bodyStyles = null;\n    /** @type {JSAnimation} */\n    this.targetStyles = null;\n    /** @type {JSAnimation} */\n    this.touchActionStyles = null;\n    this.transforms = new Transforms(this.$target);\n    this.overshootCoords = { x: 0, y: 0 };\n    this.overshootTicker = new Timer({\n      autoplay: false,\n      onUpdate: () => {\n        this.updated = true;\n        this.manual = true;\n        // Use a duration of 1 to prevent the animatable from completing immediately to prevent issues with onSettle()\n        // https://github.com/juliangarnier/anime/issues/1045\n        if (!this.disabled[0]) this.animate[this.xProp](this.overshootCoords.x, 1);\n        if (!this.disabled[1]) this.animate[this.yProp](this.overshootCoords.y, 1);\n      },\n      onComplete: () => {\n        this.manual = false;\n        if (!this.disabled[0]) this.animate[this.xProp](this.overshootCoords.x, 0);\n        if (!this.disabled[1]) this.animate[this.yProp](this.overshootCoords.y, 0);\n      },\n    }, null, 0).init();\n    this.updateTicker = new Timer({ autoplay: false, onUpdate: () => this.update() }, null,0,).init();\n    this.contained = !isUnd(container);\n    this.manual = false;\n    this.grabbed = false;\n    this.dragged = false;\n    this.updated = false;\n    this.released = false;\n    this.canScroll = false;\n    this.enabled = false;\n    this.initialized = false;\n    this.activeProp = this.disabled[1] ? xProp : yProp;\n    this.animate.callbacks.onRender = () => {\n      const hasUpdated = this.updated;\n      const hasMoved = this.grabbed && hasUpdated;\n      const hasReleased = !hasMoved && this.released;\n      const x = this.x;\n      const y = this.y;\n      const dx = x - this.coords[2];\n      const dy = y - this.coords[3];\n      this.deltaX = dx;\n      this.deltaY = dy;\n      this.coords[2] = x;\n      this.coords[3] = y;\n      // Check if dx or dy are not 0 to check if the draggable has actually moved\n      // https://github.com/juliangarnier/anime/issues/1032\n      if (hasUpdated && (dx || dy)) {\n        this.onUpdate(this);\n      }\n      if (!hasReleased) {\n        this.updated = false;\n      } else {\n        this.computeVelocity(dx, dy);\n        this.angle = atan2(dy, dx);\n      }\n    };\n    this.animate.callbacks.onComplete = () => {\n      if ((!this.grabbed && this.released)) {\n        // Set released to false before calling onSettle to avoid recursion\n        this.released = false;\n      }\n      if (!this.manual) {\n        this.deltaX = 0;\n        this.deltaY = 0;\n        this.velocity = 0;\n        this.velocityStack[0] = 0;\n        this.velocityStack[1] = 0;\n        this.velocityStack[2] = 0;\n        this.velocityStackIndex = 0;\n        this.onSettle(this);\n      }\n    };\n    this.resizeTicker = new Timer({\n      autoplay: false,\n      duration: 150 * globals.timeScale,\n      onComplete: () => {\n        this.onResize(this);\n        this.refresh();\n        this.onAfterResize(this);\n      },\n    }).init();\n    this.parameters = parameters;\n    this.resizeObserver = new ResizeObserver(() => {\n      if (this.initialized) {\n        this.resizeTicker.restart();\n      } else {\n        this.initialized = true;\n      }\n    });\n    this.enable();\n    this.refresh();\n    this.resizeObserver.observe(this.$container);\n    if (!isObj(target)) this.resizeObserver.observe(this.$target);\n  }\n\n  /**\n   * @param  {Number} dx\n   * @param  {Number} dy\n   * @return {Number}\n   */\n  computeVelocity(dx, dy) {\n    const prevTime = this.velocityTime;\n    const curTime = now();\n    const elapsed = curTime - prevTime;\n    if (elapsed < 17) return this.velocity;\n    this.velocityTime = curTime;\n    const velocityStack = this.velocityStack;\n    const vMul = this.velocityMultiplier;\n    const minV = this.minVelocity;\n    const maxV = this.maxVelocity;\n    const vi = this.velocityStackIndex;\n    velocityStack[vi] = round(clamp((sqrt(dx * dx + dy * dy) / elapsed) * vMul, minV, maxV), 5);\n    const velocity = max(velocityStack[0], velocityStack[1], velocityStack[2]);\n    this.velocity = velocity;\n    this.velocityStackIndex = (vi + 1) % 3;\n    return velocity;\n  }\n\n  /**\n   * @param {Number}  x\n   * @param {Boolean} [muteUpdateCallback]\n   * @return {this}\n   */\n  setX(x, muteUpdateCallback = false) {\n    if (this.disabled[0]) return;\n    const v = round(x, 5);\n    this.overshootTicker.pause();\n    this.manual = true;\n    this.updated = !muteUpdateCallback;\n    this.destX = v;\n    this.snapped[0] = snap(v, this.snapX);\n    this.animate[this.xProp](v, 0);\n    this.manual = false;\n    return this;\n  }\n\n  /**\n   * @param {Number}  y\n   * @param {Boolean} [muteUpdateCallback]\n   * @return {this}\n   */\n  setY(y, muteUpdateCallback = false) {\n    if (this.disabled[1]) return;\n    const v = round(y, 5);\n    this.overshootTicker.pause();\n    this.manual = true;\n    this.updated = !muteUpdateCallback;\n    this.destY = v;\n    this.snapped[1] = snap(v, this.snapY);\n    this.animate[this.yProp](v, 0);\n    this.manual = false;\n    return this;\n  }\n\n  get x() {\n    return round(/** @type {Number} */(this.animate[this.xProp]()), globals.precision);\n  }\n\n  set x(x) {\n    this.setX(x, false);\n  }\n\n  get y() {\n    return round(/** @type {Number} */(this.animate[this.yProp]()), globals.precision);\n  }\n\n  set y(y) {\n    this.setY(y, false);\n  }\n\n  get progressX() {\n    return mapRange(this.x, this.containerBounds[3], this.containerBounds[1], 0, 1);\n  }\n\n  set progressX(x) {\n    this.setX(mapRange(x, 0, 1, this.containerBounds[3], this.containerBounds[1]), false);\n  }\n\n  get progressY() {\n    return mapRange(this.y, this.containerBounds[0], this.containerBounds[2], 0, 1);\n  }\n\n  set progressY(y) {\n    this.setY(mapRange(y, 0, 1, this.containerBounds[0], this.containerBounds[2]), false);\n  }\n\n  updateScrollCoords() {\n    const sx = round(this.useWin ? win.scrollX : this.$container.scrollLeft, 0);\n    const sy = round(this.useWin ? win.scrollY : this.$container.scrollTop, 0);\n    const [ cpt, cpr, cpb, cpl ] = this.containerPadding;\n    const threshold = this.scrollThreshold;\n    this.scroll.x = sx;\n    this.scroll.y = sy;\n    this.scrollBounds[0] = sy - this.targetBounds[0] + cpt - threshold;\n    this.scrollBounds[1] = sx - this.targetBounds[1] - cpr + threshold;\n    this.scrollBounds[2] = sy - this.targetBounds[2] - cpb + threshold;\n    this.scrollBounds[3] = sx - this.targetBounds[3] + cpl - threshold;\n  }\n\n  updateBoundingValues() {\n    const $container = this.$container;\n    // Return early if no $container defined to prevents error when reading scrollWidth / scrollHeight\n    // https://github.com/juliangarnier/anime/issues/1064\n    if (!$container) return;\n    const cx = this.x;\n    const cy = this.y;\n    const cx2 = this.coords[2];\n    const cy2 =  this.coords[3];\n    // Prevents interfering with the scroll area in cases the target is outside of the container\n    // Make sure the temp coords are also adjuset to prevents wrong delta calculation on updates\n    this.coords[2] = 0;\n    this.coords[3] = 0;\n    this.setX(0, true);\n    this.setY(0, true);\n    this.transforms.remove();\n    const iw = this.window[0] = win.innerWidth;\n    const ih = this.window[1] = win.innerHeight;\n    const uw = this.useWin;\n    const sw = $container.scrollWidth;\n    const sh = $container.scrollHeight;\n    const fx = this.fixed;\n    const transformContainerRect = $container.getBoundingClientRect();\n    const [ cpt, cpr, cpb, cpl ] = this.containerPadding;\n    this.dragArea[0] = uw ? 0 : transformContainerRect.left;\n    this.dragArea[1] = uw ? 0 : transformContainerRect.top;\n    this.scrollView[0] = uw ? clamp(sw, iw, sw) : sw;\n    this.scrollView[1] = uw ? clamp(sh, ih, sh) : sh;\n    this.updateScrollCoords();\n    const { width, height, left, top, right, bottom } = $container.getBoundingClientRect();\n    this.dragArea[2] = round(uw ? clamp(width, iw, iw) : width, 0);\n    this.dragArea[3] = round(uw ? clamp(height, ih, ih) : height, 0);\n    const containerOverflow = get($container, 'overflow');\n    const visibleOverflow = containerOverflow === 'visible';\n    const hiddenOverflow = containerOverflow === 'hidden';\n    this.canScroll = fx ? false :\n      this.contained &&\n      (($container === doc.body && visibleOverflow) || (!hiddenOverflow && !visibleOverflow)) &&\n      (sw > this.dragArea[2] + cpl - cpr || sh > this.dragArea[3] + cpt - cpb) &&\n      (!this.containerArray || (this.containerArray && !isArr(this.containerArray)));\n    if (this.contained) {\n      const sx = this.scroll.x;\n      const sy = this.scroll.y;\n      const canScroll = this.canScroll;\n      const targetRect = this.$target.getBoundingClientRect();\n      const hiddenLeft = canScroll ? uw ? 0 : $container.scrollLeft : 0;\n      const hiddenTop = canScroll ? uw ? 0 : $container.scrollTop : 0;\n      const hiddenRight = canScroll ? this.scrollView[0] - hiddenLeft - width : 0;\n      const hiddenBottom = canScroll ? this.scrollView[1] - hiddenTop - height : 0;\n      this.targetBounds[0] = round((targetRect.top + sy) - (uw ? 0 : top), 0);\n      this.targetBounds[1] = round((targetRect.right + sx) - (uw ? iw : right), 0);\n      this.targetBounds[2] = round((targetRect.bottom + sy) - (uw ? ih : bottom), 0);\n      this.targetBounds[3] = round((targetRect.left + sx) - (uw ? 0 : left), 0);\n      if (this.containerArray) {\n        this.containerBounds[0] = this.containerArray[0] + cpt;\n        this.containerBounds[1] = this.containerArray[1] - cpr;\n        this.containerBounds[2] = this.containerArray[2] - cpb;\n        this.containerBounds[3] = this.containerArray[3] + cpl;\n      } else {\n        this.containerBounds[0] = -round(targetRect.top - (fx ? clamp(top, 0, ih) : top) + hiddenTop - cpt, 0);\n        this.containerBounds[1] = -round(targetRect.right - (fx ? clamp(right, 0, iw) : right) - hiddenRight + cpr, 0);\n        this.containerBounds[2] = -round(targetRect.bottom - (fx ? clamp(bottom, 0, ih) : bottom) - hiddenBottom + cpb, 0);\n        this.containerBounds[3] = -round(targetRect.left - (fx ? clamp(left, 0, iw) : left) + hiddenLeft - cpl, 0);\n      }\n    }\n    this.transforms.revert();\n    // Restore coordinates\n    this.coords[2] = cx2;\n    this.coords[3] = cy2;\n    this.setX(cx, true);\n    this.setY(cy, true);\n  }\n\n  /**\n   * @param  {Array} bounds\n   * @param  {Number} x\n   * @param  {Number} y\n   * @return {Number}\n   */\n  isOutOfBounds(bounds, x, y) {\n    // Returns 0 if not OB, 1 if x is OB, 2 if y is OB, 3 if both x and y are OB\n    if (!this.contained) return 0;\n    const [ bt, br, bb, bl ] = bounds;\n    const [ dx, dy ] = this.disabled;\n    const obx = !dx && x < bl || !dx && x > br;\n    const oby = !dy && y < bt || !dy && y > bb;\n    return obx && !oby ? 1 : !obx && oby ? 2 : obx && oby ? 3 : 0;\n  }\n\n  refresh() {\n    const params = this.parameters;\n    const paramX = params.x;\n    const paramY = params.y;\n    const container = parseDraggableFunctionParameter(params.container, this);\n    const cp = parseDraggableFunctionParameter(params.containerPadding, this) || 0;\n    const containerPadding = /** @type {[Number, Number, Number, Number]} */(isArr(cp) ? cp : [cp, cp, cp, cp]);\n    const cx = this.x;\n    const cy = this.y;\n    const parsedCursorStyles = parseDraggableFunctionParameter(params.cursor, this);\n    const cursorStyles = { onHover: 'grab', onGrab: 'grabbing' };\n    if (parsedCursorStyles) {\n      const { onHover, onGrab } = /** @type {DraggableCursorParams} */(parsedCursorStyles);\n      if (onHover) cursorStyles.onHover = onHover;\n      if (onGrab) cursorStyles.onGrab = onGrab;\n    }\n    const parsedDragThreshold = parseDraggableFunctionParameter(params.dragThreshold, this);\n    const dragThreshold = { mouse: 3, touch: 7 };\n    if (isNum(parsedDragThreshold)) {\n      dragThreshold.mouse = parsedDragThreshold;\n      dragThreshold.touch = parsedDragThreshold;\n    } else if (parsedDragThreshold) {\n      const { mouse, touch } = parsedDragThreshold;\n      if (!isUnd(mouse)) dragThreshold.mouse = mouse;\n      if (!isUnd(touch)) dragThreshold.touch = touch;\n    }\n    this.containerArray = isArr(container) ? container : null;\n    this.$container = /** @type {HTMLElement} */(container && !this.containerArray ? parseTargets(/** @type {DOMTarget} */(container))[0] : doc.body);\n    this.useWin = this.$container === doc.body;\n    /** @type {Window | HTMLElement} */\n    this.$scrollContainer = this.useWin ? win : this.$container;\n    this.isFinePointer = matchMedia('(pointer:fine)').matches;\n    this.containerPadding = setValue(containerPadding, [0, 0, 0, 0]);\n    this.containerFriction = clamp(setValue(parseDraggableFunctionParameter(params.containerFriction, this), .8), 0, 1);\n    this.releaseContainerFriction = clamp(setValue(parseDraggableFunctionParameter(params.releaseContainerFriction, this), this.containerFriction), 0, 1);\n    this.snapX = parseDraggableFunctionParameter(isObj(paramX) && !isUnd(paramX.snap) ? paramX.snap : params.snap, this);\n    this.snapY = parseDraggableFunctionParameter(isObj(paramY) && !isUnd(paramY.snap) ? paramY.snap : params.snap, this);\n    this.scrollSpeed = setValue(parseDraggableFunctionParameter(params.scrollSpeed, this), 1.5);\n    this.scrollThreshold = setValue(parseDraggableFunctionParameter(params.scrollThreshold, this), 20);\n    this.dragSpeed = setValue(parseDraggableFunctionParameter(params.dragSpeed, this), 1);\n    this.dragThreshold = this.isFinePointer ? dragThreshold.mouse : dragThreshold.touch;\n    this.minVelocity = setValue(parseDraggableFunctionParameter(params.minVelocity, this), 0);\n    this.maxVelocity = setValue(parseDraggableFunctionParameter(params.maxVelocity, this), 50);\n    this.velocityMultiplier = setValue(parseDraggableFunctionParameter(params.velocityMultiplier, this), 1);\n    this.cursor = parsedCursorStyles === false ? false : cursorStyles;\n    this.updateBoundingValues();\n\n    // const ob = this.isOutOfBounds(this.containerBounds, this.x, this.y);\n    // if (ob === 1 || ob === 3) this.progressX = px;\n    // if (ob === 2 || ob === 3) this.progressY = py;\n\n    // if (this.initialized && this.contained) {\n    //   if (this.progressX !== px) this.progressX = px;\n    //   if (this.progressY !== py) this.progressY = py;\n    // }\n\n    const [ bt, br, bb, bl ] = this.containerBounds;\n    this.setX(clamp(cx, bl, br), true);\n    this.setY(clamp(cy, bt, bb), true);\n  }\n\n  update() {\n    this.updateScrollCoords();\n    if (this.canScroll) {\n      const [ cpt, cpr, cpb, cpl ] = this.containerPadding;\n      const [ sw, sh ] = this.scrollView;\n      const daw = this.dragArea[2];\n      const dah = this.dragArea[3];\n      const csx = this.scroll.x;\n      const csy = this.scroll.y;\n      const nsw = this.$container.scrollWidth;\n      const nsh = this.$container.scrollHeight;\n      const csw = this.useWin ? clamp(nsw, this.window[0], nsw) : nsw;\n      const csh = this.useWin ? clamp(nsh, this.window[1], nsh) : nsh;\n      const swd = sw - csw;\n      const shd = sh - csh;\n      // Handle cases where the scrollarea dimensions changes during drag\n      if (this.dragged && swd > 0) {\n        this.coords[0] -= swd;\n        this.scrollView[0] = csw;\n      }\n      if (this.dragged && shd > 0) {\n        this.coords[1] -= shd;\n        this.scrollView[1] = csh;\n      }\n      // Handle autoscroll when target is at the edges of the scroll bounds\n      const s = this.scrollSpeed * 10;\n      const threshold = this.scrollThreshold;\n      const [ x, y ] = this.coords;\n      const [ st, sr, sb, sl ] = this.scrollBounds;\n      const t = round(clamp((y - st + cpt) / threshold, -1, 0) * s, 0);\n      const r = round(clamp((x - sr - cpr) / threshold, 0, 1) * s, 0);\n      const b = round(clamp((y - sb - cpb) / threshold, 0, 1) * s, 0);\n      const l = round(clamp((x - sl + cpl) / threshold, -1, 0) * s, 0);\n      if (t || b || l || r) {\n        const [nx, ny] = this.disabled;\n        let scrollX = csx;\n        let scrollY = csy;\n        if (!nx) {\n          scrollX = round(clamp(csx + (l || r), 0, sw - daw), 0);\n          this.coords[0] -= csx - scrollX;\n        }\n        if (!ny) {\n          scrollY = round(clamp(csy + (t || b), 0, sh - dah), 0);\n          this.coords[1] -= csy - scrollY;\n        }\n        // Note: Safari mobile requires to use different scroll methods depending if using the window or not\n        if (this.useWin) {\n          this.$scrollContainer.scrollBy(-(csx - scrollX), -(csy - scrollY));\n        } else {\n          this.$scrollContainer.scrollTo(scrollX, scrollY);\n        }\n      }\n    }\n    const [ ct, cr, cb, cl ] = this.containerBounds;\n    const [ px1, py1, px2, py2, px3, py3 ] = this.pointer;\n    this.coords[0] += (px1 - px3) * this.dragSpeed;\n    this.coords[1] += (py1 - py3) * this.dragSpeed;\n    this.pointer[4] = px1;\n    this.pointer[5] = py1;\n    const [ cx, cy ] = this.coords;\n    const [ sx, sy ] = this.snapped;\n    const cf = (1 - this.containerFriction) * this.dragSpeed;\n    this.setX(cx > cr ? cr + (cx - cr) * cf : cx < cl ? cl + (cx - cl) * cf : cx, false);\n    this.setY(cy > cb ? cb + (cy - cb) * cf : cy < ct ? ct + (cy - ct) * cf : cy, false);\n    this.computeVelocity(px1 - px3, py1 - py3);\n    this.angle = atan2(py1 - py2, px1 - px2);\n    const [ nsx, nsy ] = this.snapped;\n    if (nsx !== sx && this.snapX || nsy !== sy && this.snapY) {\n      this.onSnap(this);\n    }\n  }\n\n  stop() {\n    this.updateTicker.pause();\n    this.overshootTicker.pause();\n    // Pauses the in bounds onRelease animations\n    for (let prop in this.animate.animations) this.animate.animations[prop].pause();\n    removeTargetsFromRenderable([this], null, 'x');\n    removeTargetsFromRenderable([this], null, 'y');\n    removeTargetsFromRenderable([this], null, 'progressX');\n    removeTargetsFromRenderable([this], null, 'progressY');\n    removeTargetsFromRenderable([this.scroll]); // Removes any active animations on the container scroll\n    removeTargetsFromRenderable([this.overshootCoords]); // Removes active overshoot animations\n    return this;\n  }\n\n  /**\n   * @param {Number} [duration]\n   * @param {Number} [gap]\n   * @param {EasingParam} [ease]\n   * @return {this}\n   */\n  scrollInView(duration, gap = 0, ease = eases.inOutQuad) {\n    this.updateScrollCoords();\n    const x = this.destX;\n    const y = this.destY;\n    const scroll = this.scroll;\n    const scrollBounds = this.scrollBounds;\n    const canScroll = this.canScroll;\n    if (!this.containerArray && this.isOutOfBounds(scrollBounds, x, y)) {\n      const [ st, sr, sb, sl ] = scrollBounds;\n      const t = round(clamp(y - st, -maxValue, 0), 0);\n      const r = round(clamp(x - sr, 0, maxValue), 0);\n      const b = round(clamp(y - sb, 0, maxValue), 0);\n      const l = round(clamp(x - sl, -maxValue, 0), 0);\n      new JSAnimation(scroll, {\n        x: round(scroll.x + (l ? l - gap : r ? r + gap : 0), 0),\n        y: round(scroll.y + (t ? t - gap : b ? b + gap : 0), 0),\n        duration: isUnd(duration) ? 350 * globals.timeScale : duration,\n        ease,\n        onUpdate: () => {\n          this.canScroll = false;\n          this.$scrollContainer.scrollTo(scroll.x, scroll.y);\n        }\n      }).init().then(() => {\n        this.canScroll = canScroll;\n      });\n    }\n    return this;\n  }\n\n  handleHover() {\n    if (this.isFinePointer && this.cursor && !this.cursorStyles) {\n      this.cursorStyles = set(this.$trigger, {\n        cursor: /** @type {DraggableCursorParams} */(this.cursor).onHover\n      });\n    }\n  }\n\n  /**\n   * @param  {Number} [duration]\n   * @param  {Number} [gap]\n   * @param  {EasingParam} [ease]\n   * @return {this}\n   */\n  animateInView(duration, gap = 0, ease = eases.inOutQuad) {\n    this.stop();\n    this.updateBoundingValues();\n    const x = this.x;\n    const y = this.y;\n    const [ cpt, cpr, cpb, cpl ] = this.containerPadding;\n    const bt = this.scroll.y - this.targetBounds[0] + cpt + gap;\n    const br = this.scroll.x - this.targetBounds[1] - cpr - gap;\n    const bb = this.scroll.y - this.targetBounds[2] - cpb - gap;\n    const bl = this.scroll.x - this.targetBounds[3] + cpl + gap;\n    const ob = this.isOutOfBounds([bt, br, bb, bl], x, y);\n    if (ob) {\n      const [ disabledX, disabledY ] = this.disabled;\n      const destX = clamp(snap(x, this.snapX), bl, br);\n      const destY = clamp(snap(y, this.snapY), bt, bb);\n      const dur = isUnd(duration) ? 350 * globals.timeScale : duration;\n      if (!disabledX && (ob === 1 || ob === 3)) this.animate[this.xProp](destX, dur, ease);\n      if (!disabledY && (ob === 2 || ob === 3)) this.animate[this.yProp](destY, dur, ease);\n    }\n    return this;\n  }\n\n  /**\n   * @param {MouseEvent|TouchEvent} e\n   */\n  handleDown(e) {\n    const $eTarget = /** @type {HTMLElement} */(e.target);\n    if (this.grabbed || /** @type {HTMLInputElement} */($eTarget).type === 'range') return;\n\n    e.stopPropagation();\n\n    this.grabbed = true;\n    this.released = false;\n    this.stop();\n    this.updateBoundingValues();\n    const touches = /** @type {TouchEvent} */(e).changedTouches;\n    const eventX = touches ? touches[0].clientX : /** @type {MouseEvent} */(e).clientX;\n    const eventY = touches ? touches[0].clientY : /** @type {MouseEvent} */(e).clientY;\n    const { x, y } = this.transforms.normalizePoint(eventX, eventY);\n    const [ ct, cr, cb, cl ] = this.containerBounds;\n    const cf = (1 - this.containerFriction) * this.dragSpeed;\n    const cx = this.x;\n    const cy = this.y;\n    this.coords[0] = this.coords[2] = !cf ? cx : cx > cr ? cr + (cx - cr) / cf : cx < cl ? cl + (cx - cl) / cf : cx;\n    this.coords[1] = this.coords[3] = !cf ? cy : cy > cb ? cb + (cy - cb) / cf : cy < ct ? ct + (cy - ct) / cf : cy;\n    this.pointer[0] = x;\n    this.pointer[1] = y;\n    this.pointer[2] = x;\n    this.pointer[3] = y;\n    this.pointer[4] = x;\n    this.pointer[5] = y;\n    this.pointer[6] = x;\n    this.pointer[7] = y;\n    this.deltaX = 0;\n    this.deltaY = 0;\n    this.velocity = 0;\n    this.velocityStack[0] = 0;\n    this.velocityStack[1] = 0;\n    this.velocityStack[2] = 0;\n    this.velocityStackIndex = 0;\n    this.angle = 0;\n    if (this.targetStyles) {\n      this.targetStyles.revert();\n      this.targetStyles = null;\n    }\n    const z = /** @type {Number} */(get(this.$target, 'zIndex', false));\n    zIndex = (z > zIndex ? z : zIndex) + 1;\n    this.targetStyles = set(this.$target, { zIndex });\n    if (this.triggerStyles) {\n      this.triggerStyles.revert();\n      this.triggerStyles = null;\n    }\n    if (this.cursorStyles) {\n      this.cursorStyles.revert();\n      this.cursorStyles = null;\n    }\n    if (this.isFinePointer && this.cursor) {\n      this.bodyStyles = set(doc.body, {\n        cursor: /** @type {DraggableCursorParams} */(this.cursor).onGrab\n      });\n    }\n    this.scrollInView(100, 0, eases.out(3));\n    this.onGrab(this);\n\n    doc.addEventListener('touchmove', this);\n    doc.addEventListener('touchend', this);\n    doc.addEventListener('touchcancel', this);\n    doc.addEventListener('mousemove', this);\n    doc.addEventListener('mouseup', this);\n    doc.addEventListener('selectstart', this);\n  }\n\n  /**\n   * @param {MouseEvent|TouchEvent} e\n   */\n  handleMove(e) {\n    if (!this.grabbed) return;\n    const touches = /** @type {TouchEvent} */(e).changedTouches;\n    const eventX = touches ? touches[0].clientX : /** @type {MouseEvent} */(e).clientX;\n    const eventY = touches ? touches[0].clientY : /** @type {MouseEvent} */(e).clientY;\n    const { x, y } = this.transforms.normalizePoint(eventX, eventY);\n    const movedX = x - this.pointer[6];\n    const movedY = y - this.pointer[7];\n\n    let $parent = /** @type {HTMLElement} */(e.target);\n    let isAtTop = false;\n    let isAtBottom = false;\n    let canTouchScroll = false;\n\n    while (touches && $parent && $parent !== this.$trigger) {\n      const overflowY = get($parent, 'overflow-y');\n      if (overflowY !== 'hidden' && overflowY !== 'visible') {\n        const { scrollTop, scrollHeight, clientHeight } = $parent;\n        if (scrollHeight > clientHeight) {\n          canTouchScroll = true;\n          isAtTop = scrollTop <= 3;\n          isAtBottom = scrollTop >= (scrollHeight - clientHeight) - 3;\n          break;\n        }\n      }\n      $parent = $parent.parentElement;\n    }\n\n    if (canTouchScroll && ((!isAtTop && !isAtBottom) || (isAtTop && movedY < 0) || (isAtBottom && movedY > 0))) {\n\n      this.pointer[0] = x;\n      this.pointer[1] = y;\n      this.pointer[2] = x;\n      this.pointer[3] = y;\n      this.pointer[4] = x;\n      this.pointer[5] = y;\n      this.pointer[6] = x;\n      this.pointer[7] = y;\n\n    } else {\n\n      preventDefault(e);\n\n      // Needed to prevents click on handleUp\n      if (!this.triggerStyles) this.triggerStyles = set(this.$trigger, { pointerEvents: 'none' });\n      // Needed to prevent page scroll while dragging on touch devvice\n      this.$trigger.addEventListener('touchstart', preventDefault, { passive: false });\n      this.$trigger.addEventListener('touchmove', preventDefault, { passive: false });\n      this.$trigger.addEventListener('touchend', preventDefault);\n\n      // Don't check for a miminim distance move if already dragging\n      if (this.dragged || (!this.disabled[0] && abs(movedX) > this.dragThreshold) || (!this.disabled[1] && abs(movedY) > this.dragThreshold)) {\n        this.updateTicker.resume();\n        this.pointer[2] = this.pointer[0];\n        this.pointer[3] = this.pointer[1];\n        this.pointer[0] = x;\n        this.pointer[1] = y;\n        this.dragged = true;\n        this.released = false;\n        this.onDrag(this);\n      }\n    }\n  }\n\n  handleUp() {\n\n    if (!this.grabbed) return;\n\n    this.updateTicker.pause();\n\n    if (this.triggerStyles) {\n      this.triggerStyles.revert();\n      this.triggerStyles = null;\n    }\n\n    if (this.bodyStyles) {\n      this.bodyStyles.revert();\n      this.bodyStyles = null;\n    }\n\n    const [ disabledX, disabledY ] = this.disabled;\n    const [ px1, py1, px2, py2, px3, py3 ] = this.pointer;\n    const [ ct, cr, cb, cl ] = this.containerBounds;\n    const [ sx, sy ] = this.snapped;\n    const springX = this.releaseXSpring;\n    const springY = this.releaseYSpring;\n    const releaseEase = this.releaseEase;\n    const hasReleaseSpring = this.hasReleaseSpring;\n    const overshootCoords = this.overshootCoords;\n    const cx = this.x;\n    const cy = this.y;\n    const pv = this.computeVelocity(px1 - px3, py1 - py3);\n    const pa = this.angle = atan2(py1 - py2, px1 - px2);\n    const ds = pv * 150;\n    const cf = (1 - this.releaseContainerFriction) * this.dragSpeed;\n    const nx = cx + (cos(pa) * ds);\n    const ny = cy + (sin(pa) * ds);\n    const bx = nx > cr ? cr + (nx - cr) * cf : nx < cl ? cl + (nx - cl) * cf : nx;\n    const by = ny > cb ? cb + (ny - cb) * cf : ny < ct ? ct + (ny - ct) * cf : ny;\n    const dx = this.destX = clamp(round(snap(bx, this.snapX), 5), cl, cr);\n    const dy = this.destY = clamp(round(snap(by, this.snapY), 5), ct, cb);\n    const ob = this.isOutOfBounds(this.containerBounds, nx, ny);\n\n    let durationX = 0;\n    let durationY = 0;\n    let easeX = releaseEase;\n    let easeY = releaseEase;\n    let longestReleaseDuration = 0;\n\n    overshootCoords.x = cx;\n    overshootCoords.y = cy;\n\n    if (!disabledX) {\n      const directionX = dx === cr ? cx > cr ? -1 : 1 : cx < cl ? -1 : 1;\n      const distanceX = round(cx - dx, 0);\n      springX.velocity = disabledY && hasReleaseSpring ? distanceX ? (ds * directionX) / abs(distanceX) : 0 : pv;\n      const { ease, settlingDuration, restDuration } = springX;\n      durationX = cx === dx ? 0 : hasReleaseSpring ? settlingDuration : settlingDuration - (restDuration * globals.timeScale);\n      if (hasReleaseSpring) easeX = ease;\n      if (durationX > longestReleaseDuration) longestReleaseDuration = durationX;\n    }\n\n    if (!disabledY) {\n      const directionY = dy === cb ? cy > cb ? -1 : 1 : cy < ct ? -1 : 1;\n      const distanceY = round(cy - dy, 0);\n      springY.velocity = disabledX && hasReleaseSpring ? distanceY ? (ds * directionY) / abs(distanceY) : 0 : pv;\n      const { ease, settlingDuration, restDuration } = springY;\n      durationY = cy === dy ? 0 : hasReleaseSpring ? settlingDuration : settlingDuration - (restDuration * globals.timeScale);\n      if (hasReleaseSpring) easeY = ease;\n      if (durationY > longestReleaseDuration) longestReleaseDuration = durationY;\n    }\n\n    if (!hasReleaseSpring && ob && cf && (durationX || durationY)) {\n\n        const composition = compositionTypes.blend;\n\n        new JSAnimation(overshootCoords, {\n          x: { to: bx, duration: durationX * .65 },\n          y: { to: by, duration: durationY * .65 },\n          ease: releaseEase,\n          composition,\n        }).init();\n\n        new JSAnimation(overshootCoords, {\n          x: { to: dx, duration: durationX },\n          y: { to: dy, duration: durationY },\n          ease: releaseEase,\n          composition,\n        }).init();\n\n        this.overshootTicker.stretch(max(durationX, durationY)).restart();\n\n    } else {\n\n      if (!disabledX) this.animate[this.xProp](dx, durationX, easeX);\n      if (!disabledY) this.animate[this.yProp](dy, durationY, easeY);\n\n    }\n\n    this.scrollInView(longestReleaseDuration, this.scrollThreshold, releaseEase);\n\n    let hasSnapped = false;\n\n    if (dx !== sx) {\n      this.snapped[0] = dx;\n      if (this.snapX) hasSnapped = true;\n    }\n\n    if (dy !== sy && this.snapY) {\n      this.snapped[1] = dy;\n      if (this.snapY) hasSnapped = true;\n    }\n\n    if (hasSnapped) this.onSnap(this);\n\n    this.grabbed = false;\n    this.dragged = false;\n    this.updated = true;\n    this.released = true;\n\n    // It's important to trigger the callback after the release animations to be able to cancel them\n    this.onRelease(this);\n\n    this.$trigger.removeEventListener('touchstart', preventDefault);\n    this.$trigger.removeEventListener('touchmove', preventDefault);\n    this.$trigger.removeEventListener('touchend', preventDefault);\n\n    doc.removeEventListener('touchmove', this);\n    doc.removeEventListener('touchend', this);\n    doc.removeEventListener('touchcancel', this);\n    doc.removeEventListener('mousemove', this);\n    doc.removeEventListener('mouseup', this);\n    doc.removeEventListener('selectstart', this);\n  }\n\n  reset() {\n    this.stop();\n    this.resizeTicker.pause();\n    this.grabbed = false;\n    this.dragged = false;\n    this.updated = false;\n    this.released = false;\n    this.canScroll = false;\n    this.setX(0, true);\n    this.setY(0, true);\n    this.coords[0] = 0;\n    this.coords[1] = 0;\n    this.pointer[0] = 0;\n    this.pointer[1] = 0;\n    this.pointer[2] = 0;\n    this.pointer[3] = 0;\n    this.pointer[4] = 0;\n    this.pointer[5] = 0;\n    this.pointer[6] = 0;\n    this.pointer[7] = 0;\n    this.velocity = 0;\n    this.velocityStack[0] = 0;\n    this.velocityStack[1] = 0;\n    this.velocityStack[2] = 0;\n    this.velocityStackIndex = 0;\n    this.angle = 0;\n    return this;\n  }\n\n  enable() {\n    if (!this.enabled) {\n      this.enabled = true;\n      this.$target.classList.remove('is-disabled');\n      this.touchActionStyles = set(this.$trigger, {\n        touchAction: this.disabled[0] ? 'pan-x' : this.disabled[1] ? 'pan-y' : 'none'\n      });\n      this.$trigger.addEventListener('touchstart', this, { passive: true });\n      this.$trigger.addEventListener('mousedown', this, { passive: true });\n      this.$trigger.addEventListener('mouseenter', this);\n    }\n    return this;\n  }\n\n  disable() {\n    this.enabled = false;\n    this.grabbed = false;\n    this.dragged = false;\n    this.updated = false;\n    this.released = false;\n    this.canScroll = false;\n    this.touchActionStyles.revert();\n    if (this.cursorStyles) {\n      this.cursorStyles.revert();\n      this.cursorStyles = null;\n    }\n    if (this.triggerStyles) {\n      this.triggerStyles.revert();\n      this.triggerStyles = null;\n    }\n    if (this.bodyStyles) {\n      this.bodyStyles.revert();\n      this.bodyStyles = null;\n    }\n    if (this.targetStyles) {\n      this.targetStyles.revert();\n      this.targetStyles = null;\n    }\n    this.$target.classList.add('is-disabled');\n    this.$trigger.removeEventListener('touchstart', this);\n    this.$trigger.removeEventListener('mousedown', this);\n    this.$trigger.removeEventListener('mouseenter', this);\n    doc.removeEventListener('touchmove', this);\n    doc.removeEventListener('touchend', this);\n    doc.removeEventListener('touchcancel', this);\n    doc.removeEventListener('mousemove', this);\n    doc.removeEventListener('mouseup', this);\n    doc.removeEventListener('selectstart', this);\n    return this;\n  }\n\n  revert() {\n    this.reset();\n    this.disable();\n    this.$target.classList.remove('is-disabled');\n    this.updateTicker.revert();\n    this.overshootTicker.revert();\n    this.resizeTicker.revert();\n    this.animate.revert();\n    this.resizeObserver.disconnect();\n    return this;\n  }\n\n  /**\n   * @param {Event} e\n   */\n  handleEvent(e) {\n    switch (e.type) {\n      case 'mousedown':\n        this.handleDown(/** @type {MouseEvent} */(e));\n        break;\n      case 'touchstart':\n        this.handleDown(/** @type {TouchEvent} */(e));\n        break;\n      case 'mousemove':\n        this.handleMove(/** @type {MouseEvent} */(e));\n        break;\n      case 'touchmove':\n        this.handleMove(/** @type {TouchEvent} */(e));\n        break;\n      case 'mouseup':\n        this.handleUp();\n        break;\n      case 'touchend':\n        this.handleUp();\n        break;\n      case 'touchcancel':\n        this.handleUp();\n        break;\n      case 'mouseenter':\n        this.handleHover();\n        break;\n      case 'selectstart':\n        preventDefault(e);\n        break;\n    }\n  }\n}\n\n/**\n * @param {TargetsParam} target\n * @param {DraggableParams} [parameters]\n * @return {Draggable}\n */\nconst createDraggable = (target, parameters) => new Draggable(target, parameters);\n\nexport { Draggable, createDraggable };\n","/**\n * Anime.js - utils - ESM\n * @version v4.3.6\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { noop } from '../core/consts.js';\nimport { globals } from '../core/globals.js';\nimport { isFnc, isUnd } from '../core/helpers.js';\nimport { Timer } from '../timer/timer.js';\n\n/**\n * @import {\n *   Callback,\n *   Tickable,\n * } from '../types/index.js'\n*/\n\n/**\n * @param  {Callback<Timer>} [callback]\n * @return {Timer}\n */\nconst sync = (callback = noop) => {\n  return new Timer({ duration: 1 * globals.timeScale, onComplete: callback }, null, 0).resume();\n};\n\n/**\n * @param  {(...args: any[]) => Tickable | ((...args: any[]) => void)} constructor\n * @return {(...args: any[]) => Tickable | ((...args: any[]) => void)}\n */\nconst keepTime = constructor => {\n  /** @type {Tickable} */\n  let tracked;\n  return (...args) => {\n    let currentIteration, currentIterationProgress, reversed, alternate;\n    if (tracked) {\n      currentIteration = tracked.currentIteration;\n      currentIterationProgress = tracked.iterationProgress;\n      reversed = tracked.reversed;\n      alternate = tracked._alternate;\n      tracked.revert();\n    }\n    const cleanup = constructor(...args);\n    if (cleanup && !isFnc(cleanup) && cleanup.revert) tracked = cleanup;\n    if (!isUnd(currentIterationProgress)) {\n      /** @type {Tickable} */(tracked).currentIteration = currentIteration;\n      /** @type {Tickable} */(tracked).iterationProgress = (alternate ? !(currentIteration % 2) ? reversed : !reversed : reversed) ? 1 - currentIterationProgress : currentIterationProgress;\n    }\n    return cleanup || noop;\n  }\n};\n\nexport { keepTime, sync };\n","/**\n * Anime.js - scope - ESM\n * @version v4.3.6\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { doc, win } from '../core/consts.js';\nimport { globals, scope } from '../core/globals.js';\nimport { mergeObjects, isFnc } from '../core/helpers.js';\nimport { parseTargets } from '../core/targets.js';\nimport { keepTime } from '../utils/time.js';\n\n/**\n * @import {\n *   Tickable,\n *   ScopeParams,\n *   DOMTarget,\n *   ReactRef,\n *   AngularRef,\n *   DOMTargetSelector,\n *   DefaultsParams,\n *   ScopeConstructorCallback,\n *   ScopeCleanupCallback,\n *   Revertible,\n *   ScopeMethod,\n *   ScopedCallback,\n * } from '../types/index.js'\n*/\n\nclass Scope {\n  /** @param {ScopeParams} [parameters] */\n  constructor(parameters = {}) {\n    if (scope.current) scope.current.register(this);\n    const rootParam = parameters.root;\n    /** @type {Document|DOMTarget} */\n    let root = doc;\n    if (rootParam) {\n      root = /** @type {ReactRef} */(rootParam).current ||\n             /** @type {AngularRef} */(rootParam).nativeElement ||\n             parseTargets(/** @type {DOMTargetSelector} */(rootParam))[0] ||\n             doc;\n    }\n    const scopeDefaults = parameters.defaults;\n    const globalDefault = globals.defaults;\n    const mediaQueries = parameters.mediaQueries;\n    /** @type {DefaultsParams} */\n    this.defaults = scopeDefaults ? mergeObjects(scopeDefaults, globalDefault) : globalDefault;\n    /** @type {Document|DOMTarget} */\n    this.root = root;\n    /** @type {Array<ScopeConstructorCallback>} */\n    this.constructors = [];\n    /** @type {Array<ScopeCleanupCallback>} */\n    this.revertConstructors = [];\n    /** @type {Array<Revertible>} */\n    this.revertibles = [];\n    /** @type {Array<ScopeConstructorCallback | ((scope: this) => Tickable)>} */\n    this.constructorsOnce = [];\n    /** @type {Array<ScopeCleanupCallback>} */\n    this.revertConstructorsOnce = [];\n    /** @type {Array<Revertible>} */\n    this.revertiblesOnce = [];\n    /** @type {Boolean} */\n    this.once = false;\n    /** @type {Number} */\n    this.onceIndex = 0;\n    /** @type {Record<String, ScopeMethod>} */\n    this.methods = {};\n    /** @type {Record<String, Boolean>} */\n    this.matches = {};\n    /** @type {Record<String, MediaQueryList>} */\n    this.mediaQueryLists = {};\n    /** @type {Record<String, any>} */\n    this.data = {};\n    if (mediaQueries) {\n      for (let mq in mediaQueries) {\n        const _mq = win.matchMedia(mediaQueries[mq]);\n        this.mediaQueryLists[mq] = _mq;\n        _mq.addEventListener('change', this);\n      }\n    }\n  }\n\n  /**\n   * @param {Revertible} revertible\n   */\n  register(revertible) {\n    const store = this.once ? this.revertiblesOnce : this.revertibles;\n    store.push(revertible);\n  }\n\n  /**\n   * @template T\n   * @param {ScopedCallback<T>} cb\n   * @return {T}\n   */\n  execute(cb) {\n    let activeScope = scope.current;\n    let activeRoot = scope.root;\n    let activeDefaults = globals.defaults;\n    scope.current = this;\n    scope.root = this.root;\n    globals.defaults = this.defaults;\n    const mqs = this.mediaQueryLists;\n    for (let mq in mqs) this.matches[mq] = mqs[mq].matches;\n    const returned = cb(this);\n    scope.current = activeScope;\n    scope.root = activeRoot;\n    globals.defaults = activeDefaults;\n    return returned;\n  }\n\n  /**\n   * @return {this}\n   */\n  refresh() {\n    this.onceIndex = 0;\n    this.execute(() => {\n      let i = this.revertibles.length;\n      let y = this.revertConstructors.length;\n      while (i--) this.revertibles[i].revert();\n      while (y--) this.revertConstructors[y](this);\n      this.revertibles.length = 0;\n      this.revertConstructors.length = 0;\n      this.constructors.forEach((/** @type {ScopeConstructorCallback} */constructor) => {\n        const revertConstructor = constructor(this);\n        if (isFnc(revertConstructor)) {\n          this.revertConstructors.push(revertConstructor);\n        }\n      });\n    });\n    return this;\n  }\n\n  /**\n   * @overload\n   * @param {String} a1\n   * @param {ScopeMethod} a2\n   * @return {this}\n   *\n   * @overload\n   * @param {ScopeConstructorCallback} a1\n   * @return {this}\n   *\n   * @param {String|ScopeConstructorCallback} a1\n   * @param {ScopeMethod} [a2]\n   */\n  add(a1, a2) {\n    this.once = false;\n    if (isFnc(a1)) {\n      const constructor = /** @type {ScopeConstructorCallback} */(a1);\n      this.constructors.push(constructor);\n      this.execute(() => {\n        const revertConstructor = constructor(this);\n        if (isFnc(revertConstructor)) {\n          this.revertConstructors.push(revertConstructor);\n        }\n      });\n    } else {\n      this.methods[/** @type {String} */(a1)] = (/** @type {any} */...args) => this.execute(() => a2(...args));\n    }\n    return this;\n  }\n\n  /**\n   * @param {ScopeConstructorCallback} scopeConstructorCallback\n   * @return {this}\n   */\n  addOnce(scopeConstructorCallback) {\n    this.once = true;\n    if (isFnc(scopeConstructorCallback)) {\n      const currentIndex = this.onceIndex++;\n      const tracked = this.constructorsOnce[currentIndex];\n      if (tracked) return this;\n      const constructor = /** @type {ScopeConstructorCallback} */(scopeConstructorCallback);\n      this.constructorsOnce[currentIndex] = constructor;\n      this.execute(() => {\n        const revertConstructor = constructor(this);\n        if (isFnc(revertConstructor)) {\n          this.revertConstructorsOnce.push(revertConstructor);\n        }\n      });\n    }\n    return this;\n  }\n\n  /**\n   * @param  {(scope: this) => Tickable} cb\n   * @return {Tickable}\n   */\n  keepTime(cb) {\n    this.once = true;\n    const currentIndex = this.onceIndex++;\n    const tracked = /** @type {(scope: this) => Tickable} */(this.constructorsOnce[currentIndex]);\n    if (isFnc(tracked)) return tracked(this);\n    const constructor = /** @type {(scope: this) => Tickable} */(keepTime(cb));\n    this.constructorsOnce[currentIndex] = constructor;\n    let trackedTickable;\n    this.execute(() => {\n      trackedTickable = constructor(this);\n    });\n    return trackedTickable;\n  }\n\n  /**\n   * @param {Event} e\n   */\n  handleEvent(e) {\n    switch (e.type) {\n      case 'change':\n        this.refresh();\n        break;\n    }\n  }\n\n  revert() {\n    const revertibles = this.revertibles;\n    const revertConstructors = this.revertConstructors;\n    const revertiblesOnce = this.revertiblesOnce;\n    const revertConstructorsOnce = this.revertConstructorsOnce;\n    const mqs = this.mediaQueryLists;\n    let i = revertibles.length;\n    let j = revertConstructors.length;\n    let k = revertiblesOnce.length;\n    let l = revertConstructorsOnce.length;\n    while (i--) revertibles[i].revert();\n    while (j--) revertConstructors[j](this);\n    while (k--) revertiblesOnce[k].revert();\n    while (l--) revertConstructorsOnce[l](this);\n    for (let mq in mqs) mqs[mq].removeEventListener('change', this);\n    revertibles.length = 0;\n    revertConstructors.length = 0;\n    this.constructors.length = 0;\n    revertiblesOnce.length = 0;\n    revertConstructorsOnce.length = 0;\n    this.constructorsOnce.length = 0;\n    this.onceIndex = 0;\n    this.matches = {};\n    this.methods = {};\n    this.mediaQueryLists = {};\n    this.data = {};\n  }\n}\n\n/**\n * @param {ScopeParams} [params]\n * @return {Scope}\n */\nconst createScope = params => new Scope(params);\n\nexport { Scope, createScope };\n","/**\n * Anime.js - events - ESM\n * @version v4.3.6\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { noop, doc, isDomSymbol, relativeValuesExecRgx, win } from '../core/consts.js';\nimport { scope, globals } from '../core/globals.js';\nimport { isUnd, isNum, addChild, forEachChildren, round, isStr, isObj, removeChild, clamp, lerp, isFnc } from '../core/helpers.js';\nimport { parseTargets } from '../core/targets.js';\nimport { setValue, getRelativeValue, decomposeRawValue, decomposedOriginalValue } from '../core/values.js';\nimport { convertValueUnit } from '../core/units.js';\nimport { Timer } from '../timer/timer.js';\nimport { get, set } from '../utils/target.js';\nimport { sync } from '../utils/time.js';\nimport { none } from '../easings/none.js';\nimport { parseEase } from '../easings/eases/parser.js';\n\n/**\n * @import {\n *   TargetsParam,\n *   EasingFunction,\n *   Callback,\n *   EasingParam,\n *   ScrollThresholdValue,\n *   ScrollObserverParams,\n *   Tickable,\n *   ScrollThresholdParam,\n *   ScrollThresholdCallback,\n * } from '../types/index.js'\n*/\n\n/**\n * @import {\n *   JSAnimation,\n * } from '../animation/animation.js'\n*/\n\n/**\n * @import {\n *   WAAPIAnimation,\n * } from '../waapi/waapi.js'\n*/\n\n/**\n * @import {\n *   Timeline,\n * } from '../timeline/timeline.js'\n*/\n\n/**\n * @return {Number}\n */\nconst getMaxViewHeight = () => {\n  const $el = doc.createElement('div');\n  doc.body.appendChild($el);\n  $el.style.height = '100lvh';\n  const height = $el.offsetHeight;\n  doc.body.removeChild($el);\n  return height;\n};\n\n/**\n * @template {ScrollThresholdValue|String|Number|Boolean|Function|Object} T\n * @param {T | ((observer: ScrollObserver) => T)} value\n * @param {ScrollObserver} scroller\n * @return {T}\n */\nconst parseScrollObserverFunctionParameter = (value, scroller) => value && isFnc(value) ? /** @type {Function} */(value)(scroller) : /** @type {T} */(value);\n\nconst scrollContainers = new Map();\n\nclass ScrollContainer {\n  /**\n   * @param {HTMLElement} $el\n   */\n  constructor($el) {\n    /** @type {HTMLElement} */\n    this.element = $el;\n    /** @type {Boolean} */\n    this.useWin = this.element === doc.body;\n    /** @type {Number} */\n    this.winWidth = 0;\n    /** @type {Number} */\n    this.winHeight = 0;\n    /** @type {Number} */\n    this.width = 0;\n    /** @type {Number} */\n    this.height = 0;\n    /** @type {Number} */\n    this.left = 0;\n    /** @type {Number} */\n    this.top = 0;\n    /** @type {Number} */\n    this.scale = 1;\n    /** @type {Number} */\n    this.zIndex = 0;\n    /** @type {Number} */\n    this.scrollX = 0;\n    /** @type {Number} */\n    this.scrollY = 0;\n    /** @type {Number} */\n    this.prevScrollX = 0;\n    /** @type {Number} */\n    this.prevScrollY = 0;\n    /** @type {Number} */\n    this.scrollWidth = 0;\n    /** @type {Number} */\n    this.scrollHeight = 0;\n    /** @type {Number} */\n    this.velocity = 0;\n    /** @type {Boolean} */\n    this.backwardX = false;\n    /** @type {Boolean} */\n    this.backwardY = false;\n    /** @type {Timer} */\n    this.scrollTicker = new Timer({\n      autoplay: false,\n      onBegin: () => this.dataTimer.resume(),\n      onUpdate: () => {\n        const backwards = this.backwardX || this.backwardY;\n        forEachChildren(this, (/** @type {ScrollObserver} */child) => child.handleScroll(), backwards);\n      },\n      onComplete: () => this.dataTimer.pause()\n    }).init();\n    /** @type {Timer} */\n    this.dataTimer = new Timer({\n      autoplay: false,\n      frameRate: 30,\n      onUpdate: (/** @type {Timer} */self) => {\n        const dt = self.deltaTime;\n        const px = this.prevScrollX;\n        const py = this.prevScrollY;\n        const nx = this.scrollX;\n        const ny = this.scrollY;\n        const dx = px - nx;\n        const dy = py - ny;\n        this.prevScrollX = nx;\n        this.prevScrollY = ny;\n        if (dx) this.backwardX = px > nx;\n        if (dy) this.backwardY = py > ny;\n        this.velocity = round(dt > 0 ? Math.sqrt(dx * dx + dy * dy) / dt : 0, 5);\n      }\n    }).init();\n    /** @type {Timer} */\n    this.resizeTicker = new Timer({\n      autoplay: false,\n      duration: 250 * globals.timeScale,\n      onComplete: () => {\n        this.updateWindowBounds();\n        this.refreshScrollObservers();\n        this.handleScroll();\n      }\n    }).init();\n    /** @type {Timer} */\n    this.wakeTicker = new Timer({\n      autoplay: false,\n      duration: 500 * globals.timeScale,\n      onBegin: () => {\n        this.scrollTicker.resume();\n      },\n      onComplete: () => {\n        this.scrollTicker.pause();\n      }\n    }).init();\n    /** @type {ScrollObserver} */\n    this._head = null;\n    /** @type {ScrollObserver} */\n    this._tail = null;\n    this.updateScrollCoords();\n    this.updateWindowBounds();\n    this.updateBounds();\n    this.refreshScrollObservers();\n    this.handleScroll();\n    this.resizeObserver = new ResizeObserver(() => this.resizeTicker.restart());\n    this.resizeObserver.observe(this.element);\n    (this.useWin ? win : this.element).addEventListener('scroll', this, false);\n  }\n\n  updateScrollCoords() {\n    const useWin = this.useWin;\n    const $el = this.element;\n    this.scrollX = round(useWin ? win.scrollX : $el.scrollLeft, 0);\n    this.scrollY = round(useWin ? win.scrollY : $el.scrollTop, 0);\n  }\n\n  updateWindowBounds() {\n    this.winWidth = win.innerWidth;\n    this.winHeight = getMaxViewHeight();\n  }\n\n  updateBounds() {\n    const style = getComputedStyle(this.element);\n    const $el = this.element;\n    this.scrollWidth = $el.scrollWidth + parseFloat(style.marginLeft) + parseFloat(style.marginRight);\n    this.scrollHeight = $el.scrollHeight + parseFloat(style.marginTop) + parseFloat(style.marginBottom);\n    this.updateWindowBounds();\n    let width, height;\n    if (this.useWin) {\n      width = this.winWidth;\n      height = this.winHeight;\n    } else {\n      const elRect = $el.getBoundingClientRect();\n      width = $el.clientWidth;\n      height = $el.clientHeight;\n      this.top = elRect.top;\n      this.left = elRect.left;\n      this.scale = elRect.width ? width / elRect.width : (elRect.height ? height / elRect.height : 1);\n    }\n    this.width = width;\n    this.height = height;\n  }\n\n  refreshScrollObservers() {\n    forEachChildren(this, (/** @type {ScrollObserver} */child) => {\n      if (child._debug) {\n        child.removeDebug();\n      }\n    });\n    this.updateBounds();\n    forEachChildren(this, (/** @type {ScrollObserver} */child) => {\n      child.refresh();\n      child.onResize(child);\n      if (child._debug) {\n        child.debug();\n      }\n    });\n  }\n\n  refresh() {\n    this.updateWindowBounds();\n    this.updateBounds();\n    this.refreshScrollObservers();\n    this.handleScroll();\n  }\n\n  handleScroll() {\n    this.updateScrollCoords();\n    this.wakeTicker.restart();\n  }\n\n  /**\n   * @param {Event} e\n   */\n  handleEvent(e) {\n    switch (e.type) {\n      case 'scroll':\n        this.handleScroll();\n        break;\n    }\n  }\n\n  revert() {\n    this.scrollTicker.cancel();\n    this.dataTimer.cancel();\n    this.resizeTicker.cancel();\n    this.wakeTicker.cancel();\n    this.resizeObserver.disconnect();\n    (this.useWin ? win : this.element).removeEventListener('scroll', this);\n    scrollContainers.delete(this.element);\n  }\n}\n\n/**\n * @param {TargetsParam} target\n * @return {ScrollContainer}\n */\nconst registerAndGetScrollContainer = target => {\n  const $el = /** @type {HTMLElement} */(target ? parseTargets(target)[0] || doc.body : doc.body);\n  let scrollContainer = scrollContainers.get($el);\n  if (!scrollContainer) {\n    scrollContainer = new ScrollContainer($el);\n    scrollContainers.set($el, scrollContainer);\n  }\n  return scrollContainer;\n};\n\n/**\n * @param {HTMLElement} $el\n * @param {Number|string} v\n * @param {Number} size\n * @param {Number} [under]\n * @param {Number} [over]\n * @return {Number}\n */\nconst convertValueToPx = ($el, v, size, under, over) => {\n  const clampMin = v === 'min';\n  const clampMax = v === 'max';\n  const value = v === 'top' || v === 'left' || v === 'start' || clampMin ? 0 :\n                v === 'bottom' || v === 'right' || v === 'end' || clampMax ? '100%' :\n                v === 'center' ? '50%' :\n                v;\n  const { n, u } = decomposeRawValue(value, decomposedOriginalValue);\n  let px = n;\n  if (u === '%') {\n    px = (n / 100) * size;\n  } else if (u) {\n    px = convertValueUnit($el, decomposedOriginalValue, 'px', true).n;\n  }\n  if (clampMax && under < 0) px += under;\n  if (clampMin && over > 0) px += over;\n  return px;\n};\n\n/**\n * @param {HTMLElement} $el\n * @param {ScrollThresholdValue} v\n * @param {Number} size\n * @param {Number} [under]\n * @param {Number} [over]\n * @return {Number}\n */\nconst parseBoundValue = ($el, v, size, under, over) => {\n  /** @type {Number} */\n  let value;\n  if (isStr(v)) {\n    const matchedOperator = relativeValuesExecRgx.exec(/** @type {String} */(v));\n    if (matchedOperator) {\n      const splitter = matchedOperator[0];\n      const operator = splitter[0];\n      const splitted = /** @type {String} */(v).split(splitter);\n      const clampMin = splitted[0] === 'min';\n      const clampMax = splitted[0] === 'max';\n      const valueAPx = convertValueToPx($el, splitted[0], size, under, over);\n      const valueBPx = convertValueToPx($el, splitted[1], size, under, over);\n      if (clampMin) {\n        const min = getRelativeValue(convertValueToPx($el, 'min', size), valueBPx, operator);\n        value = min < valueAPx ? valueAPx : min;\n      } else if (clampMax) {\n        const max = getRelativeValue(convertValueToPx($el, 'max', size), valueBPx, operator);\n        value = max > valueAPx ? valueAPx : max;\n      } else {\n        value = getRelativeValue(valueAPx, valueBPx, operator);\n      }\n    } else {\n      value = convertValueToPx($el, v, size, under, over);\n    }\n  } else {\n    value = /** @type {Number} */(v);\n  }\n  return round(value, 0);\n};\n\n/**\n * @param {JSAnimation} linked\n * @return {HTMLElement}\n */\nconst getAnimationDomTarget = linked => {\n  let $linkedTarget;\n  const linkedTargets = linked.targets;\n  for (let i = 0, l = linkedTargets.length; i < l; i++) {\n    const target = linkedTargets[i];\n    if (target[isDomSymbol]) {\n      $linkedTarget = /** @type {HTMLElement} */(target);\n      break;\n    }\n  }\n  return $linkedTarget;\n};\n\nlet scrollerIndex = 0;\n\nconst debugColors = ['#FF4B4B','#FF971B','#FFC730','#F9F640','#7AFF5A','#18FF74','#17E09B','#3CFFEC','#05DBE9','#33B3F1','#638CF9','#C563FE','#FF4FCF','#F93F8A'];\n\nclass ScrollObserver {\n  /**\n   * @param {ScrollObserverParams} parameters\n   */\n  constructor(parameters = {}) {\n    if (scope.current) scope.current.register(this);\n    const syncMode = setValue(parameters.sync, 'play pause');\n    const ease = syncMode ? parseEase(/** @type {EasingParam} */(syncMode)) : null;\n    const isLinear = syncMode && (syncMode === 'linear' || syncMode === none);\n    const isEase = syncMode && !(ease === none && !isLinear);\n    const isSmooth = syncMode && (isNum(syncMode) || syncMode === true || isLinear);\n    const isMethods = syncMode && (isStr(syncMode) && !isEase && !isSmooth);\n    const syncMethods = isMethods ? /** @type {String} */(syncMode).split(' ').map(\n      (/** @type {String} */m) => () => {\n        const linked = this.linked;\n        return linked && linked[m] ? linked[m]() : null;\n      }\n    ) : null;\n    const biDirSync = isMethods && syncMethods.length > 2;\n    /** @type {Number} */\n    this.index = scrollerIndex++;\n    /** @type {String|Number} */\n    this.id = !isUnd(parameters.id) ? parameters.id : this.index;\n    /** @type {ScrollContainer} */\n    this.container = registerAndGetScrollContainer(parameters.container);\n    /** @type {HTMLElement} */\n    this.target = null;\n    /** @type {Tickable|WAAPIAnimation} */\n    this.linked = null;\n    /** @type {Boolean} */\n    this.repeat = null;\n    /** @type {Boolean} */\n    this.horizontal = null;\n    /** @type {ScrollThresholdParam|ScrollThresholdValue|ScrollThresholdCallback} */\n    this.enter = null;\n    /** @type {ScrollThresholdParam|ScrollThresholdValue|ScrollThresholdCallback} */\n    this.leave = null;\n    /** @type {Boolean} */\n    this.sync = isEase || isSmooth || !!syncMethods;\n    /** @type {EasingFunction} */\n    this.syncEase = isEase ? ease : null;\n    /** @type {Number} */\n    this.syncSmooth = isSmooth ? syncMode === true || isLinear ? 1 : /** @type {Number} */(syncMode) : null;\n    /** @type {Callback<ScrollObserver>} */\n    this.onSyncEnter = syncMethods && !biDirSync && syncMethods[0] ? syncMethods[0] : noop;\n    /** @type {Callback<ScrollObserver>} */\n    this.onSyncLeave = syncMethods && !biDirSync && syncMethods[1] ? syncMethods[1] : noop;\n    /** @type {Callback<ScrollObserver>} */\n    this.onSyncEnterForward = syncMethods && biDirSync && syncMethods[0] ? syncMethods[0] : noop;\n    /** @type {Callback<ScrollObserver>} */\n    this.onSyncLeaveForward = syncMethods && biDirSync && syncMethods[1] ? syncMethods[1] : noop;\n    /** @type {Callback<ScrollObserver>} */\n    this.onSyncEnterBackward = syncMethods && biDirSync && syncMethods[2] ? syncMethods[2] : noop;\n    /** @type {Callback<ScrollObserver>} */\n    this.onSyncLeaveBackward = syncMethods && biDirSync && syncMethods[3] ? syncMethods[3] : noop;\n    /** @type {Callback<ScrollObserver>} */\n    this.onEnter = parameters.onEnter || noop;\n    /** @type {Callback<ScrollObserver>} */\n    this.onLeave = parameters.onLeave || noop;\n    /** @type {Callback<ScrollObserver>} */\n    this.onEnterForward = parameters.onEnterForward || noop;\n    /** @type {Callback<ScrollObserver>} */\n    this.onLeaveForward = parameters.onLeaveForward || noop;\n    /** @type {Callback<ScrollObserver>} */\n    this.onEnterBackward = parameters.onEnterBackward || noop;\n    /** @type {Callback<ScrollObserver>} */\n    this.onLeaveBackward = parameters.onLeaveBackward || noop;\n    /** @type {Callback<ScrollObserver>} */\n    this.onUpdate = parameters.onUpdate || noop;\n    /** @type {Callback<ScrollObserver>} */\n    this.onResize = parameters.onResize || noop;\n    /** @type {Callback<ScrollObserver>} */\n    this.onSyncComplete = parameters.onSyncComplete || noop;\n    /** @type {Boolean} */\n    this.reverted = false;\n    /** @type {Boolean} */\n    this.ready = false;\n    /** @type {Boolean} */\n    this.completed = false;\n    /** @type {Boolean} */\n    this.began = false;\n    /** @type {Boolean} */\n    this.isInView = false;\n    /** @type {Boolean} */\n    this.forceEnter = false;\n    /** @type {Boolean} */\n    this.hasEntered = false;\n    /** @type {Number} */\n    this.offset = 0;\n    /** @type {Number} */\n    this.offsetStart = 0;\n    /** @type {Number} */\n    this.offsetEnd = 0;\n    /** @type {Number} */\n    this.distance = 0;\n    /** @type {Number} */\n    this.prevProgress = 0;\n    /** @type {Array} */\n    this.thresholds = ['start', 'end', 'end', 'start'];\n    /** @type {[Number, Number, Number, Number]} */\n    this.coords = [0, 0, 0, 0];\n    /** @type {JSAnimation} */\n    this.debugStyles = null;\n    /** @type {HTMLElement} */\n    this.$debug = null;\n    /** @type {ScrollObserverParams} */\n    this._params = parameters;\n    /** @type {Boolean} */\n    this._debug = setValue(parameters.debug, false);\n    /** @type {ScrollObserver} */\n    this._next = null;\n    /** @type {ScrollObserver} */\n    this._prev = null;\n    addChild(this.container, this);\n    // Wait for the next frame to add to the container in order to handle calls to link()\n    sync(() => {\n      if (this.reverted) return;\n      if (!this.target) {\n        const target = /** @type {HTMLElement} */(parseTargets(parameters.target)[0]);\n        this.target = target || doc.body;\n        this.refresh();\n      }\n      if (this._debug) this.debug();\n    });\n  }\n\n  /**\n   * @param {Tickable|WAAPIAnimation} linked\n   */\n  link(linked) {\n    if (linked) {\n      // Make sure to pause the linked object in case it's added later\n      linked.pause();\n      this.linked = linked;\n      // Forces WAAPI Animation to persist; otherwise, they will stop syncing on finish.\n      if (!isUnd(linked) && !isUnd(/** @type {WAAPIAnimation} */(linked).persist)) {\n        /** @type {WAAPIAnimation} */(linked).persist = true;\n      }\n      // Try to use a target of the linked object if no target parameters specified\n      if (!this._params.target) {\n        /** @type {HTMLElement} */\n        let $linkedTarget;\n        if (!isUnd(/** @type {JSAnimation} */(linked).targets)) {\n          $linkedTarget = getAnimationDomTarget(/** @type {JSAnimation} */(linked));\n        } else {\n          forEachChildren(/** @type {Timeline} */(linked), (/** @type {JSAnimation} */child) => {\n            if (child.targets && !$linkedTarget) {\n              $linkedTarget = getAnimationDomTarget(/** @type {JSAnimation} */(child));\n            }\n          });\n        }\n        // Fallback to body if no target found\n        this.target = $linkedTarget || doc.body;\n        this.refresh();\n      }\n    }\n    return this;\n  }\n\n  get velocity() {\n    return this.container.velocity;\n  }\n\n  get backward() {\n    return this.horizontal ? this.container.backwardX : this.container.backwardY;\n  }\n\n  get scroll() {\n    return this.horizontal ? this.container.scrollX : this.container.scrollY;\n  }\n\n  get progress() {\n    const p = (this.scroll - this.offsetStart) / this.distance;\n    return p === Infinity || isNaN(p) ? 0 : round(clamp(p, 0, 1), 6);\n  }\n\n  refresh() {\n    // This flag is used to prevent running handleScroll() outside of this.refresh() with values not yet calculated\n    this.ready = true;\n    this.reverted = false;\n    const params = this._params;\n    this.repeat = setValue(parseScrollObserverFunctionParameter(params.repeat, this), true);\n    this.horizontal = setValue(parseScrollObserverFunctionParameter(params.axis, this), 'y') === 'x';\n    this.enter = setValue(parseScrollObserverFunctionParameter(params.enter, this), 'end start');\n    this.leave = setValue(parseScrollObserverFunctionParameter(params.leave, this), 'start end');\n    this.updateBounds();\n    this.handleScroll();\n    return this;\n  }\n\n  removeDebug() {\n    if (this.$debug) {\n      this.$debug.parentNode.removeChild(this.$debug);\n      this.$debug = null;\n    }\n    if (this.debugStyles) {\n      this.debugStyles.revert();\n      this.$debug = null;\n    }\n    return this;\n  }\n\n  debug() {\n    this.removeDebug();\n    const container = this.container;\n    const isHori = this.horizontal;\n    const $existingDebug = container.element.querySelector(':scope > .animejs-onscroll-debug');\n    const $debug = doc.createElement('div');\n    const $thresholds = doc.createElement('div');\n    const $triggers = doc.createElement('div');\n    const color = debugColors[this.index % debugColors.length];\n    const useWin = container.useWin;\n    const containerWidth = useWin ? container.winWidth : container.width;\n    const containerHeight = useWin ? container.winHeight : container.height;\n    const scrollWidth = container.scrollWidth;\n    const scrollHeight = container.scrollHeight;\n    const size = this.container.width > 360 ? 320 : 260;\n    const offLeft = isHori ? 0 : 10;\n    const offTop = isHori ? 10 : 0;\n    const half = isHori ? 24 : size / 2;\n    const labelHeight = isHori ? half : 15;\n    const labelWidth = isHori ? 60 : half;\n    const labelSize = isHori ? labelWidth : labelHeight;\n    const repeat = isHori ? 'repeat-x' : 'repeat-y';\n    /**\n     * @param {Number} v\n     * @return {String}\n     */\n    const gradientOffset = v => isHori ? '0px '+(v)+'px' : (v)+'px'+' 2px';\n    /**\n     * @param {String} c\n     * @return {String}\n     */\n    const lineCSS = (c) => `linear-gradient(${isHori ? 90 : 0}deg, ${c} 2px, transparent 1px)`;\n    /**\n     * @param {String} p\n     * @param {Number} l\n     * @param {Number} t\n     * @param {Number} w\n     * @param {Number} h\n     * @return {String}\n     */\n    const baseCSS = (p, l, t, w, h) => `position:${p};left:${l}px;top:${t}px;width:${w}px;height:${h}px;`;\n    $debug.style.cssText = `${baseCSS('absolute', offLeft, offTop, isHori ? scrollWidth : size, isHori ? size : scrollHeight)}\n      pointer-events: none;\n      z-index: ${this.container.zIndex++};\n      display: flex;\n      flex-direction: ${isHori ? 'column' : 'row'};\n      filter: drop-shadow(0px 1px 0px rgba(0,0,0,.75));\n    `;\n    $thresholds.style.cssText = `${baseCSS('sticky', 0, 0, isHori ? containerWidth : half, isHori ? half : containerHeight)}`;\n    if (!$existingDebug) {\n      $thresholds.style.cssText += `background:\n        ${lineCSS('#FFFF')}${gradientOffset(half-10)} / ${isHori ? '100px 100px' : '100px 100px'} ${repeat},\n        ${lineCSS('#FFF8')}${gradientOffset(half-10)} / ${isHori ? '10px 10px' : '10px 10px'} ${repeat};\n      `;\n    }\n    $triggers.style.cssText = `${baseCSS('relative', 0, 0, isHori ? scrollWidth : half, isHori ? half : scrollHeight)}`;\n    if (!$existingDebug) {\n      $triggers.style.cssText += `background:\n        ${lineCSS('#FFFF')}${gradientOffset(0)} / ${isHori ? '100px 10px' : '10px 100px'} ${repeat},\n        ${lineCSS('#FFF8')}${gradientOffset(0)} / ${isHori ? '10px 0px' : '0px 10px'} ${repeat};\n      `;\n    }\n    const labels = [' enter: ', ' leave: '];\n    this.coords.forEach((v, i) => {\n      const isView = i > 1;\n      const value = (isView ? 0 : this.offset) + v;\n      const isTail = i % 2;\n      const isFirst = value < labelSize;\n      const isOver = value > (isView ? isHori ? containerWidth : containerHeight : isHori ? scrollWidth : scrollHeight) - labelSize;\n      const isFlip = (isView ? isTail && !isFirst : !isTail && !isFirst) || isOver;\n      const $label = doc.createElement('div');\n      const $text = doc.createElement('div');\n      const dirProp = isHori ? isFlip ? 'right' : 'left' : isFlip ? 'bottom' : 'top';\n      const flipOffset = isFlip ? (isHori ? labelWidth : labelHeight) + (!isView ? isHori ? -1 : -2 : isHori ? -1 : isOver ? 0 : -2) : !isView ? isHori ? 1 : 0 : isHori ? 1 : 0;\n      // $text.innerHTML = `${!isView ? '' : labels[isTail] + ' '}${this.id}: ${this.thresholds[i]} ${isView ? '' : labels[isTail]}`;\n      $text.innerHTML = `${this.id}${labels[isTail]}${this.thresholds[i]}`;\n      $label.style.cssText = `${baseCSS('absolute', 0, 0, labelWidth, labelHeight)}\n        display: flex;\n        flex-direction: ${isHori ? 'column' : 'row'};\n        justify-content: flex-${isView ? 'start' : 'end'};\n        align-items: flex-${isFlip ? 'end' : 'start'};\n        border-${dirProp}: 2px ${isTail ? 'solid' : 'solid'} ${color};\n      `;\n      $text.style.cssText = `\n        overflow: hidden;\n        max-width: ${(size / 2) - 10}px;\n        height: ${labelHeight};\n        margin-${isHori ? isFlip ? 'right' : 'left' : isFlip ? 'bottom' : 'top'}: -2px;\n        padding: 1px;\n        font-family: ui-monospace, monospace;\n        font-size: 10px;\n        letter-spacing: -.025em;\n        line-height: 9px;\n        font-weight: 600;\n        text-align: ${isHori && isFlip || !isHori && !isView ? 'right' : 'left'};\n        white-space: pre;\n        text-overflow: ellipsis;\n        color: ${isTail ? color : 'rgba(0,0,0,.75)'};\n        background-color: ${isTail ? 'rgba(0,0,0,.65)' : color};\n        border: 2px solid ${isTail ? color : 'transparent'};\n        border-${isHori ? isFlip ? 'top-left' : 'top-right' : isFlip ? 'top-left' : 'bottom-left'}-radius: 5px;\n        border-${isHori ? isFlip ? 'bottom-left' : 'bottom-right' : isFlip ? 'top-right' : 'bottom-right'}-radius: 5px;\n      `;\n      $label.appendChild($text);\n      let position = value - flipOffset + (isHori ? 1 : 0);\n      $label.style[isHori ? 'left' : 'top'] = `${position}px`;\n      // $label.style[isHori ? 'left' : 'top'] = value - flipOffset + (!isFlip && isFirst && !isView ? 1 : isFlip ? 0 : -2) + 'px';\n      (isView ? $thresholds : $triggers).appendChild($label);\n    });\n\n    $debug.appendChild($thresholds);\n    $debug.appendChild($triggers);\n    container.element.appendChild($debug);\n\n    if (!$existingDebug) $debug.classList.add('animejs-onscroll-debug');\n    this.$debug = $debug;\n    const containerPosition = get(container.element, 'position');\n    if (containerPosition === 'static') {\n      this.debugStyles = set(container.element, { position: 'relative '});\n    }\n\n  }\n\n  updateBounds() {\n    if (this._debug) {\n      this.removeDebug();\n    }\n    let stickys;\n    const $target = this.target;\n    const container = this.container;\n    const isHori = this.horizontal;\n    const linked = this.linked;\n    let linkedTime;\n    let $el = $target;\n    // let offsetX = 0;\n    // let offsetY = 0;\n    // let $offsetParent = $el;\n    if (linked) {\n      linkedTime = linked.currentTime;\n      linked.seek(0, true);\n    }\n    // Old implementation to get offset and targetSize before fixing https://github.com/juliangarnier/anime/issues/1021\n    // const isContainerStatic = get(container.element, 'position') === 'static' ? set(container.element, { position: 'relative '}) : false;\n    // while ($el && $el !== container.element && $el !== doc.body) {\n    //   const isSticky = get($el, 'position') === 'sticky' ?\n    //                    set($el, { position: 'static' }) :\n    //                    false;\n    //   if ($el === $offsetParent) {\n    //     offsetX += $el.offsetLeft || 0;\n    //     offsetY += $el.offsetTop || 0;\n    //     $offsetParent = $el.offsetParent;\n    //   }\n    //   $el = /** @type {HTMLElement} */($el.parentElement);\n    //   if (isSticky) {\n    //     if (!stickys) stickys = [];\n    //     stickys.push(isSticky);\n    //   }\n    // }\n    // if (isContainerStatic) isContainerStatic.revert();\n    // const offset = isHori ? offsetX : offsetY;\n    // const targetSize = isHori ? $target.offsetWidth : $target.offsetHeight;\n\n    while ($el && $el !== container.element && $el !== doc.body) {\n      const isSticky = get($el, 'position') === 'sticky' ? set($el, { position: 'static' }) : false;\n      $el = $el.parentElement;\n      if (isSticky) {\n        if (!stickys) stickys = [];\n        stickys.push(isSticky);\n      }\n    }\n    const rect = $target.getBoundingClientRect();\n    const scale = container.scale;\n    const offset = (isHori ? rect.left + container.scrollX - container.left : rect.top + container.scrollY - container.top) * scale;\n    const targetSize = (isHori ? rect.width : rect.height) * scale;\n    const containerSize = isHori ? container.width : container.height;\n    const scrollSize = isHori ? container.scrollWidth : container.scrollHeight;\n    const maxScroll = scrollSize - containerSize;\n    const enter = this.enter;\n    const leave = this.leave;\n\n    /** @type {ScrollThresholdValue} */\n    let enterTarget = 'start';\n    /** @type {ScrollThresholdValue} */\n    let leaveTarget = 'end';\n    /** @type {ScrollThresholdValue} */\n    let enterContainer = 'end';\n    /** @type {ScrollThresholdValue} */\n    let leaveContainer = 'start';\n\n    if (isStr(enter)) {\n      const splitted = /** @type {String} */(enter).split(' ');\n      enterContainer = splitted[0];\n      enterTarget = splitted.length > 1 ? splitted[1] : enterTarget;\n    } else if (isObj(enter)) {\n      const e = /** @type {ScrollThresholdParam} */(enter);\n      if (!isUnd(e.container)) enterContainer = e.container;\n      if (!isUnd(e.target)) enterTarget = e.target;\n    } else if (isNum(enter)) {\n      enterContainer = /** @type {Number} */(enter);\n    }\n\n    if (isStr(leave)) {\n      const splitted = /** @type {String} */(leave).split(' ');\n      leaveContainer = splitted[0];\n      leaveTarget = splitted.length > 1 ? splitted[1] : leaveTarget;\n    } else if (isObj(leave)) {\n      const t = /** @type {ScrollThresholdParam} */(leave);\n      if (!isUnd(t.container)) leaveContainer = t.container;\n      if (!isUnd(t.target)) leaveTarget = t.target;\n    } else if (isNum(leave)) {\n      leaveContainer = /** @type {Number} */(leave);\n    }\n\n    const parsedEnterTarget = parseBoundValue($target, enterTarget, targetSize);\n    const parsedLeaveTarget = parseBoundValue($target, leaveTarget, targetSize);\n    const under = (parsedEnterTarget + offset) - containerSize;\n    const over = (parsedLeaveTarget + offset) - maxScroll;\n    const parsedEnterContainer = parseBoundValue($target, enterContainer, containerSize, under, over);\n    const parsedLeaveContainer = parseBoundValue($target, leaveContainer, containerSize, under, over);\n    const offsetStart = parsedEnterTarget + offset - parsedEnterContainer;\n    const offsetEnd = parsedLeaveTarget + offset - parsedLeaveContainer;\n    const scrollDelta = offsetEnd - offsetStart;\n    this.offset = offset;\n    this.offsetStart = offsetStart;\n    this.offsetEnd = offsetEnd;\n    this.distance = scrollDelta <= 0 ? 0 : scrollDelta;\n    this.thresholds = [enterTarget, leaveTarget, enterContainer, leaveContainer];\n    this.coords = [parsedEnterTarget, parsedLeaveTarget, parsedEnterContainer, parsedLeaveContainer];\n    if (stickys) {\n      stickys.forEach(sticky => sticky.revert());\n    }\n    if (linked) {\n      linked.seek(linkedTime, true);\n    }\n    if (this._debug) {\n      this.debug();\n    }\n  }\n\n  handleScroll() {\n    if (!this.ready) return;\n    const linked = this.linked;\n    const sync = this.sync;\n    const syncEase = this.syncEase;\n    const syncSmooth = this.syncSmooth;\n    const shouldSeek = linked && (syncEase || syncSmooth);\n    const isHori = this.horizontal;\n    const container = this.container;\n    const scroll = this.scroll;\n    const isBefore = scroll <= this.offsetStart;\n    const isAfter = scroll >= this.offsetEnd;\n    const isInView = !isBefore && !isAfter;\n    const isOnTheEdge = scroll === this.offsetStart || scroll === this.offsetEnd;\n    const forceEnter = !this.hasEntered && isOnTheEdge;\n    const $debug = this._debug && this.$debug;\n    let hasUpdated = false;\n    let syncCompleted = false;\n    let p = this.progress;\n\n    if (isBefore && this.began) {\n      this.began = false;\n    }\n\n    if (p > 0 && !this.began) {\n      this.began = true;\n    }\n\n    if (shouldSeek) {\n      const lp = linked.progress;\n      if (syncSmooth && isNum(syncSmooth)) {\n        if (/** @type {Number} */(syncSmooth) < 1) {\n          const step = 0.0001;\n          const snap = lp < p && p === 1 ? step : lp > p && !p ? -step : 0;\n          p = round(lerp(lp, p, lerp(.01, .2, /** @type {Number} */(syncSmooth))) + snap, 6);\n        }\n      } else if (syncEase) {\n        p = syncEase(p);\n      }\n      hasUpdated = p !== this.prevProgress;\n      syncCompleted = lp === 1;\n      if (hasUpdated && !syncCompleted && (syncSmooth && lp)) {\n        container.wakeTicker.restart();\n      }\n    }\n\n    if ($debug) {\n      const sticky = isHori ? container.scrollY : container.scrollX;\n      $debug.style[isHori ? 'top' : 'left'] = sticky + 10 + 'px';\n    }\n\n    // Trigger enter callbacks if already in view or when entering the view\n    if ((isInView && !this.isInView) || (forceEnter && !this.forceEnter && !this.hasEntered)) {\n      if (isInView) this.isInView = true;\n      if (!this.forceEnter || !this.hasEntered) {\n        if ($debug && isInView) $debug.style.zIndex = `${this.container.zIndex++}`;\n        this.onSyncEnter(this);\n        this.onEnter(this);\n        if (this.backward) {\n          this.onSyncEnterBackward(this);\n          this.onEnterBackward(this);\n        } else {\n          this.onSyncEnterForward(this);\n          this.onEnterForward(this);\n        }\n        this.hasEntered = true;\n        if (forceEnter) this.forceEnter = true;\n      } else if (isInView) {\n        this.forceEnter = false;\n      }\n    }\n\n    if (isInView || !isInView && this.isInView) {\n      hasUpdated = true;\n    }\n\n    if (hasUpdated) {\n      if (shouldSeek) linked.seek(linked.duration * p);\n      this.onUpdate(this);\n    }\n\n    if (!isInView && this.isInView) {\n      this.isInView = false;\n      this.onSyncLeave(this);\n      this.onLeave(this);\n      if (this.backward) {\n        this.onSyncLeaveBackward(this);\n        this.onLeaveBackward(this);\n      } else {\n        this.onSyncLeaveForward(this);\n        this.onLeaveForward(this);\n      }\n      if (sync && !syncSmooth) {\n        syncCompleted = true;\n      }\n    }\n\n    if (p >= 1 && this.began && !this.completed && (sync && syncCompleted || !sync)) {\n      if (sync) {\n        this.onSyncComplete(this);\n      }\n      this.completed = true;\n      if ((!this.repeat && !linked) || (!this.repeat && linked && linked.completed)) {\n        this.revert();\n      }\n    }\n\n    if (p < 1 && this.completed) {\n      this.completed = false;\n    }\n\n    this.prevProgress = p;\n  }\n\n  revert() {\n    if (this.reverted) return;\n    const container = this.container;\n    removeChild(container, this);\n    if (!container._head) {\n      container.revert();\n    }\n    if (this._debug) {\n      this.removeDebug();\n    }\n    this.reverted = true;\n    this.ready = false;\n    return this;\n  }\n\n}\n\n/**\n * @param {ScrollObserverParams} [parameters={}]\n * @return {ScrollObserver}\n */\nconst onScroll = (parameters = {}) => new ScrollObserver(parameters);\n\nexport { ScrollObserver, onScroll, scrollContainers };\n","/**\n * Anime.js - easings - ESM\n * @version v4.3.6\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { abs } from '../../core/helpers.js';\nimport { none } from '../none.js';\n\n/**\n * @import {\n *   EasingFunction,\n * } from '../../types/index.js'\n*/\n\n/**\n * Cubic Bezier solver adapted from https://github.com/gre/bezier-easing\n * (c) 2014 Gaëtan Renaudeau\n */\n\n/**\n * @param  {Number} aT\n * @param  {Number} aA1\n * @param  {Number} aA2\n * @return {Number}\n */\nconst calcBezier = (aT, aA1, aA2) => (((1 - 3 * aA2 + 3 * aA1) * aT + (3 * aA2 - 6 * aA1)) * aT + (3 * aA1)) * aT;\n\n/**\n * @param  {Number} aX\n * @param  {Number} mX1\n * @param  {Number} mX2\n * @return {Number}\n */\nconst binarySubdivide = (aX, mX1, mX2) => {\n  let aA = 0, aB = 1, currentX, currentT, i = 0;\n  do {\n    currentT = aA + (aB - aA) / 2;\n    currentX = calcBezier(currentT, mX1, mX2) - aX;\n    if (currentX > 0) {\n      aB = currentT;\n    } else {\n      aA = currentT;\n    }\n  } while (abs(currentX) > .0000001 && ++i < 100);\n  return currentT;\n};\n\n/**\n * @param  {Number} [mX1] The x coordinate of the first point\n * @param  {Number} [mY1] The y coordinate of the first point\n * @param  {Number} [mX2] The x coordinate of the second point\n * @param  {Number} [mY2] The y coordinate of the second point\n * @return {EasingFunction}\n */\n\nconst cubicBezier = (mX1 = 0.5, mY1 = 0.0, mX2 = 0.5, mY2 = 1.0) => (mX1 === mY1 && mX2 === mY2) ? none :\n  t => t === 0 || t === 1 ? t :\n  calcBezier(binarySubdivide(t, mX1, mX2), mY1, mY2);\n\nexport { cubicBezier };\n","/**\n * Anime.js - easings - ESM\n * @version v4.3.6\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { ceil, floor, clamp } from '../../core/helpers.js';\n\n/**\n * @import {\n *   EasingFunction,\n * } from '../../types/index.js'\n*/\n\n/**\n * Steps ease implementation https://developer.mozilla.org/fr/docs/Web/CSS/transition-timing-function\n * Only covers 'end' and 'start' jumpterms\n * @param  {Number} steps\n * @param  {Boolean} [fromStart]\n * @return {EasingFunction}\n */\nconst steps = (steps = 10, fromStart) => {\n  const roundMethod = fromStart ? ceil : floor;\n  return t => roundMethod(clamp(t, 0, 1) * steps) * (1 / steps);\n};\n\nexport { steps };\n","/**\n * Anime.js - easings - ESM\n * @version v4.3.6\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { isStr, parseNumber, isUnd } from '../../core/helpers.js';\nimport { none } from '../none.js';\n\n/**\n * @import {\n *   EasingFunction,\n * } from '../../types/index.js'\n*/\n\n/**\n * Without parameters, the linear function creates a non-eased transition.\n * Parameters, if used, creates a piecewise linear easing by interpolating linearly between the specified points.\n *\n * @param  {...(String|Number)} args - Points\n * @return {EasingFunction}\n */\nconst linear = (...args) => {\n  const argsLength = args.length;\n  if (!argsLength) return none;\n  const totalPoints = argsLength - 1;\n  const firstArg = args[0];\n  const lastArg = args[totalPoints];\n  const xPoints = [0];\n  const yPoints = [parseNumber(firstArg)];\n  for (let i = 1; i < totalPoints; i++) {\n    const arg = args[i];\n    const splitValue = isStr(arg) ?\n    /** @type {String} */(arg).trim().split(' ') :\n    [arg];\n    const value = splitValue[0];\n    const percent = splitValue[1];\n    xPoints.push(!isUnd(percent) ? parseNumber(percent) / 100 : i / totalPoints);\n    yPoints.push(parseNumber(value));\n  }\n  yPoints.push(parseNumber(lastArg));\n  xPoints.push(1);\n  return function easeLinear(t) {\n    for (let i = 1, l = xPoints.length; i < l; i++) {\n      const currentX = xPoints[i];\n      if (t <= currentX) {\n        const prevX = xPoints[i - 1];\n        const prevY = yPoints[i - 1];\n        return prevY + (yPoints[i] - prevY) * (t - prevX) / (currentX - prevX);\n      }\n    }\n    return yPoints[yPoints.length - 1];\n  }\n};\n\nexport { linear };\n","/**\n * Anime.js - easings - ESM\n * @version v4.3.6\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { clamp } from '../../core/helpers.js';\nimport { linear } from '../linear/index.js';\n\n/**\n * @import {\n *   EasingFunction,\n * } from '../../types/index.js'\n*/\n\n/**\n * Generate random steps\n * @param  {Number} [length] - The number of steps\n * @param  {Number} [randomness] - How strong the randomness is\n * @return {EasingFunction}\n */\nconst irregular = (length = 10, randomness = 1) => {\n  const values = [0];\n  const total = length - 1;\n  for (let i = 1; i < total; i++) {\n    const previousValue = values[i - 1];\n    const spacing = i / total;\n    const segmentEnd = (i + 1) / total;\n    const randomVariation = spacing + (segmentEnd - spacing) * Math.random();\n    // Mix the even spacing and random variation based on the randomness parameter\n    const randomValue = spacing * (1 - randomness) + randomVariation * randomness;\n    values.push(clamp(randomValue, previousValue, 1));\n  }\n  values.push(1);\n  return linear(...values);\n};\n\nexport { irregular };\n","/**\n * Anime.js - waapi - ESM\n * @version v4.3.6\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { isNil, isUnd, stringStartsWith, isKey, isObj, isArr, isStr, toLowerCase, round, isFnc, isNum } from '../core/helpers.js';\nimport { scope, globals } from '../core/globals.js';\nimport { registerTargets } from '../core/targets.js';\nimport { setValue, getFunctionValue } from '../core/values.js';\nimport { isBrowser, validTransforms, noop, transformsSymbol, shortTransforms, transformsFragmentStrings, emptyString, K } from '../core/consts.js';\nimport { none } from '../easings/none.js';\nimport { parseEaseString } from '../easings/eases/parser.js';\nimport { addWAAPIAnimation } from './composition.js';\n\n/**\n * @import {\n *   Callback,\n *   EasingFunction,\n *   EasingParam,\n *   DOMTarget,\n *   DOMTargetsParam,\n *   DOMTargetsArray,\n *   WAAPIAnimationParams,\n *   WAAPITweenOptions,\n *   WAAPIKeyframeValue,\n *   WAAPITweenValue\n * } from '../types/index.js'\n*/\n\n/**\n * @import {\n *   Spring,\n * } from '../easings/spring/index.js'\n*/\n\n/**\n * @import {\n *   ScrollObserver,\n * } from '../events/scroll.js'\n*/\n\n/**\n * Converts an easing function into a valid CSS linear() timing function string\n * @param {EasingFunction} fn\n * @param {number} [samples=100]\n * @returns {string} CSS linear() timing function\n */\nconst easingToLinear = (fn, samples = 100) => {\n  const points = [];\n  for (let i = 0; i <= samples; i++) points.push(round(fn(i / samples), 4));\n  return `linear(${points.join(', ')})`;\n};\n\nconst WAAPIEasesLookups = {};\n\n/**\n * @param  {EasingParam} ease\n * @return {String}\n */\nconst parseWAAPIEasing = (ease) => {\n  let parsedEase = WAAPIEasesLookups[ease];\n  if (parsedEase) return parsedEase;\n  parsedEase = 'linear';\n  if (isStr(ease)) {\n    if (\n      stringStartsWith(ease, 'linear') ||\n      stringStartsWith(ease, 'cubic-') ||\n      stringStartsWith(ease, 'steps') ||\n      stringStartsWith(ease, 'ease')\n    ) {\n      parsedEase = ease;\n    } else if (stringStartsWith(ease, 'cubicB')) {\n      parsedEase = toLowerCase(ease);\n    } else {\n      const parsed = parseEaseString(ease);\n      if (isFnc(parsed)) parsedEase = parsed === none ? 'linear' : easingToLinear(parsed);\n    }\n    // Only cache string based easing name, otherwise function arguments get lost\n    WAAPIEasesLookups[ease] = parsedEase;\n  } else if (isFnc(ease)) {\n    const easing = easingToLinear(ease);\n    if (easing) parsedEase = easing;\n  } else if (/** @type {Spring} */(ease).ease) {\n    parsedEase = easingToLinear(/** @type {Spring} */(ease).ease);\n  }\n  return parsedEase;\n};\n\nconst transformsShorthands = ['x', 'y', 'z'];\nconst commonDefaultPXProperties = [\n  'perspective',\n  'width',\n  'height',\n  'margin',\n  'padding',\n  'top',\n  'right',\n  'bottom',\n  'left',\n  'borderWidth',\n  'fontSize',\n  'borderRadius',\n  ...transformsShorthands\n];\n\nconst validIndividualTransforms = /*#__PURE__*/ (() => [...transformsShorthands, ...validTransforms.filter(t => ['X', 'Y', 'Z'].some(axis => t.endsWith(axis)))])();\n\nlet transformsPropertiesRegistered = null;\n\n/**\n * @param  {String} propName\n * @param  {WAAPIKeyframeValue} value\n * @param  {DOMTarget} $el\n * @param  {Number} i\n * @param  {Number} targetsLength\n * @return {String}\n */\nconst normalizeTweenValue = (propName, value, $el, i, targetsLength) => {\n  // Do not try to compute strings with getFunctionValue otherwise it will convert CSS variables\n  let v = isStr(value) ? value : getFunctionValue(/** @type {any} */(value), $el, i, targetsLength);\n  if (!isNum(v)) return v;\n  if (commonDefaultPXProperties.includes(propName) || stringStartsWith(propName, 'translate')) return `${v}px`;\n  if (stringStartsWith(propName, 'rotate') || stringStartsWith(propName, 'skew')) return `${v}deg`;\n  return `${v}`;\n};\n\n/**\n * @param  {DOMTarget} $el\n * @param  {String} propName\n * @param  {WAAPIKeyframeValue} from\n * @param  {WAAPIKeyframeValue} to\n * @param  {Number} i\n * @param  {Number} targetsLength\n * @return {WAAPITweenValue}\n */\nconst parseIndividualTweenValue = ($el, propName, from, to, i, targetsLength) => {\n  /** @type {WAAPITweenValue} */\n  let tweenValue = '0';\n  const computedTo = !isUnd(to) ? normalizeTweenValue(propName, to, $el, i, targetsLength) : getComputedStyle($el)[propName];\n  if (!isUnd(from)) {\n    const computedFrom = normalizeTweenValue(propName, from, $el, i, targetsLength);\n    tweenValue = [computedFrom, computedTo];\n  } else {\n    tweenValue = isArr(to) ? to.map((/** @type {any} */v) => normalizeTweenValue(propName, v, $el, i, targetsLength)) : computedTo;\n  }\n  return tweenValue;\n};\n\nclass WAAPIAnimation {\n/**\n * @param {DOMTargetsParam} targets\n * @param {WAAPIAnimationParams} params\n */\n  constructor(targets, params) {\n\n    if (scope.current) scope.current.register(this);\n\n    // Skip the registration and fallback to no animation in case CSS.registerProperty is not supported\n    if (isNil(transformsPropertiesRegistered)) {\n      if (isBrowser && (isUnd(CSS) || !Object.hasOwnProperty.call(CSS, 'registerProperty'))) {\n        transformsPropertiesRegistered = false;\n      } else {\n        validTransforms.forEach(t => {\n          const isSkew = stringStartsWith(t, 'skew');\n          const isScale = stringStartsWith(t, 'scale');\n          const isRotate = stringStartsWith(t, 'rotate');\n          const isTranslate = stringStartsWith(t, 'translate');\n          const isAngle = isRotate || isSkew;\n          const syntax = isAngle ? '<angle>' : isScale ? \"<number>\" : isTranslate ? \"<length-percentage>\" : \"*\";\n          try {\n            CSS.registerProperty({\n              name: '--' + t,\n              syntax,\n              inherits: false,\n              initialValue: isTranslate ? '0px' : isAngle ? '0deg' : isScale ? '1' : '0',\n            });\n          } catch {}        });\n        transformsPropertiesRegistered = true;\n      }\n    }\n\n    const parsedTargets = registerTargets(targets);\n    const targetsLength = parsedTargets.length;\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    const autoplay = setValue(params.autoplay, globals.defaults.autoplay);\n    const scroll = autoplay && /** @type {ScrollObserver} */(autoplay).link ? autoplay : false;\n    const alternate = params.alternate && /** @type {Boolean} */(params.alternate) === true;\n    const reversed = params.reversed && /** @type {Boolean} */(params.reversed) === true;\n    const loop = setValue(params.loop, globals.defaults.loop);\n    const iterations = /** @type {Number} */((loop === true || loop === Infinity) ? Infinity : isNum(loop) ? loop + 1 : 1);\n    /** @type {PlaybackDirection} */\n    const direction = alternate ? reversed ? 'alternate-reverse' : 'alternate' : reversed ? 'reverse' : 'normal';\n    /** @type {FillMode} */\n    const fill = 'both'; // We use 'both' here because the animation can be reversed during playback\n    const timeScale = (globals.timeScale === 1 ? 1 : K);\n\n    /** @type {DOMTargetsArray}] */\n    this.targets = parsedTargets;\n    /** @type {Array<globalThis.Animation>}] */\n    this.animations = [];\n    /** @type {globalThis.Animation}] */\n    this.controlAnimation = null;\n    /** @type {Callback<this>} */\n    this.onComplete = params.onComplete || /** @type {Callback<WAAPIAnimation>} */(/** @type {unknown} */(globals.defaults.onComplete));\n    /** @type {Number} */\n    this.duration = 0;\n    /** @type {Boolean} */\n    this.muteCallbacks = false;\n    /** @type {Boolean} */\n    this.completed = false;\n    /** @type {Boolean} */\n    this.paused = !autoplay || scroll !== false;\n    /** @type {Boolean} */\n    this.reversed = reversed;\n    /** @type {Boolean} */\n    this.persist = setValue(params.persist, globals.defaults.persist);\n    /** @type {Boolean|ScrollObserver} */\n    this.autoplay = autoplay;\n    /** @type {Number} */\n    this._speed = setValue(params.playbackRate, globals.defaults.playbackRate);\n    /** @type {Function} */\n    this._resolve = noop; // Used by .then()\n    /** @type {Number} */\n    this._completed = 0;\n    /** @type {Array.<Object>} */\n    this._inlineStyles = [];\n\n    parsedTargets.forEach(($el, i) => {\n\n      const cachedTransforms = $el[transformsSymbol];\n      const hasIndividualTransforms = validIndividualTransforms.some(t => params.hasOwnProperty(t));\n      const elStyle = $el.style;\n      const inlineStyles = this._inlineStyles[i] = {};\n\n      const easeToParse = setValue(params.ease, globals.defaults.ease);\n\n      const easeFunctionResult = getFunctionValue(easeToParse, $el, i, targetsLength);\n      const keyEasing = isFnc(easeFunctionResult) || isStr(easeFunctionResult) ? easeFunctionResult : easeToParse;\n\n      const spring = /** @type {Spring} */(easeToParse).ease && easeToParse;\n      /** @type {String} */\n      const easing = parseWAAPIEasing(keyEasing);\n\n      /** @type {Number} */\n      const duration = (spring ? /** @type {Spring} */(spring).settlingDuration : getFunctionValue(setValue(params.duration, globals.defaults.duration), $el, i, targetsLength)) * timeScale;\n      /** @type {Number} */\n      const delay = getFunctionValue(setValue(params.delay, globals.defaults.delay), $el, i, targetsLength) * timeScale;\n      /** @type {CompositeOperation} */\n      const composite = /** @type {CompositeOperation} */(setValue(params.composition, 'replace'));\n\n      for (let name in params) {\n        if (!isKey(name)) continue;\n        /** @type {PropertyIndexedKeyframes} */\n        const keyframes = {};\n        /** @type {KeyframeAnimationOptions} */\n        const tweenParams = { iterations, direction, fill, easing, duration, delay, composite };\n        const propertyValue = params[name];\n        const individualTransformProperty = hasIndividualTransforms ? validTransforms.includes(name) ? name : shortTransforms.get(name) : false;\n\n        const styleName = individualTransformProperty ? 'transform' : name;\n        if (!inlineStyles[styleName]) {\n          inlineStyles[styleName] = elStyle[styleName];\n        }\n\n        let parsedPropertyValue;\n        if (isObj(propertyValue)) {\n          const tweenOptions = /** @type {WAAPITweenOptions} */(propertyValue);\n          const tweenOptionsEase = setValue(tweenOptions.ease, easing);\n          const tweenOptionsSpring = /** @type {Spring} */(tweenOptionsEase).ease && tweenOptionsEase;\n          const to = /** @type {WAAPITweenOptions} */(tweenOptions).to;\n          const from = /** @type {WAAPITweenOptions} */(tweenOptions).from;\n          /** @type {Number} */\n          tweenParams.duration = (tweenOptionsSpring ? /** @type {Spring} */(tweenOptionsSpring).settlingDuration : getFunctionValue(setValue(tweenOptions.duration, duration), $el, i, targetsLength)) * timeScale;\n          /** @type {Number} */\n          tweenParams.delay = getFunctionValue(setValue(tweenOptions.delay, delay), $el, i, targetsLength) * timeScale;\n          /** @type {CompositeOperation} */\n          tweenParams.composite = /** @type {CompositeOperation} */(setValue(tweenOptions.composition, composite));\n          /** @type {String} */\n          tweenParams.easing = parseWAAPIEasing(tweenOptionsEase);\n          parsedPropertyValue = parseIndividualTweenValue($el, name, from, to, i, targetsLength);\n          if (individualTransformProperty) {\n            keyframes[`--${individualTransformProperty}`] = parsedPropertyValue;\n            cachedTransforms[individualTransformProperty] = parsedPropertyValue;\n          } else {\n            keyframes[name] = parseIndividualTweenValue($el, name, from, to, i, targetsLength);\n          }\n          addWAAPIAnimation(this, $el, name, keyframes, tweenParams);\n          if (!isUnd(from)) {\n            if (!individualTransformProperty) {\n              elStyle[name] = keyframes[name][0];\n            } else {\n              const key = `--${individualTransformProperty}`;\n              elStyle.setProperty(key, keyframes[key][0]);\n            }\n          }\n        } else {\n          parsedPropertyValue = isArr(propertyValue) ?\n                                propertyValue.map((/** @type {any} */v) => normalizeTweenValue(name, v, $el, i, targetsLength)) :\n                                normalizeTweenValue(name, /** @type {any} */(propertyValue), $el, i, targetsLength);\n          if (individualTransformProperty) {\n            keyframes[`--${individualTransformProperty}`] = parsedPropertyValue;\n            cachedTransforms[individualTransformProperty] = parsedPropertyValue;\n          } else {\n            keyframes[name] = parsedPropertyValue;\n          }\n          addWAAPIAnimation(this, $el, name, keyframes, tweenParams);\n        }\n      }\n      if (hasIndividualTransforms) {\n        let transforms = emptyString;\n        for (let t in cachedTransforms) {\n          transforms += `${transformsFragmentStrings[t]}var(--${t})) `;\n        }\n        elStyle.transform = transforms;\n      }\n    });\n\n    if (scroll) {\n      /** @type {ScrollObserver} */(this.autoplay).link(this);\n    }\n  }\n\n  /**\n   * @callback forEachCallback\n   * @param {globalThis.Animation} animation\n   */\n\n  /**\n   * @param  {forEachCallback|String} callback\n   * @return {this}\n   */\n  forEach(callback) {\n    try {\n      const cb = isStr(callback) ? (/** @type {globalThis.Animation} */a) => a[callback]() : callback;\n      this.animations.forEach(cb);\n    } catch {}    return this;\n  }\n\n  get speed() {\n    return this._speed;\n  }\n\n  set speed(speed) {\n    this._speed = +speed;\n    this.forEach(anim => anim.playbackRate = speed);\n  }\n\n  get currentTime() {\n    const controlAnimation = this.controlAnimation;\n    const timeScale = globals.timeScale;\n    return this.completed ? this.duration : controlAnimation ? +controlAnimation.currentTime * (timeScale === 1 ? 1 : timeScale) : 0;\n  }\n\n  set currentTime(time) {\n    const t = time * (globals.timeScale === 1 ? 1 : K);\n    this.forEach(anim => {\n      // Make sure the animation playState is not 'paused' in order to properly trigger an onfinish callback.\n      // The \"paused\" play state supersedes the \"finished\" play state; if the animation is both paused and finished, the \"paused\" state is the one that will be reported.\n      // https://developer.mozilla.org/en-US/docs/Web/API/Animation/finish_event\n      // This is not needed for persisting animations since they never finish.\n      if (!this.persist && t >= this.duration) anim.play();\n      anim.currentTime = t;\n    });\n  }\n\n  get progress() {\n    return this.currentTime / this.duration;\n  }\n\n  set progress(progress) {\n    this.forEach(anim => anim.currentTime = progress * this.duration || 0);\n  }\n\n  resume() {\n    if (!this.paused) return this;\n    this.paused = false;\n    // TODO: Store the current time, and seek back to the last position\n    return this.forEach('play');\n  }\n\n  pause() {\n    if (this.paused) return this;\n    this.paused = true;\n    return this.forEach('pause');\n  }\n\n  alternate() {\n    this.reversed = !this.reversed;\n    this.forEach('reverse');\n    if (this.paused) this.forEach('pause');\n    return this;\n  }\n\n  play() {\n    if (this.reversed) this.alternate();\n    return this.resume();\n  }\n\n  reverse() {\n    if (!this.reversed) this.alternate();\n    return this.resume();\n  }\n\n /**\n  * @param {Number} time\n  * @param {Boolean} muteCallbacks\n  */\n  seek(time, muteCallbacks = false) {\n    if (muteCallbacks) this.muteCallbacks = true;\n    if (time < this.duration) this.completed = false;\n    this.currentTime = time;\n    this.muteCallbacks = false;\n    if (this.paused) this.pause();\n    return this;\n  }\n\n  restart() {\n    this.completed = false;\n    return this.seek(0, true).resume();\n  }\n\n  commitStyles() {\n    return this.forEach('commitStyles');\n  }\n\n  complete() {\n    return this.seek(this.duration);\n  }\n\n  cancel() {\n    this.muteCallbacks = true; // This prevents triggering the onComplete callback and resolving the Promise\n    this.commitStyles().forEach('cancel');\n    this.animations.length = 0; // Needed to release all animations from memory\n    requestAnimationFrame(() => {\n      this.targets.forEach(($el) => { // Needed to avoid unecessary inline transorms\n        if ($el.style.transform === 'none') $el.style.removeProperty('transform');\n      });\n    });\n    return this;\n  }\n\n  revert() {\n    // NOTE: We need a better way to revert the transforms, since right now the entire transform property value is reverted,\n    // This means if you have multiple animations animating different transforms on the same target,\n    // reverting one of them will also override the transform property of the other animations.\n    // A better approach would be to store the original custom property values if they exist instead of the entire transform value,\n    // and update the CSS variables with the orignal value\n    this.cancel().targets.forEach(($el, i) => {\n      const targetStyle = $el.style;\n      const targetInlineStyles = this._inlineStyles[i];\n      for (let name in targetInlineStyles) {\n        const originalInlinedValue = targetInlineStyles[name];\n        if (isUnd(originalInlinedValue) || originalInlinedValue === emptyString) {\n          targetStyle.removeProperty(toLowerCase(name));\n        } else {\n          $el.style[name] = originalInlinedValue;\n        }\n      }\n      // Remove style attribute if empty\n      if ($el.getAttribute('style') === emptyString) $el.removeAttribute('style');\n    });\n    return this;\n  }\n\n  /**\n   * @typedef {this & {then: null}} ResolvedWAAPIAnimation\n   */\n\n  /**\n   * @param  {Callback<ResolvedWAAPIAnimation>} [callback]\n   * @return Promise<this>\n   */\n  then(callback = noop) {\n    const then = this.then;\n    const onResolve = () => {\n      this.then = null;\n      callback(/** @type {ResolvedWAAPIAnimation} */(this));\n      this.then = then;\n      this._resolve = noop;\n    };\n    return new Promise(r => {\n      this._resolve = () => r(onResolve());\n      if (this.completed) this._resolve();\n      return this;\n    });\n  }\n}\n\nconst waapi = {\n/**\n * @param {DOMTargetsParam} targets\n * @param {WAAPIAnimationParams} params\n * @return {WAAPIAnimation}\n */\n  animate: (targets, params) => new WAAPIAnimation(targets, params),\n  convertEase: easingToLinear\n};\n\nexport { WAAPIAnimation, waapi };\n","/**\n * Anime.js - layout - ESM\n * @version v4.3.6\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { mergeObjects, isUnd, isSvg, isStr, isFnc, isArr } from '../core/helpers.js';\nimport { registerTargets } from '../core/targets.js';\nimport { parseEase } from '../easings/eases/parser.js';\nimport { setValue, getFunctionValue } from '../core/values.js';\nimport { createTimeline } from '../timeline/timeline.js';\nimport { waapi } from '../waapi/waapi.js';\nimport { scope, defaults } from '../core/globals.js';\n\n/**\n * @import {\n *   AnimationParams,\n *   RenderableCallbacks,\n *   TickableCallbacks,\n *   TimelineParams,\n *   TimerParams,\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 * @import {\n *   WAAPIAnimation\n * } from '../waapi/waapi.js'\n*/\n\n/**\n * @import {\n *   Spring,\n } from '../easings/spring/index.js'\n*/\n\n/**\n * @import {\n *   DOMTarget,\n *   DOMTargetSelector,\n *   FunctionValue,\n *   EasingParam,\n } from '../types/index.js'\n*/\n\n/**\n * @typedef {DOMTargetSelector|Array<DOMTargetSelector>} LayoutChildrenParam\n */\n\n/**\n * @typedef {Object} LayoutAnimationTimingsParams\n * @property {Number|FunctionValue} [delay]\n * @property {Number|FunctionValue} [duration]\n * @property {EasingParam|FunctionValue} [ease]\n */\n\n/**\n * @typedef {Record<String, Number|String|FunctionValue>} LayoutStateAnimationProperties\n */\n\n/**\n * @typedef {LayoutStateAnimationProperties & LayoutAnimationTimingsParams} LayoutStateParams\n */\n\n/**\n * @typedef {Object} LayoutSpecificAnimationParams\n * @property {Number|FunctionValue} [delay]\n * @property {Number|FunctionValue} [duration]\n * @property {EasingParam|FunctionValue} [ease]\n * @property {EasingParam} [playbackEase]\n * @property {LayoutStateParams} [swapAt]\n * @property {LayoutStateParams} [enterFrom]\n * @property {LayoutStateParams} [leaveTo]\n */\n\n/**\n * @typedef {LayoutSpecificAnimationParams & TimerParams & TickableCallbacks<Timeline> & RenderableCallbacks<Timeline>} LayoutAnimationParams\n */\n\n/**\n * @typedef {Object} LayoutOptions\n * @property {LayoutChildrenParam} [children]\n * @property {Array<String>} [properties]\n */\n\n/**\n * @typedef {LayoutAnimationParams & LayoutOptions} AutoLayoutParams\n */\n\n/**\n * @typedef {Record<String, Number|String|FunctionValue> & {\n *   transform: String,\n *   x: Number,\n *   y: Number,\n *   left: Number,\n *   top: Number,\n *   clientLeft: Number,\n *   clientTop: Number,\n *   width: Number,\n *   height: Number,\n * }} LayoutNodeProperties\n */\n\n/**\n * @typedef {Object} LayoutNode\n * @property {String} id\n * @property {DOMTarget} $el\n * @property {Number} index\n * @property {Number} total\n * @property {Number} delay\n * @property {Number} duration\n * @property {EasingParam} ease\n * @property {DOMTarget} $measure\n * @property {LayoutSnapshot} state\n * @property {AutoLayout} layout\n * @property {LayoutNode|null} parentNode\n * @property {Boolean} isTarget\n * @property {Boolean} isEntering\n * @property {Boolean} isLeaving\n * @property {Boolean} hasTransform\n * @property {Array<String>} inlineStyles\n * @property {String|null} inlineTransforms\n * @property {String|null} inlineTransition\n * @property {Boolean} branchAdded\n * @property {Boolean} branchRemoved\n * @property {Boolean} branchNotRendered\n * @property {Boolean} sizeChanged\n * @property {Boolean} isInlined\n * @property {Boolean} hasVisibilitySwap\n * @property {Boolean} hasDisplayNone\n * @property {Boolean} hasVisibilityHidden\n * @property {String|null} measuredInlineTransform\n * @property {String|null} measuredInlineTransition\n * @property {String|null} measuredDisplay\n * @property {String|null} measuredVisibility\n * @property {String|null} measuredPosition\n * @property {Boolean} measuredHasDisplayNone\n * @property {Boolean} measuredHasVisibilityHidden\n * @property {Boolean} measuredIsVisible\n * @property {Boolean} measuredIsRemoved\n * @property {Boolean} measuredIsInsideRoot\n * @property {LayoutNodeProperties} properties\n * @property {LayoutNode|null} _head\n * @property {LayoutNode|null} _tail\n * @property {LayoutNode|null} _prev\n * @property {LayoutNode|null} _next\n */\n\n/**\n * @callback LayoutNodeIterator\n * @param {LayoutNode} node\n * @param {Number} index\n * @return {void}\n */\n\nlet layoutId = 0;\nlet nodeId = 0;\n\n/**\n * @param {DOMTarget} root\n * @param {DOMTarget} $el\n * @return {Boolean}\n */\nconst isElementInRoot = (root, $el) => {\n  if (!root || !$el) return false;\n  return root === $el || root.contains($el);\n};\n\n/**\n * @param {DOMTarget|null} $el\n * @return {String|null}\n */\nconst muteElementTransition = $el => {\n  if (!$el) return null;\n  const style = $el.style;\n  const transition = style.transition || '';\n  style.setProperty('transition', 'none', 'important');\n  return transition;\n};\n\n/**\n * @param {DOMTarget|null} $el\n * @param {String|null} transition\n */\nconst restoreElementTransition = ($el, transition) => {\n  if (!$el) return;\n  const style = $el.style;\n  if (transition) {\n    style.transition = transition;\n  } else {\n    style.removeProperty('transition');\n  }\n};\n\n/**\n * @param {LayoutNode} node\n */\nconst muteNodeTransition = node => {\n  const store = node.layout.transitionMuteStore;\n  const $el = node.$el;\n  const $measure = node.$measure;\n  if ($el && !store.has($el)) store.set($el, muteElementTransition($el));\n  if ($measure && !store.has($measure)) store.set($measure, muteElementTransition($measure));\n};\n\n/**\n * @param {Map<DOMTarget, String|null>} store\n */\nconst restoreLayoutTransition = store => {\n  store.forEach((value, $el) => restoreElementTransition($el, value));\n  store.clear();\n};\n\nconst hiddenComputedStyle = /** @type {CSSStyleDeclaration} */({\n  display: 'none',\n  visibility: 'hidden',\n  opacity: '0',\n  transform: 'none',\n  position: 'static',\n});\n\n/**\n * @param {LayoutNode|null} node\n */\nconst detachNode = node => {\n  if (!node) return;\n  const parent = node.parentNode;\n  if (!parent) return;\n  if (parent._head === node) parent._head = node._next;\n  if (parent._tail === node) parent._tail = node._prev;\n  if (node._prev) node._prev._next = node._next;\n  if (node._next) node._next._prev = node._prev;\n  node._prev = null;\n  node._next = null;\n  node.parentNode = null;\n};\n\n/**\n * @param {DOMTarget} $el\n * @param {LayoutNode|null} parentNode\n * @param {LayoutSnapshot} state\n * @param {LayoutNode} recycledNode\n * @return {LayoutNode}\n */\nconst createNode = ($el, parentNode, state, recycledNode) => {\n  let dataId = $el.dataset.layoutId;\n  if (!dataId) dataId = $el.dataset.layoutId = `node-${nodeId++}`;\n  const node = recycledNode ? recycledNode : /** @type {LayoutNode} */({});\n  node.$el = $el;\n  node.$measure = $el;\n  node.id = dataId;\n  node.index = 0;\n  node.total = 1;\n  node.delay = 0;\n  node.duration = 0;\n  node.ease = null;\n  node.state = state;\n  node.layout = state.layout;\n  node.parentNode = parentNode || null;\n  node.isTarget = false;\n  node.isEntering = false;\n  node.isLeaving = false;\n  node.isInlined = false;\n  node.hasTransform = false;\n  node.inlineStyles = [];\n  node.inlineTransforms = null;\n  node.inlineTransition = null;\n  node.branchAdded = false;\n  node.branchRemoved = false;\n  node.branchNotRendered = false;\n  node.sizeChanged = false;\n  node.hasVisibilitySwap = false;\n  node.hasDisplayNone = false;\n  node.hasVisibilityHidden = false;\n  node.measuredInlineTransform = null;\n  node.measuredInlineTransition = null;\n  node.measuredDisplay = null;\n  node.measuredVisibility = null;\n  node.measuredPosition = null;\n  node.measuredHasDisplayNone = false;\n  node.measuredHasVisibilityHidden = false;\n  node.measuredIsVisible = false;\n  node.measuredIsRemoved = false;\n  node.measuredIsInsideRoot = false;\n  node.properties = /** @type {LayoutNodeProperties} */({\n    transform: 'none',\n    x: 0,\n    y: 0,\n    left: 0,\n    top: 0,\n    clientLeft: 0,\n    clientTop: 0,\n    width: 0,\n    height: 0,\n  });\n  node.layout.properties.forEach(prop => node.properties[prop] = 0);\n  node._head = null;\n  node._tail = null;\n  node._prev = null;\n  node._next = null;\n  return node;\n};\n\n/**\n * @param {LayoutNode} node\n * @param {DOMTarget} $measure\n * @param {CSSStyleDeclaration} computedStyle\n * @param {Boolean} skipMeasurements\n * @return {LayoutNode}\n */\nconst recordNodeState = (node, $measure, computedStyle, skipMeasurements) => {\n  const $el = node.$el;\n  const root = node.layout.root;\n  const isRoot = root === $el;\n  const properties = node.properties;\n  const rootNode = node.state.rootNode;\n  const parentNode = node.parentNode;\n  const computedTransforms = computedStyle.transform;\n  const inlineTransforms = $el.style.transform;\n  const parentNotRendered = parentNode ? parentNode.measuredIsRemoved : false;\n  const position = computedStyle.position;\n  if (isRoot) node.layout.absoluteCoords = position === 'fixed' || position === 'absolute';\n  node.$measure = $measure;\n  node.inlineTransforms = inlineTransforms;\n  node.hasTransform = computedTransforms && computedTransforms !== 'none';\n  node.measuredIsInsideRoot = isElementInRoot(root, $measure);\n  node.measuredInlineTransform = null;\n  node.measuredDisplay = computedStyle.display;\n  node.measuredVisibility = computedStyle.visibility;\n  node.measuredPosition = position;\n  node.measuredHasDisplayNone = computedStyle.display === 'none';\n  node.measuredHasVisibilityHidden = computedStyle.visibility === 'hidden';\n  node.measuredIsVisible = !(node.measuredHasDisplayNone || node.measuredHasVisibilityHidden);\n  node.measuredIsRemoved = node.measuredHasDisplayNone || node.measuredHasVisibilityHidden || parentNotRendered;\n  // Check if element has adjacent text that would reflow when taken out of flow\n  let hasAdjacentText = false;\n  let s = $el.previousSibling;\n  while (s && (s.nodeType === Node.COMMENT_NODE || (s.nodeType === Node.TEXT_NODE && !s.textContent.trim()))) s = s.previousSibling;\n  if (s && s.nodeType === Node.TEXT_NODE) {\n    hasAdjacentText = true;\n  } else {\n    s = $el.nextSibling;\n    while (s && (s.nodeType === Node.COMMENT_NODE || (s.nodeType === Node.TEXT_NODE && !s.textContent.trim()))) s = s.nextSibling;\n    hasAdjacentText = s !== null && s.nodeType === Node.TEXT_NODE;\n  }\n  node.isInlined = hasAdjacentText;\n\n  // Mute transforms (and transition to avoid triggering an animation) before the position calculation\n  if (node.hasTransform && !skipMeasurements) {\n    const transitionMuteStore = node.layout.transitionMuteStore;\n    if (!transitionMuteStore.get($el)) node.inlineTransition = muteElementTransition($el);\n    if ($measure === $el) {\n      $el.style.transform = 'none';\n    } else {\n      if (!transitionMuteStore.get($measure)) node.measuredInlineTransition = muteElementTransition($measure);\n      node.measuredInlineTransform = $measure.style.transform;\n      $measure.style.transform = 'none';\n    }\n  }\n\n  let left = 0;\n  let top = 0;\n  let width = 0;\n  let height = 0;\n\n  if (!skipMeasurements) {\n    const rect = $measure.getBoundingClientRect();\n    left = rect.left;\n    top = rect.top;\n    width = rect.width;\n    height = rect.height;\n  }\n\n  for (let name in properties) {\n    const computedProp = name === 'transform' ? computedTransforms : computedStyle[name] || (computedStyle.getPropertyValue && computedStyle.getPropertyValue(name));\n    if (!isUnd(computedProp)) properties[name] = computedProp;\n  }\n\n  properties.left = left;\n  properties.top = top;\n  properties.clientLeft = skipMeasurements ? 0 : $measure.clientLeft;\n  properties.clientTop = skipMeasurements ? 0 : $measure.clientTop;\n  // Compute local x/y relative to parent\n  let absoluteLeft, absoluteTop;\n  if (isRoot) {\n    if (!node.layout.absoluteCoords) {\n      absoluteLeft = 0;\n      absoluteTop = 0;\n    } else {\n      absoluteLeft = left;\n      absoluteTop = top;\n    }\n  } else {\n    const p = parentNode || rootNode;\n    const parentLeft = p.properties.left;\n    const parentTop = p.properties.top;\n    const borderLeft = p.properties.clientLeft;\n    const borderTop = p.properties.clientTop;\n    if (!node.layout.absoluteCoords) {\n      if (p === rootNode) {\n        const rootLeft = rootNode.properties.left;\n        const rootTop = rootNode.properties.top;\n        const rootBorderLeft = rootNode.properties.clientLeft;\n        const rootBorderTop = rootNode.properties.clientTop;\n        absoluteLeft = left - rootLeft - rootBorderLeft;\n        absoluteTop = top - rootTop - rootBorderTop;\n      } else {\n        absoluteLeft = left - parentLeft - borderLeft;\n        absoluteTop = top - parentTop - borderTop;\n      }\n    } else {\n      absoluteLeft = left - parentLeft - borderLeft;\n      absoluteTop = top - parentTop - borderTop;\n    }\n  }\n  properties.x = absoluteLeft;\n  properties.y = absoluteTop;\n  properties.width = width;\n  properties.height = height;\n  return node;\n};\n\n/**\n * @param {LayoutNode} node\n * @param {LayoutStateAnimationProperties} [props]\n */\nconst updateNodeProperties = (node, props) => {\n  if (!props) return;\n  for (let name in props) {\n    node.properties[name] = props[name];\n  }\n};\n\n/**\n * @param  {LayoutNode} node\n * @param  {LayoutAnimationTimingsParams} params\n */\nconst updateNodeTimingParams = (node, params) => {\n  const easeFunctionResult = getFunctionValue(params.ease, node.$el, node.index, node.total);\n  const keyEasing = isFnc(easeFunctionResult) ? easeFunctionResult : params.ease;\n  const hasSpring = !isUnd(keyEasing) && !isUnd(/** @type {Spring} */(keyEasing).ease);\n  node.ease = hasSpring ? /** @type {Spring} */(keyEasing).ease : keyEasing;\n  node.duration = hasSpring ? /** @type {Spring} */(keyEasing).settlingDuration : getFunctionValue(params.duration, node.$el, node.index, node.total);\n  node.delay = getFunctionValue(params.delay, node.$el, node.index, node.total);\n};\n\n/**\n * @param {LayoutNode} node\n */\nconst recordNodeInlineStyles = node => {\n  const style = node.$el.style;\n  const stylesStore = node.inlineStyles;\n  stylesStore.length = 0;\n  node.layout.recordedProperties.forEach(prop => {\n    stylesStore.push(prop, style[prop] || '');\n  });\n};\n\n/**\n * @param {LayoutNode} node\n */\nconst restoreNodeInlineStyles = node => {\n  const style = node.$el.style;\n  const stylesStore = node.inlineStyles;\n  for (let i = 0, l = stylesStore.length; i < l; i += 2) {\n    const property = stylesStore[i];\n    const styleValue = stylesStore[i + 1];\n    if (styleValue && styleValue !== '') {\n      style[property] = styleValue;\n    } else {\n      style[property] = '';\n      style.removeProperty(property);\n    }\n  }\n};\n\n/**\n * @param {LayoutNode} node\n */\nconst restoreNodeTransform = node => {\n  const inlineTransforms = node.inlineTransforms;\n  const nodeStyle = node.$el.style;\n  if (!node.hasTransform || !inlineTransforms || (node.hasTransform && nodeStyle.transform === 'none') || (inlineTransforms && inlineTransforms === 'none')) {\n    nodeStyle.removeProperty('transform');\n  } else if (inlineTransforms) {\n    nodeStyle.transform = inlineTransforms;\n  }\n  const $measure = node.$measure;\n  if (node.hasTransform && $measure !== node.$el) {\n    const measuredStyle = $measure.style;\n    const measuredInline = node.measuredInlineTransform;\n    if (measuredInline && measuredInline !== '') {\n      measuredStyle.transform = measuredInline;\n    } else {\n      measuredStyle.removeProperty('transform');\n    }\n  }\n  node.measuredInlineTransform = null;\n  if (node.inlineTransition !== null) {\n    restoreElementTransition(node.$el, node.inlineTransition);\n    node.inlineTransition = null;\n  }\n  if ($measure !== node.$el && node.measuredInlineTransition !== null) {\n    restoreElementTransition($measure, node.measuredInlineTransition);\n    node.measuredInlineTransition = null;\n  }\n};\n\n/**\n * @param {LayoutNode} node\n */\nconst restoreNodeVisualState = node => {\n  if (node.measuredIsRemoved || node.hasVisibilitySwap) {\n    node.$el.style.removeProperty('display');\n    node.$el.style.removeProperty('visibility');\n    if (node.hasVisibilitySwap) {\n      node.$measure.style.removeProperty('display');\n      node.$measure.style.removeProperty('visibility');\n    }\n  }\n  // if (node.measuredIsRemoved) {\n  node.layout.pendingRemoval.delete(node.$el);\n  // }\n};\n\n/**\n * @param {LayoutNode} node\n * @param {LayoutNode} targetNode\n * @param {LayoutSnapshot} newState\n * @return {LayoutNode}\n */\nconst cloneNodeProperties = (node, targetNode, newState) => {\n  targetNode.properties = /** @type {LayoutNodeProperties} */({ ...node.properties });\n  targetNode.state = newState;\n  targetNode.isTarget = node.isTarget;\n  targetNode.hasTransform = node.hasTransform;\n  targetNode.inlineTransforms = node.inlineTransforms;\n  targetNode.measuredIsVisible = node.measuredIsVisible;\n  targetNode.measuredDisplay = node.measuredDisplay;\n  targetNode.measuredIsRemoved = node.measuredIsRemoved;\n  targetNode.measuredHasDisplayNone = node.measuredHasDisplayNone;\n  targetNode.measuredHasVisibilityHidden = node.measuredHasVisibilityHidden;\n  targetNode.hasDisplayNone = node.hasDisplayNone;\n  targetNode.isInlined = node.isInlined;\n  targetNode.hasVisibilityHidden = node.hasVisibilityHidden;\n  return targetNode;\n};\n\nclass LayoutSnapshot {\n  /**\n   * @param {AutoLayout} layout\n   */\n  constructor(layout) {\n    /** @type {AutoLayout} */\n    this.layout = layout;\n    /** @type {LayoutNode|null} */\n    this.rootNode = null;\n    /** @type {Set<LayoutNode>} */\n    this.rootNodes = new Set();\n    /** @type {Map<String, LayoutNode>} */\n    this.nodes = new Map();\n    /** @type {Number} */\n    this.scrollX = 0;\n    /** @type {Number} */\n    this.scrollY = 0;\n  }\n\n  /**\n   * @return {this}\n   */\n  revert() {\n    this.forEachNode(node => {\n      this.layout.pendingRemoval.delete(node.$el);\n      node.$el.removeAttribute('data-layout-id');\n      node.$measure.removeAttribute('data-layout-id');\n    });\n    this.rootNode = null;\n    this.rootNodes.clear();\n    this.nodes.clear();\n    return this;\n  }\n\n  /**\n   * @param {DOMTarget} $el\n   * @return {LayoutNode}\n   */\n  getNode($el) {\n    if (!$el || !$el.dataset) return;\n    return this.nodes.get($el.dataset.layoutId);\n  }\n\n  /**\n   * @param {DOMTarget} $el\n   * @param {String} prop\n   * @return {Number|String}\n   */\n  getComputedValue($el, prop) {\n    const node = this.getNode($el);\n    if (!node) return;\n    return /** @type {Number|String} */(node.properties[prop]);\n  }\n\n  /**\n   * @param {LayoutNode|null} rootNode\n   * @param {LayoutNodeIterator} cb\n   */\n  forEach(rootNode, cb) {\n    let node = rootNode;\n    let i = 0;\n    while (node) {\n      cb(node, i++);\n      if (node._head) {\n        node = node._head;\n      } else if (node._next) {\n        node = node._next;\n      } else {\n        while (node && !node._next) {\n          node = node.parentNode;\n        }\n        if (node) node = node._next;\n      }\n    }\n  }\n\n  /**\n   * @param {LayoutNodeIterator} cb\n   */\n  forEachRootNode(cb) {\n    this.forEach(this.rootNode, cb);\n  }\n\n  /**\n   * @param {LayoutNodeIterator} cb\n   */\n  forEachNode(cb) {\n    for (const rootNode of this.rootNodes) {\n      this.forEach(rootNode, cb);\n    }\n  }\n\n  /**\n   * @param {DOMTarget} $el\n   * @param {LayoutNode|null} parentNode\n   * @return {LayoutNode|null}\n   */\n  registerElement($el, parentNode) {\n    if (!$el || $el.nodeType !== 1) return null;\n\n    if (!this.layout.transitionMuteStore.has($el)) this.layout.transitionMuteStore.set($el, muteElementTransition($el));\n\n    /** @type {Array<DOMTarget|LayoutNode|null>} */\n    const stack = [$el, parentNode];\n    const root = this.layout.root;\n    let firstNode = null;\n\n    while (stack.length) {\n      /** @type {LayoutNode|null} */\n      const $parent = /** @type {LayoutNode|null} */(stack.pop());\n      /** @type {DOMTarget|null} */\n      const $current = /** @type {DOMTarget|null} */(stack.pop());\n\n      if (!$current || $current.nodeType !== 1 || isSvg($current)) continue;\n\n      const skipMeasurements = $parent ? $parent.measuredIsRemoved : false;\n      const computedStyle = skipMeasurements ? hiddenComputedStyle : getComputedStyle($current);\n      const hasDisplayNone = skipMeasurements ? true : computedStyle.display === 'none';\n      const hasVisibilityHidden = skipMeasurements ? true : computedStyle.visibility === 'hidden';\n      const isVisible = !hasDisplayNone && !hasVisibilityHidden;\n      const existingId = $current.dataset.layoutId;\n      const isInsideRoot = isElementInRoot(root, $current);\n\n      let node = existingId ? this.nodes.get(existingId) : null;\n\n      if (node && node.$el !== $current) {\n        const nodeInsideRoot = isElementInRoot(root, node.$el);\n        const measuredVisible = node.measuredIsVisible;\n        const shouldReassignNode = !nodeInsideRoot && (isInsideRoot || (!isInsideRoot && !measuredVisible && isVisible));\n        const shouldReuseMeasurements = nodeInsideRoot && !measuredVisible && isVisible;\n        // Rebind nodes that move into the root or whose detached twin just became visible\n        if (shouldReassignNode) {\n          detachNode(node);\n          node = createNode($current, $parent, this, node);\n        // for hidden element with in-root sibling, keep the hidden node but borrow measurements from its visible in-root twin element\n        } else if (shouldReuseMeasurements) {\n          recordNodeState(node, $current, computedStyle, skipMeasurements);\n          let $child = $current.lastElementChild;\n          while ($child) {\n            stack.push(/** @type {DOMTarget} */($child), node);\n            $child = $child.previousElementSibling;\n          }\n          if (!firstNode) firstNode = node;\n          continue;\n        // No reassignment needed so keep walking descendants under the current parent\n        } else {\n          let $child = $current.lastElementChild;\n          while ($child) {\n            stack.push(/** @type {DOMTarget} */($child), $parent);\n            $child = $child.previousElementSibling;\n          }\n          if (!firstNode) firstNode = node;\n          continue;\n        }\n      } else {\n        node = createNode($current, $parent, this, node);\n      }\n\n      node.branchAdded = false;\n      node.branchRemoved = false;\n      node.branchNotRendered = false;\n      node.isTarget = false;\n      node.sizeChanged = false;\n      node.hasVisibilityHidden = hasVisibilityHidden;\n      node.hasDisplayNone = hasDisplayNone;\n      node.hasVisibilitySwap = (hasVisibilityHidden && !node.measuredHasVisibilityHidden) || (hasDisplayNone && !node.measuredHasDisplayNone);\n\n      this.nodes.set(node.id, node);\n\n      node.parentNode = $parent || null;\n      node._prev = null;\n      node._next = null;\n\n      if ($parent) {\n        this.rootNodes.delete(node);\n        if (!$parent._head) {\n          $parent._head = node;\n          $parent._tail = node;\n        } else {\n          $parent._tail._next = node;\n          node._prev = $parent._tail;\n          $parent._tail = node;\n        }\n      } else {\n        // Each disconnected subtree becomes its own root in the snapshot graph\n        this.rootNodes.add(node);\n      }\n\n      recordNodeState(node, node.$el, computedStyle, skipMeasurements);\n\n      let $child = $current.lastElementChild;\n      while ($child) {\n        stack.push(/** @type {DOMTarget} */($child), node);\n        $child = $child.previousElementSibling;\n      }\n\n      if (!firstNode) firstNode = node;\n    }\n\n    return firstNode;\n  }\n\n  /**\n   * @param {DOMTarget} $el\n   * @param {Set<DOMTarget>} candidates\n   * @return {LayoutNode|null}\n   */\n  ensureDetachedNode($el, candidates) {\n    if (!$el || $el === this.layout.root) return null;\n    const existingId = $el.dataset.layoutId;\n    const existingNode = existingId ? this.nodes.get(existingId) : null;\n    if (existingNode && existingNode.$el === $el) return existingNode;\n    let parentNode = null;\n    let $ancestor = $el.parentElement;\n    while ($ancestor && $ancestor !== this.layout.root) {\n      if (candidates.has($ancestor)) {\n        parentNode = this.ensureDetachedNode($ancestor, candidates);\n        break;\n      }\n      $ancestor = $ancestor.parentElement;\n    }\n    return this.registerElement($el, parentNode);\n  }\n\n  /**\n   * @return {this}\n   */\n  record() {\n    const layout = this.layout;\n    const children = layout.children;\n    const root = layout.root;\n    const toParse = isArr(children) ? children : [children];\n    const scoped = [];\n    const scopeRoot = children === '*' ? root : scope.root;\n\n    // Mute transition and transforms of root ancestors before recording the state\n\n    /** @type {Array<DOMTarget|String|null>} */\n    const rootAncestorTransformStore = [];\n    let $ancestor = root.parentElement;\n    while ($ancestor && $ancestor.nodeType === 1) {\n      const computedStyle = getComputedStyle($ancestor);\n      if (computedStyle.transform && computedStyle.transform !== 'none') {\n        const inlineTransform = $ancestor.style.transform || '';\n        const inlineTransition = muteElementTransition($ancestor);\n        rootAncestorTransformStore.push($ancestor, inlineTransform, inlineTransition);\n        $ancestor.style.transform = 'none';\n      }\n      $ancestor = $ancestor.parentElement;\n    }\n\n    for (let i = 0, l = toParse.length; i < l; i++) {\n      const child = toParse[i];\n      scoped[i] = isStr(child) ? scopeRoot.querySelectorAll(child) : child;\n    }\n\n    const parsedChildren = registerTargets(scoped);\n\n    this.nodes.clear();\n    this.rootNodes.clear();\n\n    const rootNode = this.registerElement(root, null);\n    // Root node are always targets\n    rootNode.isTarget = true;\n    this.rootNode = rootNode;\n\n    const inRootNodeIds = new Set();\n    // Update index and total for inital timing calculation\n    let index = 0, total = this.nodes.size;\n    this.nodes.forEach((node, id) => {\n      node.index = index++;\n      node.total = total;\n      // Track ids of nodes that belong to the current root to filter detached matches\n      if (node && node.measuredIsInsideRoot) {\n        inRootNodeIds.add(id);\n      }\n    });\n\n    // Elements with a layout id outside the root that match the children selector\n    const detachedElementsLookup = new Set();\n    const orderedDetachedElements = [];\n\n    for (let i = 0, l = parsedChildren.length; i < l; i++) {\n      const $el = parsedChildren[i];\n      if (!$el || $el.nodeType !== 1 || $el === root) continue;\n      const insideRoot = isElementInRoot(root, $el);\n      if (!insideRoot) {\n        const layoutNodeId = $el.dataset.layoutId;\n        if (!layoutNodeId || !inRootNodeIds.has(layoutNodeId)) continue;\n      }\n      if (!detachedElementsLookup.has($el)) {\n        detachedElementsLookup.add($el);\n        orderedDetachedElements.push($el);\n      }\n    }\n\n    for (let i = 0, l = orderedDetachedElements.length; i < l; i++) {\n      this.ensureDetachedNode(orderedDetachedElements[i], detachedElementsLookup);\n    }\n\n    for (let i = 0, l = parsedChildren.length; i < l; i++) {\n      const $el = parsedChildren[i];\n      const node = this.getNode($el);\n      if (node) {\n        let cur = node;\n        while (cur) {\n          if (cur.isTarget) break;\n          cur.isTarget = true;\n          cur = cur.parentNode;\n        }\n      }\n    }\n\n    this.scrollX = window.scrollX;\n    this.scrollY = window.scrollY;\n\n    this.forEachNode(restoreNodeTransform);\n\n    // Restore transition and transforms of root ancestors\n\n    for (let i = 0, l = rootAncestorTransformStore.length; i < l; i += 3) {\n      const $el = /** @type {DOMTarget} */(rootAncestorTransformStore[i]);\n      const inlineTransform = /** @type {String} */(rootAncestorTransformStore[i + 1]);\n      const inlineTransition = /** @type {String|null} */(rootAncestorTransformStore[i + 2]);\n      if (inlineTransform && inlineTransform !== '') {\n        $el.style.transform = inlineTransform;\n      } else {\n        $el.style.removeProperty('transform');\n      }\n      restoreElementTransition($el, inlineTransition);\n    }\n\n    return this;\n  }\n}\n\n/**\n * @param  {LayoutStateParams} params\n * @return {[LayoutStateAnimationProperties, LayoutAnimationTimingsParams]}\n */\nfunction splitPropertiesFromParams(params) {\n  /** @type {LayoutStateAnimationProperties} */\n  const properties = {};\n  /** @type {LayoutAnimationTimingsParams} */\n  const parameters = {};\n  for (let name in params) {\n    const value = params[name];\n    const isEase = name === 'ease';\n    const isTiming = name === 'duration' || name === 'delay';\n    if (isTiming || isEase) {\n      if (isEase) {\n        parameters[name] = /** @type {EasingParam} */(value);\n      } else {\n        parameters[name] = /** @type {Number|FunctionValue} */(value);\n      }\n    } else {\n      properties[name] = /** @type {Number|String} */(value);\n    }\n  }\n  return [properties, parameters];\n}\n\nclass AutoLayout {\n  /**\n   * @param {DOMTargetSelector} root\n   * @param {AutoLayoutParams} [params]\n   */\n  constructor(root, params = {}) {\n    if (scope.current) scope.current.register(this);\n    const swapAtSplitParams = splitPropertiesFromParams(params.swapAt);\n    const enterFromSplitParams = splitPropertiesFromParams(params.enterFrom);\n    const leaveToSplitParams = splitPropertiesFromParams(params.leaveTo);\n    const transitionProperties = params.properties;\n    /** @type {Number|FunctionValue} */\n    params.duration = setValue(params.duration, 350);\n    /** @type {Number|FunctionValue} */\n    params.delay = setValue(params.delay, 0);\n    /** @type {EasingParam|FunctionValue} */\n    params.ease = setValue(params.ease, 'inOut(3.5)');\n    /** @type {AutoLayoutParams} */\n    this.params = params;\n    /** @type {DOMTarget} */\n    this.root = /** @type {DOMTarget} */(registerTargets(root)[0]);\n    /** @type {Number} */\n    this.id = layoutId++;\n    /** @type {LayoutChildrenParam} */\n    this.children = params.children || '*';\n    /** @type {Boolean} */\n    this.absoluteCoords = false;\n    /** @type {LayoutStateParams} */\n    this.swapAtParams = mergeObjects(params.swapAt || { opacity: 0 }, { ease: 'inOut(1.75)' });\n    /** @type {LayoutStateParams} */\n    this.enterFromParams = params.enterFrom || { opacity: 0 };\n    /** @type {LayoutStateParams} */\n    this.leaveToParams = params.leaveTo || { opacity: 0 };\n    /** @type {Set<String>} */\n    this.properties = new Set([\n      'opacity',\n      'fontSize',\n      'color',\n      'backgroundColor',\n      'borderRadius',\n      'border',\n      'filter',\n      'clipPath',\n    ]);\n    if (swapAtSplitParams[0]) for (let name in swapAtSplitParams[0]) this.properties.add(name);\n    if (enterFromSplitParams[0]) for (let name in enterFromSplitParams[0]) this.properties.add(name);\n    if (leaveToSplitParams[0]) for (let name in leaveToSplitParams[0]) this.properties.add(name);\n    if (transitionProperties) for (let i = 0, l = transitionProperties.length; i < l; i++) this.properties.add(transitionProperties[i]);\n    /** @type {Set<String>} */\n    this.recordedProperties = new Set([\n      'display',\n      'visibility',\n      'translate',\n      'position',\n      'left',\n      'top',\n      'marginLeft',\n      'marginTop',\n      'width',\n      'height',\n      'maxWidth',\n      'maxHeight',\n      'minWidth',\n      'minHeight',\n    ]);\n    this.properties.forEach(prop => this.recordedProperties.add(prop));\n    /** @type {WeakSet<DOMTarget>} */\n    this.pendingRemoval = new WeakSet();\n    /** @type {Map<DOMTarget, String|null>} */\n    this.transitionMuteStore = new Map();\n    /** @type {LayoutSnapshot} */\n    this.oldState = new LayoutSnapshot(this);\n    /** @type {LayoutSnapshot} */\n    this.newState = new LayoutSnapshot(this);\n    /** @type {Timeline} */\n    this.timeline = null;\n    /** @type {WAAPIAnimation} */\n    this.transformAnimation = null;\n    /** @type {Array<DOMTarget>} */\n    this.animating = [];\n    /** @type {Array<DOMTarget>} */\n    this.swapping = [];\n    /** @type {Array<DOMTarget>} */\n    this.leaving = [];\n    /** @type {Array<DOMTarget>} */\n    this.entering = [];\n    // Record the current state as the old state to init the data attributes and allow imediate .animate()\n    this.oldState.record();\n    // And all layout transition muted during the record\n    restoreLayoutTransition(this.transitionMuteStore);\n  }\n\n  /**\n   * @return {this}\n   */\n  revert() {\n    this.root.classList.remove('is-animated');\n    if (this.timeline) {\n      this.timeline.complete();\n      this.timeline = null;\n    }\n    if (this.transformAnimation) {\n      this.transformAnimation.complete();\n      this.transformAnimation = null;\n    }\n    this.animating.length = this.swapping.length = this.leaving.length = this.entering.length = 0;\n    this.oldState.revert();\n    this.newState.revert();\n    requestAnimationFrame(() => restoreLayoutTransition(this.transitionMuteStore));\n    return this;\n  }\n\n  /**\n   * @return {this}\n   */\n  record() {\n    // Commit transforms before measuring\n    if (this.transformAnimation) {\n      this.transformAnimation.cancel();\n      this.transformAnimation = null;\n    }\n    // Record the old state\n    this.oldState.record();\n    // Cancel any running timeline\n    if (this.timeline) {\n      this.timeline.cancel();\n      this.timeline = null;\n    }\n    // Restore previously captured inline styles\n    this.newState.forEachRootNode(restoreNodeInlineStyles);\n    return this;\n  }\n\n  /**\n   * @param {LayoutAnimationParams} [params]\n   * @return {Timeline}\n   */\n  animate(params = {}) {\n    /** @type { LayoutAnimationTimingsParams } */\n    const animationTimings = {\n      ease: setValue(params.ease, this.params.ease),\n      delay: setValue(params.delay, this.params.delay),\n      duration: setValue(params.duration, this.params.duration),\n    };\n    /** @type {TimelineParams} */\n    const tlParams = {};\n    const onComplete = setValue(params.onComplete, this.params.onComplete);\n    const onPause = setValue(params.onPause, this.params.onPause);\n    for (let name in defaults) {\n      if (name !== 'ease' && name !== 'duration' && name !== 'delay') {\n        if (!isUnd(params[name])) {\n          tlParams[name] = params[name];\n        } else if (!isUnd(this.params[name])) {\n          tlParams[name] = this.params[name];\n        }\n      }\n    }\n    tlParams.onComplete = () => {\n      const ap = /** @type {ScrollObserver} */(params.autoplay);\n      const isScrollControled = ap && ap.linked;\n      if (isScrollControled) {\n        if (onComplete) onComplete(this.timeline);\n        return;\n      }\n      // Make sure to call .cancel() after restoreNodeInlineStyles(node); otehrwise the commited styles get reverted\n      if (this.transformAnimation) this.transformAnimation.cancel();\n      newState.forEachRootNode(node => {\n        restoreNodeVisualState(node);\n        restoreNodeInlineStyles(node);\n      });\n      for (let i = 0, l = transformed.length; i < l; i++) {\n        const $el = transformed[i];\n        $el.style.transform = newState.getComputedValue($el, 'transform');\n      }\n      if (this.root.classList.contains('is-animated')) {\n        this.root.classList.remove('is-animated');\n        if (onComplete) onComplete(this.timeline);\n      }\n      // Avoid CSS transitions at the end of the animation by restoring them on the next frame\n      requestAnimationFrame(() => {\n        if (this.root.classList.contains('is-animated')) return;\n        restoreLayoutTransition(this.transitionMuteStore);\n      });\n    };\n    tlParams.onPause = () => {\n      const ap = /** @type {ScrollObserver} */(params.autoplay);\n      const isScrollControled = ap && ap.linked;\n      if (isScrollControled) {\n        if (onComplete) onComplete(this.timeline);\n        if (onPause) onPause(this.timeline);\n        return;\n      }\n      if (!this.root.classList.contains('is-animated')) return;\n      if (this.transformAnimation) this.transformAnimation.cancel();\n      newState.forEachRootNode(restoreNodeVisualState);\n      this.root.classList.remove('is-animated');\n      if (onComplete) onComplete(this.timeline);\n      if (onPause) onPause(this.timeline);\n    };\n    tlParams.composition = false;\n\n    const swapAtParams = mergeObjects(mergeObjects(params.swapAt || {}, this.swapAtParams), animationTimings);\n    const enterFromParams = mergeObjects(mergeObjects(params.enterFrom || {}, this.enterFromParams), animationTimings);\n    const leaveToParams = mergeObjects(mergeObjects(params.leaveTo || {}, this.leaveToParams), animationTimings);\n    const [ swapAtProps, swapAtTimings ] = splitPropertiesFromParams(swapAtParams);\n    const [ enterFromProps, enterFromTimings ] = splitPropertiesFromParams(enterFromParams);\n    const [ leaveToProps, leaveToTimings ] = splitPropertiesFromParams(leaveToParams);\n\n    const oldState = this.oldState;\n    const newState = this.newState;\n    const animating = this.animating;\n    const swapping = this.swapping;\n    const entering = this.entering;\n    const leaving = this.leaving;\n    const pendingRemoval = this.pendingRemoval;\n\n    animating.length = swapping.length = entering.length = leaving.length = 0;\n\n    // Mute old state CSS transitions to prevent wrong properties calculation\n    oldState.forEachRootNode(muteNodeTransition);\n    // Capture the new state before animation\n    newState.record();\n    newState.forEachRootNode(recordNodeInlineStyles);\n\n    const targets = [];\n    const animated = [];\n    const transformed = [];\n    const animatedSwap = [];\n    const rootNode = newState.rootNode;\n    const $root = rootNode.$el;\n\n    newState.forEachRootNode(node => {\n\n      const $el = node.$el;\n      const id = node.id;\n      const parent = node.parentNode;\n      const parentAdded = parent ? parent.branchAdded : false;\n      const parentRemoved = parent ? parent.branchRemoved : false;\n      const parentNotRendered = parent ? parent.branchNotRendered : false;\n\n      let oldStateNode = oldState.nodes.get(id);\n\n      const hasNoOldState = !oldStateNode;\n\n      if (hasNoOldState) {\n        oldStateNode = cloneNodeProperties(node, /** @type {LayoutNode} */({}), oldState);\n        oldState.nodes.set(id, oldStateNode);\n        oldStateNode.measuredIsRemoved = true;\n      } else if (oldStateNode.measuredIsRemoved && !node.measuredIsRemoved) {\n        cloneNodeProperties(node, oldStateNode, oldState);\n        oldStateNode.measuredIsRemoved = true;\n      }\n\n      const oldParentNode = oldStateNode.parentNode;\n      const oldParentId = oldParentNode ? oldParentNode.id : null;\n      const newParentId = parent ? parent.id : null;\n      const parentChanged = oldParentId !== newParentId;\n      const elementChanged = oldStateNode.$el !== node.$el;\n      const wasRemovedBefore = oldStateNode.measuredIsRemoved;\n      const isRemovedNow = node.measuredIsRemoved;\n\n      // Recalculate postion relative to their parent for elements that have been moved\n      if (!oldStateNode.measuredIsRemoved && !isRemovedNow && !hasNoOldState && (parentChanged || elementChanged)) {\n        const oldAbsoluteLeft = oldStateNode.properties.left;\n        const oldAbsoluteTop = oldStateNode.properties.top;\n        const newParent = parent || newState.rootNode;\n        const oldParent = newParent.id ? oldState.nodes.get(newParent.id) : null;\n        const parentLeft = oldParent ? oldParent.properties.left : newParent.properties.left;\n        const parentTop = oldParent ? oldParent.properties.top : newParent.properties.top;\n        const borderLeft = oldParent ? oldParent.properties.clientLeft : newParent.properties.clientLeft;\n        const borderTop = oldParent ? oldParent.properties.clientTop : newParent.properties.clientTop;\n        oldStateNode.properties.x = oldAbsoluteLeft - parentLeft - borderLeft;\n        oldStateNode.properties.y = oldAbsoluteTop - parentTop - borderTop;\n      }\n\n      if (node.hasVisibilitySwap) {\n        if (node.hasVisibilityHidden) {\n          node.$el.style.visibility = 'visible';\n          node.$measure.style.visibility = 'hidden';\n        }\n        if (node.hasDisplayNone) {\n          node.$el.style.display = oldStateNode.measuredDisplay || node.measuredDisplay || '';\n          // Setting visibility 'hidden' instead of display none to avoid calculation issues\n          node.$measure.style.visibility = 'hidden';\n          // @TODO: check why setting display here can cause calculation issues\n          // node.$measure.style.display = 'none';\n        }\n      }\n\n      const wasPendingRemoval = pendingRemoval.has($el);\n      const wasVisibleBefore = oldStateNode.measuredIsVisible;\n      const isVisibleNow = node.measuredIsVisible;\n      const becomeVisible = !wasVisibleBefore && isVisibleNow && !parentNotRendered;\n      const topLevelAdded = !isRemovedNow && (wasRemovedBefore || wasPendingRemoval) && !parentAdded;\n      const newlyRemoved = isRemovedNow && !wasRemovedBefore && !parentRemoved;\n      const topLevelRemoved = newlyRemoved || isRemovedNow && wasPendingRemoval && !parentRemoved;\n\n      node.branchAdded = parentAdded || topLevelAdded;\n      node.branchRemoved = parentRemoved || topLevelRemoved;\n      node.branchNotRendered = parentNotRendered || isRemovedNow;\n\n      if (isRemovedNow && wasVisibleBefore) {\n        node.$el.style.display = oldStateNode.measuredDisplay;\n        node.$el.style.visibility = 'visible';\n        cloneNodeProperties(oldStateNode, node, newState);\n      }\n\n      // Node is leaving\n      if (newlyRemoved) {\n        if (node.isTarget) {\n          leaving.push($el);\n          node.isLeaving = true;\n        }\n        pendingRemoval.add($el);\n      } else if (!isRemovedNow && wasPendingRemoval) {\n        pendingRemoval.delete($el);\n      }\n\n      // Node is entering\n      if ((topLevelAdded && !parentNotRendered) || becomeVisible) {\n        updateNodeProperties(oldStateNode, enterFromProps);\n        if (node.isTarget) {\n          entering.push($el);\n          node.isEntering = true;\n        }\n      // Node is leaving\n      } else if (topLevelRemoved && !parentNotRendered) {\n        updateNodeProperties(node, leaveToProps);\n      }\n\n      // Node is animating\n      // The animating array is used only to calculate delays and duration on root children\n      if (node !== rootNode && node.isTarget && !node.isEntering && !node.isLeaving) {\n        animating.push($el);\n      }\n\n      targets.push($el);\n\n    });\n\n    let enteringIndex = 0;\n    let leavingIndex = 0;\n    let animatingIndex = 0;\n\n    newState.forEachRootNode(node => {\n\n      const $el = node.$el;\n      const parent = node.parentNode;\n      const oldStateNode = oldState.nodes.get(node.id);\n      const nodeProperties = node.properties;\n      const oldStateNodeProperties = oldStateNode.properties;\n\n      // Use closest animated parent index and total values so that children staggered delays are in sync with their parent\n      let animatedParent = parent !== rootNode && parent;\n      while (animatedParent && !animatedParent.isTarget && animatedParent !== rootNode) {\n        animatedParent = animatedParent.parentNode;\n      }\n\n      const animatingTotal = animating.length;\n\n      // Root is always animated first in sync with the first child (animating.length is the total of children)\n      if (node === rootNode) {\n        node.index = 0;\n        node.total = animatingTotal;\n        updateNodeTimingParams(node, animationTimings);\n      } else if (node.isEntering) {\n        node.index = animatedParent ? animatedParent.index : enteringIndex;\n        node.total = animatedParent ? animatingTotal : entering.length;\n        updateNodeTimingParams(node, enterFromTimings);\n        enteringIndex++;\n      } else if (node.isLeaving) {\n        node.index = animatedParent ? animatedParent.index : leavingIndex;\n        node.total = animatedParent ? animatingTotal : leaving.length;\n        leavingIndex++;\n        updateNodeTimingParams(node, leaveToTimings);\n      } else if (node.isTarget) {\n        node.index = animatingIndex++;\n        node.total = animatingTotal;\n        updateNodeTimingParams(node, animationTimings);\n      } else {\n        node.index = animatedParent ? animatedParent.index : 0;\n        node.total = animatingTotal;\n        updateNodeTimingParams(node, swapAtTimings);\n      }\n\n      // Make sure the old state node has its inex and total values up to date for valid \"from\" function values calculation\n      oldStateNode.index = node.index;\n      oldStateNode.total = node.total;\n\n      // Computes all values up front so we can check for changes and we don't have to re-compute them inside the animation props\n      for (let prop in nodeProperties) {\n        nodeProperties[prop] = getFunctionValue(nodeProperties[prop], $el, node.index, node.total);\n        oldStateNodeProperties[prop] = getFunctionValue(oldStateNodeProperties[prop], $el, oldStateNode.index, oldStateNode.total);\n      }\n\n      // Use a 1px tolerance to detect dimensions changes to prevent width / height animations on barelly visible elements\n      const sizeTolerance = 1;\n      const widthChanged = Math.abs(nodeProperties.width - oldStateNodeProperties.width) > sizeTolerance;\n      const heightChanged = Math.abs(nodeProperties.height - oldStateNodeProperties.height) > sizeTolerance;\n\n      node.sizeChanged = (widthChanged || heightChanged);\n\n      // const hiddenStateChanged = (topLevelAdded || newlyRemoved) && wasRemovedBefore !== isRemovedNow;\n\n      if (node.isTarget && (!node.measuredIsRemoved && oldStateNode.measuredIsVisible || node.measuredIsRemoved && node.measuredIsVisible)) {\n        if (nodeProperties.transform !== 'none' || oldStateNodeProperties.transform !== 'none') {\n          node.hasTransform = true;\n          transformed.push($el);\n        }\n        for (let prop in nodeProperties) {\n          // if (prop !== 'transform' && (nodeProperties[prop] !== oldStateNodeProperties[prop] || hiddenStateChanged)) {\n          if (prop !== 'transform' && (nodeProperties[prop] !== oldStateNodeProperties[prop])) {\n            animated.push($el);\n            break;\n          }\n        }\n      }\n\n      if (!node.isTarget) {\n        swapping.push($el);\n        if (node.sizeChanged && parent && parent.isTarget && parent.sizeChanged) {\n          if (swapAtProps.transform) {\n            node.hasTransform = true;\n            transformed.push($el);\n          }\n          animatedSwap.push($el);\n        }\n      }\n\n    });\n\n    const timingParams = {\n      delay: (/** @type {HTMLElement} */$el) => newState.getNode($el).delay,\n      duration: (/** @type {HTMLElement} */$el) => newState.getNode($el).duration,\n      ease: (/** @type {HTMLElement} */$el) => newState.getNode($el).ease,\n    };\n\n    tlParams.defaults = timingParams;\n\n    this.timeline = createTimeline(tlParams);\n\n    // Imediatly return the timeline if no layout changes detected\n    if (!animated.length && !transformed.length && !swapping.length) {\n      // Make sure to restore all CSS transition if no animation\n      restoreLayoutTransition(this.transitionMuteStore);\n      return this.timeline.complete();\n    }\n\n    if (targets.length) {\n\n      this.root.classList.add('is-animated');\n\n      for (let i = 0, l = targets.length; i < l; i++) {\n        const $el = targets[i];\n        const id = $el.dataset.layoutId;\n        const oldNode = oldState.nodes.get(id);\n        const newNode = newState.nodes.get(id);\n        const oldNodeState = oldNode.properties;\n\n        // muteNodeTransition(newNode);\n\n        // Don't animate positions of inlined elements (to avoid text reflow)\n        if (!newNode.isInlined) {\n          // Display grid can mess with the absolute positioning, so set it to block during transition\n          if (oldNode.measuredDisplay === 'grid' || newNode.measuredDisplay === 'grid') $el.style.setProperty('display', 'block', 'important');\n          // All children must be in position absolute or fixed\n          if ($el !== $root || this.absoluteCoords) {\n            $el.style.position = this.absoluteCoords ? 'fixed' : 'absolute';\n            $el.style.left = '0px';\n            $el.style.top = '0px';\n            $el.style.marginLeft = '0px';\n            $el.style.marginTop = '0px';\n            $el.style.translate = `${oldNodeState.x}px ${oldNodeState.y}px`;\n          }\n          if ($el === $root && newNode.measuredPosition === 'static') {\n            $el.style.position = 'relative';\n            // Cancel left / trop in case the static element had muted values now activated by potision relative\n            $el.style.left = '0px';\n            $el.style.top = '0px';\n          }\n        }\n        // Animate dimensions for all elements (including inlined)\n        $el.style.width = `${oldNodeState.width}px`;\n        $el.style.height = `${oldNodeState.height}px`;\n        // Overrides user defined min and max to prevents width and height clamping\n        $el.style.minWidth = `auto`;\n        $el.style.minHeight = `auto`;\n        $el.style.maxWidth = `none`;\n        $el.style.maxHeight = `none`;\n      }\n\n      // Restore the scroll position if the oldState differs from the current state\n      if (oldState.scrollX !== window.scrollX || oldState.scrollY !== window.scrollY) {\n        // Restoring in the next frame avoids race conditions if for example a waapi animation commit styles that affect the root height\n        requestAnimationFrame(() => window.scrollTo(oldState.scrollX, oldState.scrollY));\n      }\n\n      for (let i = 0, l = animated.length; i < l; i++) {\n        const $el = animated[i];\n        const id = $el.dataset.layoutId;\n        const oldNode = oldState.nodes.get(id);\n        const newNode = newState.nodes.get(id);\n        const oldNodeState = oldNode.properties;\n        const newNodeState = newNode.properties;\n        let nodeHasChanged = false;\n        /** @type {AnimationParams} */\n        const animatedProps = {\n          composition: 'none',\n        };\n        if (oldNodeState.width !== newNodeState.width) {\n          animatedProps.width = [oldNodeState.width, newNodeState.width];\n          nodeHasChanged = true;\n        }\n        if (oldNodeState.height !== newNodeState.height) {\n          animatedProps.height = [oldNodeState.height, newNodeState.height];\n          nodeHasChanged = true;\n        }\n        // If the node has transforms we handle the translate animation in waapi otherwise translate and other transforms can be out of sync\n        // And we don't animate the position of inlined elements\n        if (!newNode.hasTransform && !newNode.isInlined) {\n          animatedProps.translate = [`${oldNodeState.x}px ${oldNodeState.y}px`, `${newNodeState.x}px ${newNodeState.y}px`];\n          nodeHasChanged = true;\n        }\n        this.properties.forEach(prop => {\n          const oldVal = oldNodeState[prop];\n          const newVal = newNodeState[prop];\n          if (prop !== 'transform' && oldVal !== newVal) {\n            animatedProps[prop] = [oldVal, newVal];\n            nodeHasChanged = true;\n          }\n        });\n        if (nodeHasChanged) {\n          this.timeline.add($el, animatedProps, 0);\n        }\n      }\n\n    }\n\n    if (swapping.length) {\n\n      for (let i = 0, l = swapping.length; i < l; i++) {\n        const $el = swapping[i];\n        const oldNode = oldState.getNode($el);\n        const oldNodeProps = oldNode.properties;\n        $el.style.width = `${oldNodeProps.width}px`;\n        $el.style.height = `${oldNodeProps.height}px`;\n        // Overrides user defined min and max to prevents width and height clamping\n        $el.style.minWidth = `auto`;\n        $el.style.minHeight = `auto`;\n        $el.style.maxWidth = `none`;\n        $el.style.maxHeight = `none`;\n        // We don't animate the position of inlined elements\n        if (!oldNode.isInlined) {\n          $el.style.translate = `${oldNodeProps.x}px ${oldNodeProps.y}px`;\n        }\n        this.properties.forEach(prop => {\n          if (prop !== 'transform') {\n            $el.style[prop] = `${oldState.getComputedValue($el, prop)}`;\n          }\n        });\n      }\n\n      for (let i = 0, l = swapping.length; i < l; i++) {\n        const $el = swapping[i];\n        const newNode = newState.getNode($el);\n        const newNodeProps = newNode.properties;\n        this.timeline.call(() => {\n          $el.style.width = `${newNodeProps.width}px`;\n          $el.style.height = `${newNodeProps.height}px`;\n          // Overrides user defined min and max to prevents width and height clamping\n          $el.style.minWidth = `auto`;\n          $el.style.minHeight = `auto`;\n          $el.style.maxWidth = `none`;\n          $el.style.maxHeight = `none`;\n          // Don't set translate for inlined elements (to avoid text reflow)\n          if (!newNode.isInlined) {\n            $el.style.translate = `${newNodeProps.x}px ${newNodeProps.y}px`;\n          }\n          this.properties.forEach(prop => {\n            if (prop !== 'transform') {\n              $el.style[prop] = `${newState.getComputedValue($el, prop)}`;\n            }\n          });\n        }, newNode.delay + newNode.duration / 2);\n      }\n\n      if (animatedSwap.length) {\n        const ease = parseEase(newState.nodes.get(animatedSwap[0].dataset.layoutId).ease);\n        const inverseEased = t => 1 - ease(1 - t);\n        const animatedSwapParams = /** @type {AnimationParams} */({});\n        if (swapAtProps) {\n          for (let prop in swapAtProps) {\n            if (prop !== 'transform') {\n              animatedSwapParams[prop] = [\n                { from: (/** @type {HTMLElement} */$el) => oldState.getComputedValue($el, prop), to: swapAtProps[prop] },\n                { from: swapAtProps[prop], to: (/** @type {HTMLElement} */$el) => newState.getComputedValue($el, prop), ease: inverseEased }\n              ];\n            }\n          }\n        }\n        this.timeline.add(animatedSwap, animatedSwapParams, 0);\n      }\n\n    }\n\n    const transformedLength = transformed.length;\n\n    if (transformedLength) {\n      // We only need to set the transform property here since translate is already defined in the targets loop\n      for (let i = 0; i < transformedLength; i++) {\n        const $el = transformed[i];\n        const node = newState.getNode($el);\n        // Don't set translate for inlined elements (to avoid text reflow)\n        if (!node.isInlined) {\n          $el.style.translate = `${oldState.getComputedValue($el, 'x')}px ${oldState.getComputedValue($el, 'y')}px`;\n        }\n        $el.style.transform = oldState.getComputedValue($el, 'transform');\n        if (animatedSwap.includes($el)) {\n          node.ease = getFunctionValue(swapAtParams.ease, $el, node.index, node.total);\n          node.duration = getFunctionValue(swapAtParams.duration, $el, node.index, node.total);\n        }\n      }\n      this.transformAnimation = waapi.animate(transformed, {\n        translate: (/** @type {HTMLElement} */$el) => {\n          const node = newState.getNode($el);\n          // Don't animate translate for inlined elements (to avoid text reflow)\n          if (node.isInlined) return '0px 0px';\n          return `${newState.getComputedValue($el, 'x')}px ${newState.getComputedValue($el, 'y')}px`;\n        },\n        transform: (/** @type {HTMLElement} */$el) => {\n          const newValue = newState.getComputedValue($el, 'transform');\n          if (!animatedSwap.includes($el)) return newValue;\n          const oldValue = oldState.getComputedValue($el, 'transform');\n          const node = newState.getNode($el);\n          return [oldValue, getFunctionValue(swapAtProps.transform, $el, node.index, node.total), newValue]\n        },\n        autoplay: false,\n        // persist: true,\n        ...timingParams,\n      });\n      this.timeline.sync(this.transformAnimation, 0);\n    }\n\n    return this.timeline.init();\n  }\n\n  /**\n   * @param {(layout: this) => void} callback\n   * @param {LayoutAnimationParams} [params]\n   * @return {Timeline}\n   */\n  update(callback, params = {}) {\n    this.record();\n    callback(this);\n    return this.animate(params);\n  }\n}\n\n/**\n * @param {DOMTargetSelector} root\n * @param {AutoLayoutParams} [params]\n * @return {AutoLayout}\n */\nconst createLayout = (root, params) => new AutoLayout(root, params);\n\nexport { AutoLayout, createLayout };\n","/**\n * Anime.js - utils - ESM\n * @version v4.3.6\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { noop } from '../core/consts.js';\nimport * as number from './number.js';\n\n// Chain-able utilities\n\nconst numberUtils = number; // Needed to keep the import when bundling\n\nconst chainables = {};\n\n/**\n * @callback UtilityFunction\n * @param {...*} args\n * @return {Number|String}\n *\n * @param {UtilityFunction} fn\n * @param {Number} [last=0]\n * @return {function(...(Number|String)): function(Number|String): (Number|String)}\n */\nconst curry = (fn, last = 0) => (...args) => last ? v => fn(...args, v) : v => fn(v, ...args);\n\n/**\n * @param {Function} fn\n * @return {function(...(Number|String))}\n */\nconst chain = fn => {\n   return (...args) => {\n    const result = fn(...args);\n    return new Proxy(noop, {\n      apply: (_, __, [v]) => result(v),\n      get: (_, prop) => chain(/**@param {...Number|String} nextArgs */(...nextArgs) => {\n        const nextResult = chainables[prop](...nextArgs);\n        return (/**@type {Number|String} */v) => nextResult(result(v));\n      })\n    });\n  }\n};\n\n/**\n * @param {UtilityFunction} fn\n * @param {String} name\n * @param {Number} [right]\n * @return {function(...(Number|String)): UtilityFunction}\n */\nconst makeChainable = (name, fn, right = 0) => {\n  const chained = (...args) => (args.length < fn.length ? chain(curry(fn, right)) : fn)(...args);\n  if (!chainables[name]) chainables[name] = chained;\n  return chained;\n};\n\n/**\n * @typedef {Object} ChainablesMap\n * @property {ChainedClamp} clamp\n * @property {ChainedRound} round\n * @property {ChainedSnap} snap\n * @property {ChainedWrap} wrap\n * @property {ChainedLerp} lerp\n * @property {ChainedDamp} damp\n * @property {ChainedMapRange} mapRange\n * @property {ChainedRoundPad} roundPad\n * @property {ChainedPadStart} padStart\n * @property {ChainedPadEnd} padEnd\n * @property {ChainedDegToRad} degToRad\n * @property {ChainedRadToDeg} radToDeg\n */\n\n/**\n * @callback ChainedUtilsResult\n * @param {Number} value - The value to process through the chained operations\n * @return {Number} The processed result\n */\n\n/**\n * @typedef {ChainablesMap & ChainedUtilsResult} ChainableUtil\n */\n\n// Chainable\n\n/**\n * @callback ChainedRoundPad\n * @param {Number} decimalLength - Number of decimal places\n * @return {ChainableUtil}\n */\nconst roundPad = /** @type {typeof numberUtils.roundPad & ChainedRoundPad} */(makeChainable('roundPad', numberUtils.roundPad));\n\n/**\n * @callback ChainedPadStart\n * @param {Number} totalLength - Target length\n * @param {String} padString - String to pad with\n * @return {ChainableUtil}\n */\nconst padStart = /** @type {typeof numberUtils.padStart & ChainedPadStart} */(makeChainable('padStart', numberUtils.padStart));\n\n/**\n * @callback ChainedPadEnd\n * @param {Number} totalLength - Target length\n * @param {String} padString - String to pad with\n * @return {ChainableUtil}\n */\nconst padEnd = /** @type {typeof numberUtils.padEnd & ChainedPadEnd} */(makeChainable('padEnd', numberUtils.padEnd));\n\n/**\n * @callback ChainedWrap\n * @param {Number} min - Minimum boundary\n * @param {Number} max - Maximum boundary\n * @return {ChainableUtil}\n */\nconst wrap = /** @type {typeof numberUtils.wrap & ChainedWrap} */(makeChainable('wrap', numberUtils.wrap));\n\n/**\n * @callback ChainedMapRange\n * @param {Number} inLow - Input range minimum\n * @param {Number} inHigh - Input range maximum\n * @param {Number} outLow - Output range minimum\n * @param {Number} outHigh - Output range maximum\n * @return {ChainableUtil}\n */\nconst mapRange = /** @type {typeof numberUtils.mapRange & ChainedMapRange} */(makeChainable('mapRange', numberUtils.mapRange));\n\n/**\n * @callback ChainedDegToRad\n * @return {ChainableUtil}\n */\nconst degToRad = /** @type {typeof numberUtils.degToRad & ChainedDegToRad} */(makeChainable('degToRad', numberUtils.degToRad));\n\n/**\n * @callback ChainedRadToDeg\n * @return {ChainableUtil}\n */\nconst radToDeg = /** @type {typeof numberUtils.radToDeg & ChainedRadToDeg} */(makeChainable('radToDeg', numberUtils.radToDeg));\n\n/**\n * @callback ChainedSnap\n * @param {Number|Array<Number>} increment - Step size or array of snap points\n * @return {ChainableUtil}\n */\nconst snap = /** @type {typeof numberUtils.snap & ChainedSnap} */(makeChainable('snap', numberUtils.snap));\n\n/**\n * @callback ChainedClamp\n * @param {Number} min - Minimum boundary\n * @param {Number} max - Maximum boundary\n * @return {ChainableUtil}\n */\nconst clamp = /** @type {typeof numberUtils.clamp & ChainedClamp} */(makeChainable('clamp', numberUtils.clamp));\n\n/**\n * @callback ChainedRound\n * @param {Number} decimalLength - Number of decimal places\n * @return {ChainableUtil}\n */\nconst round = /** @type {typeof numberUtils.round & ChainedRound} */(makeChainable('round', numberUtils.round));\n\n/**\n * @callback ChainedLerp\n * @param {Number} start - Starting value\n * @param {Number} end - Ending value\n * @return {ChainableUtil}\n */\nconst lerp = /** @type {typeof numberUtils.lerp & ChainedLerp} */(makeChainable('lerp', numberUtils.lerp, 1));\n\n/**\n * @callback ChainedDamp\n * @param {Number} start - Starting value\n * @param {Number} end - Target value\n * @param {Number} deltaTime - Delta time in ms\n * @return {ChainableUtil}\n */\nconst damp = /** @type {typeof numberUtils.damp & ChainedDamp} */(makeChainable('damp', numberUtils.damp, 1));\n\nexport { clamp, damp, degToRad, lerp, mapRange, padEnd, padStart, radToDeg, round, roundPad, snap, wrap };\n","/**\n * Anime.js - utils - ESM\n * @version v4.3.6\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\n/**\n * Generate a random number between optional min and max (inclusive) and decimal precision\n *\n * @callback RandomNumberGenerator\n * @param    {Number} [min=0] - The minimum value (inclusive)\n * @param    {Number} [max=1] - The maximum value (inclusive)\n * @param    {Number} [decimalLength=0] - Number of decimal places to round to\n * @return   {Number} A random number between min and max\n */\n\n/**\n * Generates a random number between min and max (inclusive) with optional decimal precision\n *\n * @type {RandomNumberGenerator}\n */\nconst random = (min = 0, max = 1, decimalLength = 0) => {\n  const m = 10 ** decimalLength;\n  return Math.floor((Math.random() * (max - min + (1 / m)) + min) * m) / m;\n};\n\nlet _seed = 0;\n\n/**\n * Creates a seeded pseudorandom number generator function\n *\n * @param  {Number} [seed] - The seed value for the random number generator\n * @param  {Number} [seededMin=0] - The minimum default value (inclusive) of the returned function\n * @param  {Number} [seededMax=1] - The maximum default value (inclusive) of the returned function\n * @param  {Number} [seededDecimalLength=0] - Default number of decimal places to round to of the returned function\n * @return {RandomNumberGenerator} A function to generate a random number between optional min and max (inclusive) and decimal precision\n */\nconst createSeededRandom = (seed, seededMin = 0, seededMax = 1, seededDecimalLength = 0) => {\n  let t = seed === undefined ? _seed++ : seed;\n  return (min = seededMin, max = seededMax, decimalLength = seededDecimalLength) => {\n    t += 0x6D2B79F5;\n    t = Math.imul(t ^ t >>> 15, t | 1);\n    t ^= t + Math.imul(t ^ t >>> 7, t | 61);\n    const m = 10 ** decimalLength;\n    return Math.floor(((((t ^ t >>> 14) >>> 0) / 4294967296) * (max - min + (1 / m)) + min) * m) / m;\n  }\n};\n\n/**\n * Picks a random element from an array or a string\n *\n * @template T\n * @param    {String|Array<T>} items - The array or string to pick from\n * @return   {String|T} A random element from the array or character from the string\n */\nconst randomPick = items => items[random(0, items.length - 1)];\n\n/**\n * Shuffles an array in-place using the Fisher-Yates algorithm\n * Adapted from https://bost.ocks.org/mike/shuffle/\n *\n * @param  {Array} items - The array to shuffle (will be modified in-place)\n * @return {Array} The same array reference, now shuffled\n */\nconst shuffle = items => {\n  let m = items.length, t, i;\n  while (m) { i = random(0, --m); t = items[m]; items[m] = items[i]; items[i] = t; }\n  return items;\n};\n\nexport { createSeededRandom, random, randomPick, shuffle };\n","/**\n * Anime.js - utils - ESM\n * @version v4.3.6\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { unitsExecRgx, emptyString } from '../core/consts.js';\nimport { isUnd, parseNumber, isFnc, abs, floor, sqrt, round, isArr, isNum, isStr, max } from '../core/helpers.js';\nimport { parseEase } from '../easings/eases/parser.js';\nimport { parseTimelinePosition } from '../timeline/position.js';\nimport { getOriginalAnimatableValue } from '../core/values.js';\nimport { registerTargets } from '../core/targets.js';\nimport { shuffle } from './random.js';\n\n/**\n * @import {\n *   StaggerParams,\n *   StaggerFunction,\n * } from '../types/index.js'\n*/\n\n/**\n * @import {\n *   Spring,\n * } from '../easings/spring/index.js'\n*/\n\n/**\n * @overload\n * @param {Number} val\n * @param {StaggerParams} [params]\n * @return {StaggerFunction<Number>}\n */\n/**\n * @overload\n * @param {String} val\n * @param {StaggerParams} [params]\n * @return {StaggerFunction<String>}\n */\n/**\n * @overload\n * @param {[Number, Number]} val\n * @param {StaggerParams} [params]\n * @return {StaggerFunction<Number>}\n */\n/**\n * @overload\n * @param {[String, String]} val\n * @param {StaggerParams} [params]\n * @return {StaggerFunction<String>}\n */\n/**\n * @param {Number|String|[Number, Number]|[String, String]} val The staggered value or range\n * @param {StaggerParams} [params] The stagger parameters\n * @return {StaggerFunction<Number|String>}\n */\nconst stagger = (val, params = {}) => {\n  let values = [];\n  let maxValue = 0;\n  const from = params.from;\n  const reversed = params.reversed;\n  const ease = params.ease;\n  const hasEasing = !isUnd(ease);\n  const hasSpring = hasEasing && !isUnd(/** @type {Spring} */(ease).ease);\n  const staggerEase = hasSpring ? /** @type {Spring} */(ease).ease : hasEasing ? parseEase(ease) : null;\n  const grid = params.grid;\n  const axis = params.axis;\n  const customTotal = params.total;\n  const fromFirst = isUnd(from) || from === 0 || from === 'first';\n  const fromCenter = from === 'center';\n  const fromLast = from === 'last';\n  const fromRandom = from === 'random';\n  const isRange = isArr(val);\n  const useProp = params.use;\n  const val1 = isRange ? parseNumber(val[0]) : parseNumber(val);\n  const val2 = isRange ? parseNumber(val[1]) : 0;\n  const unitMatch = unitsExecRgx.exec((isRange ? val[1] : val) + emptyString);\n  const start = params.start || 0 + (isRange ? val1 : 0);\n  let fromIndex = fromFirst ? 0 : isNum(from) ? from : 0;\n  return (target, i, t, tl) => {\n    const [ registeredTarget ] = registerTargets(target);\n    const total = isUnd(customTotal) ? t : customTotal;\n    const customIndex = !isUnd(useProp) ? isFnc(useProp) ? useProp(registeredTarget, i, total) : getOriginalAnimatableValue(registeredTarget, useProp) : false;\n    const staggerIndex = isNum(customIndex) || isStr(customIndex) && isNum(+customIndex) ? +customIndex : i;\n    if (fromCenter) fromIndex = (total - 1) / 2;\n    if (fromLast) fromIndex = total - 1;\n    if (!values.length) {\n      for (let index = 0; index < total; index++) {\n        if (!grid) {\n          values.push(abs(fromIndex - index));\n        } else {\n          const fromX = !fromCenter ? fromIndex % grid[0] : (grid[0] - 1) / 2;\n          const fromY = !fromCenter ? floor(fromIndex / grid[0]) : (grid[1] - 1) / 2;\n          const toX = index % grid[0];\n          const toY = floor(index / grid[0]);\n          const distanceX = fromX - toX;\n          const distanceY = fromY - toY;\n          let value = sqrt(distanceX * distanceX + distanceY * distanceY);\n          if (axis === 'x') value = -distanceX;\n          if (axis === 'y') value = -distanceY;\n          values.push(value);\n        }\n        maxValue = max(...values);\n      }\n      if (staggerEase) values = values.map(val => staggerEase(val / maxValue) * maxValue);\n      if (reversed) values = values.map(val => axis ? (val < 0) ? val * -1 : -val : abs(maxValue - val));\n      if (fromRandom) values = shuffle(values);\n    }\n    const spacing = isRange ? (val2 - val1) / maxValue : val1;\n    const offset = tl ? parseTimelinePosition(tl, isUnd(params.start) ? tl.iterationDuration : start) : /** @type {Number} */(start);\n    /** @type {String|Number} */\n    let output = offset + ((spacing * round(values[staggerIndex], 2)) || 0);\n    if (params.modifier) output = params.modifier(output);\n    if (unitMatch) output = `${output}${unitMatch[2]}`;\n    return output;\n  }\n};\n\nexport { stagger };\n","/**\n * Anime.js - svg - ESM\n * @version v4.3.6\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { isSvg } from '../core/helpers.js';\nimport { parseTargets } from '../core/targets.js';\n\n/**\n * @import {\n *   TargetsParam,\n * } from '../types/index.js'\n*/\n\n/**\n * @param  {TargetsParam} path\n * @return {SVGGeometryElement|void}\n */\nconst getPath = path => {\n  const parsedTargets = parseTargets(path);\n  const $parsedSvg = /** @type {SVGGeometryElement} */(parsedTargets[0]);\n  if (!$parsedSvg || !isSvg($parsedSvg)) return console.warn(`${path} is not a valid SVGGeometryElement`);\n  return $parsedSvg;\n};\n\nexport { getPath };\n","/**\n * Anime.js - svg - ESM\n * @version v4.3.6\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { isSvgSymbol } from '../core/consts.js';\nimport { atan2, PI } from '../core/helpers.js';\nimport { getPath } from './helpers.js';\n\n/**\n * @import {\n *   TargetsParam,\n *   FunctionValue,\n *   TweenObjectValue,\n *   TweenModifier,\n * } from '../types/index.js'\n*/\n\n// Motion path animation\n\n/**\n * @param {SVGGeometryElement} $path\n * @param {Number} totalLength\n * @param {Number} progress\n * @param {Number} lookup\n * @param {Boolean} shouldClamp\n * @return {DOMPoint}\n */\nconst getPathPoint = ($path, totalLength, progress, lookup, shouldClamp) => {\n  const point = progress + lookup;\n  const pointOnPath = shouldClamp\n    ? Math.max(0, Math.min(point, totalLength)) // Clamp between 0 and totalLength\n    : (point % totalLength + totalLength) % totalLength; // Wrap around\n  return $path.getPointAtLength(pointOnPath);\n};\n\n/**\n * @param {SVGGeometryElement} $path\n * @param {String} pathProperty\n * @param {Number} [offset=0]\n * @return {FunctionValue}\n */\nconst getPathProgess = ($path, pathProperty, offset = 0) => {\n  return $el => {\n    const totalLength = +($path.getTotalLength());\n    const inSvg = $el[isSvgSymbol];\n    const ctm = $path.getCTM();\n    const shouldClamp = offset === 0;\n    /** @type {TweenObjectValue} */\n    return {\n      from: 0,\n      to: totalLength,\n      /** @type {TweenModifier} */\n      modifier: progress => {\n        const offsetLength = offset * totalLength;\n        const newProgress = progress + offsetLength;\n        if (pathProperty === 'a') {\n          const p0 = getPathPoint($path, totalLength, newProgress, -1, shouldClamp);\n          const p1 = getPathPoint($path, totalLength, newProgress, 1, shouldClamp);\n          return atan2(p1.y - p0.y, p1.x - p0.x) * 180 / PI;\n        } else {\n          const p = getPathPoint($path, totalLength, newProgress, 0, shouldClamp);\n          return pathProperty === 'x' ?\n            inSvg || !ctm ? p.x : p.x * ctm.a + p.y * ctm.c + ctm.e :\n            inSvg || !ctm ? p.y : p.x * ctm.b + p.y * ctm.d + ctm.f\n        }\n      }\n    }\n  }\n};\n\n/**\n * @param {TargetsParam} path\n * @param {Number} [offset=0]\n */\nconst createMotionPath = (path, offset = 0) => {\n  const $path = getPath(path);\n  if (!$path) return;\n  return {\n    translateX: getPathProgess($path, 'x', offset),\n    translateY: getPathProgess($path, 'y', offset),\n    rotate: getPathProgess($path, 'a', offset),\n  }\n};\n\nexport { createMotionPath };\n","/**\n * Anime.js - svg - ESM\n * @version v4.3.6\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { proxyTargetSymbol, K } from '../core/consts.js';\nimport { isFnc, sqrt } from '../core/helpers.js';\nimport { parseTargets } from '../core/targets.js';\n\n/**\n * @import {\n *   TargetsParam,\n *   DrawableSVGGeometry,\n * } from '../types/index.js'\n*/\n\n/**\n * @param {SVGGeometryElement} [$el]\n * @return {Number}\n */\nconst getScaleFactor = $el => {\n  let scaleFactor = 1;\n  if ($el && $el.getCTM) {\n    const ctm = $el.getCTM();\n    if (ctm) {\n      const scaleX = sqrt(ctm.a * ctm.a + ctm.b * ctm.b);\n      const scaleY = sqrt(ctm.c * ctm.c + ctm.d * ctm.d);\n      scaleFactor = (scaleX + scaleY) / 2;\n    }\n  }\n  return scaleFactor;\n};\n\n/**\n * Creates a proxy that wraps an SVGGeometryElement and adds drawing functionality.\n * @param {SVGGeometryElement} $el - The SVG element to transform into a drawable\n * @param {number} start - Starting position (0-1)\n * @param {number} end - Ending position (0-1)\n * @return {DrawableSVGGeometry} - Returns a proxy that preserves the original element's type with additional 'draw' attribute functionality\n */\nconst createDrawableProxy = ($el, start, end) => {\n  const pathLength = K;\n  const computedStyles = getComputedStyle($el);\n  const strokeLineCap = computedStyles.strokeLinecap;\n  // @ts-ignore\n  const $scalled = computedStyles.vectorEffect === 'non-scaling-stroke' ? $el : null;\n  let currentCap = strokeLineCap;\n\n  const proxy = new Proxy($el, {\n    get(target, property) {\n      const value = target[property];\n      if (property === proxyTargetSymbol) return target;\n      if (property === 'setAttribute') {\n        return (...args) => {\n          if (args[0] === 'draw') {\n            const value = args[1];\n            const values = value.split(' ');\n            const v1 = +values[0];\n            const v2 = +values[1];\n            // TOTO: Benchmark if performing two slices is more performant than one split\n            // const spaceIndex = value.indexOf(' ');\n            // const v1 = round(+value.slice(0, spaceIndex), precision);\n            // const v2 = round(+value.slice(spaceIndex + 1), precision);\n            const scaleFactor = getScaleFactor($scalled);\n            const os = v1 * -pathLength * scaleFactor;\n            const d1 = (v2 * pathLength * scaleFactor) + os;\n            const d2 = (pathLength * scaleFactor +\n                      ((v1 === 0 && v2 === 1) || (v1 === 1 && v2 === 0) ? 0 : 10 * scaleFactor) - d1);\n            if (strokeLineCap !== 'butt') {\n              const newCap = v1 === v2 ? 'butt' : strokeLineCap;\n              if (currentCap !== newCap) {\n                target.style.strokeLinecap = `${newCap}`;\n                currentCap = newCap;\n              }\n            }\n            target.setAttribute('stroke-dashoffset', `${os}`);\n            target.setAttribute('stroke-dasharray', `${d1} ${d2}`);\n          }\n          return Reflect.apply(value, target, args);\n        };\n      }\n\n      if (isFnc(value)) {\n        return (...args) => Reflect.apply(value, target, args);\n      } else {\n        return value;\n      }\n    }\n  });\n\n  if ($el.getAttribute('pathLength') !== `${pathLength}`) {\n    $el.setAttribute('pathLength', `${pathLength}`);\n    proxy.setAttribute('draw', `${start} ${end}`);\n  }\n\n  return /** @type {DrawableSVGGeometry} */(proxy);\n};\n\n/**\n * Creates drawable proxies for multiple SVG elements.\n * @param {TargetsParam} selector - CSS selector, SVG element, or array of elements and selectors\n * @param {number} [start=0] - Starting position (0-1)\n * @param {number} [end=0] - Ending position (0-1)\n * @return {Array<DrawableSVGGeometry>} - Array of proxied elements with drawing functionality\n */\nconst createDrawable = (selector, start = 0, end = 0) => {\n  const els = parseTargets(selector);\n  return els.map($el => createDrawableProxy(\n    /** @type {SVGGeometryElement} */($el),\n    start,\n    end\n  ));\n};\n\nexport { createDrawable };\n","/**\n * Anime.js - svg - ESM\n * @version v4.3.6\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { morphPointsSymbol } from '../core/consts.js';\nimport { round } from '../core/helpers.js';\nimport { getPath } from './helpers.js';\n\n/**\n * @import {\n *   TargetsParam,\n *   FunctionValue\n * } from '../types/index.js'\n*/\n\n/**\n * @param  {TargetsParam} path2\n * @param  {Number} [precision]\n * @return {FunctionValue}\n */\nconst morphTo = (path2, precision = .33) => ($path1) => {\n  const tagName1 = ($path1.tagName || '').toLowerCase();\n  if (!tagName1.match(/^(path|polygon|polyline)$/)) {\n    throw new Error(`Can't morph a <${$path1.tagName}> SVG element. Use <path>, <polygon> or <polyline>.`);\n  }\n  const $path2 = /** @type {SVGGeometryElement} */(getPath(path2));\n  if (!$path2) {\n    throw new Error(\"Can't morph to an invalid target. 'path2' must resolve to an existing <path>, <polygon> or <polyline> SVG element.\");\n  }\n  const tagName2 = ($path2.tagName || '').toLowerCase();\n  if (!tagName2.match(/^(path|polygon|polyline)$/)) {\n    throw new Error(`Can't morph a <${$path2.tagName}> SVG element. Use <path>, <polygon> or <polyline>.`);\n  }\n  const isPath = $path1.tagName === 'path';\n  const separator = isPath ? ' ' : ',';\n  const previousPoints = $path1[morphPointsSymbol];\n  if (previousPoints) $path1.setAttribute(isPath ? 'd' : 'points', previousPoints);\n\n  let v1 = '', v2 = '';\n\n  if (!precision) {\n    v1 = $path1.getAttribute(isPath ? 'd' : 'points');\n    v2 = $path2.getAttribute(isPath ? 'd' : 'points');\n  } else {\n    const length1 = /** @type {SVGGeometryElement} */($path1).getTotalLength();\n    const length2 = $path2.getTotalLength();\n    const maxPoints = Math.max(Math.ceil(length1 * precision), Math.ceil(length2 * precision));\n    for (let i = 0; i < maxPoints; i++) {\n      const t = i / (maxPoints - 1);\n      const pointOnPath1 = /** @type {SVGGeometryElement} */($path1).getPointAtLength(length1 * t);\n      const pointOnPath2 = $path2.getPointAtLength(length2 * t);\n      const prefix = isPath ? (i === 0 ? 'M' : 'L') : '';\n      v1 += prefix + round(pointOnPath1.x, 3) + separator + pointOnPath1.y + ' ';\n      v2 += prefix + round(pointOnPath2.x, 3) + separator + pointOnPath2.y + ' ';\n    }\n  }\n\n  $path1[morphPointsSymbol] = v2;\n\n  return [v1, v2];\n};\n\nexport { morphTo };\n","/**\n * Anime.js - text - ESM\n * @version v4.3.6\n * @license MIT\n * @copyright 2026 - Julian Garnier\n */\n\nimport { isBrowser, doc } from '../core/consts.js';\nimport { scope } from '../core/globals.js';\nimport { isArr, isObj, isFnc, isUnd, isStr, isNum } from '../core/helpers.js';\nimport { getNodeList } from '../core/targets.js';\nimport { setValue } from '../core/values.js';\nimport { keepTime } from '../utils/time.js';\n\n/**\n * @import {\n *   Tickable,\n *   DOMTarget,\n *   SplitTemplateParams,\n *   SplitFunctionValue,\n *   TextSplitterParams,\n * } from '../types/index.js'\n*/\n\nconst segmenter = (typeof Intl !== 'undefined') && Intl.Segmenter;\nconst valueRgx = /\\{value\\}/g;\nconst indexRgx = /\\{i\\}/g;\nconst whiteSpaceGroupRgx = /(\\s+)/;\nconst whiteSpaceRgx = /^\\s+$/;\nconst lineType = 'line';\nconst wordType = 'word';\nconst charType = 'char';\nconst dataLine = `data-line`;\n\n/**\n * @typedef {Object} Segment\n * @property {String} segment\n * @property {Boolean} [isWordLike]\n */\n\n/**\n * @typedef {Object} Segmenter\n * @property {function(String): Iterable<Segment>} segment\n */\n\n/** @type {Segmenter} */\nlet wordSegmenter = null;\n/** @type {Segmenter} */\nlet graphemeSegmenter = null;\nlet $splitTemplate = null;\n\n/**\n * @param  {Segment} seg\n * @return {Boolean}\n */\nconst isSegmentWordLike = seg => {\n  return seg.isWordLike ||\n         seg.segment === ' ' || // Consider spaces as words first, then handle them diffrently later\n         isNum(+seg.segment);   // Safari doesn't considers numbers as words\n};\n\n/**\n * @param {HTMLElement} $el\n */\nconst setAriaHidden = $el => $el.setAttribute('aria-hidden', 'true');\n\n/**\n * @param {DOMTarget} $el\n * @param {String} type\n * @return {Array<HTMLElement>}\n */\nconst getAllTopLevelElements = ($el, type) => [.../** @type {*} */($el.querySelectorAll(`[data-${type}]:not([data-${type}] [data-${type}])`))];\n\nconst debugColors = { line: '#00D672', word: '#FF4B4B', char: '#5A87FF' };\n\n/**\n * @param {HTMLElement} $el\n */\nconst filterEmptyElements = $el => {\n  if (!$el.childElementCount && !$el.textContent.trim()) {\n    const $parent = $el.parentElement;\n    $el.remove();\n    if ($parent) filterEmptyElements($parent);\n  }\n};\n\n/**\n * @param {HTMLElement} $el\n * @param {Number} lineIndex\n * @param {Set<HTMLElement|Node>} bin\n * @returns {Set<HTMLElement|Node>}\n */\nconst filterLineElements = ($el, lineIndex, bin) => {\n  const dataLineAttr = $el.getAttribute(dataLine);\n  if (dataLineAttr !== null && +dataLineAttr !== lineIndex || $el.tagName === 'BR') {\n    bin.add($el);\n    // Also remove adjacent whitespace-only text nodes\n    const prev = $el.previousSibling;\n    const next = $el.nextSibling;\n    if (prev && prev.nodeType === 3 && whiteSpaceRgx.test(prev.textContent)) {\n      bin.add(prev);\n    }\n    if (next && next.nodeType === 3 && whiteSpaceRgx.test(next.textContent)) {\n      bin.add(next);\n    }\n  }\n  let i = $el.childElementCount;\n  while (i--) filterLineElements(/** @type {HTMLElement} */($el.children[i]), lineIndex, bin);\n  return bin;\n};\n\n/**\n * @param  {'line'|'word'|'char'} type\n * @param  {SplitTemplateParams} params\n * @return {String}\n */\nconst generateTemplate = (type, params = {}) => {\n  let template = ``;\n  const classString = isStr(params.class) ? ` class=\"${params.class}\"` : '';\n  const cloneType = setValue(params.clone, false);\n  const wrapType = setValue(params.wrap, false);\n  const overflow = wrapType ? wrapType === true ? 'clip' : wrapType : cloneType ? 'clip' : false;\n  if (wrapType) template += `<span${overflow ? ` style=\"overflow:${overflow};\"` : ''}>`;\n  template += `<span${classString}${cloneType ? ` style=\"position:relative;\"` : ''} data-${type}=\"{i}\">`;\n  if (cloneType) {\n    const left = cloneType === 'left' ? '-100%' : cloneType === 'right' ? '100%' : '0';\n    const top = cloneType === 'top' ? '-100%' : cloneType === 'bottom' ? '100%' : '0';\n    template += `<span>{value}</span>`;\n    template += `<span inert style=\"position:absolute;top:${top};left:${left};white-space:nowrap;\">{value}</span>`;\n  } else {\n    template += `{value}`;\n  }\n  template += `</span>`;\n  if (wrapType) template += `</span>`;\n  return template;\n};\n\n/**\n * @param  {String|SplitFunctionValue} htmlTemplate\n * @param  {Array<HTMLElement>} store\n * @param  {Node|HTMLElement} node\n * @param  {DocumentFragment} $parentFragment\n * @param  {'line'|'word'|'char'} type\n * @param  {Boolean} debug\n * @param  {Number} lineIndex\n * @param  {Number} [wordIndex]\n * @param  {Number} [charIndex]\n * @return {HTMLElement}\n */\nconst processHTMLTemplate = (htmlTemplate, store, node, $parentFragment, type, debug, lineIndex, wordIndex, charIndex) => {\n  const isLine = type === lineType;\n  const isChar = type === charType;\n  const className = `_${type}_`;\n  const template = isFnc(htmlTemplate) ? htmlTemplate(node) : htmlTemplate;\n  const displayStyle = isLine ? 'block' : 'inline-block';\n  $splitTemplate.innerHTML = template\n    .replace(valueRgx, `<i class=\"${className}\"></i>`)\n    .replace(indexRgx, `${isChar ? charIndex : isLine ? lineIndex : wordIndex}`);\n  const $content = $splitTemplate.content;\n  const $highestParent = /** @type {HTMLElement} */($content.firstElementChild);\n  const $split = /** @type {HTMLElement} */($content.querySelector(`[data-${type}]`)) || $highestParent;\n  const $replacables = /** @type {NodeListOf<HTMLElement>} */($content.querySelectorAll(`i.${className}`));\n  const replacablesLength = $replacables.length;\n  if (replacablesLength) {\n    $highestParent.style.display = displayStyle;\n    $split.style.display = displayStyle;\n    $split.setAttribute(dataLine, `${lineIndex}`);\n    if (!isLine) {\n      $split.setAttribute('data-word', `${wordIndex}`);\n      if (isChar) $split.setAttribute('data-char', `${charIndex}`);\n    }\n    let i = replacablesLength;\n    while (i--) {\n      const $replace = $replacables[i];\n      const $closestParent = $replace.parentElement;\n      $closestParent.style.display = displayStyle;\n      if (isLine) {\n        $closestParent.innerHTML = /** @type {HTMLElement} */(node).innerHTML;\n      } else {\n        $closestParent.replaceChild(node.cloneNode(true), $replace);\n      }\n    }\n    store.push($split);\n    $parentFragment.appendChild($content);\n  } else {\n    console.warn(`The expression \"{value}\" is missing from the provided template.`);\n  }\n  if (debug) $highestParent.style.outline = `1px dotted ${debugColors[type]}`;\n  return $highestParent;\n};\n\n/**\n * A class that splits text into words and wraps them in span elements while preserving the original HTML structure.\n * @class\n */\nclass TextSplitter {\n  /**\n   * @param  {HTMLElement|NodeList|String|Array<HTMLElement>} target\n   * @param  {TextSplitterParams} [parameters]\n   */\n  constructor(target, parameters = {}) {\n    // Only init segmenters when needed\n    if (!wordSegmenter) wordSegmenter = segmenter ? new segmenter([], { granularity: wordType }) : {\n      segment: (text) => {\n        const segments = [];\n        const words = text.split(whiteSpaceGroupRgx);\n        for (let i = 0, l = words.length; i < l; i++) {\n          const segment = words[i];\n          segments.push({\n            segment,\n            isWordLike: !whiteSpaceRgx.test(segment), // Consider non-whitespace as word-like\n          });\n        }\n        return segments;\n      }\n    };\n    if (!graphemeSegmenter) graphemeSegmenter = segmenter ? new segmenter([], { granularity: 'grapheme' }) : {\n      segment: text => [...text].map(char => ({ segment: char }))\n    };\n    if (!$splitTemplate && isBrowser) $splitTemplate = doc.createElement('template');\n    if (scope.current) scope.current.register(this);\n    const { words, chars, lines, accessible, includeSpaces, debug } = parameters;\n    const $target = /** @type {HTMLElement} */((target = isArr(target) ? target[0] : target) && /** @type {Node} */(target).nodeType ? target : (getNodeList(target) || [])[0]);\n    const lineParams = lines === true ? {} : lines;\n    const wordParams = words === true || isUnd(words) ? {} : words;\n    const charParams = chars === true ? {} : chars;\n    this.debug = setValue(debug, false);\n    this.includeSpaces = setValue(includeSpaces, false);\n    this.accessible = setValue(accessible, true);\n    this.linesOnly = lineParams && (!wordParams && !charParams);\n    /** @type {String|false|SplitFunctionValue} */\n    this.lineTemplate = isObj(lineParams) ? generateTemplate(lineType, /** @type {SplitTemplateParams} */(lineParams)) : lineParams;\n    /** @type {String|false|SplitFunctionValue} */\n    this.wordTemplate = isObj(wordParams) || this.linesOnly ? generateTemplate(wordType, /** @type {SplitTemplateParams} */(wordParams)) : wordParams;\n    /** @type {String|false|SplitFunctionValue} */\n    this.charTemplate = isObj(charParams) ? generateTemplate(charType, /** @type {SplitTemplateParams} */(charParams)) : charParams;\n    this.$target = $target;\n    this.html = $target && $target.innerHTML;\n    this.lines = [];\n    this.words = [];\n    this.chars = [];\n    this.effects = [];\n    this.effectsCleanups = [];\n    this.cache = null;\n    this.ready = false;\n    this.width = 0;\n    this.resizeTimeout = null;\n    const handleSplit = () => this.html && (lineParams || wordParams || charParams) && this.split();\n    // Make sure this is declared before calling handleSplit() in case revert() is called inside an effect callback\n    this.resizeObserver = new ResizeObserver(() => {\n      // Use a setTimeout instead of a Timer for better tree shaking\n      clearTimeout(this.resizeTimeout);\n      this.resizeTimeout = setTimeout(() => {\n        const currentWidth = /** @type {HTMLElement} */($target).offsetWidth;\n        if (currentWidth === this.width) return;\n        this.width = currentWidth;\n        handleSplit();\n      }, 150);\n    });\n    // Only declare the font ready promise when splitting by lines and not alreay split\n    if (this.lineTemplate && !this.ready) {\n      doc.fonts.ready.then(handleSplit);\n    } else {\n      handleSplit();\n    }\n    $target ? this.resizeObserver.observe($target) : console.warn('No Text Splitter target found.');\n  }\n\n  /**\n   * @param  {(...args: any[]) => Tickable | (() => void)} effect\n   * @return this\n   */\n  addEffect(effect) {\n    if (!isFnc(effect)) return console.warn('Effect must return a function.');\n    const refreshableEffect = keepTime(effect);\n    this.effects.push(refreshableEffect);\n    if (this.ready) this.effectsCleanups[this.effects.length - 1] = refreshableEffect(this);\n    return this;\n  }\n\n  revert() {\n    clearTimeout(this.resizeTimeout);\n    this.lines.length = this.words.length = this.chars.length = 0;\n    this.resizeObserver.disconnect();\n    // Make sure to revert the effects after disconnecting the resizeObserver to avoid triggering it in the process\n    this.effectsCleanups.forEach(cleanup => isFnc(cleanup) ? cleanup(this) : cleanup.revert && cleanup.revert());\n    this.$target.innerHTML = this.html;\n    return this;\n  }\n\n  /**\n   * Recursively processes a node and its children\n   * @param {Node} node\n   */\n  splitNode(node) {\n    const wordTemplate = this.wordTemplate;\n    const charTemplate = this.charTemplate;\n    const includeSpaces = this.includeSpaces;\n    const debug = this.debug;\n    const nodeType = node.nodeType;\n    if (nodeType === 3) {\n      const nodeText = node.nodeValue;\n      // If the nodeText is only whitespace, leave it as is\n      if (nodeText.trim()) {\n        const tempWords = [];\n        const words = this.words;\n        const chars = this.chars;\n        const wordSegments = wordSegmenter.segment(nodeText);\n        const $wordsFragment = doc.createDocumentFragment();\n        let prevSeg = null;\n        for (const wordSegment of wordSegments) {\n          const segment = wordSegment.segment;\n          const isWordLike = isSegmentWordLike(wordSegment);\n          // Determine if this segment should be a new word, first segment always becomes a new word\n          if (!prevSeg || (isWordLike && (prevSeg && (isSegmentWordLike(prevSeg))))) {\n            tempWords.push(segment);\n          } else {\n            // Only concatenate if both current and previous are non-word-like and don't contain spaces\n            const lastWordIndex = tempWords.length - 1;\n            const lastWord = tempWords[lastWordIndex];\n            if (!whiteSpaceGroupRgx.test(lastWord) && !whiteSpaceGroupRgx.test(segment)) {\n              tempWords[lastWordIndex] += segment;\n            } else {\n              tempWords.push(segment);\n            }\n          }\n          prevSeg = wordSegment;\n        }\n\n        for (let i = 0, l = tempWords.length; i < l; i++) {\n          const word = tempWords[i];\n          if (!word.trim()) {\n            // Preserve whitespace only if includeSpaces is false and if the current space is not the first node\n            if (i && includeSpaces) continue;\n            $wordsFragment.appendChild(doc.createTextNode(word));\n          } else {\n            const nextWord = tempWords[i + 1];\n            const hasWordFollowingSpace = includeSpaces && nextWord && !nextWord.trim();\n            const wordToProcess = word;\n            const charSegments = charTemplate ? graphemeSegmenter.segment(wordToProcess) : null;\n            const $charsFragment = charTemplate ? doc.createDocumentFragment() : doc.createTextNode(hasWordFollowingSpace ? word + '\\xa0' : word);\n            if (charTemplate) {\n              const charSegmentsArray = [...charSegments];\n              for (let j = 0, jl = charSegmentsArray.length; j < jl; j++) {\n                const charSegment = charSegmentsArray[j];\n                const isLastChar = j === jl - 1;\n                // If this is the last character and includeSpaces is true with a following space, append the space\n                const charText = isLastChar && hasWordFollowingSpace ? charSegment.segment + '\\xa0' : charSegment.segment;\n                const $charNode = doc.createTextNode(charText);\n                processHTMLTemplate(charTemplate, chars, $charNode, /** @type {DocumentFragment} */($charsFragment), charType, debug, -1, words.length, chars.length);\n              }\n            }\n            if (wordTemplate) {\n              processHTMLTemplate(wordTemplate, words, $charsFragment, $wordsFragment, wordType, debug, -1, words.length, chars.length);\n              // Chars elements must be re-parsed in the split() method if both words and chars are parsed\n            } else if (charTemplate) {\n              $wordsFragment.appendChild($charsFragment);\n            } else {\n              $wordsFragment.appendChild(doc.createTextNode(word));\n            }\n            // Skip the next iteration if we included a space\n            if (hasWordFollowingSpace) i++;\n          }\n        }\n        node.parentNode.replaceChild($wordsFragment, node);\n      }\n    } else if (nodeType === 1) {\n      // Converting to an array is necessary to work around childNodes pottential mutation\n      const childNodes = /** @type {Array<Node>} */([.../** @type {*} */(node.childNodes)]);\n      for (let i = 0, l = childNodes.length; i < l; i++) this.splitNode(childNodes[i]);\n    }\n  }\n\n  /**\n   * @param {Boolean} clearCache\n   * @return {this}\n   */\n  split(clearCache = false) {\n    const $el = this.$target;\n    const isCached = !!this.cache && !clearCache;\n    const lineTemplate = this.lineTemplate;\n    const wordTemplate = this.wordTemplate;\n    const charTemplate = this.charTemplate;\n    const fontsReady = doc.fonts.status !== 'loading';\n    const canSplitLines = lineTemplate && fontsReady;\n    this.ready = !lineTemplate || fontsReady;\n    if (canSplitLines || clearCache) {\n      // No need to revert effects animations here since it's already taken care by the refreshable\n      this.effectsCleanups.forEach(cleanup => isFnc(cleanup) && cleanup(this));\n    }\n    if (!isCached) {\n      if (clearCache) {\n        $el.innerHTML = this.html;\n        this.words.length = this.chars.length = 0;\n      }\n      this.splitNode($el);\n      this.cache = $el.innerHTML;\n    }\n    if (canSplitLines) {\n      if (isCached) $el.innerHTML = this.cache;\n      this.lines.length = 0;\n      if (wordTemplate) this.words = getAllTopLevelElements($el, wordType);\n    }\n    // Always reparse characters after a line reset or if both words and chars are activated\n    if (charTemplate && (canSplitLines || wordTemplate)) {\n      this.chars = getAllTopLevelElements($el, charType);\n    }\n    // Words are used when lines only and prioritized over chars\n    const elementsArray = this.words.length ? this.words : this.chars;\n    let y, linesCount = 0;\n    for (let i = 0, l = elementsArray.length; i < l; i++) {\n      const $el = elementsArray[i];\n      const { top, height } = $el.getBoundingClientRect();\n      if (!isUnd(y) && top - y > height * .5) linesCount++;\n      $el.setAttribute(dataLine, `${linesCount}`);\n      const nested = $el.querySelectorAll(`[${dataLine}]`);\n      let c = nested.length;\n      while (c--) nested[c].setAttribute(dataLine, `${linesCount}`);\n      y = top;\n    }\n    if (canSplitLines) {\n      const linesFragment = doc.createDocumentFragment();\n      const parents = new Set();\n      const clones = [];\n      for (let lineIndex = 0; lineIndex < linesCount + 1; lineIndex++) {\n        const $clone = /** @type {HTMLElement} */($el.cloneNode(true));\n        filterLineElements($clone, lineIndex, new Set()).forEach($el => {\n          const $parent = $el.parentNode;\n          if ($parent) {\n            if ($el.nodeType === 1) parents.add(/** @type {HTMLElement} */($parent));\n            $parent.removeChild($el);\n          }\n        });\n        clones.push($clone);\n      }\n      parents.forEach(filterEmptyElements);\n      for (let cloneIndex = 0, clonesLength = clones.length; cloneIndex < clonesLength; cloneIndex++) {\n        processHTMLTemplate(lineTemplate, this.lines, clones[cloneIndex], linesFragment, lineType, this.debug, cloneIndex);\n      }\n      $el.innerHTML = '';\n      $el.appendChild(linesFragment);\n      if (wordTemplate) this.words = getAllTopLevelElements($el, wordType);\n      if (charTemplate) this.chars = getAllTopLevelElements($el, charType);\n    }\n\n    // Remove the word wrappers and clear the words array if lines split only\n    if (this.linesOnly) {\n      const words = this.words;\n      let w = words.length;\n      while (w--) {\n        const $word = words[w];\n        $word.replaceWith($word.textContent);\n      }\n      words.length = 0;\n    }\n    if (this.accessible && (canSplitLines || !isCached)) {\n      const $accessible = doc.createElement('span');\n      // Make the accessible element visually-hidden (https://www.scottohara.me/blog/2017/04/14/inclusively-hidden.html)\n      $accessible.style.cssText = `position:absolute;overflow:hidden;clip:rect(0 0 0 0);clip-path:inset(50%);width:1px;height:1px;white-space:nowrap;`;\n      // $accessible.setAttribute('tabindex', '-1');\n      $accessible.innerHTML = this.html;\n      $el.insertBefore($accessible, $el.firstChild);\n      this.lines.forEach(setAriaHidden);\n      this.words.forEach(setAriaHidden);\n      this.chars.forEach(setAriaHidden);\n    }\n    this.width = /** @type {HTMLElement} */($el).offsetWidth;\n    if (canSplitLines || clearCache) {\n      this.effects.forEach((effect, i) => this.effectsCleanups[i] = effect(this));\n    }\n    return this;\n  }\n\n  refresh() {\n    this.split(true);\n  }\n}\n\n/**\n * @param  {HTMLElement|NodeList|String|Array<HTMLElement>} target\n * @param  {TextSplitterParams} [parameters]\n * @return {TextSplitter}\n */\nconst splitText = (target, parameters) => new TextSplitter(target, parameters);\n\n/**\n * @deprecated text.split() is deprecated, import splitText() directly, or text.splitText()\n *\n * @param  {HTMLElement|NodeList|String|Array<HTMLElement>} target\n * @param  {TextSplitterParams} [parameters]\n * @return {TextSplitter}\n */\nconst split = (target, parameters) => {\n  console.warn('text.split() is deprecated, import splitText() directly, or text.splitText()');\n  return new TextSplitter(target, parameters);\n};\n\nexport { TextSplitter, split, splitText };\n"]}