Добавила ресурсы.

source/files/gsap-public/umd/CSSRulePlugin.js

@@ -0,0 +1,139 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+	typeof define === 'function' && define.amd ? define(['exports'], factory) :
+	(global = global || self, factory(global.window = global.window || {}));
+}(this, (function (exports) { 'use strict';
+
+	/*!
+	 * CSSRulePlugin 3.13.0
+	 * https://gsap.com
+	 *
+	 * @license Copyright 2008-2025, GreenSock. All rights reserved.
+	 * Subject to the terms at https://gsap.com/standard-license
+	 * @author: Jack Doyle, jack@greensock.com
+	*/
+	var gsap,
+	    _coreInitted,
+	    _doc,
+	    CSSPlugin,
+	    _windowExists = function _windowExists() {
+	  return typeof window !== "undefined";
+	},
+	    _getGSAP = function _getGSAP() {
+	  return gsap || _windowExists() && (gsap = window.gsap) && gsap.registerPlugin && gsap;
+	},
+	    _checkRegister = function _checkRegister() {
+	  if (!_coreInitted) {
+	    _initCore();
+
+	    if (!CSSPlugin) {
+	      console.warn("Please gsap.registerPlugin(CSSPlugin, CSSRulePlugin)");
+	    }
+	  }
+
+	  return _coreInitted;
+	},
+	    _initCore = function _initCore(core) {
+	  gsap = core || _getGSAP();
+
+	  if (_windowExists()) {
+	    _doc = document;
+	  }
+
+	  if (gsap) {
+	    CSSPlugin = gsap.plugins.css;
+
+	    if (CSSPlugin) {
+	      _coreInitted = 1;
+	    }
+	  }
+	};
+
+	var CSSRulePlugin = {
+	  version: "3.13.0",
+	  name: "cssRule",
+	  init: function init(target, value, tween, index, targets) {
+	    if (!_checkRegister() || typeof target.cssText === "undefined") {
+	      return false;
+	    }
+
+	    var div = target._gsProxy = target._gsProxy || _doc.createElement("div");
+
+	    this.ss = target;
+	    this.style = div.style;
+	    div.style.cssText = target.cssText;
+	    CSSPlugin.prototype.init.call(this, div, value, tween, index, targets);
+	  },
+	  render: function render(ratio, data) {
+	    var pt = data._pt,
+	        style = data.style,
+	        ss = data.ss,
+	        i;
+
+	    while (pt) {
+	      pt.r(ratio, pt.d);
+	      pt = pt._next;
+	    }
+
+	    i = style.length;
+
+	    while (--i > -1) {
+	      ss[style[i]] = style[style[i]];
+	    }
+	  },
+	  getRule: function getRule(selector) {
+	    _checkRegister();
+
+	    var ruleProp = _doc.all ? "rules" : "cssRules",
+	        styleSheets = _doc.styleSheets,
+	        i = styleSheets.length,
+	        pseudo = selector.charAt(0) === ":",
+	        j,
+	        curSS,
+	        cs,
+	        a;
+	    selector = (pseudo ? "" : ",") + selector.split("::").join(":").toLowerCase() + ",";
+
+	    if (pseudo) {
+	      a = [];
+	    }
+
+	    while (i--) {
+	      try {
+	        curSS = styleSheets[i][ruleProp];
+
+	        if (!curSS) {
+	          continue;
+	        }
+
+	        j = curSS.length;
+	      } catch (e) {
+	        console.warn(e);
+	        continue;
+	      }
+
+	      while (--j > -1) {
+	        cs = curSS[j];
+
+	        if (cs.selectorText && ("," + cs.selectorText.split("::").join(":").toLowerCase() + ",").indexOf(selector) !== -1) {
+	          if (pseudo) {
+	            a.push(cs.style);
+	          } else {
+	            return cs.style;
+	          }
+	        }
+	      }
+	    }
+
+	    return a;
+	  },
+	  register: _initCore
+	};
+	_getGSAP() && gsap.registerPlugin(CSSRulePlugin);
+
+	exports.CSSRulePlugin = CSSRulePlugin;
+	exports.default = CSSRulePlugin;
+
+	Object.defineProperty(exports, '__esModule', { value: true });
+
+})));

source/files/gsap-public/umd/CustomBounce.js

@@ -0,0 +1,168 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+	typeof define === 'function' && define.amd ? define(['exports'], factory) :
+	(global = global || self, factory(global.window = global.window || {}));
+}(this, (function (exports) { 'use strict';
+
+	/*!
+	 * CustomBounce 3.13.0
+	 * https://gsap.com
+	 *
+	 * @license Copyright 2008-2025, GreenSock. All rights reserved.
+	 * Subject to the terms at https://gsap.com/standard-license
+	 * @author: Jack Doyle, jack@greensock.com
+	*/
+	var gsap,
+	    _coreInitted,
+	    createCustomEase,
+	    _getGSAP = function _getGSAP() {
+	  return gsap || typeof window !== "undefined" && (gsap = window.gsap) && gsap.registerPlugin && gsap;
+	},
+	    _initCore = function _initCore(required) {
+	  gsap = _getGSAP();
+	  createCustomEase = gsap && gsap.parseEase("_CE");
+
+	  if (createCustomEase) {
+	    _coreInitted = 1;
+
+	    gsap.parseEase("bounce").config = function (vars) {
+	      return typeof vars === "object" ? _create("", vars) : _create("bounce(" + vars + ")", {
+	        strength: +vars
+	      });
+	    };
+	  } else {
+	    required && console.warn("Please gsap.registerPlugin(CustomEase, CustomBounce)");
+	  }
+	},
+	    _normalizeX = function _normalizeX(a) {
+	  var l = a.length,
+	      s = 1 / a[l - 2],
+	      rnd = 1000,
+	      i;
+
+	  for (i = 2; i < l; i += 2) {
+	    a[i] = ~~(a[i] * s * rnd) / rnd;
+	  }
+
+	  a[l - 2] = 1;
+	},
+	    _create = function _create(id, vars) {
+	  if (!_coreInitted) {
+	    _initCore(1);
+	  }
+
+	  vars = vars || {};
+
+	  {
+	    var max = 0.999,
+	        decay = Math.min(max, vars.strength || 0.7),
+	        decayX = decay,
+	        gap = (vars.squash || 0) / 100,
+	        originalGap = gap,
+	        slope = 1 / 0.03,
+	        w = 0.2,
+	        h = 1,
+	        prevX = 0.1,
+	        path = [0, 0, 0.07, 0, 0.1, 1, 0.1, 1],
+	        squashPath = [0, 0, 0, 0, 0.1, 0, 0.1, 0],
+	        cp1,
+	        cp2,
+	        x,
+	        y,
+	        i,
+	        nextX,
+	        squishMagnitude;
+
+	    for (i = 0; i < 200; i++) {
+	      w *= decayX * ((decayX + 1) / 2);
+	      h *= decay * decay;
+	      nextX = prevX + w;
+	      x = prevX + w * 0.49;
+	      y = 1 - h;
+	      cp1 = prevX + h / slope;
+	      cp2 = x + (x - cp1) * 0.8;
+
+	      if (gap) {
+	        prevX += gap;
+	        cp1 += gap;
+	        x += gap;
+	        cp2 += gap;
+	        nextX += gap;
+	        squishMagnitude = gap / originalGap;
+	        squashPath.push(prevX - gap, 0, prevX - gap, squishMagnitude, prevX - gap / 2, squishMagnitude, prevX, squishMagnitude, prevX, 0, prevX, 0, prevX, squishMagnitude * -0.6, prevX + (nextX - prevX) / 6, 0, nextX, 0);
+	        path.push(prevX - gap, 1, prevX, 1, prevX, 1);
+	        gap *= decay * decay;
+	      }
+
+	      path.push(prevX, 1, cp1, y, x, y, cp2, y, nextX, 1, nextX, 1);
+	      decay *= 0.95;
+	      slope = h / (nextX - cp2);
+	      prevX = nextX;
+
+	      if (y > max) {
+	        break;
+	      }
+	    }
+
+	    if (vars.endAtStart && vars.endAtStart !== "false") {
+	      x = -0.1;
+	      path.unshift(x, 1, x, 1, -0.07, 0);
+
+	      if (originalGap) {
+	        gap = originalGap * 2.5;
+	        x -= gap;
+	        path.unshift(x, 1, x, 1, x, 1);
+	        squashPath.splice(0, 6);
+	        squashPath.unshift(x, 0, x, 0, x, 1, x + gap / 2, 1, x + gap, 1, x + gap, 0, x + gap, 0, x + gap, -0.6, x + gap + 0.033, 0);
+
+	        for (i = 0; i < squashPath.length; i += 2) {
+	          squashPath[i] -= x;
+	        }
+	      }
+
+	      for (i = 0; i < path.length; i += 2) {
+	        path[i] -= x;
+	        path[i + 1] = 1 - path[i + 1];
+	      }
+	    }
+
+	    if (gap) {
+	      _normalizeX(squashPath);
+
+	      squashPath[2] = "C" + squashPath[2];
+	      createCustomEase(vars.squashID || id + "-squash", "M" + squashPath.join(","));
+	    }
+
+	    _normalizeX(path);
+
+	    path[2] = "C" + path[2];
+	    return createCustomEase(id, "M" + path.join(","));
+	  }
+	};
+
+	var CustomBounce = function () {
+	  function CustomBounce(id, vars) {
+	    this.ease = _create(id, vars);
+	  }
+
+	  CustomBounce.create = function create(id, vars) {
+	    return _create(id, vars);
+	  };
+
+	  CustomBounce.register = function register(core) {
+	    gsap = core;
+
+	    _initCore();
+	  };
+
+	  return CustomBounce;
+	}();
+	_getGSAP() && gsap.registerPlugin(CustomBounce);
+	CustomBounce.version = "3.13.0";
+
+	exports.CustomBounce = CustomBounce;
+	exports.default = CustomBounce;
+
+	Object.defineProperty(exports, '__esModule', { value: true });
+
+})));

source/files/gsap-public/umd/CustomEase.js

@@ -0,0 +1,716 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+	typeof define === 'function' && define.amd ? define(['exports'], factory) :
+	(global = global || self, factory(global.window = global.window || {}));
+}(this, (function (exports) { 'use strict';
+
+	var _svgPathExp = /[achlmqstvz]|(-?\d*\.?\d*(?:e[\-+]?\d+)?)[0-9]/ig,
+	    _scientific = /[\+\-]?\d*\.?\d+e[\+\-]?\d+/ig,
+	    _DEG2RAD = Math.PI / 180,
+	    _sin = Math.sin,
+	    _cos = Math.cos,
+	    _abs = Math.abs,
+	    _sqrt = Math.sqrt,
+	    _isNumber = function _isNumber(value) {
+	  return typeof value === "number";
+	},
+	    _roundingNum = 1e5,
+	    _round = function _round(value) {
+	  return Math.round(value * _roundingNum) / _roundingNum || 0;
+	};
+	function transformRawPath(rawPath, a, b, c, d, tx, ty) {
+	  var j = rawPath.length,
+	      segment,
+	      l,
+	      i,
+	      x,
+	      y;
+
+	  while (--j > -1) {
+	    segment = rawPath[j];
+	    l = segment.length;
+
+	    for (i = 0; i < l; i += 2) {
+	      x = segment[i];
+	      y = segment[i + 1];
+	      segment[i] = x * a + y * c + tx;
+	      segment[i + 1] = x * b + y * d + ty;
+	    }
+	  }
+
+	  rawPath._dirty = 1;
+	  return rawPath;
+	}
+
+	function arcToSegment(lastX, lastY, rx, ry, angle, largeArcFlag, sweepFlag, x, y) {
+	  if (lastX === x && lastY === y) {
+	    return;
+	  }
+
+	  rx = _abs(rx);
+	  ry = _abs(ry);
+
+	  var angleRad = angle % 360 * _DEG2RAD,
+	      cosAngle = _cos(angleRad),
+	      sinAngle = _sin(angleRad),
+	      PI = Math.PI,
+	      TWOPI = PI * 2,
+	      dx2 = (lastX - x) / 2,
+	      dy2 = (lastY - y) / 2,
+	      x1 = cosAngle * dx2 + sinAngle * dy2,
+	      y1 = -sinAngle * dx2 + cosAngle * dy2,
+	      x1_sq = x1 * x1,
+	      y1_sq = y1 * y1,
+	      radiiCheck = x1_sq / (rx * rx) + y1_sq / (ry * ry);
+
+	  if (radiiCheck > 1) {
+	    rx = _sqrt(radiiCheck) * rx;
+	    ry = _sqrt(radiiCheck) * ry;
+	  }
+
+	  var rx_sq = rx * rx,
+	      ry_sq = ry * ry,
+	      sq = (rx_sq * ry_sq - rx_sq * y1_sq - ry_sq * x1_sq) / (rx_sq * y1_sq + ry_sq * x1_sq);
+
+	  if (sq < 0) {
+	    sq = 0;
+	  }
+
+	  var coef = (largeArcFlag === sweepFlag ? -1 : 1) * _sqrt(sq),
+	      cx1 = coef * (rx * y1 / ry),
+	      cy1 = coef * -(ry * x1 / rx),
+	      sx2 = (lastX + x) / 2,
+	      sy2 = (lastY + y) / 2,
+	      cx = sx2 + (cosAngle * cx1 - sinAngle * cy1),
+	      cy = sy2 + (sinAngle * cx1 + cosAngle * cy1),
+	      ux = (x1 - cx1) / rx,
+	      uy = (y1 - cy1) / ry,
+	      vx = (-x1 - cx1) / rx,
+	      vy = (-y1 - cy1) / ry,
+	      temp = ux * ux + uy * uy,
+	      angleStart = (uy < 0 ? -1 : 1) * Math.acos(ux / _sqrt(temp)),
+	      angleExtent = (ux * vy - uy * vx < 0 ? -1 : 1) * Math.acos((ux * vx + uy * vy) / _sqrt(temp * (vx * vx + vy * vy)));
+
+	  isNaN(angleExtent) && (angleExtent = PI);
+
+	  if (!sweepFlag && angleExtent > 0) {
+	    angleExtent -= TWOPI;
+	  } else if (sweepFlag && angleExtent < 0) {
+	    angleExtent += TWOPI;
+	  }
+
+	  angleStart %= TWOPI;
+	  angleExtent %= TWOPI;
+
+	  var segments = Math.ceil(_abs(angleExtent) / (TWOPI / 4)),
+	      rawPath = [],
+	      angleIncrement = angleExtent / segments,
+	      controlLength = 4 / 3 * _sin(angleIncrement / 2) / (1 + _cos(angleIncrement / 2)),
+	      ma = cosAngle * rx,
+	      mb = sinAngle * rx,
+	      mc = sinAngle * -ry,
+	      md = cosAngle * ry,
+	      i;
+
+	  for (i = 0; i < segments; i++) {
+	    angle = angleStart + i * angleIncrement;
+	    x1 = _cos(angle);
+	    y1 = _sin(angle);
+	    ux = _cos(angle += angleIncrement);
+	    uy = _sin(angle);
+	    rawPath.push(x1 - controlLength * y1, y1 + controlLength * x1, ux + controlLength * uy, uy - controlLength * ux, ux, uy);
+	  }
+
+	  for (i = 0; i < rawPath.length; i += 2) {
+	    x1 = rawPath[i];
+	    y1 = rawPath[i + 1];
+	    rawPath[i] = x1 * ma + y1 * mc + cx;
+	    rawPath[i + 1] = x1 * mb + y1 * md + cy;
+	  }
+
+	  rawPath[i - 2] = x;
+	  rawPath[i - 1] = y;
+	  return rawPath;
+	}
+
+	function stringToRawPath(d) {
+	  var a = (d + "").replace(_scientific, function (m) {
+	    var n = +m;
+	    return n < 0.0001 && n > -0.0001 ? 0 : n;
+	  }).match(_svgPathExp) || [],
+	      path = [],
+	      relativeX = 0,
+	      relativeY = 0,
+	      twoThirds = 2 / 3,
+	      elements = a.length,
+	      points = 0,
+	      errorMessage = "ERROR: malformed path: " + d,
+	      i,
+	      j,
+	      x,
+	      y,
+	      command,
+	      isRelative,
+	      segment,
+	      startX,
+	      startY,
+	      difX,
+	      difY,
+	      beziers,
+	      prevCommand,
+	      flag1,
+	      flag2,
+	      line = function line(sx, sy, ex, ey) {
+	    difX = (ex - sx) / 3;
+	    difY = (ey - sy) / 3;
+	    segment.push(sx + difX, sy + difY, ex - difX, ey - difY, ex, ey);
+	  };
+
+	  if (!d || !isNaN(a[0]) || isNaN(a[1])) {
+	    console.log(errorMessage);
+	    return path;
+	  }
+
+	  for (i = 0; i < elements; i++) {
+	    prevCommand = command;
+
+	    if (isNaN(a[i])) {
+	      command = a[i].toUpperCase();
+	      isRelative = command !== a[i];
+	    } else {
+	      i--;
+	    }
+
+	    x = +a[i + 1];
+	    y = +a[i + 2];
+
+	    if (isRelative) {
+	      x += relativeX;
+	      y += relativeY;
+	    }
+
+	    if (!i) {
+	      startX = x;
+	      startY = y;
+	    }
+
+	    if (command === "M") {
+	      if (segment) {
+	        if (segment.length < 8) {
+	          path.length -= 1;
+	        } else {
+	          points += segment.length;
+	        }
+	      }
+
+	      relativeX = startX = x;
+	      relativeY = startY = y;
+	      segment = [x, y];
+	      path.push(segment);
+	      i += 2;
+	      command = "L";
+	    } else if (command === "C") {
+	      if (!segment) {
+	        segment = [0, 0];
+	      }
+
+	      if (!isRelative) {
+	        relativeX = relativeY = 0;
+	      }
+
+	      segment.push(x, y, relativeX + a[i + 3] * 1, relativeY + a[i + 4] * 1, relativeX += a[i + 5] * 1, relativeY += a[i + 6] * 1);
+	      i += 6;
+	    } else if (command === "S") {
+	      difX = relativeX;
+	      difY = relativeY;
+
+	      if (prevCommand === "C" || prevCommand === "S") {
+	        difX += relativeX - segment[segment.length - 4];
+	        difY += relativeY - segment[segment.length - 3];
+	      }
+
+	      if (!isRelative) {
+	        relativeX = relativeY = 0;
+	      }
+
+	      segment.push(difX, difY, x, y, relativeX += a[i + 3] * 1, relativeY += a[i + 4] * 1);
+	      i += 4;
+	    } else if (command === "Q") {
+	      difX = relativeX + (x - relativeX) * twoThirds;
+	      difY = relativeY + (y - relativeY) * twoThirds;
+
+	      if (!isRelative) {
+	        relativeX = relativeY = 0;
+	      }
+
+	      relativeX += a[i + 3] * 1;
+	      relativeY += a[i + 4] * 1;
+	      segment.push(difX, difY, relativeX + (x - relativeX) * twoThirds, relativeY + (y - relativeY) * twoThirds, relativeX, relativeY);
+	      i += 4;
+	    } else if (command === "T") {
+	      difX = relativeX - segment[segment.length - 4];
+	      difY = relativeY - segment[segment.length - 3];
+	      segment.push(relativeX + difX, relativeY + difY, x + (relativeX + difX * 1.5 - x) * twoThirds, y + (relativeY + difY * 1.5 - y) * twoThirds, relativeX = x, relativeY = y);
+	      i += 2;
+	    } else if (command === "H") {
+	      line(relativeX, relativeY, relativeX = x, relativeY);
+	      i += 1;
+	    } else if (command === "V") {
+	      line(relativeX, relativeY, relativeX, relativeY = x + (isRelative ? relativeY - relativeX : 0));
+	      i += 1;
+	    } else if (command === "L" || command === "Z") {
+	      if (command === "Z") {
+	        x = startX;
+	        y = startY;
+	        segment.closed = true;
+	      }
+
+	      if (command === "L" || _abs(relativeX - x) > 0.5 || _abs(relativeY - y) > 0.5) {
+	        line(relativeX, relativeY, x, y);
+
+	        if (command === "L") {
+	          i += 2;
+	        }
+	      }
+
+	      relativeX = x;
+	      relativeY = y;
+	    } else if (command === "A") {
+	      flag1 = a[i + 4];
+	      flag2 = a[i + 5];
+	      difX = a[i + 6];
+	      difY = a[i + 7];
+	      j = 7;
+
+	      if (flag1.length > 1) {
+	        if (flag1.length < 3) {
+	          difY = difX;
+	          difX = flag2;
+	          j--;
+	        } else {
+	          difY = flag2;
+	          difX = flag1.substr(2);
+	          j -= 2;
+	        }
+
+	        flag2 = flag1.charAt(1);
+	        flag1 = flag1.charAt(0);
+	      }
+
+	      beziers = arcToSegment(relativeX, relativeY, +a[i + 1], +a[i + 2], +a[i + 3], +flag1, +flag2, (isRelative ? relativeX : 0) + difX * 1, (isRelative ? relativeY : 0) + difY * 1);
+	      i += j;
+
+	      if (beziers) {
+	        for (j = 0; j < beziers.length; j++) {
+	          segment.push(beziers[j]);
+	        }
+	      }
+
+	      relativeX = segment[segment.length - 2];
+	      relativeY = segment[segment.length - 1];
+	    } else {
+	      console.log(errorMessage);
+	    }
+	  }
+
+	  i = segment.length;
+
+	  if (i < 6) {
+	    path.pop();
+	    i = 0;
+	  } else if (segment[0] === segment[i - 2] && segment[1] === segment[i - 1]) {
+	    segment.closed = true;
+	  }
+
+	  path.totalPoints = points + i;
+	  return path;
+	}
+	function rawPathToString(rawPath) {
+	  if (_isNumber(rawPath[0])) {
+	    rawPath = [rawPath];
+	  }
+
+	  var result = "",
+	      l = rawPath.length,
+	      sl,
+	      s,
+	      i,
+	      segment;
+
+	  for (s = 0; s < l; s++) {
+	    segment = rawPath[s];
+	    result += "M" + _round(segment[0]) + "," + _round(segment[1]) + " C";
+	    sl = segment.length;
+
+	    for (i = 2; i < sl; i++) {
+	      result += _round(segment[i++]) + "," + _round(segment[i++]) + " " + _round(segment[i++]) + "," + _round(segment[i++]) + " " + _round(segment[i++]) + "," + _round(segment[i]) + " ";
+	    }
+
+	    if (segment.closed) {
+	      result += "z";
+	    }
+	  }
+
+	  return result;
+	}
+
+	/*!
+	 * CustomEase 3.13.0
+	 * https://gsap.com
+	 *
+	 * @license Copyright 2008-2025, GreenSock. All rights reserved.
+	 * Subject to the terms at https://gsap.com/standard-license
+	 * @author: Jack Doyle, jack@greensock.com
+	*/
+
+	var gsap,
+	    _coreInitted,
+	    _getGSAP = function _getGSAP() {
+	  return gsap || typeof window !== "undefined" && (gsap = window.gsap) && gsap.registerPlugin && gsap;
+	},
+	    _initCore = function _initCore() {
+	  gsap = _getGSAP();
+
+	  if (gsap) {
+	    gsap.registerEase("_CE", CustomEase.create);
+	    _coreInitted = 1;
+	  } else {
+	    console.warn("Please gsap.registerPlugin(CustomEase)");
+	  }
+	},
+	    _bigNum = 1e20,
+	    _round$1 = function _round(value) {
+	  return ~~(value * 1000 + (value < 0 ? -.5 : .5)) / 1000;
+	},
+	    _numExp = /[-+=.]*\d+[.e\-+]*\d*[e\-+]*\d*/gi,
+	    _needsParsingExp = /[cLlsSaAhHvVtTqQ]/g,
+	    _findMinimum = function _findMinimum(values) {
+	  var l = values.length,
+	      min = _bigNum,
+	      i;
+
+	  for (i = 1; i < l; i += 6) {
+	    +values[i] < min && (min = +values[i]);
+	  }
+
+	  return min;
+	},
+	    _normalize = function _normalize(values, height, originY) {
+	  if (!originY && originY !== 0) {
+	    originY = Math.max(+values[values.length - 1], +values[1]);
+	  }
+
+	  var tx = +values[0] * -1,
+	      ty = -originY,
+	      l = values.length,
+	      sx = 1 / (+values[l - 2] + tx),
+	      sy = -height || (Math.abs(+values[l - 1] - +values[1]) < 0.01 * (+values[l - 2] - +values[0]) ? _findMinimum(values) + ty : +values[l - 1] + ty),
+	      i;
+
+	  if (sy) {
+	    sy = 1 / sy;
+	  } else {
+	    sy = -sx;
+	  }
+
+	  for (i = 0; i < l; i += 2) {
+	    values[i] = (+values[i] + tx) * sx;
+	    values[i + 1] = (+values[i + 1] + ty) * sy;
+	  }
+	},
+	    _bezierToPoints = function _bezierToPoints(x1, y1, x2, y2, x3, y3, x4, y4, threshold, points, index) {
+	  var x12 = (x1 + x2) / 2,
+	      y12 = (y1 + y2) / 2,
+	      x23 = (x2 + x3) / 2,
+	      y23 = (y2 + y3) / 2,
+	      x34 = (x3 + x4) / 2,
+	      y34 = (y3 + y4) / 2,
+	      x123 = (x12 + x23) / 2,
+	      y123 = (y12 + y23) / 2,
+	      x234 = (x23 + x34) / 2,
+	      y234 = (y23 + y34) / 2,
+	      x1234 = (x123 + x234) / 2,
+	      y1234 = (y123 + y234) / 2,
+	      dx = x4 - x1,
+	      dy = y4 - y1,
+	      d2 = Math.abs((x2 - x4) * dy - (y2 - y4) * dx),
+	      d3 = Math.abs((x3 - x4) * dy - (y3 - y4) * dx),
+	      length;
+
+	  if (!points) {
+	    points = [{
+	      x: x1,
+	      y: y1
+	    }, {
+	      x: x4,
+	      y: y4
+	    }];
+	    index = 1;
+	  }
+
+	  points.splice(index || points.length - 1, 0, {
+	    x: x1234,
+	    y: y1234
+	  });
+
+	  if ((d2 + d3) * (d2 + d3) > threshold * (dx * dx + dy * dy)) {
+	    length = points.length;
+
+	    _bezierToPoints(x1, y1, x12, y12, x123, y123, x1234, y1234, threshold, points, index);
+
+	    _bezierToPoints(x1234, y1234, x234, y234, x34, y34, x4, y4, threshold, points, index + 1 + (points.length - length));
+	  }
+
+	  return points;
+	};
+
+	var CustomEase = function () {
+	  function CustomEase(id, data, config) {
+	    _coreInitted || _initCore();
+	    this.id = id;
+	     this.setData(data, config);
+	  }
+
+	  var _proto = CustomEase.prototype;
+
+	  _proto.setData = function setData(data, config) {
+	    config = config || {};
+	    data = data || "0,0,1,1";
+	    var values = data.match(_numExp),
+	        closest = 1,
+	        points = [],
+	        lookup = [],
+	        precision = config.precision || 1,
+	        fast = precision <= 1,
+	        l,
+	        a1,
+	        a2,
+	        i,
+	        inc,
+	        j,
+	        point,
+	        prevPoint,
+	        p;
+	    this.data = data;
+
+	    if (_needsParsingExp.test(data) || ~data.indexOf("M") && data.indexOf("C") < 0) {
+	      values = stringToRawPath(data)[0];
+	    }
+
+	    l = values.length;
+
+	    if (l === 4) {
+	      values.unshift(0, 0);
+	      values.push(1, 1);
+	      l = 8;
+	    } else if ((l - 2) % 6) {
+	      throw "Invalid CustomEase";
+	    }
+
+	    if (+values[0] !== 0 || +values[l - 2] !== 1) {
+	      _normalize(values, config.height, config.originY);
+	    }
+
+	    this.segment = values;
+
+	    for (i = 2; i < l; i += 6) {
+	      a1 = {
+	        x: +values[i - 2],
+	        y: +values[i - 1]
+	      };
+	      a2 = {
+	        x: +values[i + 4],
+	        y: +values[i + 5]
+	      };
+	      points.push(a1, a2);
+
+	      _bezierToPoints(a1.x, a1.y, +values[i], +values[i + 1], +values[i + 2], +values[i + 3], a2.x, a2.y, 1 / (precision * 200000), points, points.length - 1);
+	    }
+
+	    l = points.length;
+
+	    for (i = 0; i < l; i++) {
+	      point = points[i];
+	      prevPoint = points[i - 1] || point;
+
+	      if ((point.x > prevPoint.x || prevPoint.y !== point.y && prevPoint.x === point.x || point === prevPoint) && point.x <= 1) {
+	        prevPoint.cx = point.x - prevPoint.x;
+	        prevPoint.cy = point.y - prevPoint.y;
+	        prevPoint.n = point;
+	        prevPoint.nx = point.x;
+
+	        if (fast && i > 1 && Math.abs(prevPoint.cy / prevPoint.cx - points[i - 2].cy / points[i - 2].cx) > 2) {
+	          fast = 0;
+	        }
+
+	        if (prevPoint.cx < closest) {
+	          if (!prevPoint.cx) {
+	            prevPoint.cx = 0.001;
+
+	            if (i === l - 1) {
+	              prevPoint.x -= 0.001;
+	              closest = Math.min(closest, 0.001);
+	              fast = 0;
+	            }
+	          } else {
+	            closest = prevPoint.cx;
+	          }
+	        }
+	      } else {
+	        points.splice(i--, 1);
+	        l--;
+	      }
+	    }
+
+	    l = 1 / closest + 1 | 0;
+	    inc = 1 / l;
+	    j = 0;
+	    point = points[0];
+
+	    if (fast) {
+	      for (i = 0; i < l; i++) {
+	        p = i * inc;
+
+	        if (point.nx < p) {
+	          point = points[++j];
+	        }
+
+	        a1 = point.y + (p - point.x) / point.cx * point.cy;
+	        lookup[i] = {
+	          x: p,
+	          cx: inc,
+	          y: a1,
+	          cy: 0,
+	          nx: 9
+	        };
+
+	        if (i) {
+	          lookup[i - 1].cy = a1 - lookup[i - 1].y;
+	        }
+	      }
+
+	      j = points[points.length - 1];
+	      lookup[l - 1].cy = j.y - a1;
+	      lookup[l - 1].cx = j.x - lookup[lookup.length - 1].x;
+	    } else {
+	      for (i = 0; i < l; i++) {
+	        if (point.nx < i * inc) {
+	          point = points[++j];
+	        }
+
+	        lookup[i] = point;
+	      }
+
+	      if (j < points.length - 1) {
+	        lookup[i - 1] = points[points.length - 2];
+	      }
+	    }
+
+	    this.ease = function (p) {
+	      var point = lookup[p * l | 0] || lookup[l - 1];
+
+	      if (point.nx < p) {
+	        point = point.n;
+	      }
+
+	      return point.y + (p - point.x) / point.cx * point.cy;
+	    };
+
+	    this.ease.custom = this;
+	    this.id && gsap && gsap.registerEase(this.id, this.ease);
+	    return this;
+	  };
+
+	  _proto.getSVGData = function getSVGData(config) {
+	    return CustomEase.getSVGData(this, config);
+	  };
+
+	  CustomEase.create = function create(id, data, config) {
+	    return new CustomEase(id, data, config).ease;
+	  };
+
+	  CustomEase.register = function register(core) {
+	    gsap = core;
+
+	    _initCore();
+	  };
+
+	  CustomEase.get = function get(id) {
+	    return gsap.parseEase(id);
+	  };
+
+	  CustomEase.getSVGData = function getSVGData(ease, config) {
+	    config = config || {};
+	    var width = config.width || 100,
+	        height = config.height || 100,
+	        x = config.x || 0,
+	        y = (config.y || 0) + height,
+	        e = gsap.utils.toArray(config.path)[0],
+	        a,
+	        slope,
+	        i,
+	        inc,
+	        tx,
+	        ty,
+	        precision,
+	        threshold,
+	        prevX,
+	        prevY;
+
+	    if (config.invert) {
+	      height = -height;
+	      y = 0;
+	    }
+
+	    if (typeof ease === "string") {
+	      ease = gsap.parseEase(ease);
+	    }
+
+	    if (ease.custom) {
+	      ease = ease.custom;
+	    }
+
+	    if (ease instanceof CustomEase) {
+	      a = rawPathToString(transformRawPath([ease.segment], width, 0, 0, -height, x, y));
+	    } else {
+	      a = [x, y];
+	      precision = Math.max(5, (config.precision || 1) * 200);
+	      inc = 1 / precision;
+	      precision += 2;
+	      threshold = 5 / precision;
+	      prevX = _round$1(x + inc * width);
+	      prevY = _round$1(y + ease(inc) * -height);
+	      slope = (prevY - y) / (prevX - x);
+
+	      for (i = 2; i < precision; i++) {
+	        tx = _round$1(x + i * inc * width);
+	        ty = _round$1(y + ease(i * inc) * -height);
+
+	        if (Math.abs((ty - prevY) / (tx - prevX) - slope) > threshold || i === precision - 1) {
+	          a.push(prevX, prevY);
+	          slope = (ty - prevY) / (tx - prevX);
+	        }
+
+	        prevX = tx;
+	        prevY = ty;
+	      }
+
+	      a = "M" + a.join(",");
+	    }
+
+	    e && e.setAttribute("d", a);
+	    return a;
+	  };
+
+	  return CustomEase;
+	}();
+	CustomEase.version = "3.13.0";
+	CustomEase.headless = true;
+	_getGSAP() && gsap.registerPlugin(CustomEase);
+
+	exports.CustomEase = CustomEase;
+	exports.default = CustomEase;
+
+	Object.defineProperty(exports, '__esModule', { value: true });
+
+})));

source/files/gsap-public/umd/CustomWiggle.js

@@ -0,0 +1,167 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+	typeof define === 'function' && define.amd ? define(['exports'], factory) :
+	(global = global || self, factory(global.window = global.window || {}));
+}(this, (function (exports) { 'use strict';
+
+	/*!
+	 * CustomWiggle 3.13.0
+	 * https://gsap.com
+	 *
+	 * @license Copyright 2008-2025, GreenSock. All rights reserved.
+	 * Subject to the terms at https://gsap.com/standard-license
+	 * @author: Jack Doyle, jack@greensock.com
+	*/
+	var gsap,
+	    _coreInitted,
+	    createCustomEase,
+	    _getGSAP = function _getGSAP() {
+	  return gsap || typeof window !== "undefined" && (gsap = window.gsap) && gsap.registerPlugin && gsap;
+	},
+	    _eases = {
+	  easeOut: "M0,1,C0.7,1,0.6,0,1,0",
+	  easeInOut: "M0,0,C0.1,0,0.24,1,0.444,1,0.644,1,0.6,0,1,0",
+	  anticipate: "M0,0,C0,0.222,0.024,0.386,0,0.4,0.18,0.455,0.65,0.646,0.7,0.67,0.9,0.76,1,0.846,1,1",
+	  uniform: "M0,0,C0,0.95,0,1,0,1,0,1,1,1,1,1,1,1,1,0,1,0"
+	},
+	    _linearEase = function _linearEase(p) {
+	  return p;
+	},
+	    _initCore = function _initCore(required) {
+	  if (!_coreInitted) {
+	    gsap = _getGSAP();
+	    createCustomEase = gsap && gsap.parseEase("_CE");
+
+	    if (createCustomEase) {
+	      for (var p in _eases) {
+	        _eases[p] = createCustomEase("", _eases[p]);
+	      }
+
+	      _coreInitted = 1;
+
+	      _create("wiggle").config = function (vars) {
+	        return typeof vars === "object" ? _create("", vars) : _create("wiggle(" + vars + ")", {
+	          wiggles: +vars
+	        });
+	      };
+	    } else {
+	      required && console.warn("Please gsap.registerPlugin(CustomEase, CustomWiggle)");
+	    }
+	  }
+	},
+	    _parseEase = function _parseEase(ease, invertNonCustomEases) {
+	  if (typeof ease !== "function") {
+	    ease = gsap.parseEase(ease) || createCustomEase("", ease);
+	  }
+
+	  return ease.custom || !invertNonCustomEases ? ease : function (p) {
+	    return 1 - ease(p);
+	  };
+	},
+	    _create = function _create(id, vars) {
+	  if (!_coreInitted) {
+	    _initCore(1);
+	  }
+
+	  vars = vars || {};
+	  var wiggles = (vars.wiggles || 10) | 0,
+	      inc = 1 / wiggles,
+	      x = inc / 2,
+	      anticipate = vars.type === "anticipate",
+	      yEase = _eases[vars.type] || _eases.easeOut,
+	      xEase = _linearEase,
+	      rnd = 1000,
+	      nextX,
+	      nextY,
+	      angle,
+	      handleX,
+	      handleY,
+	      easedX,
+	      y,
+	      path,
+	      i;
+
+	  {
+	    if (anticipate) {
+	      xEase = yEase;
+	      yEase = _eases.easeOut;
+	    }
+
+	    if (vars.timingEase) {
+	      xEase = _parseEase(vars.timingEase);
+	    }
+
+	    if (vars.amplitudeEase) {
+	      yEase = _parseEase(vars.amplitudeEase, true);
+	    }
+
+	    easedX = xEase(x);
+	    y = anticipate ? -yEase(x) : yEase(x);
+	    path = [0, 0, easedX / 4, 0, easedX / 2, y, easedX, y];
+
+	    if (vars.type === "random") {
+	      path.length = 4;
+	      nextX = xEase(inc);
+	      nextY = Math.random() * 2 - 1;
+
+	      for (i = 2; i < wiggles; i++) {
+	        x = nextX;
+	        y = nextY;
+	        nextX = xEase(inc * i);
+	        nextY = Math.random() * 2 - 1;
+	        angle = Math.atan2(nextY - path[path.length - 3], nextX - path[path.length - 4]);
+	        handleX = Math.cos(angle) * inc;
+	        handleY = Math.sin(angle) * inc;
+	        path.push(x - handleX, y - handleY, x, y, x + handleX, y + handleY);
+	      }
+
+	      path.push(nextX, 0, 1, 0);
+	    } else {
+	      for (i = 1; i < wiggles; i++) {
+	        path.push(xEase(x + inc / 2), y);
+	        x += inc;
+	        y = (y > 0 ? -1 : 1) * yEase(i * inc);
+	        easedX = xEase(x);
+	        path.push(xEase(x - inc / 2), y, easedX, y);
+	      }
+
+	      path.push(xEase(x + inc / 4), y, xEase(x + inc / 4), 0, 1, 0);
+	    }
+
+	    i = path.length;
+
+	    while (--i > -1) {
+	      path[i] = ~~(path[i] * rnd) / rnd;
+	    }
+
+	    path[2] = "C" + path[2];
+	    return createCustomEase(id, "M" + path.join(","));
+	  }
+	};
+
+	var CustomWiggle = function () {
+	  function CustomWiggle(id, vars) {
+	    this.ease = _create(id, vars);
+	  }
+
+	  CustomWiggle.create = function create(id, vars) {
+	    return _create(id, vars);
+	  };
+
+	  CustomWiggle.register = function register(core) {
+	    gsap = core;
+
+	    _initCore();
+	  };
+
+	  return CustomWiggle;
+	}();
+	_getGSAP() && gsap.registerPlugin(CustomWiggle);
+	CustomWiggle.version = "3.13.0";
+
+	exports.CustomWiggle = CustomWiggle;
+	exports.default = CustomWiggle;
+
+	Object.defineProperty(exports, '__esModule', { value: true });
+
+})));

source/files/gsap-public/umd/DrawSVGPlugin.js

@@ -0,0 +1,310 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+	typeof define === 'function' && define.amd ? define(['exports'], factory) :
+	(global = global || self, factory(global.window = global.window || {}));
+}(this, (function (exports) { 'use strict';
+
+	/*!
+	 * DrawSVGPlugin 3.13.0
+	 * https://gsap.com
+	 *
+	 * @license Copyright 2008-2025, GreenSock. All rights reserved.
+	 * Subject to the terms at https://gsap.com/standard-license
+	 * @author: Jack Doyle, jack@greensock.com
+	*/
+	var gsap,
+	    _toArray,
+	    _win,
+	    _isEdge,
+	    _coreInitted,
+	    _warned,
+	    _getStyleSaver,
+	    _reverting,
+	    _windowExists = function _windowExists() {
+	  return typeof window !== "undefined";
+	},
+	    _getGSAP = function _getGSAP() {
+	  return gsap || _windowExists() && (gsap = window.gsap) && gsap.registerPlugin && gsap;
+	},
+	    _numExp = /[-+=\.]*\d+[\.e\-\+]*\d*[e\-\+]*\d*/gi,
+	    _types = {
+	  rect: ["width", "height"],
+	  circle: ["r", "r"],
+	  ellipse: ["rx", "ry"],
+	  line: ["x2", "y2"]
+	},
+	    _round = function _round(value) {
+	  return Math.round(value * 10000) / 10000;
+	},
+	    _parseNum = function _parseNum(value) {
+	  return parseFloat(value) || 0;
+	},
+	    _parseSingleVal = function _parseSingleVal(value, length) {
+	  var num = _parseNum(value);
+
+	  return ~value.indexOf("%") ? num / 100 * length : num;
+	},
+	    _getAttributeAsNumber = function _getAttributeAsNumber(target, attr) {
+	  return _parseNum(target.getAttribute(attr));
+	},
+	    _sqrt = Math.sqrt,
+	    _getDistance = function _getDistance(x1, y1, x2, y2, scaleX, scaleY) {
+	  return _sqrt(Math.pow((_parseNum(x2) - _parseNum(x1)) * scaleX, 2) + Math.pow((_parseNum(y2) - _parseNum(y1)) * scaleY, 2));
+	},
+	    _warn = function _warn(message) {
+	  return console.warn(message);
+	},
+	    _hasNonScalingStroke = function _hasNonScalingStroke(target) {
+	  return target.getAttribute("vector-effect") === "non-scaling-stroke";
+	},
+	    _bonusValidated = 1,
+	    _parse = function _parse(value, length, defaultStart) {
+	  var i = value.indexOf(" "),
+	      s,
+	      e;
+
+	  if (i < 0) {
+	    s = defaultStart !== undefined ? defaultStart + "" : value;
+	    e = value;
+	  } else {
+	    s = value.substr(0, i);
+	    e = value.substr(i + 1);
+	  }
+
+	  s = _parseSingleVal(s, length);
+	  e = _parseSingleVal(e, length);
+	  return s > e ? [e, s] : [s, e];
+	},
+	    _getLength = function _getLength(target) {
+	  target = _toArray(target)[0];
+
+	  if (!target) {
+	    return 0;
+	  }
+
+	  var type = target.tagName.toLowerCase(),
+	      style = target.style,
+	      scaleX = 1,
+	      scaleY = 1,
+	      length,
+	      bbox,
+	      points,
+	      prevPoint,
+	      i,
+	      rx,
+	      ry;
+
+	  if (_hasNonScalingStroke(target)) {
+	    scaleY = target.getScreenCTM();
+	    scaleX = _sqrt(scaleY.a * scaleY.a + scaleY.b * scaleY.b);
+	    scaleY = _sqrt(scaleY.d * scaleY.d + scaleY.c * scaleY.c);
+	  }
+
+	  try {
+	    bbox = target.getBBox();
+	  } catch (e) {
+	    _warn("Some browsers won't measure invisible elements (like display:none or masks inside defs).");
+	  }
+
+	  var _ref = bbox || {
+	    x: 0,
+	    y: 0,
+	    width: 0,
+	    height: 0
+	  },
+	      x = _ref.x,
+	      y = _ref.y,
+	      width = _ref.width,
+	      height = _ref.height;
+
+	  if ((!bbox || !width && !height) && _types[type]) {
+	    width = _getAttributeAsNumber(target, _types[type][0]);
+	    height = _getAttributeAsNumber(target, _types[type][1]);
+
+	    if (type !== "rect" && type !== "line") {
+	      width *= 2;
+	      height *= 2;
+	    }
+
+	    if (type === "line") {
+	      x = _getAttributeAsNumber(target, "x1");
+	      y = _getAttributeAsNumber(target, "y1");
+	      width = Math.abs(width - x);
+	      height = Math.abs(height - y);
+	    }
+	  }
+
+	  if (type === "path") {
+	    prevPoint = style.strokeDasharray;
+	    style.strokeDasharray = "none";
+	    length = target.getTotalLength() || 0;
+	    _round(scaleX) !== _round(scaleY) && !_warned && (_warned = 1) && _warn("Warning: <path> length cannot be measured when vector-effect is non-scaling-stroke and the element isn't proportionally scaled.");
+	    length *= (scaleX + scaleY) / 2;
+	    style.strokeDasharray = prevPoint;
+	  } else if (type === "rect") {
+	    length = width * 2 * scaleX + height * 2 * scaleY;
+	  } else if (type === "line") {
+	    length = _getDistance(x, y, x + width, y + height, scaleX, scaleY);
+	  } else if (type === "polyline" || type === "polygon") {
+	    points = target.getAttribute("points").match(_numExp) || [];
+	    type === "polygon" && points.push(points[0], points[1]);
+	    length = 0;
+
+	    for (i = 2; i < points.length; i += 2) {
+	      length += _getDistance(points[i - 2], points[i - 1], points[i], points[i + 1], scaleX, scaleY) || 0;
+	    }
+	  } else if (type === "circle" || type === "ellipse") {
+	    rx = width / 2 * scaleX;
+	    ry = height / 2 * scaleY;
+	    length = Math.PI * (3 * (rx + ry) - _sqrt((3 * rx + ry) * (rx + 3 * ry)));
+	  }
+
+	  return length || 0;
+	},
+	    _getPosition = function _getPosition(target, length) {
+	  target = _toArray(target)[0];
+
+	  if (!target) {
+	    return [0, 0];
+	  }
+
+	  length || (length = _getLength(target) + 1);
+
+	  var cs = _win.getComputedStyle(target),
+	      dash = cs.strokeDasharray || "",
+	      offset = _parseNum(cs.strokeDashoffset),
+	      i = dash.indexOf(",");
+
+	  i < 0 && (i = dash.indexOf(" "));
+	  dash = i < 0 ? length : _parseNum(dash.substr(0, i));
+	  dash > length && (dash = length);
+	  return [-offset || 0, dash - offset || 0];
+	},
+	    _initCore = function _initCore() {
+	  if (_windowExists()) {
+	    _win = window;
+	    _coreInitted = gsap = _getGSAP();
+	    _toArray = gsap.utils.toArray;
+	    _getStyleSaver = gsap.core.getStyleSaver;
+
+	    _reverting = gsap.core.reverting || function () {};
+
+	    _isEdge = ((_win.navigator || {}).userAgent || "").indexOf("Edge") !== -1;
+	  }
+	};
+
+	var DrawSVGPlugin = {
+	  version: "3.13.0",
+	  name: "drawSVG",
+	  register: function register(core) {
+	    gsap = core;
+
+	    _initCore();
+	  },
+	  init: function init(target, value, tween, index, targets) {
+	    if (!target.getBBox) {
+	      return false;
+	    }
+
+	    _coreInitted || _initCore();
+
+	    var length = _getLength(target),
+	        start,
+	        end,
+	        cs;
+
+	    this.styles = _getStyleSaver && _getStyleSaver(target, "strokeDashoffset,strokeDasharray,strokeMiterlimit");
+	    this.tween = tween;
+	    this._style = target.style;
+	    this._target = target;
+
+	    if (value + "" === "true") {
+	      value = "0 100%";
+	    } else if (!value) {
+	      value = "0 0";
+	    } else if ((value + "").indexOf(" ") === -1) {
+	      value = "0 " + value;
+	    }
+
+	    start = _getPosition(target, length);
+	    end = _parse(value, length, start[0]);
+	    this._length = _round(length);
+	    this._dash = _round(start[1] - start[0]);
+	    this._offset = _round(-start[0]);
+	    this._dashPT = this.add(this, "_dash", this._dash, _round(end[1] - end[0]), 0, 0, 0, 0, 0, 1);
+	    this._offsetPT = this.add(this, "_offset", this._offset, _round(-end[0]), 0, 0, 0, 0, 0, 1);
+
+	    if (_isEdge) {
+	      cs = _win.getComputedStyle(target);
+
+	      if (cs.strokeLinecap !== cs.strokeLinejoin) {
+	        end = _parseNum(cs.strokeMiterlimit);
+	        this.add(target.style, "strokeMiterlimit", end, end + 0.01);
+	      }
+	    }
+
+	    this._live = _hasNonScalingStroke(target) || ~(value + "").indexOf("live");
+	    this._nowrap = ~(value + "").indexOf("nowrap");
+
+	    this._props.push("drawSVG");
+
+	    return _bonusValidated;
+	  },
+	  render: function render(ratio, data) {
+	    if (data.tween._time || !_reverting()) {
+	      var pt = data._pt,
+	          style = data._style,
+	          length,
+	          lengthRatio,
+	          dash,
+	          offset;
+
+	      if (pt) {
+	        if (data._live) {
+	          length = _getLength(data._target);
+
+	          if (length !== data._length) {
+	            lengthRatio = length / data._length;
+	            data._length = length;
+
+	            if (data._offsetPT) {
+	              data._offsetPT.s *= lengthRatio;
+	              data._offsetPT.c *= lengthRatio;
+	            }
+
+	            if (data._dashPT) {
+	              data._dashPT.s *= lengthRatio;
+	              data._dashPT.c *= lengthRatio;
+	            } else {
+	              data._dash *= lengthRatio;
+	            }
+	          }
+	        }
+
+	        while (pt) {
+	          pt.r(ratio, pt.d);
+	          pt = pt._next;
+	        }
+
+	        dash = data._dash || ratio && ratio !== 1 && 0.0001 || 0;
+	        length = data._length - dash + 0.1;
+	        offset = data._offset;
+	        dash && offset && dash + Math.abs(offset % data._length) > data._length - 0.05 && (offset += offset < 0 ? 0.005 : -0.005) && (length += 0.005);
+	        style.strokeDashoffset = dash ? offset : offset + 0.001;
+	        style.strokeDasharray = length < 0.1 ? "none" : dash ? dash + "px," + (data._nowrap ? 999999 : length) + "px" : "0px, 999999px";
+	      }
+	    } else {
+	      data.styles.revert();
+	    }
+	  },
+	  getLength: _getLength,
+	  getPosition: _getPosition
+	};
+	_getGSAP() && gsap.registerPlugin(DrawSVGPlugin);
+
+	exports.DrawSVGPlugin = DrawSVGPlugin;
+	exports.default = DrawSVGPlugin;
+
+	Object.defineProperty(exports, '__esModule', { value: true });
+
+})));

source/files/gsap-public/umd/EasePack.js

@@ -0,0 +1,216 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+	typeof define === 'function' && define.amd ? define(['exports'], factory) :
+	(global = global || self, factory(global.window = global.window || {}));
+}(this, (function (exports) { 'use strict';
+
+	/*!
+	 * EasePack 3.13.0
+	 * https://gsap.com
+	 *
+	 * @license Copyright 2008-2025, GreenSock. All rights reserved.
+	 * Subject to the terms at https://gsap.com/standard-license
+	 * @author: Jack Doyle, jack@greensock.com
+	*/
+	var gsap,
+	    _registerEase,
+	    _getGSAP = function _getGSAP() {
+	  return gsap || typeof window !== "undefined" && (gsap = window.gsap) && gsap.registerPlugin && gsap;
+	},
+	    _boolean = function _boolean(value, defaultValue) {
+	  return !!(typeof value === "undefined" ? defaultValue : value && !~(value + "").indexOf("false"));
+	},
+	    _initCore = function _initCore(core) {
+	  gsap = core || _getGSAP();
+
+	  if (gsap) {
+	    _registerEase = gsap.registerEase;
+
+	    var eases = gsap.parseEase(),
+	        createConfig = function createConfig(ease) {
+	      return function (ratio) {
+	        var y = 0.5 + ratio / 2;
+
+	        ease.config = function (p) {
+	          return ease(2 * (1 - p) * p * y + p * p);
+	        };
+	      };
+	    },
+	        p;
+
+	    for (p in eases) {
+	      if (!eases[p].config) {
+	        createConfig(eases[p]);
+	      }
+	    }
+
+	    _registerEase("slow", SlowMo);
+
+	    _registerEase("expoScale", ExpoScaleEase);
+
+	    _registerEase("rough", RoughEase);
+
+	    for (p in EasePack) {
+	      p !== "version" && gsap.core.globals(p, EasePack[p]);
+	    }
+	  }
+	},
+	    _createSlowMo = function _createSlowMo(linearRatio, power, yoyoMode) {
+	  linearRatio = Math.min(1, linearRatio || 0.7);
+
+	  var pow = linearRatio < 1 ? power || power === 0 ? power : 0.7 : 0,
+	      p1 = (1 - linearRatio) / 2,
+	      p3 = p1 + linearRatio,
+	      calcEnd = _boolean(yoyoMode);
+
+	  return function (p) {
+	    var r = p + (0.5 - p) * pow;
+	    return p < p1 ? calcEnd ? 1 - (p = 1 - p / p1) * p : r - (p = 1 - p / p1) * p * p * p * r : p > p3 ? calcEnd ? p === 1 ? 0 : 1 - (p = (p - p3) / p1) * p : r + (p - r) * (p = (p - p3) / p1) * p * p * p : calcEnd ? 1 : r;
+	  };
+	},
+	    _createExpoScale = function _createExpoScale(start, end, ease) {
+	  var p1 = Math.log(end / start),
+	      p2 = end - start;
+	  ease && (ease = gsap.parseEase(ease));
+	  return function (p) {
+	    return (start * Math.exp(p1 * (ease ? ease(p) : p)) - start) / p2;
+	  };
+	},
+	    EasePoint = function EasePoint(time, value, next) {
+	  this.t = time;
+	  this.v = value;
+
+	  if (next) {
+	    this.next = next;
+	    next.prev = this;
+	    this.c = next.v - value;
+	    this.gap = next.t - time;
+	  }
+	},
+	    _createRoughEase = function _createRoughEase(vars) {
+	  if (typeof vars !== "object") {
+	    vars = {
+	      points: +vars || 20
+	    };
+	  }
+
+	  var taper = vars.taper || "none",
+	      a = [],
+	      cnt = 0,
+	      points = (+vars.points || 20) | 0,
+	      i = points,
+	      randomize = _boolean(vars.randomize, true),
+	      clamp = _boolean(vars.clamp),
+	      template = gsap ? gsap.parseEase(vars.template) : 0,
+	      strength = (+vars.strength || 1) * 0.4,
+	      x,
+	      y,
+	      bump,
+	      invX,
+	      obj,
+	      pnt,
+	      recent;
+
+	  while (--i > -1) {
+	    x = randomize ? Math.random() : 1 / points * i;
+	    y = template ? template(x) : x;
+
+	    if (taper === "none") {
+	      bump = strength;
+	    } else if (taper === "out") {
+	      invX = 1 - x;
+	      bump = invX * invX * strength;
+	    } else if (taper === "in") {
+	      bump = x * x * strength;
+	    } else if (x < 0.5) {
+	      invX = x * 2;
+	      bump = invX * invX * 0.5 * strength;
+	    } else {
+	      invX = (1 - x) * 2;
+	      bump = invX * invX * 0.5 * strength;
+	    }
+
+	    if (randomize) {
+	      y += Math.random() * bump - bump * 0.5;
+	    } else if (i % 2) {
+	      y += bump * 0.5;
+	    } else {
+	      y -= bump * 0.5;
+	    }
+
+	    if (clamp) {
+	      if (y > 1) {
+	        y = 1;
+	      } else if (y < 0) {
+	        y = 0;
+	      }
+	    }
+
+	    a[cnt++] = {
+	      x: x,
+	      y: y
+	    };
+	  }
+
+	  a.sort(function (a, b) {
+	    return a.x - b.x;
+	  });
+	  pnt = new EasePoint(1, 1, null);
+	  i = points;
+
+	  while (i--) {
+	    obj = a[i];
+	    pnt = new EasePoint(obj.x, obj.y, pnt);
+	  }
+
+	  recent = new EasePoint(0, 0, pnt.t ? pnt : pnt.next);
+	  return function (p) {
+	    var pnt = recent;
+
+	    if (p > pnt.t) {
+	      while (pnt.next && p >= pnt.t) {
+	        pnt = pnt.next;
+	      }
+
+	      pnt = pnt.prev;
+	    } else {
+	      while (pnt.prev && p <= pnt.t) {
+	        pnt = pnt.prev;
+	      }
+	    }
+
+	    recent = pnt;
+	    return pnt.v + (p - pnt.t) / pnt.gap * pnt.c;
+	  };
+	};
+
+	var SlowMo = _createSlowMo(0.7);
+	SlowMo.ease = SlowMo;
+	SlowMo.config = _createSlowMo;
+	var ExpoScaleEase = _createExpoScale(1, 2);
+	ExpoScaleEase.config = _createExpoScale;
+	var RoughEase = _createRoughEase();
+	RoughEase.ease = RoughEase;
+	RoughEase.config = _createRoughEase;
+	var EasePack = {
+	  SlowMo: SlowMo,
+	  RoughEase: RoughEase,
+	  ExpoScaleEase: ExpoScaleEase
+	};
+
+	for (var p in EasePack) {
+	  EasePack[p].register = _initCore;
+	  EasePack[p].version = "3.13.0";
+	}
+
+	_getGSAP() && gsap.registerPlugin(SlowMo);
+
+	exports.EasePack = EasePack;
+	exports.ExpoScaleEase = ExpoScaleEase;
+	exports.RoughEase = RoughEase;
+	exports.SlowMo = SlowMo;
+	exports.default = EasePack;
+
+	Object.defineProperty(exports, '__esModule', { value: true });
+
+})));

source/files/gsap-public/umd/EaselPlugin.js

@@ -0,0 +1,350 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+	typeof define === 'function' && define.amd ? define(['exports'], factory) :
+	(global = global || self, factory(global.window = global.window || {}));
+}(this, (function (exports) { 'use strict';
+
+	/*!
+	 * EaselPlugin 3.13.0
+	 * https://gsap.com
+	 *
+	 * @license Copyright 2008-2025, GreenSock. All rights reserved.
+	 * Subject to the terms at https://gsap.com/standard-license
+	 * @author: Jack Doyle, jack@greensock.com
+	*/
+	var gsap,
+	    _coreInitted,
+	    _win,
+	    _createJS,
+	    _ColorFilter,
+	    _ColorMatrixFilter,
+	    _colorProps = "redMultiplier,greenMultiplier,blueMultiplier,alphaMultiplier,redOffset,greenOffset,blueOffset,alphaOffset".split(","),
+	    _windowExists = function _windowExists() {
+	  return typeof window !== "undefined";
+	},
+	    _getGSAP = function _getGSAP() {
+	  return gsap || _windowExists() && (gsap = window.gsap) && gsap.registerPlugin && gsap;
+	},
+	    _getCreateJS = function _getCreateJS() {
+	  return _createJS || _win && _win.createjs || _win || {};
+	},
+	    _warn = function _warn(message) {
+	  return console.warn(message);
+	},
+	    _cache = function _cache(target) {
+	  var b = target.getBounds && target.getBounds();
+
+	  if (!b) {
+	    b = target.nominalBounds || {
+	      x: 0,
+	      y: 0,
+	      width: 100,
+	      height: 100
+	    };
+	    target.setBounds && target.setBounds(b.x, b.y, b.width, b.height);
+	  }
+
+	  target.cache && target.cache(b.x, b.y, b.width, b.height);
+
+	  _warn("EaselPlugin: for filters to display in EaselJS, you must call the object's cache() method first. GSAP attempted to use the target's getBounds() for the cache but that may not be completely accurate. " + target);
+	},
+	    _parseColorFilter = function _parseColorFilter(target, v, plugin) {
+	  if (!_ColorFilter) {
+	    _ColorFilter = _getCreateJS().ColorFilter;
+
+	    if (!_ColorFilter) {
+	      _warn("EaselPlugin error: The EaselJS ColorFilter JavaScript file wasn't loaded.");
+	    }
+	  }
+
+	  var filters = target.filters || [],
+	      i = filters.length,
+	      c,
+	      s,
+	      e,
+	      a,
+	      p,
+	      pt;
+
+	  while (i--) {
+	    if (filters[i] instanceof _ColorFilter) {
+	      s = filters[i];
+	      break;
+	    }
+	  }
+
+	  if (!s) {
+	    s = new _ColorFilter();
+	    filters.push(s);
+	    target.filters = filters;
+	  }
+
+	  e = s.clone();
+
+	  if (v.tint != null) {
+	    c = gsap.utils.splitColor(v.tint);
+	    a = v.tintAmount != null ? +v.tintAmount : 1;
+	    e.redOffset = +c[0] * a;
+	    e.greenOffset = +c[1] * a;
+	    e.blueOffset = +c[2] * a;
+	    e.redMultiplier = e.greenMultiplier = e.blueMultiplier = 1 - a;
+	  } else {
+	    for (p in v) {
+	      if (p !== "exposure") if (p !== "brightness") {
+	        e[p] = +v[p];
+	      }
+	    }
+	  }
+
+	  if (v.exposure != null) {
+	    e.redOffset = e.greenOffset = e.blueOffset = 255 * (+v.exposure - 1);
+	    e.redMultiplier = e.greenMultiplier = e.blueMultiplier = 1;
+	  } else if (v.brightness != null) {
+	    a = +v.brightness - 1;
+	    e.redOffset = e.greenOffset = e.blueOffset = a > 0 ? a * 255 : 0;
+	    e.redMultiplier = e.greenMultiplier = e.blueMultiplier = 1 - Math.abs(a);
+	  }
+
+	  i = 8;
+
+	  while (i--) {
+	    p = _colorProps[i];
+
+	    if (s[p] !== e[p]) {
+	      pt = plugin.add(s, p, s[p], e[p], 0, 0, 0, 0, 0, 1);
+
+	      if (pt) {
+	        pt.op = "easel_colorFilter";
+	      }
+	    }
+	  }
+
+	  plugin._props.push("easel_colorFilter");
+
+	  if (!target.cacheID) {
+	    _cache(target);
+	  }
+	},
+	    _idMatrix = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0],
+	    _lumR = 0.212671,
+	    _lumG = 0.715160,
+	    _lumB = 0.072169,
+	    _applyMatrix = function _applyMatrix(m, m2) {
+	  if (!(m instanceof Array) || !(m2 instanceof Array)) {
+	    return m2;
+	  }
+
+	  var temp = [],
+	      i = 0,
+	      z = 0,
+	      y,
+	      x;
+
+	  for (y = 0; y < 4; y++) {
+	    for (x = 0; x < 5; x++) {
+	      z = x === 4 ? m[i + 4] : 0;
+	      temp[i + x] = m[i] * m2[x] + m[i + 1] * m2[x + 5] + m[i + 2] * m2[x + 10] + m[i + 3] * m2[x + 15] + z;
+	    }
+
+	    i += 5;
+	  }
+
+	  return temp;
+	},
+	    _setSaturation = function _setSaturation(m, n) {
+	  if (isNaN(n)) {
+	    return m;
+	  }
+
+	  var inv = 1 - n,
+	      r = inv * _lumR,
+	      g = inv * _lumG,
+	      b = inv * _lumB;
+	  return _applyMatrix([r + n, g, b, 0, 0, r, g + n, b, 0, 0, r, g, b + n, 0, 0, 0, 0, 0, 1, 0], m);
+	},
+	    _colorize = function _colorize(m, color, amount) {
+	  if (isNaN(amount)) {
+	    amount = 1;
+	  }
+
+	  var c = gsap.utils.splitColor(color),
+	      r = c[0] / 255,
+	      g = c[1] / 255,
+	      b = c[2] / 255,
+	      inv = 1 - amount;
+	  return _applyMatrix([inv + amount * r * _lumR, amount * r * _lumG, amount * r * _lumB, 0, 0, amount * g * _lumR, inv + amount * g * _lumG, amount * g * _lumB, 0, 0, amount * b * _lumR, amount * b * _lumG, inv + amount * b * _lumB, 0, 0, 0, 0, 0, 1, 0], m);
+	},
+	    _setHue = function _setHue(m, n) {
+	  if (isNaN(n)) {
+	    return m;
+	  }
+
+	  n *= Math.PI / 180;
+	  var c = Math.cos(n),
+	      s = Math.sin(n);
+	  return _applyMatrix([_lumR + c * (1 - _lumR) + s * -_lumR, _lumG + c * -_lumG + s * -_lumG, _lumB + c * -_lumB + s * (1 - _lumB), 0, 0, _lumR + c * -_lumR + s * 0.143, _lumG + c * (1 - _lumG) + s * 0.14, _lumB + c * -_lumB + s * -0.283, 0, 0, _lumR + c * -_lumR + s * -(1 - _lumR), _lumG + c * -_lumG + s * _lumG, _lumB + c * (1 - _lumB) + s * _lumB, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1], m);
+	},
+	    _setContrast = function _setContrast(m, n) {
+	  if (isNaN(n)) {
+	    return m;
+	  }
+
+	  n += 0.01;
+	  return _applyMatrix([n, 0, 0, 0, 128 * (1 - n), 0, n, 0, 0, 128 * (1 - n), 0, 0, n, 0, 128 * (1 - n), 0, 0, 0, 1, 0], m);
+	},
+	    _parseColorMatrixFilter = function _parseColorMatrixFilter(target, v, plugin) {
+	  if (!_ColorMatrixFilter) {
+	    _ColorMatrixFilter = _getCreateJS().ColorMatrixFilter;
+
+	    if (!_ColorMatrixFilter) {
+	      _warn("EaselPlugin: The EaselJS ColorMatrixFilter JavaScript file wasn't loaded.");
+	    }
+	  }
+
+	  var filters = target.filters || [],
+	      i = filters.length,
+	      matrix,
+	      startMatrix,
+	      s,
+	      pg;
+
+	  while (--i > -1) {
+	    if (filters[i] instanceof _ColorMatrixFilter) {
+	      s = filters[i];
+	      break;
+	    }
+	  }
+
+	  if (!s) {
+	    s = new _ColorMatrixFilter(_idMatrix.slice());
+	    filters.push(s);
+	    target.filters = filters;
+	  }
+
+	  startMatrix = s.matrix;
+	  matrix = _idMatrix.slice();
+
+	  if (v.colorize != null) {
+	    matrix = _colorize(matrix, v.colorize, Number(v.colorizeAmount));
+	  }
+
+	  if (v.contrast != null) {
+	    matrix = _setContrast(matrix, Number(v.contrast));
+	  }
+
+	  if (v.hue != null) {
+	    matrix = _setHue(matrix, Number(v.hue));
+	  }
+
+	  if (v.saturation != null) {
+	    matrix = _setSaturation(matrix, Number(v.saturation));
+	  }
+
+	  i = matrix.length;
+
+	  while (--i > -1) {
+	    if (matrix[i] !== startMatrix[i]) {
+	      pg = plugin.add(startMatrix, i, startMatrix[i], matrix[i], 0, 0, 0, 0, 0, 1);
+
+	      if (pg) {
+	        pg.op = "easel_colorMatrixFilter";
+	      }
+	    }
+	  }
+
+	  plugin._props.push("easel_colorMatrixFilter");
+
+	  if (!target.cacheID) {
+	    _cache();
+	  }
+
+	  plugin._matrix = startMatrix;
+	},
+	    _initCore = function _initCore(core) {
+	  gsap = core || _getGSAP();
+
+	  if (_windowExists()) {
+	    _win = window;
+	  }
+
+	  if (gsap) {
+	    _coreInitted = 1;
+	  }
+	};
+
+	var EaselPlugin = {
+	  version: "3.13.0",
+	  name: "easel",
+	  init: function init(target, value, tween, index, targets) {
+	    if (!_coreInitted) {
+	      _initCore();
+
+	      if (!gsap) {
+	        _warn("Please gsap.registerPlugin(EaselPlugin)");
+	      }
+	    }
+
+	    this.target = target;
+	    var p, pt, tint, colorMatrix, end, labels, i;
+
+	    for (p in value) {
+	      end = value[p];
+
+	      if (p === "colorFilter" || p === "tint" || p === "tintAmount" || p === "exposure" || p === "brightness") {
+	        if (!tint) {
+	          _parseColorFilter(target, value.colorFilter || value, this);
+
+	          tint = true;
+	        }
+	      } else if (p === "saturation" || p === "contrast" || p === "hue" || p === "colorize" || p === "colorizeAmount") {
+	        if (!colorMatrix) {
+	          _parseColorMatrixFilter(target, value.colorMatrixFilter || value, this);
+
+	          colorMatrix = true;
+	        }
+	      } else if (p === "frame") {
+	        if (typeof end === "string" && end.charAt(1) !== "=" && (labels = target.labels)) {
+	          for (i = 0; i < labels.length; i++) {
+	            if (labels[i].label === end) {
+	              end = labels[i].position;
+	            }
+	          }
+	        }
+
+	        pt = this.add(target, "gotoAndStop", target.currentFrame, end, index, targets, Math.round, 0, 0, 1);
+
+	        if (pt) {
+	          pt.op = p;
+	        }
+	      } else if (target[p] != null) {
+	        this.add(target, p, "get", end);
+	      }
+	    }
+	  },
+	  render: function render(ratio, data) {
+	    var pt = data._pt;
+
+	    while (pt) {
+	      pt.r(ratio, pt.d);
+	      pt = pt._next;
+	    }
+
+	    if (data.target.cacheID) {
+	      data.target.updateCache();
+	    }
+	  },
+	  register: _initCore
+	};
+
+	EaselPlugin.registerCreateJS = function (createjs) {
+	  _createJS = createjs;
+	};
+
+	_getGSAP() && gsap.registerPlugin(EaselPlugin);
+
+	exports.EaselPlugin = EaselPlugin;
+	exports.default = EaselPlugin;
+
+	Object.defineProperty(exports, '__esModule', { value: true });
+
+})));

source/files/gsap-public/umd/InertiaPlugin.js

@@ -0,0 +1,718 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+	typeof define === 'function' && define.amd ? define(['exports'], factory) :
+	(global = global || self, factory(global.window = global.window || {}));
+}(this, (function (exports) { 'use strict';
+
+	var gsap,
+	    _coreInitted,
+	    _toArray,
+	    _getUnit,
+	    _first,
+	    _ticker,
+	    _time1,
+	    _time2,
+	    _getCache,
+	    _getGSAP = function _getGSAP() {
+	  return gsap || typeof window !== "undefined" && (gsap = window.gsap);
+	},
+	    _lookup = {},
+	    _round = function _round(value) {
+	  return Math.round(value * 10000) / 10000;
+	},
+	    _getID = function _getID(target) {
+	  return _getCache(target).id;
+	},
+	    _getByTarget = function _getByTarget(target) {
+	  return _lookup[_getID(typeof target === "string" ? _toArray(target)[0] : target)];
+	},
+	    _onTick = function _onTick(time) {
+	  var pt = _first,
+	      val;
+
+	  if (time - _time1 >= 0.05) {
+	    _time2 = _time1;
+	    _time1 = time;
+
+	    while (pt) {
+	      val = pt.g(pt.t, pt.p);
+
+	      if (val !== pt.v1 || time - pt.t1 > 0.2) {
+	        pt.v2 = pt.v1;
+	        pt.v1 = val;
+	        pt.t2 = pt.t1;
+	        pt.t1 = time;
+	      }
+
+	      pt = pt._next;
+	    }
+	  }
+	},
+	    _types = {
+	  deg: 360,
+	  rad: Math.PI * 2
+	},
+	    _initCore = function _initCore() {
+	  gsap = _getGSAP();
+
+	  if (gsap) {
+	    _toArray = gsap.utils.toArray;
+	    _getUnit = gsap.utils.getUnit;
+	    _getCache = gsap.core.getCache;
+	    _ticker = gsap.ticker;
+	    _coreInitted = 1;
+	  }
+	};
+
+	var PropTracker = function PropTracker(target, property, type, next) {
+	  this.t = target;
+	  this.p = property;
+	  this.g = target._gsap.get;
+	  this.rCap = _types[type || _getUnit(this.g(target, property))];
+	  this.v1 = this.v2 = 0;
+	  this.t1 = this.t2 = _ticker.time;
+
+	  if (next) {
+	    this._next = next;
+	    next._prev = this;
+	  }
+	};
+
+	var VelocityTracker = function () {
+	  function VelocityTracker(target, property) {
+	    if (!_coreInitted) {
+	      _initCore();
+	    }
+
+	    this.target = _toArray(target)[0];
+	    _lookup[_getID(this.target)] = this;
+	    this._props = {};
+	    property && this.add(property);
+	  }
+
+	  VelocityTracker.register = function register(core) {
+	    gsap = core;
+
+	    _initCore();
+	  };
+
+	  var _proto = VelocityTracker.prototype;
+
+	  _proto.get = function get(property, skipRecentTick) {
+	    var pt = this._props[property] || console.warn("Not tracking " + property + " velocity."),
+	        val,
+	        dif,
+	        rotationCap;
+	    val = parseFloat(skipRecentTick ? pt.v1 : pt.g(pt.t, pt.p));
+	    dif = val - parseFloat(pt.v2);
+	    rotationCap = pt.rCap;
+
+	    if (rotationCap) {
+	      dif = dif % rotationCap;
+
+	      if (dif !== dif % (rotationCap / 2)) {
+	        dif = dif < 0 ? dif + rotationCap : dif - rotationCap;
+	      }
+	    }
+
+	    return _round(dif / ((skipRecentTick ? pt.t1 : _ticker.time) - pt.t2));
+	  };
+
+	  _proto.getAll = function getAll() {
+	    var result = {},
+	        props = this._props,
+	        p;
+
+	    for (p in props) {
+	      result[p] = this.get(p);
+	    }
+
+	    return result;
+	  };
+
+	  _proto.isTracking = function isTracking(property) {
+	    return property in this._props;
+	  };
+
+	  _proto.add = function add(property, type) {
+	    if (!(property in this._props)) {
+	      if (!_first) {
+	        _ticker.add(_onTick);
+
+	        _time1 = _time2 = _ticker.time;
+	      }
+
+	      _first = this._props[property] = new PropTracker(this.target, property, type, _first);
+	    }
+	  };
+
+	  _proto.remove = function remove(property) {
+	    var pt = this._props[property],
+	        prev,
+	        next;
+
+	    if (pt) {
+	      prev = pt._prev;
+	      next = pt._next;
+
+	      if (prev) {
+	        prev._next = next;
+	      }
+
+	      if (next) {
+	        next._prev = prev;
+	      } else if (_first === pt) {
+	        _ticker.remove(_onTick);
+
+	        _first = 0;
+	      }
+
+	      delete this._props[property];
+	    }
+	  };
+
+	  _proto.kill = function kill(shallow) {
+	    for (var p in this._props) {
+	      this.remove(p);
+	    }
+
+	    if (!shallow) {
+	      delete _lookup[_getID(this.target)];
+	    }
+	  };
+
+	  VelocityTracker.track = function track(targets, properties, types) {
+	    if (!_coreInitted) {
+	      _initCore();
+	    }
+
+	    var result = [],
+	        targs = _toArray(targets),
+	        a = properties.split(","),
+	        t = (types || "").split(","),
+	        i = targs.length,
+	        tracker,
+	        j;
+
+	    while (i--) {
+	      tracker = _getByTarget(targs[i]) || new VelocityTracker(targs[i]);
+	      j = a.length;
+
+	      while (j--) {
+	        tracker.add(a[j], t[j] || t[0]);
+	      }
+
+	      result.push(tracker);
+	    }
+
+	    return result;
+	  };
+
+	  VelocityTracker.untrack = function untrack(targets, properties) {
+	    var props = (properties || "").split(",");
+
+	    _toArray(targets).forEach(function (target) {
+	      var tracker = _getByTarget(target);
+
+	      if (tracker) {
+	        if (!props.length) {
+	          tracker.kill(1);
+	        } else {
+	          props.forEach(function (p) {
+	            return tracker.remove(p);
+	          });
+	        }
+	      }
+	    });
+	  };
+
+	  VelocityTracker.isTracking = function isTracking(target, property) {
+	    var tracker = _getByTarget(target);
+
+	    return tracker && tracker.isTracking(property);
+	  };
+
+	  VelocityTracker.getVelocity = function getVelocity(target, property) {
+	    var tracker = _getByTarget(target);
+
+	    return !tracker || !tracker.isTracking(property) ? console.warn("Not tracking velocity of " + property) : tracker.get(property);
+	  };
+
+	  return VelocityTracker;
+	}();
+	VelocityTracker.getByTarget = _getByTarget;
+	_getGSAP() && gsap.registerPlugin(VelocityTracker);
+
+	/*!
+	 * InertiaPlugin 3.13.0
+	 * https://gsap.com
+	 *
+	 * @license Copyright 2008-2025, GreenSock. All rights reserved.
+	 * Subject to the terms at https://gsap.com/standard-license
+	 * @author: Jack Doyle, jack@greensock.com
+	*/
+
+	var gsap$1,
+	    _coreInitted$1,
+	    _parseEase,
+	    _toArray$1,
+	    _power3,
+	    _config,
+	    _getUnit$1,
+	    PropTween,
+	    _getCache$1,
+	    _checkPointRatio,
+	    _clamp,
+	    _processingVars,
+	    _getStyleSaver,
+	    _reverting,
+	    _getTracker = VelocityTracker.getByTarget,
+	    _getGSAP$1 = function _getGSAP() {
+	  return gsap$1 || typeof window !== "undefined" && (gsap$1 = window.gsap) && gsap$1.registerPlugin && gsap$1;
+	},
+	    _isString = function _isString(value) {
+	  return typeof value === "string";
+	},
+	    _isNumber = function _isNumber(value) {
+	  return typeof value === "number";
+	},
+	    _isObject = function _isObject(value) {
+	  return typeof value === "object";
+	},
+	    _isFunction = function _isFunction(value) {
+	  return typeof value === "function";
+	},
+	    _bonusValidated = 1,
+	    _isArray = Array.isArray,
+	    _emptyFunc = function _emptyFunc(p) {
+	  return p;
+	},
+	    _bigNum = 1e10,
+	    _tinyNum = 1 / _bigNum,
+	    _checkPoint = 0.05,
+	    _round$1 = function _round(value) {
+	  return Math.round(value * 10000) / 10000;
+	},
+	    _extend = function _extend(obj, defaults, exclude) {
+	  for (var p in defaults) {
+	    if (!(p in obj) && p !== exclude) {
+	      obj[p] = defaults[p];
+	    }
+	  }
+
+	  return obj;
+	},
+	    _deepClone = function _deepClone(obj) {
+	  var copy = {},
+	      p,
+	      v;
+
+	  for (p in obj) {
+	    copy[p] = _isObject(v = obj[p]) && !_isArray(v) ? _deepClone(v) : v;
+	  }
+
+	  return copy;
+	},
+	    _getClosest = function _getClosest(n, values, max, min, radius) {
+	  var i = values.length,
+	      closest = 0,
+	      absDif = _bigNum,
+	      val,
+	      dif,
+	      p,
+	      dist;
+
+	  if (_isObject(n)) {
+	    while (i--) {
+	      val = values[i];
+	      dif = 0;
+
+	      for (p in n) {
+	        dist = val[p] - n[p];
+	        dif += dist * dist;
+	      }
+
+	      if (dif < absDif) {
+	        closest = i;
+	        absDif = dif;
+	      }
+	    }
+
+	    if ((radius || _bigNum) < _bigNum && radius < Math.sqrt(absDif)) {
+	      return n;
+	    }
+	  } else {
+	    while (i--) {
+	      val = values[i];
+	      dif = val - n;
+
+	      if (dif < 0) {
+	        dif = -dif;
+	      }
+
+	      if (dif < absDif && val >= min && val <= max) {
+	        closest = i;
+	        absDif = dif;
+	      }
+	    }
+	  }
+
+	  return values[closest];
+	},
+	    _parseEnd = function _parseEnd(curProp, end, max, min, name, radius, velocity) {
+	  if (curProp.end === "auto") {
+	    return curProp;
+	  }
+
+	  var endVar = curProp.end,
+	      adjustedEnd,
+	      p;
+	  max = isNaN(max) ? _bigNum : max;
+	  min = isNaN(min) ? -_bigNum : min;
+
+	  if (_isObject(end)) {
+	    adjustedEnd = end.calculated ? end : (_isFunction(endVar) ? endVar(end, velocity) : _getClosest(end, endVar, max, min, radius)) || end;
+
+	    if (!end.calculated) {
+	      for (p in adjustedEnd) {
+	        end[p] = adjustedEnd[p];
+	      }
+
+	      end.calculated = true;
+	    }
+
+	    adjustedEnd = adjustedEnd[name];
+	  } else {
+	    adjustedEnd = _isFunction(endVar) ? endVar(end, velocity) : _isArray(endVar) ? _getClosest(end, endVar, max, min, radius) : parseFloat(endVar);
+	  }
+
+	  if (adjustedEnd > max) {
+	    adjustedEnd = max;
+	  } else if (adjustedEnd < min) {
+	    adjustedEnd = min;
+	  }
+
+	  return {
+	    max: adjustedEnd,
+	    min: adjustedEnd,
+	    unitFactor: curProp.unitFactor
+	  };
+	},
+	    _getNumOrDefault = function _getNumOrDefault(vars, property, defaultValue) {
+	  return isNaN(vars[property]) ? defaultValue : +vars[property];
+	},
+	    _calculateChange = function _calculateChange(velocity, duration) {
+	  return duration * _checkPoint * velocity / _checkPointRatio;
+	},
+	    _calculateDuration = function _calculateDuration(start, end, velocity) {
+	  return Math.abs((end - start) * _checkPointRatio / velocity / _checkPoint);
+	},
+	    _reservedProps = {
+	  resistance: 1,
+	  checkpoint: 1,
+	  preventOvershoot: 1,
+	  linkedProps: 1,
+	  radius: 1,
+	  duration: 1
+	},
+	    _processLinkedProps = function _processLinkedProps(target, vars, getVal, resistance) {
+	  if (vars.linkedProps) {
+	    var linkedPropNames = vars.linkedProps.split(","),
+	        linkedProps = {},
+	        i,
+	        p,
+	        curProp,
+	        curVelocity,
+	        tracker,
+	        curDuration;
+
+	    for (i = 0; i < linkedPropNames.length; i++) {
+	      p = linkedPropNames[i];
+	      curProp = vars[p];
+
+	      if (curProp) {
+	        if (_isNumber(curProp.velocity)) {
+	          curVelocity = curProp.velocity;
+	        } else {
+	          tracker = tracker || _getTracker(target);
+	          curVelocity = tracker && tracker.isTracking(p) ? tracker.get(p) : 0;
+	        }
+
+	        curDuration = Math.abs(curVelocity / _getNumOrDefault(curProp, "resistance", resistance));
+	        linkedProps[p] = parseFloat(getVal(target, p)) + _calculateChange(curVelocity, curDuration);
+	      }
+	    }
+
+	    return linkedProps;
+	  }
+	},
+	    _calculateTweenDuration = function _calculateTweenDuration(target, vars, maxDuration, minDuration, overshootTolerance, recordEnd) {
+	  if (maxDuration === void 0) {
+	    maxDuration = 10;
+	  }
+
+	  if (minDuration === void 0) {
+	    minDuration = 0.2;
+	  }
+
+	  if (overshootTolerance === void 0) {
+	    overshootTolerance = 1;
+	  }
+
+	  if (recordEnd === void 0) {
+	    recordEnd = 0;
+	  }
+
+	  _isString(target) && (target = _toArray$1(target)[0]);
+
+	  if (!target) {
+	    return 0;
+	  }
+
+	  var duration = 0,
+	      clippedDuration = _bigNum,
+	      inertiaVars = vars.inertia || vars,
+	      getVal = _getCache$1(target).get,
+	      resistance = _getNumOrDefault(inertiaVars, "resistance", _config.resistance),
+	      p,
+	      curProp,
+	      curDuration,
+	      curVelocity,
+	      curVal,
+	      end,
+	      curClippedDuration,
+	      tracker,
+	      unitFactor,
+	      linkedProps;
+
+	  linkedProps = _processLinkedProps(target, inertiaVars, getVal, resistance);
+
+	  for (p in inertiaVars) {
+	    if (!_reservedProps[p]) {
+	      curProp = inertiaVars[p];
+
+	      if (!_isObject(curProp)) {
+	        tracker = tracker || _getTracker(target);
+
+	        if (tracker && tracker.isTracking(p)) {
+	          curProp = _isNumber(curProp) ? {
+	            velocity: curProp
+	          } : {
+	            velocity: tracker.get(p)
+	          };
+	        } else {
+	          curVelocity = +curProp || 0;
+	          curDuration = Math.abs(curVelocity / resistance);
+	        }
+	      }
+
+	      if (_isObject(curProp)) {
+	        if (_isNumber(curProp.velocity)) {
+	          curVelocity = curProp.velocity;
+	        } else {
+	          tracker = tracker || _getTracker(target);
+	          curVelocity = tracker && tracker.isTracking(p) ? tracker.get(p) : 0;
+	        }
+
+	        curDuration = _clamp(minDuration, maxDuration, Math.abs(curVelocity / _getNumOrDefault(curProp, "resistance", resistance)));
+	        curVal = parseFloat(getVal(target, p)) || 0;
+	        end = curVal + _calculateChange(curVelocity, curDuration);
+
+	        if ("end" in curProp) {
+	          curProp = _parseEnd(curProp, linkedProps && p in linkedProps ? linkedProps : end, curProp.max, curProp.min, p, inertiaVars.radius, curVelocity);
+
+	          if (recordEnd) {
+	            _processingVars === vars && (_processingVars = inertiaVars = _deepClone(vars));
+	            inertiaVars[p] = _extend(curProp, inertiaVars[p], "end");
+	          }
+	        }
+
+	        if ("max" in curProp && end > +curProp.max + _tinyNum) {
+	          unitFactor = curProp.unitFactor || _config.unitFactors[p] || 1;
+	          curClippedDuration = curVal > curProp.max && curProp.min !== curProp.max || curVelocity * unitFactor > -15 && curVelocity * unitFactor < 45 ? minDuration + (maxDuration - minDuration) * 0.1 : _calculateDuration(curVal, curProp.max, curVelocity);
+
+	          if (curClippedDuration + overshootTolerance < clippedDuration) {
+	            clippedDuration = curClippedDuration + overshootTolerance;
+	          }
+	        } else if ("min" in curProp && end < +curProp.min - _tinyNum) {
+	          unitFactor = curProp.unitFactor || _config.unitFactors[p] || 1;
+	          curClippedDuration = curVal < curProp.min && curProp.min !== curProp.max || curVelocity * unitFactor > -45 && curVelocity * unitFactor < 15 ? minDuration + (maxDuration - minDuration) * 0.1 : _calculateDuration(curVal, curProp.min, curVelocity);
+
+	          if (curClippedDuration + overshootTolerance < clippedDuration) {
+	            clippedDuration = curClippedDuration + overshootTolerance;
+	          }
+	        }
+
+	        curClippedDuration > duration && (duration = curClippedDuration);
+	      }
+
+	      curDuration > duration && (duration = curDuration);
+	    }
+	  }
+
+	  duration > clippedDuration && (duration = clippedDuration);
+	  return duration > maxDuration ? maxDuration : duration < minDuration ? minDuration : duration;
+	},
+	    _initCore$1 = function _initCore() {
+	  gsap$1 = _getGSAP$1();
+
+	  if (gsap$1) {
+	    _parseEase = gsap$1.parseEase;
+	    _toArray$1 = gsap$1.utils.toArray;
+	    _getUnit$1 = gsap$1.utils.getUnit;
+	    _getCache$1 = gsap$1.core.getCache;
+	    _clamp = gsap$1.utils.clamp;
+	    _getStyleSaver = gsap$1.core.getStyleSaver;
+
+	    _reverting = gsap$1.core.reverting || function () {};
+
+	    _power3 = _parseEase("power3");
+	    _checkPointRatio = _power3(0.05);
+	    PropTween = gsap$1.core.PropTween;
+	    gsap$1.config({
+	      resistance: 100,
+	      unitFactors: {
+	        time: 1000,
+	        totalTime: 1000,
+	        progress: 1000,
+	        totalProgress: 1000
+	      }
+	    });
+	    _config = gsap$1.config();
+	    gsap$1.registerPlugin(VelocityTracker);
+	    _coreInitted$1 = 1;
+	  }
+	};
+
+	var InertiaPlugin = {
+	  version: "3.13.0",
+	  name: "inertia",
+	  register: function register(core) {
+	    gsap$1 = core;
+
+	    _initCore$1();
+	  },
+	  init: function init(target, vars, tween, index, targets) {
+	    _coreInitted$1 || _initCore$1();
+
+	    var tracker = _getTracker(target);
+
+	    if (vars === "auto") {
+	      if (!tracker) {
+	        console.warn("No inertia tracking on " + target + ". InertiaPlugin.track(target) first.");
+	        return;
+	      }
+
+	      vars = tracker.getAll();
+	    }
+
+	    this.styles = _getStyleSaver && typeof target.style === "object" && _getStyleSaver(target);
+	    this.target = target;
+	    this.tween = tween;
+	    _processingVars = vars;
+
+	    var cache = target._gsap,
+	        getVal = cache.get,
+	        dur = vars.duration,
+	        durIsObj = _isObject(dur),
+	        preventOvershoot = vars.preventOvershoot || durIsObj && dur.overshoot === 0,
+	        resistance = _getNumOrDefault(vars, "resistance", _config.resistance),
+	        duration = _isNumber(dur) ? dur : _calculateTweenDuration(target, vars, durIsObj && dur.max || 10, durIsObj && dur.min || 0.2, durIsObj && "overshoot" in dur ? +dur.overshoot : preventOvershoot ? 0 : 1, true),
+	        p,
+	        curProp,
+	        curVal,
+	        unit,
+	        velocity,
+	        change1,
+	        end,
+	        change2,
+	        linkedProps;
+
+	    vars = _processingVars;
+	    _processingVars = 0;
+	    linkedProps = _processLinkedProps(target, vars, getVal, resistance);
+
+	    for (p in vars) {
+	      if (!_reservedProps[p]) {
+	        curProp = vars[p];
+	        _isFunction(curProp) && (curProp = curProp(index, target, targets));
+
+	        if (_isNumber(curProp)) {
+	          velocity = curProp;
+	        } else if (_isObject(curProp) && !isNaN(curProp.velocity)) {
+	          velocity = +curProp.velocity;
+	        } else {
+	          if (tracker && tracker.isTracking(p)) {
+	            velocity = tracker.get(p);
+	          } else {
+	            console.warn("ERROR: No velocity was defined for " + target + " property: " + p);
+	          }
+	        }
+
+	        change1 = _calculateChange(velocity, duration);
+	        change2 = 0;
+	        curVal = getVal(target, p);
+	        unit = _getUnit$1(curVal);
+	        curVal = parseFloat(curVal);
+
+	        if (_isObject(curProp)) {
+	          end = curVal + change1;
+
+	          if ("end" in curProp) {
+	            curProp = _parseEnd(curProp, linkedProps && p in linkedProps ? linkedProps : end, curProp.max, curProp.min, p, vars.radius, velocity);
+	          }
+
+	          if ("max" in curProp && +curProp.max < end) {
+	            if (preventOvershoot || curProp.preventOvershoot) {
+	              change1 = curProp.max - curVal;
+	            } else {
+	              change2 = curProp.max - curVal - change1;
+	            }
+	          } else if ("min" in curProp && +curProp.min > end) {
+	            if (preventOvershoot || curProp.preventOvershoot) {
+	              change1 = curProp.min - curVal;
+	            } else {
+	              change2 = curProp.min - curVal - change1;
+	            }
+	          }
+	        }
+
+	        this._props.push(p);
+
+	        this.styles && this.styles.save(p);
+	        this._pt = new PropTween(this._pt, target, p, curVal, 0, _emptyFunc, 0, cache.set(target, p, this));
+	        this._pt.u = unit || 0;
+	        this._pt.c1 = change1;
+	        this._pt.c2 = change2;
+	      }
+	    }
+
+	    tween.duration(duration);
+	    return _bonusValidated;
+	  },
+	  render: function render(ratio, data) {
+	    var pt = data._pt;
+	    ratio = _power3(data.tween._time / data.tween._dur);
+
+	    if (ratio || !_reverting()) {
+	      while (pt) {
+	        pt.set(pt.t, pt.p, _round$1(pt.s + pt.c1 * ratio + pt.c2 * ratio * ratio) + pt.u, pt.d, ratio);
+	        pt = pt._next;
+	      }
+	    } else {
+	      data.styles.revert();
+	    }
+	  }
+	};
+	"track,untrack,isTracking,getVelocity,getByTarget".split(",").forEach(function (name) {
+	  return InertiaPlugin[name] = VelocityTracker[name];
+	});
+	_getGSAP$1() && gsap$1.registerPlugin(InertiaPlugin);
+
+	exports.InertiaPlugin = InertiaPlugin;
+	exports.VelocityTracker = VelocityTracker;
+	exports.default = InertiaPlugin;
+
+	Object.defineProperty(exports, '__esModule', { value: true });
+
+})));

source/files/gsap-public/umd/Observer.js

@@ -0,0 +1,716 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  (global = global || self, factory(global.window = global.window || {}));
+}(this, (function (exports) { 'use strict';
+
+  function _defineProperties(target, props) {
+    for (var i = 0; i < props.length; i++) {
+      var descriptor = props[i];
+      descriptor.enumerable = descriptor.enumerable || false;
+      descriptor.configurable = true;
+      if ("value" in descriptor) descriptor.writable = true;
+      Object.defineProperty(target, descriptor.key, descriptor);
+    }
+  }
+
+  function _createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+  }
+
+  /*!
+   * Observer 3.13.0
+   * https://gsap.com
+   *
+   * @license Copyright 2008-2025, GreenSock. All rights reserved.
+   * Subject to the terms at https://gsap.com/standard-license
+   * @author: Jack Doyle, jack@greensock.com
+  */
+  var gsap,
+      _coreInitted,
+      _clamp,
+      _win,
+      _doc,
+      _docEl,
+      _body,
+      _isTouch,
+      _pointerType,
+      ScrollTrigger,
+      _root,
+      _normalizer,
+      _eventTypes,
+      _context,
+      _getGSAP = function _getGSAP() {
+    return gsap || typeof window !== "undefined" && (gsap = window.gsap) && gsap.registerPlugin && gsap;
+  },
+      _startup = 1,
+      _observers = [];
+      exports._scrollers = [];
+      exports._proxies = [];
+      var _getTime = Date.now,
+      _bridge = function _bridge(name, value) {
+    return value;
+  },
+      _integrate = function _integrate() {
+    var core = ScrollTrigger.core,
+        data = core.bridge || {},
+        scrollers = core._scrollers,
+        proxies = core._proxies;
+    scrollers.push.apply(scrollers, exports._scrollers);
+    proxies.push.apply(proxies, exports._proxies);
+    exports._scrollers = scrollers;
+    exports._proxies = proxies;
+
+    _bridge = function _bridge(name, value) {
+      return data[name](value);
+    };
+  },
+      _getProxyProp = function _getProxyProp(element, property) {
+    return ~exports._proxies.indexOf(element) && exports._proxies[exports._proxies.indexOf(element) + 1][property];
+  },
+      _isViewport = function _isViewport(el) {
+    return !!~_root.indexOf(el);
+  },
+      _addListener = function _addListener(element, type, func, passive, capture) {
+    return element.addEventListener(type, func, {
+      passive: passive !== false,
+      capture: !!capture
+    });
+  },
+      _removeListener = function _removeListener(element, type, func, capture) {
+    return element.removeEventListener(type, func, !!capture);
+  },
+      _scrollLeft = "scrollLeft",
+      _scrollTop = "scrollTop",
+      _onScroll = function _onScroll() {
+    return _normalizer && _normalizer.isPressed || exports._scrollers.cache++;
+  },
+      _scrollCacheFunc = function _scrollCacheFunc(f, doNotCache) {
+    var cachingFunc = function cachingFunc(value) {
+      if (value || value === 0) {
+        _startup && (_win.history.scrollRestoration = "manual");
+        var isNormalizing = _normalizer && _normalizer.isPressed;
+        value = cachingFunc.v = Math.round(value) || (_normalizer && _normalizer.iOS ? 1 : 0);
+        f(value);
+        cachingFunc.cacheID = exports._scrollers.cache;
+        isNormalizing && _bridge("ss", value);
+      } else if (doNotCache || exports._scrollers.cache !== cachingFunc.cacheID || _bridge("ref")) {
+        cachingFunc.cacheID = exports._scrollers.cache;
+        cachingFunc.v = f();
+      }
+
+      return cachingFunc.v + cachingFunc.offset;
+    };
+
+    cachingFunc.offset = 0;
+    return f && cachingFunc;
+  },
+      _horizontal = {
+    s: _scrollLeft,
+    p: "left",
+    p2: "Left",
+    os: "right",
+    os2: "Right",
+    d: "width",
+    d2: "Width",
+    a: "x",
+    sc: _scrollCacheFunc(function (value) {
+      return arguments.length ? _win.scrollTo(value, _vertical.sc()) : _win.pageXOffset || _doc[_scrollLeft] || _docEl[_scrollLeft] || _body[_scrollLeft] || 0;
+    })
+  },
+      _vertical = {
+    s: _scrollTop,
+    p: "top",
+    p2: "Top",
+    os: "bottom",
+    os2: "Bottom",
+    d: "height",
+    d2: "Height",
+    a: "y",
+    op: _horizontal,
+    sc: _scrollCacheFunc(function (value) {
+      return arguments.length ? _win.scrollTo(_horizontal.sc(), value) : _win.pageYOffset || _doc[_scrollTop] || _docEl[_scrollTop] || _body[_scrollTop] || 0;
+    })
+  },
+      _getTarget = function _getTarget(t, self) {
+    return (self && self._ctx && self._ctx.selector || gsap.utils.toArray)(t)[0] || (typeof t === "string" && gsap.config().nullTargetWarn !== false ? console.warn("Element not found:", t) : null);
+  },
+      _isWithin = function _isWithin(element, list) {
+    var i = list.length;
+
+    while (i--) {
+      if (list[i] === element || list[i].contains(element)) {
+        return true;
+      }
+    }
+
+    return false;
+  },
+      _getScrollFunc = function _getScrollFunc(element, _ref) {
+    var s = _ref.s,
+        sc = _ref.sc;
+    _isViewport(element) && (element = _doc.scrollingElement || _docEl);
+
+    var i = exports._scrollers.indexOf(element),
+        offset = sc === _vertical.sc ? 1 : 2;
+
+    !~i && (i = exports._scrollers.push(element) - 1);
+    exports._scrollers[i + offset] || _addListener(element, "scroll", _onScroll);
+    var prev = exports._scrollers[i + offset],
+        func = prev || (exports._scrollers[i + offset] = _scrollCacheFunc(_getProxyProp(element, s), true) || (_isViewport(element) ? sc : _scrollCacheFunc(function (value) {
+      return arguments.length ? element[s] = value : element[s];
+    })));
+    func.target = element;
+    prev || (func.smooth = gsap.getProperty(element, "scrollBehavior") === "smooth");
+    return func;
+  },
+      _getVelocityProp = function _getVelocityProp(value, minTimeRefresh, useDelta) {
+    var v1 = value,
+        v2 = value,
+        t1 = _getTime(),
+        t2 = t1,
+        min = minTimeRefresh || 50,
+        dropToZeroTime = Math.max(500, min * 3),
+        update = function update(value, force) {
+      var t = _getTime();
+
+      if (force || t - t1 > min) {
+        v2 = v1;
+        v1 = value;
+        t2 = t1;
+        t1 = t;
+      } else if (useDelta) {
+        v1 += value;
+      } else {
+        v1 = v2 + (value - v2) / (t - t2) * (t1 - t2);
+      }
+    },
+        reset = function reset() {
+      v2 = v1 = useDelta ? 0 : v1;
+      t2 = t1 = 0;
+    },
+        getVelocity = function getVelocity(latestValue) {
+      var tOld = t2,
+          vOld = v2,
+          t = _getTime();
+
+      (latestValue || latestValue === 0) && latestValue !== v1 && update(latestValue);
+      return t1 === t2 || t - t2 > dropToZeroTime ? 0 : (v1 + (useDelta ? vOld : -vOld)) / ((useDelta ? t : t1) - tOld) * 1000;
+    };
+
+    return {
+      update: update,
+      reset: reset,
+      getVelocity: getVelocity
+    };
+  },
+      _getEvent = function _getEvent(e, preventDefault) {
+    preventDefault && !e._gsapAllow && e.preventDefault();
+    return e.changedTouches ? e.changedTouches[0] : e;
+  },
+      _getAbsoluteMax = function _getAbsoluteMax(a) {
+    var max = Math.max.apply(Math, a),
+        min = Math.min.apply(Math, a);
+    return Math.abs(max) >= Math.abs(min) ? max : min;
+  },
+      _setScrollTrigger = function _setScrollTrigger() {
+    ScrollTrigger = gsap.core.globals().ScrollTrigger;
+    ScrollTrigger && ScrollTrigger.core && _integrate();
+  },
+      _initCore = function _initCore(core) {
+    gsap = core || _getGSAP();
+
+    if (!_coreInitted && gsap && typeof document !== "undefined" && document.body) {
+      _win = window;
+      _doc = document;
+      _docEl = _doc.documentElement;
+      _body = _doc.body;
+      _root = [_win, _doc, _docEl, _body];
+      _clamp = gsap.utils.clamp;
+
+      _context = gsap.core.context || function () {};
+
+      _pointerType = "onpointerenter" in _body ? "pointer" : "mouse";
+      _isTouch = Observer.isTouch = _win.matchMedia && _win.matchMedia("(hover: none), (pointer: coarse)").matches ? 1 : "ontouchstart" in _win || navigator.maxTouchPoints > 0 || navigator.msMaxTouchPoints > 0 ? 2 : 0;
+      _eventTypes = Observer.eventTypes = ("ontouchstart" in _docEl ? "touchstart,touchmove,touchcancel,touchend" : !("onpointerdown" in _docEl) ? "mousedown,mousemove,mouseup,mouseup" : "pointerdown,pointermove,pointercancel,pointerup").split(",");
+      setTimeout(function () {
+        return _startup = 0;
+      }, 500);
+
+      _setScrollTrigger();
+
+      _coreInitted = 1;
+    }
+
+    return _coreInitted;
+  };
+
+  _horizontal.op = _vertical;
+  exports._scrollers.cache = 0;
+  var Observer = function () {
+    function Observer(vars) {
+      this.init(vars);
+    }
+
+    var _proto = Observer.prototype;
+
+    _proto.init = function init(vars) {
+      _coreInitted || _initCore(gsap) || console.warn("Please gsap.registerPlugin(Observer)");
+      ScrollTrigger || _setScrollTrigger();
+      var tolerance = vars.tolerance,
+          dragMinimum = vars.dragMinimum,
+          type = vars.type,
+          target = vars.target,
+          lineHeight = vars.lineHeight,
+          debounce = vars.debounce,
+          preventDefault = vars.preventDefault,
+          onStop = vars.onStop,
+          onStopDelay = vars.onStopDelay,
+          ignore = vars.ignore,
+          wheelSpeed = vars.wheelSpeed,
+          event = vars.event,
+          onDragStart = vars.onDragStart,
+          onDragEnd = vars.onDragEnd,
+          onDrag = vars.onDrag,
+          onPress = vars.onPress,
+          onRelease = vars.onRelease,
+          onRight = vars.onRight,
+          onLeft = vars.onLeft,
+          onUp = vars.onUp,
+          onDown = vars.onDown,
+          onChangeX = vars.onChangeX,
+          onChangeY = vars.onChangeY,
+          onChange = vars.onChange,
+          onToggleX = vars.onToggleX,
+          onToggleY = vars.onToggleY,
+          onHover = vars.onHover,
+          onHoverEnd = vars.onHoverEnd,
+          onMove = vars.onMove,
+          ignoreCheck = vars.ignoreCheck,
+          isNormalizer = vars.isNormalizer,
+          onGestureStart = vars.onGestureStart,
+          onGestureEnd = vars.onGestureEnd,
+          onWheel = vars.onWheel,
+          onEnable = vars.onEnable,
+          onDisable = vars.onDisable,
+          onClick = vars.onClick,
+          scrollSpeed = vars.scrollSpeed,
+          capture = vars.capture,
+          allowClicks = vars.allowClicks,
+          lockAxis = vars.lockAxis,
+          onLockAxis = vars.onLockAxis;
+      this.target = target = _getTarget(target) || _docEl;
+      this.vars = vars;
+      ignore && (ignore = gsap.utils.toArray(ignore));
+      tolerance = tolerance || 1e-9;
+      dragMinimum = dragMinimum || 0;
+      wheelSpeed = wheelSpeed || 1;
+      scrollSpeed = scrollSpeed || 1;
+      type = type || "wheel,touch,pointer";
+      debounce = debounce !== false;
+      lineHeight || (lineHeight = parseFloat(_win.getComputedStyle(_body).lineHeight) || 22);
+
+      var id,
+          onStopDelayedCall,
+          dragged,
+          moved,
+          wheeled,
+          locked,
+          axis,
+          self = this,
+          prevDeltaX = 0,
+          prevDeltaY = 0,
+          passive = vars.passive || !preventDefault && vars.passive !== false,
+          scrollFuncX = _getScrollFunc(target, _horizontal),
+          scrollFuncY = _getScrollFunc(target, _vertical),
+          scrollX = scrollFuncX(),
+          scrollY = scrollFuncY(),
+          limitToTouch = ~type.indexOf("touch") && !~type.indexOf("pointer") && _eventTypes[0] === "pointerdown",
+          isViewport = _isViewport(target),
+          ownerDoc = target.ownerDocument || _doc,
+          deltaX = [0, 0, 0],
+          deltaY = [0, 0, 0],
+          onClickTime = 0,
+          clickCapture = function clickCapture() {
+        return onClickTime = _getTime();
+      },
+          _ignoreCheck = function _ignoreCheck(e, isPointerOrTouch) {
+        return (self.event = e) && ignore && _isWithin(e.target, ignore) || isPointerOrTouch && limitToTouch && e.pointerType !== "touch" || ignoreCheck && ignoreCheck(e, isPointerOrTouch);
+      },
+          onStopFunc = function onStopFunc() {
+        self._vx.reset();
+
+        self._vy.reset();
+
+        onStopDelayedCall.pause();
+        onStop && onStop(self);
+      },
+          update = function update() {
+        var dx = self.deltaX = _getAbsoluteMax(deltaX),
+            dy = self.deltaY = _getAbsoluteMax(deltaY),
+            changedX = Math.abs(dx) >= tolerance,
+            changedY = Math.abs(dy) >= tolerance;
+
+        onChange && (changedX || changedY) && onChange(self, dx, dy, deltaX, deltaY);
+
+        if (changedX) {
+          onRight && self.deltaX > 0 && onRight(self);
+          onLeft && self.deltaX < 0 && onLeft(self);
+          onChangeX && onChangeX(self);
+          onToggleX && self.deltaX < 0 !== prevDeltaX < 0 && onToggleX(self);
+          prevDeltaX = self.deltaX;
+          deltaX[0] = deltaX[1] = deltaX[2] = 0;
+        }
+
+        if (changedY) {
+          onDown && self.deltaY > 0 && onDown(self);
+          onUp && self.deltaY < 0 && onUp(self);
+          onChangeY && onChangeY(self);
+          onToggleY && self.deltaY < 0 !== prevDeltaY < 0 && onToggleY(self);
+          prevDeltaY = self.deltaY;
+          deltaY[0] = deltaY[1] = deltaY[2] = 0;
+        }
+
+        if (moved || dragged) {
+          onMove && onMove(self);
+
+          if (dragged) {
+            onDragStart && dragged === 1 && onDragStart(self);
+            onDrag && onDrag(self);
+            dragged = 0;
+          }
+
+          moved = false;
+        }
+
+        locked && !(locked = false) && onLockAxis && onLockAxis(self);
+
+        if (wheeled) {
+          onWheel(self);
+          wheeled = false;
+        }
+
+        id = 0;
+      },
+          onDelta = function onDelta(x, y, index) {
+        deltaX[index] += x;
+        deltaY[index] += y;
+
+        self._vx.update(x);
+
+        self._vy.update(y);
+
+        debounce ? id || (id = requestAnimationFrame(update)) : update();
+      },
+          onTouchOrPointerDelta = function onTouchOrPointerDelta(x, y) {
+        if (lockAxis && !axis) {
+          self.axis = axis = Math.abs(x) > Math.abs(y) ? "x" : "y";
+          locked = true;
+        }
+
+        if (axis !== "y") {
+          deltaX[2] += x;
+
+          self._vx.update(x, true);
+        }
+
+        if (axis !== "x") {
+          deltaY[2] += y;
+
+          self._vy.update(y, true);
+        }
+
+        debounce ? id || (id = requestAnimationFrame(update)) : update();
+      },
+          _onDrag = function _onDrag(e) {
+        if (_ignoreCheck(e, 1)) {
+          return;
+        }
+
+        e = _getEvent(e, preventDefault);
+        var x = e.clientX,
+            y = e.clientY,
+            dx = x - self.x,
+            dy = y - self.y,
+            isDragging = self.isDragging;
+        self.x = x;
+        self.y = y;
+
+        if (isDragging || (dx || dy) && (Math.abs(self.startX - x) >= dragMinimum || Math.abs(self.startY - y) >= dragMinimum)) {
+          dragged = isDragging ? 2 : 1;
+          isDragging || (self.isDragging = true);
+          onTouchOrPointerDelta(dx, dy);
+        }
+      },
+          _onPress = self.onPress = function (e) {
+        if (_ignoreCheck(e, 1) || e && e.button) {
+          return;
+        }
+
+        self.axis = axis = null;
+        onStopDelayedCall.pause();
+        self.isPressed = true;
+        e = _getEvent(e);
+        prevDeltaX = prevDeltaY = 0;
+        self.startX = self.x = e.clientX;
+        self.startY = self.y = e.clientY;
+
+        self._vx.reset();
+
+        self._vy.reset();
+
+        _addListener(isNormalizer ? target : ownerDoc, _eventTypes[1], _onDrag, passive, true);
+
+        self.deltaX = self.deltaY = 0;
+        onPress && onPress(self);
+      },
+          _onRelease = self.onRelease = function (e) {
+        if (_ignoreCheck(e, 1)) {
+          return;
+        }
+
+        _removeListener(isNormalizer ? target : ownerDoc, _eventTypes[1], _onDrag, true);
+
+        var isTrackingDrag = !isNaN(self.y - self.startY),
+            wasDragging = self.isDragging,
+            isDragNotClick = wasDragging && (Math.abs(self.x - self.startX) > 3 || Math.abs(self.y - self.startY) > 3),
+            eventData = _getEvent(e);
+
+        if (!isDragNotClick && isTrackingDrag) {
+          self._vx.reset();
+
+          self._vy.reset();
+
+          if (preventDefault && allowClicks) {
+            gsap.delayedCall(0.08, function () {
+              if (_getTime() - onClickTime > 300 && !e.defaultPrevented) {
+                if (e.target.click) {
+                  e.target.click();
+                } else if (ownerDoc.createEvent) {
+                  var syntheticEvent = ownerDoc.createEvent("MouseEvents");
+                  syntheticEvent.initMouseEvent("click", true, true, _win, 1, eventData.screenX, eventData.screenY, eventData.clientX, eventData.clientY, false, false, false, false, 0, null);
+                  e.target.dispatchEvent(syntheticEvent);
+                }
+              }
+            });
+          }
+        }
+
+        self.isDragging = self.isGesturing = self.isPressed = false;
+        onStop && wasDragging && !isNormalizer && onStopDelayedCall.restart(true);
+        dragged && update();
+        onDragEnd && wasDragging && onDragEnd(self);
+        onRelease && onRelease(self, isDragNotClick);
+      },
+          _onGestureStart = function _onGestureStart(e) {
+        return e.touches && e.touches.length > 1 && (self.isGesturing = true) && onGestureStart(e, self.isDragging);
+      },
+          _onGestureEnd = function _onGestureEnd() {
+        return (self.isGesturing = false) || onGestureEnd(self);
+      },
+          onScroll = function onScroll(e) {
+        if (_ignoreCheck(e)) {
+          return;
+        }
+
+        var x = scrollFuncX(),
+            y = scrollFuncY();
+        onDelta((x - scrollX) * scrollSpeed, (y - scrollY) * scrollSpeed, 1);
+        scrollX = x;
+        scrollY = y;
+        onStop && onStopDelayedCall.restart(true);
+      },
+          _onWheel = function _onWheel(e) {
+        if (_ignoreCheck(e)) {
+          return;
+        }
+
+        e = _getEvent(e, preventDefault);
+        onWheel && (wheeled = true);
+        var multiplier = (e.deltaMode === 1 ? lineHeight : e.deltaMode === 2 ? _win.innerHeight : 1) * wheelSpeed;
+        onDelta(e.deltaX * multiplier, e.deltaY * multiplier, 0);
+        onStop && !isNormalizer && onStopDelayedCall.restart(true);
+      },
+          _onMove = function _onMove(e) {
+        if (_ignoreCheck(e)) {
+          return;
+        }
+
+        var x = e.clientX,
+            y = e.clientY,
+            dx = x - self.x,
+            dy = y - self.y;
+        self.x = x;
+        self.y = y;
+        moved = true;
+        onStop && onStopDelayedCall.restart(true);
+        (dx || dy) && onTouchOrPointerDelta(dx, dy);
+      },
+          _onHover = function _onHover(e) {
+        self.event = e;
+        onHover(self);
+      },
+          _onHoverEnd = function _onHoverEnd(e) {
+        self.event = e;
+        onHoverEnd(self);
+      },
+          _onClick = function _onClick(e) {
+        return _ignoreCheck(e) || _getEvent(e, preventDefault) && onClick(self);
+      };
+
+      onStopDelayedCall = self._dc = gsap.delayedCall(onStopDelay || 0.25, onStopFunc).pause();
+      self.deltaX = self.deltaY = 0;
+      self._vx = _getVelocityProp(0, 50, true);
+      self._vy = _getVelocityProp(0, 50, true);
+      self.scrollX = scrollFuncX;
+      self.scrollY = scrollFuncY;
+      self.isDragging = self.isGesturing = self.isPressed = false;
+
+      _context(this);
+
+      self.enable = function (e) {
+        if (!self.isEnabled) {
+          _addListener(isViewport ? ownerDoc : target, "scroll", _onScroll);
+
+          type.indexOf("scroll") >= 0 && _addListener(isViewport ? ownerDoc : target, "scroll", onScroll, passive, capture);
+          type.indexOf("wheel") >= 0 && _addListener(target, "wheel", _onWheel, passive, capture);
+
+          if (type.indexOf("touch") >= 0 && _isTouch || type.indexOf("pointer") >= 0) {
+            _addListener(target, _eventTypes[0], _onPress, passive, capture);
+
+            _addListener(ownerDoc, _eventTypes[2], _onRelease);
+
+            _addListener(ownerDoc, _eventTypes[3], _onRelease);
+
+            allowClicks && _addListener(target, "click", clickCapture, true, true);
+            onClick && _addListener(target, "click", _onClick);
+            onGestureStart && _addListener(ownerDoc, "gesturestart", _onGestureStart);
+            onGestureEnd && _addListener(ownerDoc, "gestureend", _onGestureEnd);
+            onHover && _addListener(target, _pointerType + "enter", _onHover);
+            onHoverEnd && _addListener(target, _pointerType + "leave", _onHoverEnd);
+            onMove && _addListener(target, _pointerType + "move", _onMove);
+          }
+
+          self.isEnabled = true;
+          self.isDragging = self.isGesturing = self.isPressed = moved = dragged = false;
+
+          self._vx.reset();
+
+          self._vy.reset();
+
+          scrollX = scrollFuncX();
+          scrollY = scrollFuncY();
+          e && e.type && _onPress(e);
+          onEnable && onEnable(self);
+        }
+
+        return self;
+      };
+
+      self.disable = function () {
+        if (self.isEnabled) {
+          _observers.filter(function (o) {
+            return o !== self && _isViewport(o.target);
+          }).length || _removeListener(isViewport ? ownerDoc : target, "scroll", _onScroll);
+
+          if (self.isPressed) {
+            self._vx.reset();
+
+            self._vy.reset();
+
+            _removeListener(isNormalizer ? target : ownerDoc, _eventTypes[1], _onDrag, true);
+          }
+
+          _removeListener(isViewport ? ownerDoc : target, "scroll", onScroll, capture);
+
+          _removeListener(target, "wheel", _onWheel, capture);
+
+          _removeListener(target, _eventTypes[0], _onPress, capture);
+
+          _removeListener(ownerDoc, _eventTypes[2], _onRelease);
+
+          _removeListener(ownerDoc, _eventTypes[3], _onRelease);
+
+          _removeListener(target, "click", clickCapture, true);
+
+          _removeListener(target, "click", _onClick);
+
+          _removeListener(ownerDoc, "gesturestart", _onGestureStart);
+
+          _removeListener(ownerDoc, "gestureend", _onGestureEnd);
+
+          _removeListener(target, _pointerType + "enter", _onHover);
+
+          _removeListener(target, _pointerType + "leave", _onHoverEnd);
+
+          _removeListener(target, _pointerType + "move", _onMove);
+
+          self.isEnabled = self.isPressed = self.isDragging = false;
+          onDisable && onDisable(self);
+        }
+      };
+
+      self.kill = self.revert = function () {
+        self.disable();
+
+        var i = _observers.indexOf(self);
+
+        i >= 0 && _observers.splice(i, 1);
+        _normalizer === self && (_normalizer = 0);
+      };
+
+      _observers.push(self);
+
+      isNormalizer && _isViewport(target) && (_normalizer = self);
+      self.enable(event);
+    };
+
+    _createClass(Observer, [{
+      key: "velocityX",
+      get: function get() {
+        return this._vx.getVelocity();
+      }
+    }, {
+      key: "velocityY",
+      get: function get() {
+        return this._vy.getVelocity();
+      }
+    }]);
+
+    return Observer;
+  }();
+  Observer.version = "3.13.0";
+
+  Observer.create = function (vars) {
+    return new Observer(vars);
+  };
+
+  Observer.register = _initCore;
+
+  Observer.getAll = function () {
+    return _observers.slice();
+  };
+
+  Observer.getById = function (id) {
+    return _observers.filter(function (o) {
+      return o.vars.id === id;
+    })[0];
+  };
+
+  _getGSAP() && gsap.registerPlugin(Observer);
+
+  exports.Observer = Observer;
+  exports._getProxyProp = _getProxyProp;
+  exports._getScrollFunc = _getScrollFunc;
+  exports._getTarget = _getTarget;
+  exports._getVelocityProp = _getVelocityProp;
+  exports._horizontal = _horizontal;
+  exports._isViewport = _isViewport;
+  exports._vertical = _vertical;
+  exports.default = Observer;
+
+  if (typeof(window) === 'undefined' || window !== exports) {Object.defineProperty(exports, '__esModule', { value: true });} else {delete window.default;}
+
+})));

source/files/gsap-public/umd/Physics2DPlugin.js

@@ -0,0 +1,167 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+	typeof define === 'function' && define.amd ? define(['exports'], factory) :
+	(global = global || self, factory(global.window = global.window || {}));
+}(this, (function (exports) { 'use strict';
+
+	/*!
+	 * Physics2DPlugin 3.13.0
+	 * https://gsap.com
+	 *
+	 * @license Copyright 2008-2025, GreenSock. All rights reserved.
+	 * Subject to the terms at https://gsap.com/standard-license
+	 * @author: Jack Doyle, jack@greensock.com
+	*/
+	var gsap,
+	    _coreInitted,
+	    _getUnit,
+	    _getStyleSaver,
+	    _reverting,
+	    _DEG2RAD = Math.PI / 180,
+	    _getGSAP = function _getGSAP() {
+	  return gsap || typeof window !== "undefined" && (gsap = window.gsap) && gsap.registerPlugin && gsap;
+	},
+	    _round = function _round(value) {
+	  return Math.round(value * 10000) / 10000;
+	},
+	    _initCore = function _initCore(core) {
+	  gsap = core || _getGSAP();
+
+	  if (!_coreInitted) {
+	    _getUnit = gsap.utils.getUnit;
+	    _getStyleSaver = gsap.core.getStyleSaver;
+
+	    _reverting = gsap.core.reverting || function () {};
+
+	    _coreInitted = 1;
+	  }
+	};
+
+	var PhysicsProp = function PhysicsProp(target, p, velocity, acceleration, stepsPerTimeUnit) {
+	  var cache = target._gsap,
+	      curVal = cache.get(target, p);
+	  this.p = p;
+	  this.set = cache.set(target, p);
+	  this.s = this.val = parseFloat(curVal);
+	  this.u = _getUnit(curVal) || 0;
+	  this.vel = velocity || 0;
+	  this.v = this.vel / stepsPerTimeUnit;
+
+	  if (acceleration || acceleration === 0) {
+	    this.acc = acceleration;
+	    this.a = this.acc / (stepsPerTimeUnit * stepsPerTimeUnit);
+	  } else {
+	    this.acc = this.a = 0;
+	  }
+	};
+
+	var Physics2DPlugin = {
+	  version: "3.13.0",
+	  name: "physics2D",
+	  register: _initCore,
+	  init: function init(target, value, tween) {
+	    _coreInitted || _initCore();
+	    var data = this,
+	        angle = +value.angle || 0,
+	        velocity = +value.velocity || 0,
+	        acceleration = +value.acceleration || 0,
+	        xProp = value.xProp || "x",
+	        yProp = value.yProp || "y",
+	        aAngle = value.accelerationAngle || value.accelerationAngle === 0 ? +value.accelerationAngle : angle;
+	    data.styles = _getStyleSaver && _getStyleSaver(target, value.xProp && value.xProp !== "x" ? value.xProp + "," + value.yProp : "transform");
+	    data.target = target;
+	    data.tween = tween;
+	    data.step = 0;
+	    data.sps = 30;
+
+	    if (value.gravity) {
+	      acceleration = +value.gravity;
+	      aAngle = 90;
+	    }
+
+	    angle *= _DEG2RAD;
+	    aAngle *= _DEG2RAD;
+	    data.fr = 1 - (+value.friction || 0);
+
+	    data._props.push(xProp, yProp);
+
+	    data.xp = new PhysicsProp(target, xProp, Math.cos(angle) * velocity, Math.cos(aAngle) * acceleration, data.sps);
+	    data.yp = new PhysicsProp(target, yProp, Math.sin(angle) * velocity, Math.sin(aAngle) * acceleration, data.sps);
+	    data.skipX = data.skipY = 0;
+	  },
+	  render: function render(ratio, data) {
+	    var xp = data.xp,
+	        yp = data.yp,
+	        tween = data.tween,
+	        target = data.target,
+	        step = data.step,
+	        sps = data.sps,
+	        fr = data.fr,
+	        skipX = data.skipX,
+	        skipY = data.skipY,
+	        time = tween._from ? tween._dur - tween._time : tween._time,
+	        x,
+	        y,
+	        tt,
+	        steps,
+	        remainder,
+	        i;
+
+	    if (tween._time || !_reverting()) {
+	      if (fr === 1) {
+	        tt = time * time * 0.5;
+	        x = xp.s + xp.vel * time + xp.acc * tt;
+	        y = yp.s + yp.vel * time + yp.acc * tt;
+	      } else {
+	        time *= sps;
+	        steps = i = (time | 0) - step;
+
+	        if (i < 0) {
+	          xp.v = xp.vel / sps;
+	          yp.v = yp.vel / sps;
+	          xp.val = xp.s;
+	          yp.val = yp.s;
+	          data.step = 0;
+	          steps = i = time | 0;
+	        }
+
+	        remainder = time % 1 * fr;
+
+	        while (i--) {
+	          xp.v += xp.a;
+	          yp.v += yp.a;
+	          xp.v *= fr;
+	          yp.v *= fr;
+	          xp.val += xp.v;
+	          yp.val += yp.v;
+	        }
+
+	        x = xp.val + xp.v * remainder;
+	        y = yp.val + yp.v * remainder;
+	        data.step += steps;
+	      }
+
+	      skipX || xp.set(target, xp.p, _round(x) + xp.u);
+	      skipY || yp.set(target, yp.p, _round(y) + yp.u);
+	    } else {
+	      data.styles.revert();
+	    }
+	  },
+	  kill: function kill(property) {
+	    if (this.xp.p === property) {
+	      this.skipX = 1;
+	    }
+
+	    if (this.yp.p === property) {
+	      this.skipY = 1;
+	    }
+	  }
+	};
+	_getGSAP() && gsap.registerPlugin(Physics2DPlugin);
+
+	exports.Physics2DPlugin = Physics2DPlugin;
+	exports.default = Physics2DPlugin;
+
+	Object.defineProperty(exports, '__esModule', { value: true });
+
+})));

source/files/gsap-public/umd/PhysicsPropsPlugin.js

@@ -0,0 +1,166 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+	typeof define === 'function' && define.amd ? define(['exports'], factory) :
+	(global = global || self, factory(global.window = global.window || {}));
+}(this, (function (exports) { 'use strict';
+
+	/*!
+	 * PhysicsPropsPlugin 3.13.0
+	 * https://gsap.com
+	 *
+	 * @license Copyright 2008-2025, GreenSock. All rights reserved.
+	 * Subject to the terms at https://gsap.com/standard-license
+	 * @author: Jack Doyle, jack@greensock.com
+	*/
+	var gsap,
+	    _coreInitted,
+	    _getUnit,
+	    _getStyleSaver,
+	    _reverting,
+	    _getGSAP = function _getGSAP() {
+	  return gsap || typeof window !== "undefined" && (gsap = window.gsap) && gsap.registerPlugin && gsap;
+	},
+	    _round = function _round(value) {
+	  return Math.round(value * 10000) / 10000;
+	},
+	    _initCore = function _initCore(core) {
+	  gsap = core || _getGSAP();
+
+	  if (!_coreInitted) {
+	    _getUnit = gsap.utils.getUnit;
+	    _getStyleSaver = gsap.core.getStyleSaver;
+
+	    _reverting = gsap.core.reverting || function () {};
+
+	    _coreInitted = 1;
+	  }
+	};
+
+	var PhysicsProp = function PhysicsProp(target, p, velocity, acceleration, friction, stepsPerTimeUnit) {
+	  var cache = target._gsap,
+	      curVal = cache.get(target, p);
+	  this.p = p;
+	  this.set = cache.set(target, p);
+	  this.s = this.val = parseFloat(curVal);
+	  this.u = _getUnit(curVal) || 0;
+	  this.vel = velocity || 0;
+	  this.v = this.vel / stepsPerTimeUnit;
+
+	  if (acceleration || acceleration === 0) {
+	    this.acc = acceleration;
+	    this.a = this.acc / (stepsPerTimeUnit * stepsPerTimeUnit);
+	  } else {
+	    this.acc = this.a = 0;
+	  }
+
+	  this.fr = 1 - (friction || 0);
+	};
+
+	var PhysicsPropsPlugin = {
+	  version: "3.13.0",
+	  name: "physicsProps",
+	  register: _initCore,
+	  init: function init(target, value, tween) {
+	    _coreInitted || _initCore();
+	    var data = this,
+	        p;
+	    data.styles = _getStyleSaver && _getStyleSaver(target);
+	    data.target = target;
+	    data.tween = tween;
+	    data.step = 0;
+	    data.sps = 30;
+	    data.vProps = [];
+
+	    for (p in value) {
+	      var _value$p = value[p],
+	          velocity = _value$p.velocity,
+	          acceleration = _value$p.acceleration,
+	          friction = _value$p.friction;
+
+	      if (velocity || acceleration) {
+	        data.vProps.push(new PhysicsProp(target, p, velocity, acceleration, friction, data.sps));
+
+	        data._props.push(p);
+
+	        _getStyleSaver && data.styles.save(p);
+	        friction && (data.hasFr = 1);
+	      }
+	    }
+	  },
+	  render: function render(ratio, data) {
+	    var vProps = data.vProps,
+	        tween = data.tween,
+	        target = data.target,
+	        step = data.step,
+	        hasFr = data.hasFr,
+	        sps = data.sps,
+	        i = vProps.length,
+	        time = tween._from ? tween._dur - tween._time : tween._time,
+	        curProp,
+	        steps,
+	        remainder,
+	        j,
+	        tt;
+
+	    if (tween._time || !_reverting()) {
+	      if (hasFr) {
+	        time *= sps;
+	        steps = (time | 0) - step;
+
+	        if (steps < 0) {
+	          while (i--) {
+	            curProp = vProps[i];
+	            curProp.v = curProp.vel / sps;
+	            curProp.val = curProp.s;
+	          }
+
+	          i = vProps.length;
+	          data.step = step = 0;
+	          steps = time | 0;
+	        }
+
+	        remainder = time % 1;
+
+	        while (i--) {
+	          curProp = vProps[i];
+	          j = steps;
+
+	          while (j--) {
+	            curProp.v += curProp.a;
+	            curProp.v *= curProp.fr;
+	            curProp.val += curProp.v;
+	          }
+
+	          curProp.set(target, curProp.p, _round(curProp.val + curProp.v * remainder * curProp.fr) + curProp.u);
+	        }
+
+	        data.step += steps;
+	      } else {
+	        tt = time * time * 0.5;
+
+	        while (i--) {
+	          curProp = vProps[i];
+	          curProp.set(target, curProp.p, _round(curProp.s + curProp.vel * time + curProp.acc * tt) + curProp.u);
+	        }
+	      }
+	    } else {
+	      data.styles.revert();
+	    }
+	  },
+	  kill: function kill(property) {
+	    var vProps = this.vProps,
+	        i = vProps.length;
+
+	    while (i--) {
+	      vProps[i].p === property && vProps.splice(i, 1);
+	    }
+	  }
+	};
+	_getGSAP() && gsap.registerPlugin(PhysicsPropsPlugin);
+
+	exports.PhysicsPropsPlugin = PhysicsPropsPlugin;
+	exports.default = PhysicsPropsPlugin;
+
+	Object.defineProperty(exports, '__esModule', { value: true });
+
+})));

source/files/gsap-public/umd/PixiPlugin.js

@@ -0,0 +1,474 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+	typeof define === 'function' && define.amd ? define(['exports'], factory) :
+	(global = global || self, factory(global.window = global.window || {}));
+}(this, (function (exports) { 'use strict';
+
+	/*!
+	 * PixiPlugin 3.13.0
+	 * https://gsap.com
+	 *
+	 * @license Copyright 2008-2025, GreenSock. All rights reserved.
+	 * Subject to the terms at https://gsap.com/standard-license
+	 * @author: Jack Doyle, jack@greensock.com
+	*/
+	var gsap,
+	    _splitColor,
+	    _coreInitted,
+	    _PIXI,
+	    PropTween,
+	    _getSetter,
+	    _isV4,
+	    _isV8Plus,
+	    _windowExists = function _windowExists() {
+	  return typeof window !== "undefined";
+	},
+	    _getGSAP = function _getGSAP() {
+	  return gsap || _windowExists() && (gsap = window.gsap) && gsap.registerPlugin && gsap;
+	},
+	    _isFunction = function _isFunction(value) {
+	  return typeof value === "function";
+	},
+	    _warn = function _warn(message) {
+	  return console.warn(message);
+	},
+	    _idMatrix = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0],
+	    _lumR = 0.212671,
+	    _lumG = 0.715160,
+	    _lumB = 0.072169,
+	    _filterClass = function _filterClass(name) {
+	  return _isFunction(_PIXI[name]) ? _PIXI[name] : _PIXI.filters[name];
+	},
+	    _applyMatrix = function _applyMatrix(m, m2) {
+	  var temp = [],
+	      i = 0,
+	      z = 0,
+	      y,
+	      x;
+
+	  for (y = 0; y < 4; y++) {
+	    for (x = 0; x < 5; x++) {
+	      z = x === 4 ? m[i + 4] : 0;
+	      temp[i + x] = m[i] * m2[x] + m[i + 1] * m2[x + 5] + m[i + 2] * m2[x + 10] + m[i + 3] * m2[x + 15] + z;
+	    }
+
+	    i += 5;
+	  }
+
+	  return temp;
+	},
+	    _setSaturation = function _setSaturation(m, n) {
+	  var inv = 1 - n,
+	      r = inv * _lumR,
+	      g = inv * _lumG,
+	      b = inv * _lumB;
+	  return _applyMatrix([r + n, g, b, 0, 0, r, g + n, b, 0, 0, r, g, b + n, 0, 0, 0, 0, 0, 1, 0], m);
+	},
+	    _colorize = function _colorize(m, color, amount) {
+	  var c = _splitColor(color),
+	      r = c[0] / 255,
+	      g = c[1] / 255,
+	      b = c[2] / 255,
+	      inv = 1 - amount;
+
+	  return _applyMatrix([inv + amount * r * _lumR, amount * r * _lumG, amount * r * _lumB, 0, 0, amount * g * _lumR, inv + amount * g * _lumG, amount * g * _lumB, 0, 0, amount * b * _lumR, amount * b * _lumG, inv + amount * b * _lumB, 0, 0, 0, 0, 0, 1, 0], m);
+	},
+	    _setHue = function _setHue(m, n) {
+	  n *= Math.PI / 180;
+	  var c = Math.cos(n),
+	      s = Math.sin(n);
+	  return _applyMatrix([_lumR + c * (1 - _lumR) + s * -_lumR, _lumG + c * -_lumG + s * -_lumG, _lumB + c * -_lumB + s * (1 - _lumB), 0, 0, _lumR + c * -_lumR + s * 0.143, _lumG + c * (1 - _lumG) + s * 0.14, _lumB + c * -_lumB + s * -0.283, 0, 0, _lumR + c * -_lumR + s * -(1 - _lumR), _lumG + c * -_lumG + s * _lumG, _lumB + c * (1 - _lumB) + s * _lumB, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1], m);
+	},
+	    _setContrast = function _setContrast(m, n) {
+	  return _applyMatrix([n, 0, 0, 0, 0.5 * (1 - n), 0, n, 0, 0, 0.5 * (1 - n), 0, 0, n, 0, 0.5 * (1 - n), 0, 0, 0, 1, 0], m);
+	},
+	    _getFilter = function _getFilter(target, type) {
+	  var filterClass = _filterClass(type),
+	      filters = target.filters || [],
+	      i = filters.length,
+	      filter;
+
+	  filterClass || _warn(type + " not found. PixiPlugin.registerPIXI(PIXI)");
+
+	  while (--i > -1) {
+	    if (filters[i] instanceof filterClass) {
+	      return filters[i];
+	    }
+	  }
+
+	  filter = new filterClass();
+
+	  if (type === "BlurFilter") {
+	    if (_isV8Plus) {
+	      filter.strength = 0;
+	    } else {
+	      filter.blur = 0;
+	    }
+	  }
+
+	  target.filters = [].concat(filters, [filter]);
+	  return filter;
+	},
+	    _addColorMatrixFilterCacheTween = function _addColorMatrixFilterCacheTween(p, plugin, cache, vars) {
+	  plugin.add(cache, p, cache[p], vars[p]);
+
+	  plugin._props.push(p);
+	},
+	    _applyBrightnessToMatrix = function _applyBrightnessToMatrix(brightness, matrix) {
+	  var filterClass = _filterClass("ColorMatrixFilter"),
+	      temp = new filterClass();
+
+	  temp.matrix = matrix;
+	  temp.brightness(brightness, true);
+	  return temp.matrix;
+	},
+	    _copy = function _copy(obj) {
+	  var copy = {},
+	      p;
+
+	  for (p in obj) {
+	    copy[p] = obj[p];
+	  }
+
+	  return copy;
+	},
+	    _CMFdefaults = {
+	  contrast: 1,
+	  saturation: 1,
+	  colorizeAmount: 0,
+	  colorize: "rgb(255,255,255)",
+	  hue: 0,
+	  brightness: 1
+	},
+	    _parseColorMatrixFilter = function _parseColorMatrixFilter(target, v, pg) {
+	  var filter = _getFilter(target, "ColorMatrixFilter"),
+	      cache = target._gsColorMatrixFilter = target._gsColorMatrixFilter || _copy(_CMFdefaults),
+	      combine = v.combineCMF && !("colorMatrixFilter" in v && !v.colorMatrixFilter),
+	      i,
+	      matrix,
+	      startMatrix;
+
+	  startMatrix = filter.matrix;
+
+	  if (v.resolution) {
+	    filter.resolution = v.resolution;
+	  }
+
+	  if (v.matrix && v.matrix.length === startMatrix.length) {
+	    matrix = v.matrix;
+
+	    if (cache.contrast !== 1) {
+	      _addColorMatrixFilterCacheTween("contrast", pg, cache, _CMFdefaults);
+	    }
+
+	    if (cache.hue) {
+	      _addColorMatrixFilterCacheTween("hue", pg, cache, _CMFdefaults);
+	    }
+
+	    if (cache.brightness !== 1) {
+	      _addColorMatrixFilterCacheTween("brightness", pg, cache, _CMFdefaults);
+	    }
+
+	    if (cache.colorizeAmount) {
+	      _addColorMatrixFilterCacheTween("colorize", pg, cache, _CMFdefaults);
+
+	      _addColorMatrixFilterCacheTween("colorizeAmount", pg, cache, _CMFdefaults);
+	    }
+
+	    if (cache.saturation !== 1) {
+	      _addColorMatrixFilterCacheTween("saturation", pg, cache, _CMFdefaults);
+	    }
+	  } else {
+	    matrix = _idMatrix.slice();
+
+	    if (v.contrast != null) {
+	      matrix = _setContrast(matrix, +v.contrast);
+
+	      _addColorMatrixFilterCacheTween("contrast", pg, cache, v);
+	    } else if (cache.contrast !== 1) {
+	      if (combine) {
+	        matrix = _setContrast(matrix, cache.contrast);
+	      } else {
+	        _addColorMatrixFilterCacheTween("contrast", pg, cache, _CMFdefaults);
+	      }
+	    }
+
+	    if (v.hue != null) {
+	      matrix = _setHue(matrix, +v.hue);
+
+	      _addColorMatrixFilterCacheTween("hue", pg, cache, v);
+	    } else if (cache.hue) {
+	      if (combine) {
+	        matrix = _setHue(matrix, cache.hue);
+	      } else {
+	        _addColorMatrixFilterCacheTween("hue", pg, cache, _CMFdefaults);
+	      }
+	    }
+
+	    if (v.brightness != null) {
+	      matrix = _applyBrightnessToMatrix(+v.brightness, matrix);
+
+	      _addColorMatrixFilterCacheTween("brightness", pg, cache, v);
+	    } else if (cache.brightness !== 1) {
+	      if (combine) {
+	        matrix = _applyBrightnessToMatrix(cache.brightness, matrix);
+	      } else {
+	        _addColorMatrixFilterCacheTween("brightness", pg, cache, _CMFdefaults);
+	      }
+	    }
+
+	    if (v.colorize != null) {
+	      v.colorizeAmount = "colorizeAmount" in v ? +v.colorizeAmount : 1;
+	      matrix = _colorize(matrix, v.colorize, v.colorizeAmount);
+
+	      _addColorMatrixFilterCacheTween("colorize", pg, cache, v);
+
+	      _addColorMatrixFilterCacheTween("colorizeAmount", pg, cache, v);
+	    } else if (cache.colorizeAmount) {
+	      if (combine) {
+	        matrix = _colorize(matrix, cache.colorize, cache.colorizeAmount);
+	      } else {
+	        _addColorMatrixFilterCacheTween("colorize", pg, cache, _CMFdefaults);
+
+	        _addColorMatrixFilterCacheTween("colorizeAmount", pg, cache, _CMFdefaults);
+	      }
+	    }
+
+	    if (v.saturation != null) {
+	      matrix = _setSaturation(matrix, +v.saturation);
+
+	      _addColorMatrixFilterCacheTween("saturation", pg, cache, v);
+	    } else if (cache.saturation !== 1) {
+	      if (combine) {
+	        matrix = _setSaturation(matrix, cache.saturation);
+	      } else {
+	        _addColorMatrixFilterCacheTween("saturation", pg, cache, _CMFdefaults);
+	      }
+	    }
+	  }
+
+	  i = matrix.length;
+
+	  while (--i > -1) {
+	    if (matrix[i] !== startMatrix[i]) {
+	      pg.add(startMatrix, i, startMatrix[i], matrix[i], "colorMatrixFilter");
+	    }
+	  }
+
+	  pg._props.push("colorMatrixFilter");
+	},
+	    _renderColor = function _renderColor(ratio, _ref) {
+	  var t = _ref.t,
+	      p = _ref.p,
+	      color = _ref.color,
+	      set = _ref.set;
+	  set(t, p, color[0] << 16 | color[1] << 8 | color[2]);
+	},
+	    _renderDirtyCache = function _renderDirtyCache(ratio, _ref2) {
+	  var g = _ref2.g;
+
+	  if (_isV8Plus) {
+	    g.fill();
+	    g.stroke();
+	  } else if (g) {
+	    g.dirty++;
+	    g.clearDirty++;
+	  }
+	},
+	    _renderAutoAlpha = function _renderAutoAlpha(ratio, data) {
+	  data.t.visible = !!data.t.alpha;
+	},
+	    _addColorTween = function _addColorTween(target, p, value, plugin) {
+	  var currentValue = target[p],
+	      startColor = _splitColor(_isFunction(currentValue) ? target[p.indexOf("set") || !_isFunction(target["get" + p.substr(3)]) ? p : "get" + p.substr(3)]() : currentValue),
+	      endColor = _splitColor(value);
+
+	  plugin._pt = new PropTween(plugin._pt, target, p, 0, 0, _renderColor, {
+	    t: target,
+	    p: p,
+	    color: startColor,
+	    set: _getSetter(target, p)
+	  });
+	  plugin.add(startColor, 0, startColor[0], endColor[0]);
+	  plugin.add(startColor, 1, startColor[1], endColor[1]);
+	  plugin.add(startColor, 2, startColor[2], endColor[2]);
+	},
+	    _colorProps = {
+	  tint: 1,
+	  lineColor: 1,
+	  fillColor: 1,
+	  strokeColor: 1
+	},
+	    _xyContexts = "position,scale,skew,pivot,anchor,tilePosition,tileScale".split(","),
+	    _contexts = {
+	  x: "position",
+	  y: "position",
+	  tileX: "tilePosition",
+	  tileY: "tilePosition"
+	},
+	    _colorMatrixFilterProps = {
+	  colorMatrixFilter: 1,
+	  saturation: 1,
+	  contrast: 1,
+	  hue: 1,
+	  colorize: 1,
+	  colorizeAmount: 1,
+	  brightness: 1,
+	  combineCMF: 1
+	},
+	    _DEG2RAD = Math.PI / 180,
+	    _isString = function _isString(value) {
+	  return typeof value === "string";
+	},
+	    _degreesToRadians = function _degreesToRadians(value) {
+	  return _isString(value) && value.charAt(1) === "=" ? value.substr(0, 2) + parseFloat(value.substr(2)) * _DEG2RAD : value * _DEG2RAD;
+	},
+	    _renderPropWithEnd = function _renderPropWithEnd(ratio, data) {
+	  return data.set(data.t, data.p, ratio === 1 ? data.e : Math.round((data.s + data.c * ratio) * 100000) / 100000, data);
+	},
+	    _addRotationalPropTween = function _addRotationalPropTween(plugin, target, property, startNum, endValue, radians) {
+	  var cap = 360 * (radians ? _DEG2RAD : 1),
+	      isString = _isString(endValue),
+	      relative = isString && endValue.charAt(1) === "=" ? +(endValue.charAt(0) + "1") : 0,
+	      endNum = parseFloat(relative ? endValue.substr(2) : endValue) * (radians ? _DEG2RAD : 1),
+	      change = relative ? endNum * relative : endNum - startNum,
+	      finalValue = startNum + change,
+	      direction,
+	      pt;
+
+	  if (isString) {
+	    direction = endValue.split("_")[1];
+
+	    if (direction === "short") {
+	      change %= cap;
+
+	      if (change !== change % (cap / 2)) {
+	        change += change < 0 ? cap : -cap;
+	      }
+	    }
+
+	    if (direction === "cw" && change < 0) {
+	      change = (change + cap * 1e10) % cap - ~~(change / cap) * cap;
+	    } else if (direction === "ccw" && change > 0) {
+	      change = (change - cap * 1e10) % cap - ~~(change / cap) * cap;
+	    }
+	  }
+
+	  plugin._pt = pt = new PropTween(plugin._pt, target, property, startNum, change, _renderPropWithEnd);
+	  pt.e = finalValue;
+	  return pt;
+	},
+	    _initCore = function _initCore() {
+	  if (!_coreInitted) {
+	    gsap = _getGSAP();
+	    _PIXI = _coreInitted = _PIXI || _windowExists() && window.PIXI;
+	    var version = _PIXI && _PIXI.VERSION && parseFloat(_PIXI.VERSION.split(".")[0]) || 0;
+	    _isV4 = version === 4;
+	    _isV8Plus = version >= 8;
+
+	    _splitColor = function _splitColor(color) {
+	      return gsap.utils.splitColor((color + "").substr(0, 2) === "0x" ? "#" + color.substr(2) : color);
+	    };
+	  }
+	},
+	    i,
+	    p;
+
+	for (i = 0; i < _xyContexts.length; i++) {
+	  p = _xyContexts[i];
+	  _contexts[p + "X"] = p;
+	  _contexts[p + "Y"] = p;
+	}
+
+	var PixiPlugin = {
+	  version: "3.13.0",
+	  name: "pixi",
+	  register: function register(core, Plugin, propTween) {
+	    gsap = core;
+	    PropTween = propTween;
+	    _getSetter = Plugin.getSetter;
+
+	    _initCore();
+	  },
+	  headless: true,
+	  registerPIXI: function registerPIXI(pixi) {
+	    _PIXI = pixi;
+	  },
+	  init: function init(target, values, tween, index, targets) {
+	    _PIXI || _initCore();
+
+	    if (!_PIXI) {
+	      _warn("PIXI was not found. PixiPlugin.registerPIXI(PIXI);");
+
+	      return false;
+	    }
+
+	    var context, axis, value, colorMatrix, filter, p, padding, i, data, subProp;
+
+	    for (p in values) {
+	      context = _contexts[p];
+	      value = values[p];
+
+	      if (context) {
+	        axis = ~p.charAt(p.length - 1).toLowerCase().indexOf("x") ? "x" : "y";
+	        this.add(target[context], axis, target[context][axis], context === "skew" ? _degreesToRadians(value) : value, 0, 0, 0, 0, 0, 1);
+	      } else if (p === "scale" || p === "anchor" || p === "pivot" || p === "tileScale") {
+	        this.add(target[p], "x", target[p].x, value);
+	        this.add(target[p], "y", target[p].y, value);
+	      } else if (p === "rotation" || p === "angle") {
+	        _addRotationalPropTween(this, target, p, target[p], value, p === "rotation");
+	      } else if (_colorMatrixFilterProps[p]) {
+	        if (!colorMatrix) {
+	          _parseColorMatrixFilter(target, values.colorMatrixFilter || values, this);
+
+	          colorMatrix = true;
+	        }
+	      } else if (p === "blur" || p === "blurX" || p === "blurY" || p === "blurPadding") {
+	        filter = _getFilter(target, "BlurFilter");
+	        this.add(filter, p, filter[p], value);
+
+	        if (values.blurPadding !== 0) {
+	          padding = values.blurPadding || Math.max(filter[p], value) * 2;
+	          i = target.filters.length;
+
+	          while (--i > -1) {
+	            target.filters[i].padding = Math.max(target.filters[i].padding, padding);
+	          }
+	        }
+	      } else if (_colorProps[p]) {
+	        if ((p === "lineColor" || p === "fillColor" || p === "strokeColor") && target instanceof _PIXI.Graphics) {
+	          data = "fillStyle" in target ? [target] : (target.geometry || target).graphicsData;
+	          subProp = p.substr(0, p.length - 5);
+	          _isV8Plus && subProp === "line" && (subProp = "stroke");
+	          this._pt = new PropTween(this._pt, target, p, 0, 0, _renderDirtyCache, {
+	            g: target.geometry || target
+	          });
+	          i = data.length;
+
+	          while (--i > -1) {
+	            _addColorTween(_isV4 ? data[i] : data[i][subProp + "Style"], _isV4 ? p : "color", value, this);
+	          }
+	        } else {
+	          _addColorTween(target, p, value, this);
+	        }
+	      } else if (p === "autoAlpha") {
+	        this._pt = new PropTween(this._pt, target, "visible", 0, 0, _renderAutoAlpha);
+	        this.add(target, "alpha", target.alpha, value);
+
+	        this._props.push("alpha", "visible");
+	      } else if (p !== "resolution") {
+	        this.add(target, p, "get", value);
+	      }
+
+	      this._props.push(p);
+	    }
+	  }
+	};
+	_getGSAP() && gsap.registerPlugin(PixiPlugin);
+
+	exports.PixiPlugin = PixiPlugin;
+	exports.default = PixiPlugin;
+
+	Object.defineProperty(exports, '__esModule', { value: true });
+
+})));

source/files/gsap-public/umd/ScrollSmoother.js

@@ -0,0 +1,972 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  (global = global || self, factory(global.window = global.window || {}));
+}(this, (function (exports) { 'use strict';
+
+  function _defineProperties(target, props) {
+    for (var i = 0; i < props.length; i++) {
+      var descriptor = props[i];
+      descriptor.enumerable = descriptor.enumerable || false;
+      descriptor.configurable = true;
+      if ("value" in descriptor) descriptor.writable = true;
+      Object.defineProperty(target, descriptor.key, descriptor);
+    }
+  }
+
+  function _createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+  }
+
+  /*!
+   * ScrollSmoother 3.13.0
+   * https://gsap.com
+   *
+   * @license Copyright 2008-2025, GreenSock. All rights reserved.
+   * Subject to the terms at https://gsap.com/standard-license
+   * @author: Jack Doyle, jack@greensock.com
+  */
+  var gsap,
+      _coreInitted,
+      _win,
+      _doc,
+      _docEl,
+      _body,
+      _toArray,
+      _clamp,
+      ScrollTrigger,
+      _mainInstance,
+      _expo,
+      _getVelocityProp,
+      _inputObserver,
+      _context,
+      _onResizeDelayedCall,
+      _windowExists = function _windowExists() {
+    return typeof window !== "undefined";
+  },
+      _getGSAP = function _getGSAP() {
+    return gsap || _windowExists() && (gsap = window.gsap) && gsap.registerPlugin && gsap;
+  },
+      _round = function _round(value) {
+    return Math.round(value * 100000) / 100000 || 0;
+  },
+      _maxScroll = function _maxScroll(scroller) {
+    return ScrollTrigger.maxScroll(scroller || _win);
+  },
+      _autoDistance = function _autoDistance(el, progress) {
+    var parent = el.parentNode || _docEl,
+        b1 = el.getBoundingClientRect(),
+        b2 = parent.getBoundingClientRect(),
+        gapTop = b2.top - b1.top,
+        gapBottom = b2.bottom - b1.bottom,
+        change = (Math.abs(gapTop) > Math.abs(gapBottom) ? gapTop : gapBottom) / (1 - progress),
+        offset = -change * progress,
+        ratio,
+        extraChange;
+
+    if (change > 0) {
+      ratio = b2.height / (_win.innerHeight + b2.height);
+      extraChange = ratio === 0.5 ? b2.height * 2 : Math.min(b2.height, Math.abs(-change * ratio / (2 * ratio - 1))) * 2 * (progress || 1);
+      offset += progress ? -extraChange * progress : -extraChange / 2;
+      change += extraChange;
+    }
+
+    return {
+      change: change,
+      offset: offset
+    };
+  },
+      _wrap = function _wrap(el) {
+    var wrapper = _doc.querySelector(".ScrollSmoother-wrapper");
+
+    if (!wrapper) {
+      wrapper = _doc.createElement("div");
+      wrapper.classList.add("ScrollSmoother-wrapper");
+      el.parentNode.insertBefore(wrapper, el);
+      wrapper.appendChild(el);
+    }
+
+    return wrapper;
+  };
+
+  var ScrollSmoother = function () {
+    function ScrollSmoother(vars) {
+      var _this = this;
+
+      _coreInitted || ScrollSmoother.register(gsap) || console.warn("Please gsap.registerPlugin(ScrollSmoother)");
+      vars = this.vars = vars || {};
+      _mainInstance && _mainInstance.kill();
+      _mainInstance = this;
+
+      _context(this);
+
+      var _vars = vars,
+          smoothTouch = _vars.smoothTouch,
+          _onUpdate = _vars.onUpdate,
+          onStop = _vars.onStop,
+          smooth = _vars.smooth,
+          onFocusIn = _vars.onFocusIn,
+          normalizeScroll = _vars.normalizeScroll,
+          wholePixels = _vars.wholePixels,
+          content,
+          wrapper,
+          height,
+          mainST,
+          effects,
+          sections,
+          intervalID,
+          wrapperCSS,
+          contentCSS,
+          paused,
+          pausedNormalizer,
+          recordedRefreshScroll,
+          recordedRefreshScrub,
+          allowUpdates,
+          self = this,
+          effectsPrefix = vars.effectsPrefix || "",
+          scrollFunc = ScrollTrigger.getScrollFunc(_win),
+          smoothDuration = ScrollTrigger.isTouch === 1 ? smoothTouch === true ? 0.8 : parseFloat(smoothTouch) || 0 : smooth === 0 || smooth === false ? 0 : parseFloat(smooth) || 0.8,
+          speed = smoothDuration && +vars.speed || 1,
+          currentY = 0,
+          delta = 0,
+          startupPhase = 1,
+          tracker = _getVelocityProp(0),
+          updateVelocity = function updateVelocity() {
+        return tracker.update(-currentY);
+      },
+          scroll = {
+        y: 0
+      },
+          removeScroll = function removeScroll() {
+        return content.style.overflow = "visible";
+      },
+          isProxyScrolling,
+          killScrub = function killScrub(trigger) {
+        trigger.update();
+        var scrub = trigger.getTween();
+
+        if (scrub) {
+          scrub.pause();
+          scrub._time = scrub._dur;
+          scrub._tTime = scrub._tDur;
+        }
+
+        isProxyScrolling = false;
+        trigger.animation.progress(trigger.progress, true);
+      },
+          render = function render(y, force) {
+        if (y !== currentY && !paused || force) {
+          wholePixels && (y = Math.round(y));
+
+          if (smoothDuration) {
+            content.style.transform = "matrix3d(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, " + y + ", 0, 1)";
+            content._gsap.y = y + "px";
+          }
+
+          delta = y - currentY;
+          currentY = y;
+          ScrollTrigger.isUpdating || ScrollSmoother.isRefreshing || ScrollTrigger.update();
+        }
+      },
+          scrollTop = function scrollTop(value) {
+        if (arguments.length) {
+          value < 0 && (value = 0);
+          scroll.y = -value;
+          isProxyScrolling = true;
+          paused ? currentY = -value : render(-value);
+          ScrollTrigger.isRefreshing ? mainST.update() : scrollFunc(value / speed);
+          return this;
+        }
+
+        return -currentY;
+      },
+          resizeObserver = typeof ResizeObserver !== "undefined" && vars.autoResize !== false && new ResizeObserver(function () {
+        if (!ScrollTrigger.isRefreshing) {
+          var max = _maxScroll(wrapper) * speed;
+          max < -currentY && scrollTop(max);
+
+          _onResizeDelayedCall.restart(true);
+        }
+      }),
+          lastFocusElement,
+          _onFocusIn = function _onFocusIn(e) {
+        wrapper.scrollTop = 0;
+
+        if (e.target.contains && e.target.contains(wrapper) || onFocusIn && onFocusIn(_this, e) === false) {
+          return;
+        }
+
+        ScrollTrigger.isInViewport(e.target) || e.target === lastFocusElement || _this.scrollTo(e.target, false, "center center");
+        lastFocusElement = e.target;
+      },
+          _transformPosition = function _transformPosition(position, st) {
+        if (position < st.start) {
+          return position;
+        }
+
+        var ratio = isNaN(st.ratio) ? 1 : st.ratio,
+            change = st.end - st.start,
+            distance = position - st.start,
+            offset = st.offset || 0,
+            pins = st.pins || [],
+            pinOffset = pins.offset || 0,
+            progressOffset = st._startClamp && st.start <= 0 || st.pins && st.pins.offset ? 0 : st._endClamp && st.end === _maxScroll() ? 1 : 0.5;
+        pins.forEach(function (p) {
+          change -= p.distance;
+
+          if (p.nativeStart <= position) {
+            distance -= p.distance;
+          }
+        });
+
+        if (pinOffset) {
+          distance *= (change - pinOffset / ratio) / change;
+        }
+
+        return position + (distance - offset * progressOffset) / ratio - distance;
+      },
+          adjustEffectRelatedTriggers = function adjustEffectRelatedTriggers(st, triggers, partial) {
+        partial || (st.pins.length = st.pins.offset = 0);
+        var pins = st.pins,
+            markers = st.markers,
+            dif,
+            isClamped,
+            start,
+            end,
+            nativeStart,
+            nativeEnd,
+            i,
+            trig;
+
+        for (i = 0; i < triggers.length; i++) {
+          trig = triggers[i];
+
+          if (st.trigger && trig.trigger && st !== trig && (trig.trigger === st.trigger || trig.pinnedContainer === st.trigger || st.trigger.contains(trig.trigger))) {
+            nativeStart = trig._startNative || trig._startClamp || trig.start;
+            nativeEnd = trig._endNative || trig._endClamp || trig.end;
+            start = _transformPosition(nativeStart, st);
+            end = trig.pin && nativeEnd > 0 ? start + (nativeEnd - nativeStart) : _transformPosition(nativeEnd, st);
+            trig.setPositions(start, end, true, (trig._startClamp ? Math.max(0, start) : start) - nativeStart);
+            trig.markerStart && markers.push(gsap.quickSetter([trig.markerStart, trig.markerEnd], "y", "px"));
+
+            if (trig.pin && trig.end > 0 && !partial) {
+              dif = trig.end - trig.start;
+              isClamped = st._startClamp && trig.start < 0;
+
+              if (isClamped) {
+                if (st.start > 0) {
+                  st.setPositions(0, st.end + (st._startNative - st.start), true);
+                  adjustEffectRelatedTriggers(st, triggers);
+                  return;
+                }
+
+                dif += trig.start;
+                pins.offset = -trig.start;
+              }
+
+              pins.push({
+                start: trig.start,
+                nativeStart: nativeStart,
+                end: trig.end,
+                distance: dif,
+                trig: trig
+              });
+              st.setPositions(st.start, st.end + (isClamped ? -trig.start : dif), true);
+            }
+          }
+        }
+      },
+          adjustParallaxPosition = function adjustParallaxPosition(triggers, createdAfterEffectWasApplied) {
+        effects.forEach(function (st) {
+          return adjustEffectRelatedTriggers(st, triggers, createdAfterEffectWasApplied);
+        });
+      },
+          onRefresh = function onRefresh() {
+        _docEl = _doc.documentElement;
+        _body = _doc.body;
+        removeScroll();
+        requestAnimationFrame(removeScroll);
+
+        if (effects) {
+          ScrollTrigger.getAll().forEach(function (st) {
+            st._startNative = st.start;
+            st._endNative = st.end;
+          });
+          effects.forEach(function (st) {
+            var start = st._startClamp || st.start,
+                end = st.autoSpeed ? Math.min(_maxScroll(), st.end) : start + Math.abs((st.end - start) / st.ratio),
+                offset = end - st.end;
+            start -= offset / 2;
+            end -= offset / 2;
+
+            if (start > end) {
+              var s = start;
+              start = end;
+              end = s;
+            }
+
+            if (st._startClamp && start < 0) {
+              end = st.ratio < 0 ? _maxScroll() : st.end / st.ratio;
+              offset = end - st.end;
+              start = 0;
+            } else if (st.ratio < 0 || st._endClamp && end >= _maxScroll()) {
+              end = _maxScroll();
+              start = st.ratio < 0 ? 0 : st.ratio > 1 ? 0 : end - (end - st.start) / st.ratio;
+              offset = (end - start) * st.ratio - (st.end - st.start);
+            }
+
+            st.offset = offset || 0.0001;
+            st.pins.length = st.pins.offset = 0;
+            st.setPositions(start, end, true);
+          });
+          adjustParallaxPosition(ScrollTrigger.sort());
+        }
+
+        tracker.reset();
+      },
+          addOnRefresh = function addOnRefresh() {
+        return ScrollTrigger.addEventListener("refresh", onRefresh);
+      },
+          restoreEffects = function restoreEffects() {
+        return effects && effects.forEach(function (st) {
+          return st.vars.onRefresh(st);
+        });
+      },
+          revertEffects = function revertEffects() {
+        effects && effects.forEach(function (st) {
+          return st.vars.onRefreshInit(st);
+        });
+        return restoreEffects;
+      },
+          effectValueGetter = function effectValueGetter(name, value, index, el) {
+        return function () {
+          var v = typeof value === "function" ? value(index, el) : value;
+          v || v === 0 || (v = el.getAttribute("data-" + effectsPrefix + name) || (name === "speed" ? 1 : 0));
+          el.setAttribute("data-" + effectsPrefix + name, v);
+          var clamp = (v + "").substr(0, 6) === "clamp(";
+          return {
+            clamp: clamp,
+            value: clamp ? v.substr(6, v.length - 7) : v
+          };
+        };
+      },
+          createEffect = function createEffect(el, speed, lag, index, effectsPadding) {
+        effectsPadding = (typeof effectsPadding === "function" ? effectsPadding(index, el) : effectsPadding) || 0;
+
+        var getSpeed = effectValueGetter("speed", speed, index, el),
+            getLag = effectValueGetter("lag", lag, index, el),
+            startY = gsap.getProperty(el, "y"),
+            cache = el._gsap,
+            ratio,
+            st,
+            autoSpeed,
+            scrub,
+            progressOffset,
+            yOffset,
+            pins = [],
+            initDynamicValues = function initDynamicValues() {
+          speed = getSpeed();
+          lag = parseFloat(getLag().value);
+          ratio = parseFloat(speed.value) || 1;
+          autoSpeed = speed.value === "auto";
+          progressOffset = autoSpeed || st && st._startClamp && st.start <= 0 || pins.offset ? 0 : st && st._endClamp && st.end === _maxScroll() ? 1 : 0.5;
+          scrub && scrub.kill();
+          scrub = lag && gsap.to(el, {
+            ease: _expo,
+            overwrite: false,
+            y: "+=0",
+            duration: lag
+          });
+
+          if (st) {
+            st.ratio = ratio;
+            st.autoSpeed = autoSpeed;
+          }
+        },
+            revert = function revert() {
+          cache.y = startY + "px";
+          cache.renderTransform(1);
+          initDynamicValues();
+        },
+            markers = [],
+            change = 0,
+            updateChange = function updateChange(self) {
+          if (autoSpeed) {
+            revert();
+
+            var auto = _autoDistance(el, _clamp(0, 1, -self.start / (self.end - self.start)));
+
+            change = auto.change;
+            yOffset = auto.offset;
+          } else {
+            yOffset = pins.offset || 0;
+            change = (self.end - self.start - yOffset) * (1 - ratio);
+          }
+
+          pins.forEach(function (p) {
+            return change -= p.distance * (1 - ratio);
+          });
+          self.offset = change || 0.001;
+          self.vars.onUpdate(self);
+          scrub && scrub.progress(1);
+        };
+
+        initDynamicValues();
+
+        if (ratio !== 1 || autoSpeed || scrub) {
+          st = ScrollTrigger.create({
+            trigger: autoSpeed ? el.parentNode : el,
+            start: function start() {
+              return speed.clamp ? "clamp(top bottom+=" + effectsPadding + ")" : "top bottom+=" + effectsPadding;
+            },
+            end: function end() {
+              return speed.value < 0 ? "max" : speed.clamp ? "clamp(bottom top-=" + effectsPadding + ")" : "bottom top-=" + effectsPadding;
+            },
+            scroller: wrapper,
+            scrub: true,
+            refreshPriority: -999,
+            onRefreshInit: revert,
+            onRefresh: updateChange,
+            onKill: function onKill(self) {
+              var i = effects.indexOf(self);
+              i >= 0 && effects.splice(i, 1);
+              revert();
+            },
+            onUpdate: function onUpdate(self) {
+              var y = startY + change * (self.progress - progressOffset),
+                  i = pins.length,
+                  extraY = 0,
+                  pin,
+                  scrollY,
+                  end;
+
+              if (self.offset) {
+                if (i) {
+                  scrollY = -currentY;
+                  end = self.end;
+
+                  while (i--) {
+                    pin = pins[i];
+
+                    if (pin.trig.isActive || scrollY >= pin.start && scrollY <= pin.end) {
+                      if (scrub) {
+                        pin.trig.progress += pin.trig.direction < 0 ? 0.001 : -0.001;
+                        pin.trig.update(0, 0, 1);
+                        scrub.resetTo("y", parseFloat(cache.y), -delta, true);
+                        startupPhase && scrub.progress(1);
+                      }
+
+                      return;
+                    }
+
+                    scrollY > pin.end && (extraY += pin.distance);
+                    end -= pin.distance;
+                  }
+
+                  y = startY + extraY + change * ((gsap.utils.clamp(self.start, self.end, scrollY) - self.start - extraY) / (end - self.start) - progressOffset);
+                }
+
+                markers.length && !autoSpeed && markers.forEach(function (setter) {
+                  return setter(y - extraY);
+                });
+                y = _round(y + yOffset);
+
+                if (scrub) {
+                  scrub.resetTo("y", y, -delta, true);
+                  startupPhase && scrub.progress(1);
+                } else {
+                  cache.y = y + "px";
+                  cache.renderTransform(1);
+                }
+              }
+            }
+          });
+          updateChange(st);
+          gsap.core.getCache(st.trigger).stRevert = revertEffects;
+          st.startY = startY;
+          st.pins = pins;
+          st.markers = markers;
+          st.ratio = ratio;
+          st.autoSpeed = autoSpeed;
+          el.style.willChange = "transform";
+        }
+
+        return st;
+      };
+
+      addOnRefresh();
+      ScrollTrigger.addEventListener("killAll", addOnRefresh);
+      gsap.delayedCall(0.5, function () {
+        return startupPhase = 0;
+      });
+      this.scrollTop = scrollTop;
+
+      this.scrollTo = function (target, smooth, position) {
+        var p = gsap.utils.clamp(0, _maxScroll(), isNaN(target) ? _this.offset(target, position, !!smooth && !paused) : +target);
+        !smooth ? scrollTop(p) : paused ? gsap.to(_this, {
+          duration: smoothDuration,
+          scrollTop: p,
+          overwrite: "auto",
+          ease: _expo
+        }) : scrollFunc(p);
+      };
+
+      this.offset = function (target, position, ignoreSpeed) {
+        target = _toArray(target)[0];
+        var cssText = target.style.cssText,
+            st = ScrollTrigger.create({
+          trigger: target,
+          start: position || "top top"
+        }),
+            y;
+
+        if (effects) {
+          startupPhase ? ScrollTrigger.refresh() : adjustParallaxPosition([st], true);
+        }
+
+        y = st.start / (ignoreSpeed ? speed : 1);
+        st.kill(false);
+        target.style.cssText = cssText;
+        gsap.core.getCache(target).uncache = 1;
+        return y;
+      };
+
+      function refreshHeight() {
+        height = content.clientHeight;
+        content.style.overflow = "visible";
+        _body.style.height = _win.innerHeight + (height - _win.innerHeight) / speed + "px";
+        return height - _win.innerHeight;
+      }
+
+      this.content = function (element) {
+        if (arguments.length) {
+          var newContent = _toArray(element || "#smooth-content")[0] || console.warn("ScrollSmoother needs a valid content element.") || _body.children[0];
+
+          if (newContent !== content) {
+            content = newContent;
+            contentCSS = content.getAttribute("style") || "";
+            resizeObserver && resizeObserver.observe(content);
+            gsap.set(content, {
+              overflow: "visible",
+              width: "100%",
+              boxSizing: "border-box",
+              y: "+=0"
+            });
+            smoothDuration || gsap.set(content, {
+              clearProps: "transform"
+            });
+          }
+
+          return this;
+        }
+
+        return content;
+      };
+
+      this.wrapper = function (element) {
+        if (arguments.length) {
+          wrapper = _toArray(element || "#smooth-wrapper")[0] || _wrap(content);
+          wrapperCSS = wrapper.getAttribute("style") || "";
+          refreshHeight();
+          gsap.set(wrapper, smoothDuration ? {
+            overflow: "hidden",
+            position: "fixed",
+            height: "100%",
+            width: "100%",
+            top: 0,
+            left: 0,
+            right: 0,
+            bottom: 0
+          } : {
+            overflow: "visible",
+            position: "relative",
+            width: "100%",
+            height: "auto",
+            top: "auto",
+            bottom: "auto",
+            left: "auto",
+            right: "auto"
+          });
+          return this;
+        }
+
+        return wrapper;
+      };
+
+      this.effects = function (targets, config) {
+        var _effects;
+
+        effects || (effects = []);
+
+        if (!targets) {
+          return effects.slice(0);
+        }
+
+        targets = _toArray(targets);
+        targets.forEach(function (target) {
+          var i = effects.length;
+
+          while (i--) {
+            effects[i].trigger === target && effects[i].kill();
+          }
+        });
+        config = config || {};
+        var _config = config,
+            speed = _config.speed,
+            lag = _config.lag,
+            effectsPadding = _config.effectsPadding,
+            effectsToAdd = [],
+            i,
+            st;
+
+        for (i = 0; i < targets.length; i++) {
+          st = createEffect(targets[i], speed, lag, i, effectsPadding);
+          st && effectsToAdd.push(st);
+        }
+
+        (_effects = effects).push.apply(_effects, effectsToAdd);
+
+        config.refresh !== false && ScrollTrigger.refresh();
+        return effectsToAdd;
+      };
+
+      this.sections = function (targets, config) {
+        var _sections;
+
+        sections || (sections = []);
+
+        if (!targets) {
+          return sections.slice(0);
+        }
+
+        var newSections = _toArray(targets).map(function (el) {
+          return ScrollTrigger.create({
+            trigger: el,
+            start: "top 120%",
+            end: "bottom -20%",
+            onToggle: function onToggle(self) {
+              el.style.opacity = self.isActive ? "1" : "0";
+              el.style.pointerEvents = self.isActive ? "all" : "none";
+            }
+          });
+        });
+
+        config && config.add ? (_sections = sections).push.apply(_sections, newSections) : sections = newSections.slice(0);
+        return newSections;
+      };
+
+      this.content(vars.content);
+      this.wrapper(vars.wrapper);
+
+      this.render = function (y) {
+        return render(y || y === 0 ? y : currentY);
+      };
+
+      this.getVelocity = function () {
+        return tracker.getVelocity(-currentY);
+      };
+
+      ScrollTrigger.scrollerProxy(wrapper, {
+        scrollTop: scrollTop,
+        scrollHeight: function scrollHeight() {
+          return refreshHeight() && _body.scrollHeight;
+        },
+        fixedMarkers: vars.fixedMarkers !== false && !!smoothDuration,
+        content: content,
+        getBoundingClientRect: function getBoundingClientRect() {
+          return {
+            top: 0,
+            left: 0,
+            width: _win.innerWidth,
+            height: _win.innerHeight
+          };
+        }
+      });
+      ScrollTrigger.defaults({
+        scroller: wrapper
+      });
+      var existingScrollTriggers = ScrollTrigger.getAll().filter(function (st) {
+        return st.scroller === _win || st.scroller === wrapper;
+      });
+      existingScrollTriggers.forEach(function (st) {
+        return st.revert(true, true);
+      });
+      mainST = ScrollTrigger.create({
+        animation: gsap.fromTo(scroll, {
+          y: function y() {
+            allowUpdates = 0;
+            return 0;
+          }
+        }, {
+          y: function y() {
+            allowUpdates = 1;
+            return -refreshHeight();
+          },
+          immediateRender: false,
+          ease: "none",
+          data: "ScrollSmoother",
+          duration: 100,
+          onUpdate: function onUpdate() {
+            if (allowUpdates) {
+              var force = isProxyScrolling;
+
+              if (force) {
+                killScrub(mainST);
+                scroll.y = currentY;
+              }
+
+              render(scroll.y, force);
+              updateVelocity();
+              _onUpdate && !paused && _onUpdate(self);
+            }
+          }
+        }),
+        onRefreshInit: function onRefreshInit(self) {
+          if (ScrollSmoother.isRefreshing) {
+            return;
+          }
+
+          ScrollSmoother.isRefreshing = true;
+
+          if (effects) {
+            var _pins = ScrollTrigger.getAll().filter(function (st) {
+              return !!st.pin;
+            });
+
+            effects.forEach(function (st) {
+              if (!st.vars.pinnedContainer) {
+                _pins.forEach(function (pinST) {
+                  if (pinST.pin.contains(st.trigger)) {
+                    var v = st.vars;
+                    v.pinnedContainer = pinST.pin;
+                    st.vars = null;
+                    st.init(v, st.animation);
+                  }
+                });
+              }
+            });
+          }
+
+          var scrub = self.getTween();
+          recordedRefreshScrub = scrub && scrub._end > scrub._dp._time;
+          recordedRefreshScroll = currentY;
+          scroll.y = 0;
+
+          if (smoothDuration) {
+            ScrollTrigger.isTouch === 1 && (wrapper.style.position = "absolute");
+            wrapper.scrollTop = 0;
+            ScrollTrigger.isTouch === 1 && (wrapper.style.position = "fixed");
+          }
+        },
+        onRefresh: function onRefresh(self) {
+          self.animation.invalidate();
+          self.setPositions(self.start, refreshHeight() / speed);
+          recordedRefreshScrub || killScrub(self);
+          scroll.y = -scrollFunc() * speed;
+          render(scroll.y);
+
+          if (!startupPhase) {
+            recordedRefreshScrub && (isProxyScrolling = false);
+            self.animation.progress(gsap.utils.clamp(0, 1, recordedRefreshScroll / speed / -self.end));
+          }
+
+          if (recordedRefreshScrub) {
+            self.progress -= 0.001;
+            self.update();
+          }
+
+          ScrollSmoother.isRefreshing = false;
+        },
+        id: "ScrollSmoother",
+        scroller: _win,
+        invalidateOnRefresh: true,
+        start: 0,
+        refreshPriority: -9999,
+        end: function end() {
+          return refreshHeight() / speed;
+        },
+        onScrubComplete: function onScrubComplete() {
+          tracker.reset();
+          onStop && onStop(_this);
+        },
+        scrub: smoothDuration || true
+      });
+
+      this.smooth = function (value) {
+        if (arguments.length) {
+          smoothDuration = value || 0;
+          speed = smoothDuration && +vars.speed || 1;
+          mainST.scrubDuration(value);
+        }
+
+        return mainST.getTween() ? mainST.getTween().duration() : 0;
+      };
+
+      mainST.getTween() && (mainST.getTween().vars.ease = vars.ease || _expo);
+      this.scrollTrigger = mainST;
+      vars.effects && this.effects(vars.effects === true ? "[data-" + effectsPrefix + "speed], [data-" + effectsPrefix + "lag]" : vars.effects, {
+        effectsPadding: vars.effectsPadding,
+        refresh: false
+      });
+      vars.sections && this.sections(vars.sections === true ? "[data-section]" : vars.sections);
+      existingScrollTriggers.forEach(function (st) {
+        st.vars.scroller = wrapper;
+        st.revert(false, true);
+        st.init(st.vars, st.animation);
+      });
+
+      this.paused = function (value, allowNestedScroll) {
+        if (arguments.length) {
+          if (!!paused !== value) {
+            if (value) {
+              mainST.getTween() && mainST.getTween().pause();
+              scrollFunc(-currentY / speed);
+              tracker.reset();
+              pausedNormalizer = ScrollTrigger.normalizeScroll();
+              pausedNormalizer && pausedNormalizer.disable();
+              paused = ScrollTrigger.observe({
+                preventDefault: true,
+                type: "wheel,touch,scroll",
+                debounce: false,
+                allowClicks: true,
+                onChangeY: function onChangeY() {
+                  return scrollTop(-currentY);
+                }
+              });
+              paused.nested = _inputObserver(_docEl, "wheel,touch,scroll", true, allowNestedScroll !== false);
+            } else {
+              paused.nested.kill();
+              paused.kill();
+              paused = 0;
+              pausedNormalizer && pausedNormalizer.enable();
+              mainST.progress = (-currentY / speed - mainST.start) / (mainST.end - mainST.start);
+              killScrub(mainST);
+            }
+          }
+
+          return this;
+        }
+
+        return !!paused;
+      };
+
+      this.kill = this.revert = function () {
+        _this.paused(false);
+
+        killScrub(mainST);
+        mainST.kill();
+        var triggers = (effects || []).concat(sections || []),
+            i = triggers.length;
+
+        while (i--) {
+          triggers[i].kill();
+        }
+
+        ScrollTrigger.scrollerProxy(wrapper);
+        ScrollTrigger.removeEventListener("killAll", addOnRefresh);
+        ScrollTrigger.removeEventListener("refresh", onRefresh);
+        wrapper.style.cssText = wrapperCSS;
+        content.style.cssText = contentCSS;
+        var defaults = ScrollTrigger.defaults({});
+        defaults && defaults.scroller === wrapper && ScrollTrigger.defaults({
+          scroller: _win
+        });
+        _this.normalizer && ScrollTrigger.normalizeScroll(false);
+        clearInterval(intervalID);
+        _mainInstance = null;
+        resizeObserver && resizeObserver.disconnect();
+
+        _body.style.removeProperty("height");
+
+        _win.removeEventListener("focusin", _onFocusIn);
+      };
+
+      this.refresh = function (soft, force) {
+        return mainST.refresh(soft, force);
+      };
+
+      if (normalizeScroll) {
+        this.normalizer = ScrollTrigger.normalizeScroll(normalizeScroll === true ? {
+          debounce: true,
+          content: !smoothDuration && content
+        } : normalizeScroll);
+      }
+
+      ScrollTrigger.config(vars);
+      "scrollBehavior" in _win.getComputedStyle(_body) && gsap.set([_body, _docEl], {
+        scrollBehavior: "auto"
+      });
+
+      _win.addEventListener("focusin", _onFocusIn);
+
+      intervalID = setInterval(updateVelocity, 250);
+      _doc.readyState === "loading" || requestAnimationFrame(function () {
+        return ScrollTrigger.refresh();
+      });
+    }
+
+    ScrollSmoother.register = function register(core) {
+      if (!_coreInitted) {
+        gsap = core || _getGSAP();
+
+        if (_windowExists() && window.document) {
+          _win = window;
+          _doc = document;
+          _docEl = _doc.documentElement;
+          _body = _doc.body;
+        }
+
+        if (gsap) {
+          _toArray = gsap.utils.toArray;
+          _clamp = gsap.utils.clamp;
+          _expo = gsap.parseEase("expo");
+
+          _context = gsap.core.context || function () {};
+
+          ScrollTrigger = gsap.core.globals().ScrollTrigger;
+          gsap.core.globals("ScrollSmoother", ScrollSmoother);
+
+          if (_body && ScrollTrigger) {
+            _onResizeDelayedCall = gsap.delayedCall(0.2, function () {
+              return ScrollTrigger.isRefreshing || _mainInstance && _mainInstance.refresh();
+            }).pause();
+            _getVelocityProp = ScrollTrigger.core._getVelocityProp;
+            _inputObserver = ScrollTrigger.core._inputObserver;
+            ScrollSmoother.refresh = ScrollTrigger.refresh;
+            _coreInitted = 1;
+          }
+        }
+      }
+
+      return _coreInitted;
+    };
+
+    _createClass(ScrollSmoother, [{
+      key: "progress",
+      get: function get() {
+        return this.scrollTrigger ? this.scrollTrigger.animation._time / 100 : 0;
+      }
+    }]);
+
+    return ScrollSmoother;
+  }();
+  ScrollSmoother.version = "3.13.0";
+
+  ScrollSmoother.create = function (vars) {
+    return _mainInstance && vars && _mainInstance.content() === _toArray(vars.content)[0] ? _mainInstance : new ScrollSmoother(vars);
+  };
+
+  ScrollSmoother.get = function () {
+    return _mainInstance;
+  };
+
+  _getGSAP() && gsap.registerPlugin(ScrollSmoother);
+
+  exports.ScrollSmoother = ScrollSmoother;
+  exports.default = ScrollSmoother;
+
+  if (typeof(window) === 'undefined' || window !== exports) {Object.defineProperty(exports, '__esModule', { value: true });} else {delete window.default;}
+
+})));

source/files/gsap-public/umd/ScrollToPlugin.js

@@ -0,0 +1,285 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+	typeof define === 'function' && define.amd ? define(['exports'], factory) :
+	(global = global || self, factory(global.window = global.window || {}));
+}(this, (function (exports) { 'use strict';
+
+	/*!
+	 * ScrollToPlugin 3.13.0
+	 * https://gsap.com
+	 *
+	 * @license Copyright 2008-2025, GreenSock. All rights reserved.
+	 * Subject to the terms at https://gsap.com/standard-license
+	 * @author: Jack Doyle, jack@greensock.com
+	*/
+	var gsap,
+	    _coreInitted,
+	    _window,
+	    _docEl,
+	    _body,
+	    _toArray,
+	    _config,
+	    ScrollTrigger,
+	    _windowExists = function _windowExists() {
+	  return typeof window !== "undefined";
+	},
+	    _getGSAP = function _getGSAP() {
+	  return gsap || _windowExists() && (gsap = window.gsap) && gsap.registerPlugin && gsap;
+	},
+	    _isString = function _isString(value) {
+	  return typeof value === "string";
+	},
+	    _isFunction = function _isFunction(value) {
+	  return typeof value === "function";
+	},
+	    _max = function _max(element, axis) {
+	  var dim = axis === "x" ? "Width" : "Height",
+	      scroll = "scroll" + dim,
+	      client = "client" + dim;
+	  return element === _window || element === _docEl || element === _body ? Math.max(_docEl[scroll], _body[scroll]) - (_window["inner" + dim] || _docEl[client] || _body[client]) : element[scroll] - element["offset" + dim];
+	},
+	    _buildGetter = function _buildGetter(e, axis) {
+	  var p = "scroll" + (axis === "x" ? "Left" : "Top");
+
+	  if (e === _window) {
+	    if (e.pageXOffset != null) {
+	      p = "page" + axis.toUpperCase() + "Offset";
+	    } else {
+	      e = _docEl[p] != null ? _docEl : _body;
+	    }
+	  }
+
+	  return function () {
+	    return e[p];
+	  };
+	},
+	    _clean = function _clean(value, index, target, targets) {
+	  _isFunction(value) && (value = value(index, target, targets));
+
+	  if (typeof value !== "object") {
+	    return _isString(value) && value !== "max" && value.charAt(1) !== "=" ? {
+	      x: value,
+	      y: value
+	    } : {
+	      y: value
+	    };
+	  } else if (value.nodeType) {
+	    return {
+	      y: value,
+	      x: value
+	    };
+	  } else {
+	    var result = {},
+	        p;
+
+	    for (p in value) {
+	      result[p] = p !== "onAutoKill" && _isFunction(value[p]) ? value[p](index, target, targets) : value[p];
+	    }
+
+	    return result;
+	  }
+	},
+	    _getOffset = function _getOffset(element, container) {
+	  element = _toArray(element)[0];
+
+	  if (!element || !element.getBoundingClientRect) {
+	    return console.warn("scrollTo target doesn't exist. Using 0") || {
+	      x: 0,
+	      y: 0
+	    };
+	  }
+
+	  var rect = element.getBoundingClientRect(),
+	      isRoot = !container || container === _window || container === _body,
+	      cRect = isRoot ? {
+	    top: _docEl.clientTop - (_window.pageYOffset || _docEl.scrollTop || _body.scrollTop || 0),
+	    left: _docEl.clientLeft - (_window.pageXOffset || _docEl.scrollLeft || _body.scrollLeft || 0)
+	  } : container.getBoundingClientRect(),
+	      offsets = {
+	    x: rect.left - cRect.left,
+	    y: rect.top - cRect.top
+	  };
+
+	  if (!isRoot && container) {
+	    offsets.x += _buildGetter(container, "x")();
+	    offsets.y += _buildGetter(container, "y")();
+	  }
+
+	  return offsets;
+	},
+	    _parseVal = function _parseVal(value, target, axis, currentVal, offset) {
+	  return !isNaN(value) && typeof value !== "object" ? parseFloat(value) - offset : _isString(value) && value.charAt(1) === "=" ? parseFloat(value.substr(2)) * (value.charAt(0) === "-" ? -1 : 1) + currentVal - offset : value === "max" ? _max(target, axis) - offset : Math.min(_max(target, axis), _getOffset(value, target)[axis] - offset);
+	},
+	    _initCore = function _initCore() {
+	  gsap = _getGSAP();
+
+	  if (_windowExists() && gsap && typeof document !== "undefined" && document.body) {
+	    _window = window;
+	    _body = document.body;
+	    _docEl = document.documentElement;
+	    _toArray = gsap.utils.toArray;
+	    gsap.config({
+	      autoKillThreshold: 7
+	    });
+	    _config = gsap.config();
+	    _coreInitted = 1;
+	  }
+	};
+
+	var ScrollToPlugin = {
+	  version: "3.13.0",
+	  name: "scrollTo",
+	  rawVars: 1,
+	  register: function register(core) {
+	    gsap = core;
+
+	    _initCore();
+	  },
+	  init: function init(target, value, tween, index, targets) {
+	    _coreInitted || _initCore();
+	    var data = this,
+	        snapType = gsap.getProperty(target, "scrollSnapType");
+	    data.isWin = target === _window;
+	    data.target = target;
+	    data.tween = tween;
+	    value = _clean(value, index, target, targets);
+	    data.vars = value;
+	    data.autoKill = !!("autoKill" in value ? value : _config).autoKill;
+	    data.getX = _buildGetter(target, "x");
+	    data.getY = _buildGetter(target, "y");
+	    data.x = data.xPrev = data.getX();
+	    data.y = data.yPrev = data.getY();
+	    ScrollTrigger || (ScrollTrigger = gsap.core.globals().ScrollTrigger);
+	    gsap.getProperty(target, "scrollBehavior") === "smooth" && gsap.set(target, {
+	      scrollBehavior: "auto"
+	    });
+
+	    if (snapType && snapType !== "none") {
+	      data.snap = 1;
+	      data.snapInline = target.style.scrollSnapType;
+	      target.style.scrollSnapType = "none";
+	    }
+
+	    if (value.x != null) {
+	      data.add(data, "x", data.x, _parseVal(value.x, target, "x", data.x, value.offsetX || 0), index, targets);
+
+	      data._props.push("scrollTo_x");
+	    } else {
+	      data.skipX = 1;
+	    }
+
+	    if (value.y != null) {
+	      data.add(data, "y", data.y, _parseVal(value.y, target, "y", data.y, value.offsetY || 0), index, targets);
+
+	      data._props.push("scrollTo_y");
+	    } else {
+	      data.skipY = 1;
+	    }
+	  },
+	  render: function render(ratio, data) {
+	    var pt = data._pt,
+	        target = data.target,
+	        tween = data.tween,
+	        autoKill = data.autoKill,
+	        xPrev = data.xPrev,
+	        yPrev = data.yPrev,
+	        isWin = data.isWin,
+	        snap = data.snap,
+	        snapInline = data.snapInline,
+	        x,
+	        y,
+	        yDif,
+	        xDif,
+	        threshold;
+
+	    while (pt) {
+	      pt.r(ratio, pt.d);
+	      pt = pt._next;
+	    }
+
+	    x = isWin || !data.skipX ? data.getX() : xPrev;
+	    y = isWin || !data.skipY ? data.getY() : yPrev;
+	    yDif = y - yPrev;
+	    xDif = x - xPrev;
+	    threshold = _config.autoKillThreshold;
+
+	    if (data.x < 0) {
+	      data.x = 0;
+	    }
+
+	    if (data.y < 0) {
+	      data.y = 0;
+	    }
+
+	    if (autoKill) {
+	      if (!data.skipX && (xDif > threshold || xDif < -threshold) && x < _max(target, "x")) {
+	        data.skipX = 1;
+	      }
+
+	      if (!data.skipY && (yDif > threshold || yDif < -threshold) && y < _max(target, "y")) {
+	        data.skipY = 1;
+	      }
+
+	      if (data.skipX && data.skipY) {
+	        tween.kill();
+	        data.vars.onAutoKill && data.vars.onAutoKill.apply(tween, data.vars.onAutoKillParams || []);
+	      }
+	    }
+
+	    if (isWin) {
+	      _window.scrollTo(!data.skipX ? data.x : x, !data.skipY ? data.y : y);
+	    } else {
+	      data.skipY || (target.scrollTop = data.y);
+	      data.skipX || (target.scrollLeft = data.x);
+	    }
+
+	    if (snap && (ratio === 1 || ratio === 0)) {
+	      y = target.scrollTop;
+	      x = target.scrollLeft;
+	      snapInline ? target.style.scrollSnapType = snapInline : target.style.removeProperty("scroll-snap-type");
+	      target.scrollTop = y + 1;
+	      target.scrollLeft = x + 1;
+	      target.scrollTop = y;
+	      target.scrollLeft = x;
+	    }
+
+	    data.xPrev = data.x;
+	    data.yPrev = data.y;
+	    ScrollTrigger && ScrollTrigger.update();
+	  },
+	  kill: function kill(property) {
+	    var both = property === "scrollTo",
+	        i = this._props.indexOf(property);
+
+	    if (both || property === "scrollTo_x") {
+	      this.skipX = 1;
+	    }
+
+	    if (both || property === "scrollTo_y") {
+	      this.skipY = 1;
+	    }
+
+	    i > -1 && this._props.splice(i, 1);
+	    return !this._props.length;
+	  }
+	};
+	ScrollToPlugin.max = _max;
+	ScrollToPlugin.getOffset = _getOffset;
+	ScrollToPlugin.buildGetter = _buildGetter;
+
+	ScrollToPlugin.config = function (vars) {
+	  _config || _initCore() || (_config = gsap.config());
+
+	  for (var p in vars) {
+	    _config[p] = vars[p];
+	  }
+	};
+
+	_getGSAP() && gsap.registerPlugin(ScrollToPlugin);
+
+	exports.ScrollToPlugin = ScrollToPlugin;
+	exports.default = ScrollToPlugin;
+
+	Object.defineProperty(exports, '__esModule', { value: true });
+
+})));

source/files/gsap-public/umd/SplitText.js

@@ -0,0 +1,321 @@
+/*!
+ * SplitText 3.13.0
+ * https://gsap.com
+ *
+ * @license Copyright 2025, GreenSock. All rights reserved. Subject to the terms at https://gsap.com/standard-license.
+ * @author: Jack Doyle
+ */
+
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+	typeof define === 'function' && define.amd ? define(['exports'], factory) :
+	(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.window = global.window || {}));
+})(this, (function (exports) { 'use strict';
+
+	let gsap, _fonts, _coreInitted, _initIfNecessary = () => _coreInitted || SplitText.register(window.gsap), _charSegmenter = typeof Intl !== "undefined" ? new Intl.Segmenter() : 0, _toArray = (r) => typeof r === "string" ? _toArray(document.querySelectorAll(r)) : "length" in r ? Array.from(r) : [r], _elements = (targets) => _toArray(targets).filter((e) => e instanceof HTMLElement), _emptyArray = [], _context = function() {
+	}, _spacesRegEx = /\s+/g, _emojiSafeRegEx = new RegExp("\\p{RI}\\p{RI}|\\p{Emoji}(\\p{EMod}|\\u{FE0F}\\u{20E3}?|[\\u{E0020}-\\u{E007E}]+\\u{E007F})?(\\u{200D}\\p{Emoji}(\\p{EMod}|\\u{FE0F}\\u{20E3}?|[\\u{E0020}-\\u{E007E}]+\\u{E007F})?)*|.", "gu"), _emptyBounds = { left: 0, top: 0, width: 0, height: 0 }, _stretchToFitSpecialChars = (collection, specialCharsRegEx) => {
+	  if (specialCharsRegEx) {
+	    let charsFound = new Set(collection.join("").match(specialCharsRegEx) || _emptyArray), i = collection.length, slots, word, char, combined;
+	    if (charsFound.size) {
+	      while (--i > -1) {
+	        word = collection[i];
+	        for (char of charsFound) {
+	          if (char.startsWith(word) && char.length > word.length) {
+	            slots = 0;
+	            combined = word;
+	            while (char.startsWith(combined += collection[i + ++slots]) && combined.length < char.length) {
+	            }
+	            if (slots && combined.length === char.length) {
+	              collection[i] = char;
+	              collection.splice(i + 1, slots);
+	              break;
+	            }
+	          }
+	        }
+	      }
+	    }
+	  }
+	  return collection;
+	}, _disallowInline = (element) => window.getComputedStyle(element).display === "inline" && (element.style.display = "inline-block"), _insertNodeBefore = (newChild, parent, existingChild) => parent.insertBefore(typeof newChild === "string" ? document.createTextNode(newChild) : newChild, existingChild), _getWrapper = (type, config, collection) => {
+	  let className = config[type + "sClass"] || "", { tag = "div", aria = "auto", propIndex = false } = config, display = type === "line" ? "block" : "inline-block", incrementClass = className.indexOf("++") > -1, wrapper = (text) => {
+	    let el = document.createElement(tag), i = collection.length + 1;
+	    className && (el.className = className + (incrementClass ? " " + className + i : ""));
+	    propIndex && el.style.setProperty("--" + type, i + "");
+	    aria !== "none" && el.setAttribute("aria-hidden", "true");
+	    if (tag !== "span") {
+	      el.style.position = "relative";
+	      el.style.display = display;
+	    }
+	    el.textContent = text;
+	    collection.push(el);
+	    return el;
+	  };
+	  incrementClass && (className = className.replace("++", ""));
+	  wrapper.collection = collection;
+	  return wrapper;
+	}, _getLineWrapper = (element, nodes, config, collection) => {
+	  let lineWrapper = _getWrapper("line", config, collection), textAlign = window.getComputedStyle(element).textAlign || "left";
+	  return (startIndex, endIndex) => {
+	    let newLine = lineWrapper("");
+	    newLine.style.textAlign = textAlign;
+	    element.insertBefore(newLine, nodes[startIndex]);
+	    for (; startIndex < endIndex; startIndex++) {
+	      newLine.appendChild(nodes[startIndex]);
+	    }
+	    newLine.normalize();
+	  };
+	}, _splitWordsAndCharsRecursively = (element, config, wordWrapper, charWrapper, prepForCharsOnly, deepSlice, ignore, charSplitRegEx, specialCharsRegEx, isNested) => {
+	  var _a;
+	  let nodes = Array.from(element.childNodes), i = 0, { wordDelimiter, reduceWhiteSpace = true, prepareText } = config, elementBounds = element.getBoundingClientRect(), lastBounds = elementBounds, isPreformatted = !reduceWhiteSpace && window.getComputedStyle(element).whiteSpace.substring(0, 3) === "pre", ignoredPreviousSibling = 0, wordsCollection = wordWrapper.collection, wordDelimIsNotSpace, wordDelimString, wordDelimSplitter, curNode, words, curWordEl, startsWithSpace, endsWithSpace, j, bounds, curWordChars, clonedNode, curSubNode, tempSubNode, curTextContent, wordText, lastWordText, k;
+	  if (typeof wordDelimiter === "object") {
+	    wordDelimSplitter = wordDelimiter.delimiter || wordDelimiter;
+	    wordDelimString = wordDelimiter.replaceWith || "";
+	  } else {
+	    wordDelimString = wordDelimiter === "" ? "" : wordDelimiter || " ";
+	  }
+	  wordDelimIsNotSpace = wordDelimString !== " ";
+	  for (; i < nodes.length; i++) {
+	    curNode = nodes[i];
+	    if (curNode.nodeType === 3) {
+	      curTextContent = curNode.textContent || "";
+	      if (reduceWhiteSpace) {
+	        curTextContent = curTextContent.replace(_spacesRegEx, " ");
+	      } else if (isPreformatted) {
+	        curTextContent = curTextContent.replace(/\n/g, wordDelimString + "\n");
+	      }
+	      prepareText && (curTextContent = prepareText(curTextContent, element));
+	      curNode.textContent = curTextContent;
+	      words = wordDelimString || wordDelimSplitter ? curTextContent.split(wordDelimSplitter || wordDelimString) : curTextContent.match(charSplitRegEx) || _emptyArray;
+	      lastWordText = words[words.length - 1];
+	      endsWithSpace = wordDelimIsNotSpace ? lastWordText.slice(-1) === " " : !lastWordText;
+	      lastWordText || words.pop();
+	      lastBounds = elementBounds;
+	      startsWithSpace = wordDelimIsNotSpace ? words[0].charAt(0) === " " : !words[0];
+	      startsWithSpace && _insertNodeBefore(" ", element, curNode);
+	      words[0] || words.shift();
+	      _stretchToFitSpecialChars(words, specialCharsRegEx);
+	      deepSlice && isNested || (curNode.textContent = "");
+	      for (j = 1; j <= words.length; j++) {
+	        wordText = words[j - 1];
+	        if (!reduceWhiteSpace && isPreformatted && wordText.charAt(0) === "\n") {
+	          (_a = curNode.previousSibling) == null ? void 0 : _a.remove();
+	          _insertNodeBefore(document.createElement("br"), element, curNode);
+	          wordText = wordText.slice(1);
+	        }
+	        if (!reduceWhiteSpace && wordText === "") {
+	          _insertNodeBefore(wordDelimString, element, curNode);
+	        } else if (wordText === " ") {
+	          element.insertBefore(document.createTextNode(" "), curNode);
+	        } else {
+	          wordDelimIsNotSpace && wordText.charAt(0) === " " && _insertNodeBefore(" ", element, curNode);
+	          if (ignoredPreviousSibling && j === 1 && !startsWithSpace && wordsCollection.indexOf(ignoredPreviousSibling.parentNode) > -1) {
+	            curWordEl = wordsCollection[wordsCollection.length - 1];
+	            curWordEl.appendChild(document.createTextNode(charWrapper ? "" : wordText));
+	          } else {
+	            curWordEl = wordWrapper(charWrapper ? "" : wordText);
+	            _insertNodeBefore(curWordEl, element, curNode);
+	            ignoredPreviousSibling && j === 1 && !startsWithSpace && curWordEl.insertBefore(ignoredPreviousSibling, curWordEl.firstChild);
+	          }
+	          if (charWrapper) {
+	            curWordChars = _charSegmenter ? _stretchToFitSpecialChars([..._charSegmenter.segment(wordText)].map((s) => s.segment), specialCharsRegEx) : wordText.match(charSplitRegEx) || _emptyArray;
+	            for (k = 0; k < curWordChars.length; k++) {
+	              curWordEl.appendChild(curWordChars[k] === " " ? document.createTextNode(" ") : charWrapper(curWordChars[k]));
+	            }
+	          }
+	          if (deepSlice && isNested) {
+	            curTextContent = curNode.textContent = curTextContent.substring(wordText.length + 1, curTextContent.length);
+	            bounds = curWordEl.getBoundingClientRect();
+	            if (bounds.top > lastBounds.top && bounds.left <= lastBounds.left) {
+	              clonedNode = element.cloneNode();
+	              curSubNode = element.childNodes[0];
+	              while (curSubNode && curSubNode !== curWordEl) {
+	                tempSubNode = curSubNode;
+	                curSubNode = curSubNode.nextSibling;
+	                clonedNode.appendChild(tempSubNode);
+	              }
+	              element.parentNode.insertBefore(clonedNode, element);
+	              prepForCharsOnly && _disallowInline(clonedNode);
+	            }
+	            lastBounds = bounds;
+	          }
+	          if (j < words.length || endsWithSpace) {
+	            _insertNodeBefore(j >= words.length ? " " : wordDelimIsNotSpace && wordText.slice(-1) === " " ? " " + wordDelimString : wordDelimString, element, curNode);
+	          }
+	        }
+	      }
+	      element.removeChild(curNode);
+	      ignoredPreviousSibling = 0;
+	    } else if (curNode.nodeType === 1) {
+	      if (ignore && ignore.indexOf(curNode) > -1) {
+	        wordsCollection.indexOf(curNode.previousSibling) > -1 && wordsCollection[wordsCollection.length - 1].appendChild(curNode);
+	        ignoredPreviousSibling = curNode;
+	      } else {
+	        _splitWordsAndCharsRecursively(curNode, config, wordWrapper, charWrapper, prepForCharsOnly, deepSlice, ignore, charSplitRegEx, specialCharsRegEx, true);
+	        ignoredPreviousSibling = 0;
+	      }
+	      prepForCharsOnly && _disallowInline(curNode);
+	    }
+	  }
+	};
+	const _SplitText = class _SplitText {
+	  constructor(elements, config) {
+	    this.isSplit = false;
+	    _initIfNecessary();
+	    this.elements = _elements(elements);
+	    this.chars = [];
+	    this.words = [];
+	    this.lines = [];
+	    this.masks = [];
+	    this.vars = config;
+	    this._split = () => this.isSplit && this.split(this.vars);
+	    let orig = [], timerId, checkWidths = () => {
+	      let i = orig.length, o;
+	      while (i--) {
+	        o = orig[i];
+	        let w = o.element.offsetWidth;
+	        if (w !== o.width) {
+	          o.width = w;
+	          this._split();
+	          return;
+	        }
+	      }
+	    };
+	    this._data = { orig, obs: typeof ResizeObserver !== "undefined" && new ResizeObserver(() => {
+	      clearTimeout(timerId);
+	      timerId = setTimeout(checkWidths, 200);
+	    }) };
+	    _context(this);
+	    this.split(config);
+	  }
+	  split(config) {
+	    this.isSplit && this.revert();
+	    this.vars = config = config || this.vars || {};
+	    let { type = "chars,words,lines", aria = "auto", deepSlice = true, smartWrap, onSplit, autoSplit = false, specialChars, mask } = this.vars, splitLines = type.indexOf("lines") > -1, splitCharacters = type.indexOf("chars") > -1, splitWords = type.indexOf("words") > -1, onlySplitCharacters = splitCharacters && !splitWords && !splitLines, specialCharsRegEx = specialChars && ("push" in specialChars ? new RegExp("(?:" + specialChars.join("|") + ")", "gu") : specialChars), finalCharSplitRegEx = specialCharsRegEx ? new RegExp(specialCharsRegEx.source + "|" + _emojiSafeRegEx.source, "gu") : _emojiSafeRegEx, ignore = !!config.ignore && _elements(config.ignore), { orig, animTime, obs } = this._data, onSplitResult;
+	    if (splitCharacters || splitWords || splitLines) {
+	      this.elements.forEach((element, index) => {
+	        orig[index] = {
+	          element,
+	          html: element.innerHTML,
+	          ariaL: element.getAttribute("aria-label"),
+	          ariaH: element.getAttribute("aria-hidden")
+	        };
+	        aria === "auto" ? element.setAttribute("aria-label", (element.textContent || "").trim()) : aria === "hidden" && element.setAttribute("aria-hidden", "true");
+	        let chars = [], words = [], lines = [], charWrapper = splitCharacters ? _getWrapper("char", config, chars) : null, wordWrapper = _getWrapper("word", config, words), i, curWord, smartWrapSpan, nextSibling;
+	        _splitWordsAndCharsRecursively(element, config, wordWrapper, charWrapper, onlySplitCharacters, deepSlice && (splitLines || onlySplitCharacters), ignore, finalCharSplitRegEx, specialCharsRegEx, false);
+	        if (splitLines) {
+	          let nodes = _toArray(element.childNodes), wrapLine = _getLineWrapper(element, nodes, config, lines), curNode, toRemove = [], lineStartIndex = 0, allBounds = nodes.map((n) => n.nodeType === 1 ? n.getBoundingClientRect() : _emptyBounds), lastBounds = _emptyBounds;
+	          for (i = 0; i < nodes.length; i++) {
+	            curNode = nodes[i];
+	            if (curNode.nodeType === 1) {
+	              if (curNode.nodeName === "BR") {
+	                toRemove.push(curNode);
+	                wrapLine(lineStartIndex, i + 1);
+	                lineStartIndex = i + 1;
+	                lastBounds = allBounds[lineStartIndex];
+	              } else {
+	                if (i && allBounds[i].top > lastBounds.top && allBounds[i].left <= lastBounds.left) {
+	                  wrapLine(lineStartIndex, i);
+	                  lineStartIndex = i;
+	                }
+	                lastBounds = allBounds[i];
+	              }
+	            }
+	          }
+	          lineStartIndex < i && wrapLine(lineStartIndex, i);
+	          toRemove.forEach((el) => {
+	            var _a;
+	            return (_a = el.parentNode) == null ? void 0 : _a.removeChild(el);
+	          });
+	        }
+	        if (!splitWords) {
+	          for (i = 0; i < words.length; i++) {
+	            curWord = words[i];
+	            if (splitCharacters || !curWord.nextSibling || curWord.nextSibling.nodeType !== 3) {
+	              if (smartWrap && !splitLines) {
+	                smartWrapSpan = document.createElement("span");
+	                smartWrapSpan.style.whiteSpace = "nowrap";
+	                while (curWord.firstChild) {
+	                  smartWrapSpan.appendChild(curWord.firstChild);
+	                }
+	                curWord.replaceWith(smartWrapSpan);
+	              } else {
+	                curWord.replaceWith(...curWord.childNodes);
+	              }
+	            } else {
+	              nextSibling = curWord.nextSibling;
+	              if (nextSibling && nextSibling.nodeType === 3) {
+	                nextSibling.textContent = (curWord.textContent || "") + (nextSibling.textContent || "");
+	                curWord.remove();
+	              }
+	            }
+	          }
+	          words.length = 0;
+	          element.normalize();
+	        }
+	        this.lines.push(...lines);
+	        this.words.push(...words);
+	        this.chars.push(...chars);
+	      });
+	      mask && this[mask] && this.masks.push(...this[mask].map((el) => {
+	        let maskEl = el.cloneNode();
+	        el.replaceWith(maskEl);
+	        maskEl.appendChild(el);
+	        el.className && (maskEl.className = el.className.replace(/(\b\w+\b)/g, "$1-mask"));
+	        maskEl.style.overflow = "clip";
+	        return maskEl;
+	      }));
+	    }
+	    this.isSplit = true;
+	    _fonts && (autoSplit ? _fonts.addEventListener("loadingdone", this._split) : _fonts.status === "loading" && console.warn("SplitText called before fonts loaded"));
+	    if ((onSplitResult = onSplit && onSplit(this)) && onSplitResult.totalTime) {
+	      this._data.anim = animTime ? onSplitResult.totalTime(animTime) : onSplitResult;
+	    }
+	    splitLines && autoSplit && this.elements.forEach((element, index) => {
+	      orig[index].width = element.offsetWidth;
+	      obs && obs.observe(element);
+	    });
+	    return this;
+	  }
+	  revert() {
+	    var _a, _b;
+	    let { orig, anim, obs } = this._data;
+	    obs && obs.disconnect();
+	    orig.forEach(({ element, html, ariaL, ariaH }) => {
+	      element.innerHTML = html;
+	      ariaL ? element.setAttribute("aria-label", ariaL) : element.removeAttribute("aria-label");
+	      ariaH ? element.setAttribute("aria-hidden", ariaH) : element.removeAttribute("aria-hidden");
+	    });
+	    this.chars.length = this.words.length = this.lines.length = orig.length = this.masks.length = 0;
+	    this.isSplit = false;
+	    _fonts == null ? void 0 : _fonts.removeEventListener("loadingdone", this._split);
+	    if (anim) {
+	      this._data.animTime = anim.totalTime();
+	      anim.revert();
+	    }
+	    (_b = (_a = this.vars).onRevert) == null ? void 0 : _b.call(_a, this);
+	    return this;
+	  }
+	  static create(elements, config) {
+	    return new _SplitText(elements, config);
+	  }
+	  static register(core) {
+	    gsap = gsap || core || window.gsap;
+	    if (gsap) {
+	      _toArray = gsap.utils.toArray;
+	      _context = gsap.core.context || _context;
+	    }
+	    if (!_coreInitted && window.innerWidth > 0) {
+	      _fonts = document.fonts;
+	      _coreInitted = true;
+	    }
+	  }
+	};
+	_SplitText.version = "3.13.0";
+	let SplitText = _SplitText;
+
+	exports.SplitText = SplitText;
+	exports.default = SplitText;
+
+	Object.defineProperty(exports, '__esModule', { value: true });
+
+}));