https://casazogbi.com/wp-content/themes/zogbi/assets/js/main.js?ver=3.0.3

1function _assertThisInitialized(self) {
2  if (self === void 0) {
3    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
4  }
5  return self;
6}
7function _inheritsLoose(subClass, superClass) {
8  subClass.prototype = Object.create(superClass.prototype);
9  subClass.prototype.constructor = subClass;
10  subClass.__proto__ = superClass;
11}
12/*!
13 * GSAP 3.12.5
14 * https://gsap.com
15 *
16 * @license Copyright 2008-2024, GreenSock. All rights reserved.
17 * Subject to the terms at https://gsap.com/standard-license or for
18 * Club GSAP members, the agreement issued with that membership.
19 * @author: Jack Doyle, [email protected]
20*/
21var _config = {
22  autoSleep: 120,
23  force3D: "auto",
24  nullTargetWarn: 1,
25  units: {
26    lineHeight: ""
27  }
28}, _defaults = {
29  duration: 0.5,
30  overwrite: false,
31  delay: 0
32}, _suppressOverwrites, _reverting$1, _context, _bigNum$1 = 1e8, _tinyNum = 1 / _bigNum$1, _2PI = Math.PI * 2, _HALF_PI = _2PI / 4, _gsID = 0, _sqrt = Math.sqrt, _cos = Math.cos, _sin = Math.sin, _isString = function _isString2(value) {
33  return typeof value === "string";
34}, _isFunction = function _isFunction2(value) {
35  return typeof value === "function";
36}, _isNumber = function _isNumber2(value) {
37  return typeof value === "number";
38}, _isUndefined = function _isUndefined2(value) {
39  return typeof value === "undefined";
40}, _isObject = function _isObject2(value) {
41  return typeof value === "object";
42}, _isNotFalse = function _isNotFalse2(value) {
43  return value !== false;
44}, _windowExists$1 = function _windowExists() {
45  return typeof window !== "undefined";
46}, _isFuncOrString = function _isFuncOrString2(value) {
47  return _isFunction(value) || _isString(value);
48}, _isTypedArray = typeof ArrayBuffer === "function" && ArrayBuffer.isView || function() {
49}, _isArray = Array.isArray, _strictNumExp = /(?:-?\.?\d|\.)+/gi, _numExp = /[-+=.]*\d+[.e\-+]*\d*[e\-+]*\d*/g, _numWithUnitExp = /[-+=.]*\d+[.e-]*\d*[a-z%]*/g, _complexStringNumExp = /[-+=.]*\d+\.?\d*(?:e-|e\+)?\d*/gi, _relExp = /[+-]=-?[.\d]+/, _delimitedValueExp = /[^,'"\[\]\s]+/gi, _unitExp = /^[+\-=e\s\d]*\d+[.\d]*([a-z]*|%)\s*$/i, _globalTimeline, _win$1, _coreInitted, _doc$1, _globals = {}, _installScope = {}, _coreReady, _install = function _install2(scope) {
50  return (_installScope = _merge(scope, _globals)) && gsap;
51}, _missingPlugin = function _missingPlugin2(property, value) {
52  return console.warn("Invalid property", property, "set to", value, "Missing plugin? gsap.registerPlugin()");
53}, _warn = function _warn2(message, suppress) {
54  return !suppress && console.warn(message);
55}, _addGlobal = function _addGlobal2(name, obj) {
56  return name && (_globals[name] = obj) && _installScope && (_installScope[name] = obj) || _globals;
57}, _emptyFunc = function _emptyFunc2() {
58  return 0;
59}, _startAtRevertConfig = {
60  suppressEvents: true,
61  isStart: true,
62  kill: false
63}, _revertConfigNoKill = {
64  suppressEvents: true,
65  kill: false
66}, _revertConfig = {
67  suppressEvents: true
68}, _reservedProps = {}, _lazyTweens = [], _lazyLookup = {}, _lastRenderedFrame, _plugins = {}, _effects = {}, _nextGCFrame = 30, _harnessPlugins = [], _callbackNames = "", _harness = function _harness2(targets) {
69  var target = targets[0], harnessPlugin, i;
70  _isObject(target) || _isFunction(target) || (targets = [targets]);
71  if (!(harnessPlugin = (target._gsap || {}).harness)) {
72    i = _harnessPlugins.length;
73    while (i-- && !_harnessPlugins[i].targetTest(target)) {
74    }
75    harnessPlugin = _harnessPlugins[i];
76  }
77  i = targets.length;
78  while (i--) {
79    targets[i] && (targets[i]._gsap || (targets[i]._gsap = new GSCache(targets[i], harnessPlugin))) || targets.splice(i, 1);
80  }
81  return targets;
82}, _getCache = function _getCache2(target) {
83  return target._gsap || _harness(toArray(target))[0]._gsap;
84}, _getProperty = function _getProperty2(target, property, v) {
85  return (v = target[property]) && _isFunction(v) ? target[property]() : _isUndefined(v) && target.getAttribute && target.getAttribute(property) || v;
86}, _forEachName = function _forEachName2(names, func) {

87  return (names = names.split(",")).forEach(func) || names;
88}, _round = function _round2(value) {
89  return Math.round(value * 1e5) / 1e5 || 0;
90}, _roundPrecise = function _roundPrecise2(value) {
91  return Math.round(value * 1e7) / 1e7 || 0;
92}, _parseRelative = function _parseRelative2(start, value) {
93  var operator = value.charAt(0), end = parseFloat(value.substr(2));
94  start = parseFloat(start);
95  return operator === "+" ? start + end : operator === "-" ? start - end : operator === "*" ? start * end : start / end;
96}, _arrayContainsAny = function _arrayContainsAny2(toSearch, toFind) {
97  var l = toFind.length, i = 0;
98  for (; toSearch.indexOf(toFind[i]) < 0 && ++i < l; ) {
99  }
100  return i < l;
101}, _lazyRender = function _lazyRender2() {
102  var l = _lazyTweens.length, a = _lazyTweens.slice(0), i, tween;
103  _lazyLookup = {};
104  _lazyTweens.length = 0;
105  for (i = 0; i < l; i++) {
106    tween = a[i];
107    tween && tween._lazy && (tween.render(tween._lazy[0], tween._lazy[1], true)._lazy = 0);
108  }
109}, _lazySafeRender = function _lazySafeRender2(animation, time, suppressEvents, force) {
110  _lazyTweens.length && !_reverting$1 && _lazyRender();
111  animation.render(time, suppressEvents, force || _reverting$1 && time < 0 && (animation._initted || animation._startAt));
112  _lazyTweens.length && !_reverting$1 && _lazyRender();
113}, _numericIfPossible = function _numericIfPossible2(value) {
114  var n = parseFloat(value);
115  return (n || n === 0) && (value + "").match(_delimitedValueExp).length < 2 ? n : _isString(value) ? value.trim() : value;
116}, _passThrough = function _passThrough2(p) {
117  return p;
118}, _setDefaults = function _setDefaults2(obj, defaults2) {
119  for (var p in defaults2) {
120    p in obj || (obj[p] = defaults2[p]);
121  }
122  return obj;
123}, _setKeyframeDefaults = function _setKeyframeDefaults2(excludeDuration) {
124  return function(obj, defaults2) {
125    for (var p in defaults2) {
126      p in obj || p === "duration" && excludeDuration || p === "ease" || (obj[p] = defaults2[p]);
127    }
128  };
129}, _merge = function _merge2(base, toMerge) {
130  for (var p in toMerge) {
131    base[p] = toMerge[p];
132  }
133  return base;
134}, _mergeDeep = function _mergeDeep2(base, toMerge) {
135  for (var p in toMerge) {
136    p !== "__proto__" && p !== "constructor" && p !== "prototype" && (base[p] = _isObject(toMerge[p]) ? _mergeDeep2(base[p] || (base[p] = {}), toMerge[p]) : toMerge[p]);
137  }
138  return base;
139}, _copyExcluding = function _copyExcluding2(obj, excluding) {
140  var copy = {}, p;
141  for (p in obj) {
142    p in excluding || (copy[p] = obj[p]);
143  }
144  return copy;
145}, _inheritDefaults = function _inheritDefaults2(vars) {
146  var parent = vars.parent || _globalTimeline, func = vars.keyframes ? _setKeyframeDefaults(_isArray(vars.keyframes)) : _setDefaults;
147  if (_isNotFalse(vars.inherit)) {
148    while (parent) {
149      func(vars, parent.vars.defaults);
150      parent = parent.parent || parent._dp;
151    }
152  }
153  return vars;
154}, _arraysMatch = function _arraysMatch2(a1, a2) {
155  var i = a1.length, match = i === a2.length;
156  while (match && i-- && a1[i] === a2[i]) {
157  }
158  return i < 0;
159}, _addLinkedListItem = function _addLinkedListItem2(parent, child, firstProp, lastProp, sortBy) {
160  if (firstProp === void 0) {
161    firstProp = "_first";
162  }
163  if (lastProp === void 0) {
164    lastProp = "_last";
165  }
166  var prev = parent[lastProp], t;
167  if (sortBy) {
168    t = child[sortBy];
169    while (prev && prev[sortBy] > t) {
170      prev = prev._prev;
171    }
172  }
173  if (prev) {
174    child._next = prev._next;
175    prev._next = child;
176  } else {
177    child._next = parent[firstProp];
178    parent[firstProp] = child;
179  }
180  if (child._next) {
181    child._next._prev = child;
182  } else {
183    parent[lastProp] = child;
184  }
185  child._prev = prev;
186  child.parent = child._dp = parent;
187  return child;
188}, _removeLinkedListItem = function _removeLinkedListItem2(parent, child, firstProp, lastProp) {
189  if (firstProp === void 0) {
190    firstProp = "_first";
191  }
192  if (lastProp === void 0) {
193    lastProp = "_last";
194  }
195  var prev = child._prev, next = child._next;
196  if (prev) {
197    prev._next = next;
198  } else if (parent[firstProp] === child) {
199    parent[firstProp] = next;
200  }
201  if (next) {
202    next._prev = prev;
203  } else if (parent[lastProp] === child) {
204    parent[lastProp] = prev;
205  }
206  child._next = child._prev = child.parent = null;
207}, _removeFromParent = function _removeFromParent2(child, onlyIfParentHasAutoRemove) {
208  child.parent && (!onlyIfParentHasAutoRemove || child.parent.autoRemoveChildren) && child.parent.remove && child.parent.remove(child);
209  child._act = 0;
210}, _uncache = function _uncache2(animation, child) {
211  if (animation && (!child || child._end > animation._dur || child._start < 0)) {
212    var a = animation;
213    while (a) {
214      a._dirty = 1;
215      a = a.parent;
216    }
217  }
218  return animation;
219}, _recacheAncestors = function _recacheAncestors2(animation) {
220  var parent = animation.parent;
221  while (parent && parent.parent) {
222    parent._dirty = 1;
223    parent.totalDuration();
224    parent = parent.parent;
225  }
226  return animation;
227}, _rewindStartAt = function _rewindStartAt2(tween, totalTime, suppressEvents, force) {
228  return tween._startAt && (_reverting$1 ? tween._startAt.revert(_revertConfigNoKill) : tween.vars.immediateRender && !tween.vars.autoRevert || tween._startAt.render(totalTime, true, force));
229}, _hasNoPausedAncestors = function _hasNoPausedAncestors2(animation) {
230  return !animation || animation._ts && _hasNoPausedAncestors2(animation.parent);
231}, _elapsedCycleDuration = function _elapsedCycleDuration2(animation) {
232  return animation._repeat ? _animationCycle(animation._tTime, animation = animation.duration() + animation._rDelay) * animation : 0;
233}, _animationCycle = function _animationCycle2(tTime, cycleDuration) {
234  var whole = Math.floor(tTime /= cycleDuration);
235  return tTime && whole === tTime ? whole - 1 : whole;
236}, _parentToChildTotalTime = function _parentToChildTotalTime2(parentTime, child) {
237  return (parentTime - child._start) * child._ts + (child._ts >= 0 ? 0 : child._dirty ? child.totalDuration() : child._tDur);
238}, _setEnd = function _setEnd2(animation) {
239  return animation._end = _roundPrecise(animation._start + (animation._tDur / Math.abs(animation._ts || animation._rts || _tinyNum) || 0));
240}, _alignPlayhead = function _alignPlayhead2(animation, totalTime) {
241  var parent = animation._dp;
242  if (parent && parent.smoothChildTiming && animation._ts) {
243    animation._start = _roundPrecise(parent._time - (animation._ts > 0 ? totalTime / animation._ts : ((animation._dirty ? animation.totalDuration() : animation._tDur) - totalTime) / -animation._ts));
244    _setEnd(animation);
245    parent._dirty || _uncache(parent, animation);
246  }
247  return animation;
248}, _postAddChecks = function _postAddChecks2(timeline2, child) {
249  var t;
250  if (child._time || !child._dur && child._initted || child._start < timeline2._time && (child._dur || !child.add)) {
251    t = _parentToChildTotalTime(timeline2.rawTime(), child);
252    if (!child._dur || _clamp(0, child.totalDuration(), t) - child._tTime > _tinyNum) {
253      child.render(t, true);
254    }
255  }
256  if (_uncache(timeline2, child)._dp && timeline2._initted && timeline2._time >= timeline2._dur && timeline2._ts) {
257    if (timeline2._dur < timeline2.duration()) {
258      t = timeline2;
259      while (t._dp) {
260        t.rawTime() >= 0 && t.totalTime(t._tTime);
261        t = t._dp;
262      }
263    }
264    timeline2._zTime = -_tinyNum;
265  }
266}, _addToTimeline = function _addToTimeline2(timeline2, child, position, skipChecks) {
267  child.parent && _removeFromParent(child);
268  child._start = _roundPrecise((_isNumber(position) ? position : position || timeline2 !== _globalTimeline ? _parsePosition(timeline2, position, child) : timeline2._time) + child._delay);
269  child._end = _roundPrecise(child._start + (child.totalDuration() / Math.abs(child.timeScale()) || 0));
270  _addLinkedListItem(timeline2, child, "_first", "_last", timeline2._sort ? "_start" : 0);
271  _isFromOrFromStart(child) || (timeline2._recent = child);
272  skipChecks || _postAddChecks(timeline2, child);
273  timeline2._ts < 0 && _alignPlayhead(timeline2, timeline2._tTime);
274  return timeline2;
275}, _scrollTrigger = function _scrollTrigger2(animation, trigger) {
276  return (_globals.ScrollTrigger || _missingPlugin("scrollTrigger", trigger)) && _globals.ScrollTrigger.create(trigger, animation);
277}, _attemptInitTween = function _attemptInitTween2(tween, time, force, suppressEvents, tTime) {
278  _initTween(tween, time, tTime);
279  if (!tween._initted) {
280    return 1;
281  }
282  if (!force && tween._pt && !_reverting$1 && (tween._dur && tween.vars.lazy !== false || !tween._dur && tween.vars.lazy) && _lastRenderedFrame !== _ticker.frame) {
283    _lazyTweens.push(tween);
284    tween._lazy = [tTime, suppressEvents];
285    return 1;
286  }
287}, _parentPlayheadIsBeforeStart = function _parentPlayheadIsBeforeStart2(_ref) {
288  var parent = _ref.parent;
289  return parent && parent._ts && parent._initted && !parent._lock && (parent.rawTime() < 0 || _parentPlayheadIsBeforeStart2(parent));
290}, _isFromOrFromStart = function _isFromOrFromStart2(_ref2) {
291  var data = _ref2.data;
292  return data === "isFromStart" || data === "isStart";
293}, _renderZeroDurationTween = function _renderZeroDurationTween2(tween, totalTime, suppressEvents, force) {
294  var prevRatio = tween.ratio, ratio = totalTime < 0 || !totalTime && (!tween._start && _parentPlayheadIsBeforeStart(tween) && !(!tween._initted && _isFromOrFromStart(tween)) || (tween._ts < 0 || tween._dp._ts < 0) && !_isFromOrFromStart(tween)) ? 0 : 1, repeatDelay = tween._rDelay, tTime = 0, pt, iteration, prevIteration;
295  if (repeatDelay && tween._repeat) {
296    tTime = _clamp(0, tween._tDur, totalTime);
297    iteration = _animationCycle(tTime, repeatDelay);
298    tween._yoyo && iteration & 1 && (ratio = 1 - ratio);
299    if (iteration !== _animationCycle(tween._tTime, repeatDelay)) {
300      prevRatio = 1 - ratio;
301      tween.vars.repeatRefresh && tween._initted && tween.invalidate();
302    }
303  }
304  if (ratio !== prevRatio || _reverting$1 || force || tween._zTime === _tinyNum || !totalTime && tween._zTime) {
305    if (!tween._initted && _attemptInitTween(tween, totalTime, force, suppressEvents, tTime)) {
306      return;
307    }
308    prevIteration = tween._zTime;
309    tween._zTime = totalTime || (suppressEvents ? _tinyNum : 0);
310    suppressEvents || (suppressEvents = totalTime && !prevIteration);
311    tween.ratio = ratio;
312    tween._from && (ratio = 1 - ratio);
313    tween._time = 0;
314    tween._tTime = tTime;
315    pt = tween._pt;
316    while (pt) {
317      pt.r(ratio, pt.d);
318      pt = pt._next;
319    }
320    totalTime < 0 && _rewindStartAt(tween, totalTime, suppressEvents, true);
321    tween._onUpdate && !suppressEvents && _callback(tween, "onUpdate");
322    tTime && tween._repeat && !suppressEvents && tween.parent && _callback(tween, "onRepeat");
323    if ((totalTime >= tween._tDur || totalTime < 0) && tween.ratio === ratio) {
324      ratio && _removeFromParent(tween, 1);
325      if (!suppressEvents && !_reverting$1) {
326        _callback(tween, ratio ? "onComplete" : "onReverseComplete", true);
327        tween._prom && tween._prom();
328      }
329    }
330  } else if (!tween._zTime) {
331    tween._zTime = totalTime;
332  }
333}, _findNextPauseTween = function _findNextPauseTween2(animation, prevTime, time) {
334  var child;
335  if (time > prevTime) {
336    child = animation._first;
337    while (child && child._start <= time) {
338      if (child.data === "isPause" && child._start > prevTime) {
339        return child;
340      }
341      child = child._next;
342    }
343  } else {
344    child = animation._last;
345    while (child && child._start >= time) {
346      if (child.data === "isPause" && child._start < prevTime) {
347        return child;
348      }
349      child = child._prev;
350    }
351  }
352}, _setDuration = function _setDuration2(animation, duration, skipUncache, leavePlayhead) {
353  var repeat = animation._repeat, dur = _roundPrecise(duration) || 0, totalProgress = animation._tTime / animation._tDur;
354  totalProgress && !leavePlayhead && (animation._time *= dur / animation._dur);
355  animation._dur = dur;
356  animation._tDur = !repeat ? dur : repeat < 0 ? 1e10 : _roundPrecise(dur * (repeat + 1) + animation._rDelay * repeat);
357  totalProgress > 0 && !leavePlayhead && _alignPlayhead(animation, animation._tTime = animation._tDur * totalProgress);
358  animation.parent && _setEnd(animation);
359  skipUncache || _uncache(animation.parent, animation);
360  return animation;
361}, _onUpdateTotalDuration = function _onUpdateTotalDuration2(animation) {
362  return animation instanceof Timeline ? _uncache(animation) : _setDuration(animation, animation._dur);
363}, _zeroPosition = {
364  _start: 0,
365  endTime: _emptyFunc,
366  totalDuration: _emptyFunc
367}, _parsePosition = function _parsePosition2(animation, position, percentAnimation) {
368  var labels = animation.labels, recent = animation._recent || _zeroPosition, clippedDuration = animation.duration() >= _bigNum$1 ? recent.endTime(false) : animation._dur, i, offset, isPercent;
369  if (_isString(position) && (isNaN(position) || position in labels)) {
370    offset = position.charAt(0);
371    isPercent = position.substr(-1) === "%";
372    i = position.indexOf("=");
373    if (offset === "<" || offset === ">") {
374      i >= 0 && (position = position.replace(/=/, ""));
375      return (offset === "<" ? recent._start : recent.endTime(recent._repeat >= 0)) + (parseFloat(position.substr(1)) || 0) * (isPercent ? (i < 0 ? recent : percentAnimation).totalDuration() / 100 : 1);
376    }
377    if (i < 0) {
378      position in labels || (labels[position] = clippedDuration);
379      return labels[position];
380    }
381    offset = parseFloat(position.charAt(i - 1) + position.substr(i + 1));
382    if (isPercent && percentAnimation) {
383      offset = offset / 100 * (_isArray(percentAnimation) ? percentAnimation[0] : percentAnimation).totalDuration();
384    }
385    return i > 1 ? _parsePosition2(animation, position.substr(0, i - 1), percentAnimation) + offset : clippedDuration + offset;
386  }
387  return position == null ? clippedDuration : +position;
388}, _createTweenType = function _createTweenType2(type, params, timeline2) {
389  var isLegacy = _isNumber(params[1]), varsIndex = (isLegacy ? 2 : 1) + (type < 2 ? 0 : 1), vars = params[varsIndex], irVars, parent;
390  isLegacy && (vars.duration = params[1]);
391  vars.parent = timeline2;
392  if (type) {
393    irVars = vars;
394    parent = timeline2;
395    while (parent && !("immediateRender" in irVars)) {
396      irVars = parent.vars.defaults || {};
397      parent = _isNotFalse(parent.vars.inherit) && parent.parent;
398    }
399    vars.immediateRender = _isNotFalse(irVars.immediateRender);
400    type < 2 ? vars.runBackwards = 1 : vars.startAt = params[varsIndex - 1];
401  }
402  return new Tween(params[0], vars, params[varsIndex + 1]);
403}, _conditionalReturn = function _conditionalReturn2(value, func) {
404  return value || value === 0 ? func(value) : func;
405}, _clamp = function _clamp2(min, max, value) {
406  return value < min ? min : value > max ? max : value;
407}, getUnit = function getUnit2(value, v) {
408  return !_isString(value) || !(v = _unitExp.exec(value)) ? "" : v[1];
409}, clamp = function clamp2(min, max, value) {
410  return _conditionalReturn(value, function(v) {
411    return _clamp(min, max, v);
412  });
413}, _slice = [].slice, _isArrayLike = function _isArrayLike2(value, nonEmpty) {
414  return value && _isObject(value) && "length" in value && (!nonEmpty && !value.length || value.length - 1 in value && _isObject(value[0])) && !value.nodeType && value !== _win$1;
415}, _flatten = function _flatten2(ar, leaveStrings, accumulator) {
416  if (accumulator === void 0) {
417    accumulator = [];
418  }
419  return ar.forEach(function(value) {
420    var _accumulator;
421    return _isString(value) && !leaveStrings || _isArrayLike(value, 1) ? (_accumulator = accumulator).push.apply(_accumulator, toArray(value)) : accumulator.push(value);
422  }) || accumulator;
423}, toArray = function toArray2(value, scope, leaveStrings) {
424  return _context && !scope && _context.selector ? _context.selector(value) : _isString(value) && !leaveStrings && (_coreInitted || !_wake()) ? _slice.call((scope || _doc$1).querySelectorAll(value), 0) : _isArray(value) ? _flatten(value, leaveStrings) : _isArrayLike(value) ? _slice.call(value, 0) : value ? [value] : [];
425}, selector = function selector2(value) {
426  value = toArray(value)[0] || _warn("Invalid scope") || {};
427  return function(v) {
428    var el = value.current || value.nativeElement || value;
429    return toArray(v, el.querySelectorAll ? el : el === value ? _warn("Invalid scope") || _doc$1.createElement("div") : value);
430  };
431}, shuffle = function shuffle2(a) {
432  return a.sort(function() {
433    return 0.5 - Math.random();
434  });
435}, distribute = function distribute2(v) {
436  if (_isFunction(v)) {
437    return v;
438  }
439  var vars = _isObject(v) ? v : {
440    each: v
441  }, ease = _parseEase(vars.ease), from = vars.from || 0, base = parseFloat(vars.base) || 0, cache = {}, isDecimal = from > 0 && from < 1, ratios = isNaN(from) || isDecimal, axis = vars.axis, ratioX = from, ratioY = from;
442  if (_isString(from)) {
443    ratioX = ratioY = {
444      center: 0.5,
445      edges: 0.5,
446      end: 1
447    }[from] || 0;
448  } else if (!isDecimal && ratios) {
449    ratioX = from[0];
450    ratioY = from[1];
451  }
452  return function(i, target, a) {
453    var l = (a || vars).length, distances = cache[l], originX, originY, x, y, d, j, max, min, wrapAt;
454    if (!distances) {
455      wrapAt = vars.grid === "auto" ? 0 : (vars.grid || [1, _bigNum$1])[1];
456      if (!wrapAt) {
457        max = -_bigNum$1;
458        while (max < (max = a[wrapAt++].getBoundingClientRect().left) && wrapAt < l) {
459        }
460        wrapAt < l && wrapAt--;
461      }
462      distances = cache[l] = [];
463      originX = ratios ? Math.min(wrapAt, l) * ratioX - 0.5 : from % wrapAt;
464      originY = wrapAt === _bigNum$1 ? 0 : ratios ? l * ratioY / wrapAt - 0.5 : from / wrapAt | 0;
465      max = 0;
466      min = _bigNum$1;
467      for (j = 0; j < l; j++) {
468        x = j % wrapAt - originX;
469        y = originY - (j / wrapAt | 0);
470        distances[j] = d = !axis ? _sqrt(x * x + y * y) : Math.abs(axis === "y" ? y : x);
471        d > max && (max = d);
472        d < min && (min = d);
473      }
474      from === "random" && shuffle(distances);
475      distances.max = max - min;
476      distances.min = min;
477      distances.v = l = (parseFloat(vars.amount) || parseFloat(vars.each) * (wrapAt > l ? l - 1 : !axis ? Math.max(wrapAt, l / wrapAt) : axis === "y" ? l / wrapAt : wrapAt) || 0) * (from === "edges" ? -1 : 1);
478      distances.b = l < 0 ? base - l : base;
479      distances.u = getUnit(vars.amount || vars.each) || 0;
480      ease = ease && l < 0 ? _invertEase(ease) : ease;
481    }
482    l = (distances[i] - distances.min) / distances.max || 0;
483    return _roundPrecise(distances.b + (ease ? ease(l) : l) * distances.v) + distances.u;
484  };
485}, _roundModifier = function _roundModifier2(v) {
486  var p = Math.pow(10, ((v + "").split(".")[1] || "").length);
487  return function(raw) {
488    var n = _roundPrecise(Math.round(parseFloat(raw) / v) * v * p);
489    return (n - n % 1) / p + (_isNumber(raw) ? 0 : getUnit(raw));
490  };
491}, snap = function snap2(snapTo, value) {
492  var isArray = _isArray(snapTo), radius, is2D;
493  if (!isArray && _isObject(snapTo)) {
494    radius = isArray = snapTo.radius || _bigNum$1;
495    if (snapTo.values) {
496      snapTo = toArray(snapTo.values);
497      if (is2D = !_isNumber(snapTo[0])) {
498        radius *= radius;
499      }
500    } else {
501      snapTo = _roundModifier(snapTo.increment);
502    }
503  }
504  return _conditionalReturn(value, !isArray ? _roundModifier(snapTo) : _isFunction(snapTo) ? function(raw) {
505    is2D = snapTo(raw);
506    return Math.abs(is2D - raw) <= radius ? is2D : raw;
507  } : function(raw) {
508    var x = parseFloat(is2D ? raw.x : raw), y = parseFloat(is2D ? raw.y : 0), min = _bigNum$1, closest = 0, i = snapTo.length, dx, dy;
509    while (i--) {
510      if (is2D) {
511        dx = snapTo[i].x - x;
512        dy = snapTo[i].y - y;
513        dx = dx * dx + dy * dy;
514      } else {
515        dx = Math.abs(snapTo[i] - x);
516      }
517      if (dx < min) {
518        min = dx;
519        closest = i;
520      }
521    }
522    closest = !radius || min <= radius ? snapTo[closest] : raw;
523    return is2D || closest === raw || _isNumber(raw) ? closest : closest + getUnit(raw);
524  });
525}, random = function random2(min, max, roundingIncrement, returnFunction) {
526  return _conditionalReturn(_isArray(min) ? !max : roundingIncrement === true ? !!(roundingIncrement = 0) : !returnFunction, function() {
527    return _isArray(min) ? min[~~(Math.random() * min.length)] : (roundingIncrement = roundingIncrement || 1e

527-5) && (returnFunction = roundingIncrement < 1 ? Math.pow(10, (roundingIncrement + "").length - 2) : 1) && Math.floor(Math.round((min - roundingIncrement / 2 + Math.random() * (max - min + roundingIncrement * 0.99)) / roundingIncrement) * roundingIncrement * returnFunction) / returnFunction;
528  });
529}, pipe = function pipe2() {
530  for (var _len = arguments.length, functions = new Array(_len), _key = 0; _key < _len; _key++) {
531    functions[_key] = arguments[_key];
532  }
533  return function(value) {
534    return functions.reduce(function(v, f) {
535      return f(v);
536    }, value);
537  };
538}, unitize = function unitize2(func, unit) {
539  return function(value) {
540    return func(parseFloat(value)) + (unit || getUnit(value));
541  };
542}, normalize = function normalize2(min, max, value) {
543  return mapRange(min, max, 0, 1, value);
544}, _wrapArray = function _wrapArray2(a, wrapper, value) {
545  return _conditionalReturn(value, function(index) {
546    return a[~~wrapper(index)];
547  });
548}, wrap = function wrap2(min, max, value) {
549  var range = max - min;
550  return _isArray(min) ? _wrapArray(min, wrap2(0, min.length), max) : _conditionalReturn(value, function(value2) {
551    return (range + (value2 - min) % range) % range + min;
552  });
553}, wrapYoyo = function wrapYoyo2(min, max, value) {
554  var range = max - min, total = range * 2;
555  return _isArray(min) ? _wrapArray(min, wrapYoyo2(0, min.length - 1), max) : _conditionalReturn(value, function(value2) {
556    value2 = (total + (value2 - min) % total) % total || 0;
557    return min + (value2 > range ? total - value2 : value2);
558  });
559}, _replaceRandom = function _replaceRandom2(value) {
560  var prev = 0, s = "", i, nums, end, isArray;
561  while (~(i = value.indexOf("random(", prev))) {
562    end = value.indexOf(")", i);
563    isArray = value.charAt(i + 7) === "[";
564    nums = value.substr(i + 7, end - i - 7).match(isArray ? _delimitedValueExp : _strictNumExp);
565    s += value.substr(prev, i - prev) + random(isArray ? nums : +nums[0], isArray ? 0 : +nums[1], +nums[2] || 1e-5);
566    prev = end + 1;
567  }
568  return s + value.substr(prev, value.length - prev);
569}, mapRange = function mapRange2(inMin, inMax, outMin, outMax, value) {
570  var inRange = inMax - inMin, outRange = outMax - outMin;
571  return _conditionalReturn(value, function(value2) {
572    return outMin + ((value2 - inMin) / inRange * outRange || 0);
573  });
574}, interpolate = function interpolate2(start, end, progress, mutate) {
575  var func = isNaN(start + end) ? 0 : function(p2) {
576    return (1 - p2) * start + p2 * end;
577  };
578  if (!func) {
579    var isString = _isString(start), master = {}, p, i, interpolators, l, il;
580    progress === true && (mutate = 1) && (progress = null);
581    if (isString) {
582      start = {
583        p: start
584      };
585      end = {
586        p: end
587      };
588    } else if (_isArray(start) && !_isArray(end)) {
589      interpolators = [];
590      l = start.length;
591      il = l - 2;
592      for (i = 1; i < l; i++) {
593        interpolators.push(interpolate2(start[i - 1], start[i]));
594      }
595      l--;
596      func = function func2(p2) {
597        p2 *= l;
598        var i2 = Math.min(il, ~~p2);
599        return interpolators[i2](p2 - i2);
600      };
601      progress = end;
602    } else if (!mutate) {
603      start = _merge(_isArray(start) ? [] : {}, start);
604    }
605    if (!interpolators) {
606      for (p in end) {
607        _addPropTween.call(master, start, p, "get", end[p]);
608      }
609      func = function func2(p2) {
610        return _renderPropTweens(p2, master) || (isString ? start.p : start);
611      };
612    }
613  }
614  return _conditionalReturn(progress, func);
615}, _getLabelInDirection = function _getLabelInDirection2(timeline2, fromTime, backward) {
616  var labels = timeline2.labels, min = _bigNum$1, p, distance, label;
617  for (p in labels) {
618    distance = labels[p] - fromTime;
619    if (distance < 0 === !!backward && distance && min > (distance = Math.abs(distance))) {
620      label = p;
621      min = distance;
622    }
623  }
624  return label;
625}, _callback = function _callback2(animation, type, executeLazyFirst) {
626  var v = animation.vars, callback = v[type], prevContext = _context, context3 = animation._ctx, params, scope, result;
627  if (!callback) {
628    return;
629  }
630  params = v[type + "Params"];
631  scope = v.callbackScope || animation;
632  executeLazyFirst && _lazyTweens.length && _lazyRender();
633  context3 && (_context = context3);
634  result = params ? callback.apply(scope, params) : callback.call(scope);
635  _context = prevContext;
636  return result;
637}, _interrupt = function _interrupt2(animation) {
638  _removeFromParent(animation);
639  animation.scrollTrigger && animation.scrollTrigger.kill(!!_reverting$1);

640  animation.progress() < 1 && _callback(animation, "onInterrupt");
641  return animation;
642}, _quickTween, _registerPluginQueue = [], _createPlugin = function _createPlugin2(config3) {
643  if (!config3)
644    return;
645  config3 = !config3.name && config3["default"] || config3;
646  if (_windowExists$1() || config3.headless) {
647    var name = config3.name, isFunc = _isFunction(config3), Plugin = name && !isFunc && config3.init ? function() {
648      this._props = [];
649    } : config3, instanceDefaults = {
650      init: _emptyFunc,
651      render: _renderPropTweens,
652      add: _addPropTween,
653      kill: _killPropTweensOf,
654      modifier: _addPluginModifier,
655      rawVars: 0
656    }, statics = {
657      targetTest: 0,
658      get: 0,
659      getSetter: _getSetter,
660      aliases: {},
661      register: 0
662    };
663    _wake();
664    if (config3 !== Plugin) {
665      if (_plugins[name]) {
666        return;
667      }
668      _setDefaults(Plugin, _setDefaults(_copyExcluding(config3, instanceDefaults), statics));
669      _merge(Plugin.prototype, _merge(instanceDefaults, _copyExcluding(config3, statics)));
670      _plugins[Plugin.prop = name] = Plugin;
671      if (config3.targetTest) {
672        _harnessPlugins.push(Plugin);
673        _reservedProps[name] = 1;
674      }
675      name = (name === "css" ? "CSS" : name.charAt(0).toUpperCase() + name.substr(1)) + "Plugin";
676    }
677    _addGlobal(name, Plugin);
678    config3.register && config3.register(gsap, Plugin, PropTween);
679  } else {
680    _registerPluginQueue.push(config3);
681  }
682}, _255 = 255, _colorLookup = {
683  aqua: [0, _255, _255],
684  lime: [0, _255, 0],
685  silver: [192, 192, 192],
686  black: [0, 0, 0],
687  maroon: [128, 0, 0],
688  teal: [0, 128, 128],
689  blue: [0, 0, _255],
690  navy: [0, 0, 128],
691  white: [_255, _255, _255],
692  olive: [128, 128, 0],
693  yellow: [_255, _255, 0],
694  orange: [_255, 165, 0],
695  gray: [128, 128, 128],
696  purple: [128, 0, 128],
697  green: [0, 128, 0],
698  red: [_255, 0, 0],
699  pink: [_255, 192, 203],
700  cyan: [0, _255, _255],
701  transparent: [_255, _255, _255, 0]
702}, _hue = function _hue2(h, m1, m2) {
703  h += h < 0 ? 1 : h > 1 ? -1 : 0;
704  return (h * 6 < 1 ? m1 + (m2 - m1) * h * 6 : h < 0.5 ? m2 : h * 3 < 2 ? m1 + (m2 - m1) * (2 / 3 - h) * 6 : m1) * _255 + 0.5 | 0;
705}, splitColor = function splitColor2(v, toHSL, forceAlpha) {
706  var a = !v ? _colorLookup.black : _isNumber(v) ? [v >> 16, v >> 8 & _255, v & _255] : 0, r, g, b, h, s, l, max, min, d, wasHSL;
707  if (!a) {
708    if (v.substr(-1) === ",") {
709      v = v.substr(0, v.length - 1);
710    }
711    if (_colorLookup[v]) {
712      a = _colorLookup[v];
713    } else if (v.charAt(0) === "#") {
714      if (v.length < 6) {
715        r = v.charAt(1);
716        g = v.charAt(2);
717        b = v.charAt(3);
718        v = "#" + r + r + g + g + b + b + (v.length === 5 ? v.charAt(4) + v.charAt(4) : "");
719      }
720      if (v.length === 9) {
721        a = parseInt(v.substr(1, 6), 16);
722        return [a >> 16, a >> 8 & _255, a & _255, parseInt(v.substr(7), 16) / 255];
723      }
724      v = parseInt(v.substr(1), 16);
725      a = [v >> 16, v >> 8 & _255, v & _255];
726    } else if (v.substr(0, 3) === "hsl") {
727      a = wasHSL = v.match(_strictNumExp);
728      if (!toHSL) {
729        h = +a[0] % 360 / 360;
730        s = +a[1] / 100;
731        l = +a[2] / 100;
732        g = l <= 0.5 ? l * (s + 1) : l + s - l * s;
733        r = l * 2 - g;
734        a.length > 3 && (a[3] *= 1);
735        a[0] = _hue(h + 1 / 3, r, g);
736        a[1] = _hue(h, r, g);
737        a[2] = _hue(h - 1 / 3, r, g);
738      } else if (~v.indexOf("=")) {
739        a = v.match(_numExp);
740        forceAlpha && a.length < 4 && (a[3] = 1);
741        return a;
742      }
743    } else {
744      a = v.match(_strictNumExp) || _colorLookup.transparent;
745    }
746    a = a.map(Number);
747  }
748  if (toHSL && !wasHSL) {
749    r = a[0] / _255;
750    g = a[1] / _255;
751    b = a[2] / _255;
752    max = Math.max(r, g, b);
753    min = Math.min(r, g, b);
754    l = (max + min) / 2;
755    if (max === min) {
756      h = s = 0;
757    } else {
758      d = max - min;
759      s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
760      h = max === r ? (g - b) / d + (g < b ? 6 : 0) : max === g ? (b - r) / d + 2 : (r - g) / d + 4;
761      h *= 60;
762    }
763    a[0] = ~~(h + 0.5);
764    a[1] = ~~(s * 100 + 0.5);
765    a[2] = ~~(l * 100 + 0.5);
766  }
767  forceAlpha && a.length < 4 && (a[3] = 1);
768  return a;
769}, _colorOrderData = function _colorOrderData2(v) {
770  var values = [], c = [], i = -1;
771  v.split(_colorExp).forEach(function(v2) {
772    var a = v2.match(_numWithUnitExp) || [];
773    values.push.apply(values, a);
774    c.push(i += a.length + 1);
775  });
776  values.c = c;
777  return values;
778}, _formatColors = function _formatColors2(s, toHSL, orderMatchData) {
779  var result = "", colors = (s + result).match(_colorExp), type = toHSL ? "hsla(" : "rgba(", i = 0, c, shell, d, l;
780  if (!colors) {
781    return s;
782  }
783  colors = colors.map(function(color) {
784    return (color = splitColor(color, toHSL, 1)) && type + (toHSL ? color[0] + "," + color[1] + "%," + color[2] + "%," + color[3] : color.join(",")) + ")";
785  });
786  if (orderMatchData) {
787    d = _colorOrderData(s);
788    c = orderMatchData.c;
789    if (c.join(result) !== d.c.join(result)) {
790      shell = s.replace(_colorExp, "1").split(_numWithUnitExp);
791      l = shell.length - 1;
792      for (; i < l; i++) {
793        result += shell[i] + (~c.indexOf(i) ? colors.shift() || type + "0,0,0,0)" : (d.length ? d : colors.length ? colors : orderMatchData).shift());
794      }
795    }
796  }
797  if (!shell) {
798    shell = s.split(_colorExp);
799    l = shell.length - 1;
800    for (; i < l; i++) {
801      result += shell[i] + colors[i];
802    }
803  }
804  return result + shell[l];
805}, _colorExp = function() {
806  var s = "(?:\\b(?:(?:rgb|rgba|hsl|hsla)\\(.+?\\))|\\B#(?:[0-9a-f]{3,4}){1,2}\\b", p;
807  for (p in _colorLookup) {
808    s += "|" + p + "\\b";
809  }
810  return new RegExp(s + ")", "gi");
811}(), _hslExp = /hsl[a]?\(/, _colorStringFilter = function _colorStringFilter2(a) {
812  var combined = a.join(" "), toHSL;
813  _colorExp.lastIndex = 0;
814  if (_colorExp.test(combined)) {
815    toHSL = _hslExp.test(combined);
816    a[1] = _formatColors(a[1], toHSL);
817    a[0] = _formatColors(a[0], toHSL, _colorOrderData(a[1]));
818    return true;
819  }
820}, _tickerActive, _ticker = function() {
821  var _getTime = Date.now, _lagThreshold = 500, _adjustedLag = 33, _startTime = _getTime(), _lastUpdate = _startTime, _gap = 1e3 / 240, _nextTime = _gap, _listeners2 = [], _id, _req, _raf, _self, _delta, _i, _tick = function _tick2(v) {
822    var elapsed = _getTime() - _lastUpdate, manual = v === true, overlap, dispatch, time, frame;
823    (elapsed > _lagThreshold || elapsed < 0) && (_startTime += elapsed - _adjustedLag);
824    _lastUpdate += elapsed;
825    time = _lastUpdate - _startTime;
826    overlap = time - _nextTime;
827    if (overlap > 0 || manual) {
828      frame = ++_self.frame;
829      _delta = time - _self.time * 1e3;
830      _self.time = time = time / 1e3;
831      _nextTime += overlap + (overlap >= _gap ? 4 : _gap - overlap);
832      dispatch = 1;
833    }
834    manual || (_id = _req(_tick2));
835    if (dispatch) {
836      for (_i = 0; _i < _listeners2.length; _i++) {
837        _listeners2[_i](time, _delta, frame, v);
838      }
839    }
840  };
841  _self = {
842    time: 0,
843    frame: 0,
844    tick: function tick() {
845      _tick(true);
846    },
847    deltaRatio: function deltaRatio(fps) {
848      return _delta / (1e3 / (fps || 60));
849    },
850    wake: function wake() {
851      if (_coreReady) {
852        if (!_coreInitted && _windowExists$1()) {

853          _win$1 = _coreInitted = window;
854          _doc$1 = _win$1.document || {};
855          _globals.gsap = gsap;
856          (_win$1.gsapVersions || (_win$1.gsapVersions = [])).push(gsap.version);
857          _install(_installScope || _win$1.GreenSockGlobals || !_win$1.gsap && _win$1 || {});
858          _registerPluginQueue.forEach(_createPlugin);
859        }
860        _raf = typeof requestAnimationFrame !== "undefined" && requestAnimationFrame;
861        _id && _self.sleep();
862        _req = _raf || function(f) {
863          return setTimeout(f, _nextTime - _self.time * 1e3 + 1 | 0);
864        };
865        _tickerActive = 1;
866        _tick(2);
867      }
868    },
869    sleep: function sleep() {
870      (_raf ? cancelAnimationFrame : clearTimeout)(_id);
871      _tickerActive = 0;
872      _req = _emptyFunc;
873    },
874    lagSmoothing: function lagSmoothing(threshold, adjustedLag) {
875      _lagThreshold = threshold || Infinity;
876      _adjustedLag = Math.min(adjustedLag || 33, _lagThreshold);
877    },
878    fps: function fps(_fps) {
879      _gap = 1e3 / (_fps || 240);
880      _nextTime = _self.time * 1e3 + _gap;
881    },
882    add: function add(callback, once, prioritize) {
883      var func = once ? function(t, d, f, v) {
884        callback(t, d, f, v);
885        _self.remove(func);
886      } : callback;
887      _self.remove(callback);
888      _listeners2[prioritize ? "unshift" : "push"](func);
889      _wake();
890      return func;
891    },
892    remove: function remove(callback, i) {
893      ~(i = _listeners2.indexOf(callback)) && _listeners2.splice(i, 1) && _i >= i && _i--;
894    },
895    _listeners: _listeners2
896  };
897  return _self;
898}(), _wake = function _wake2() {
899  return !_tickerActive && _ticker.wake();
900}, _easeMap = {}, _customEaseExp = /^[\d.\-M][\d.\-,\s]/, _quotesExp = /["']/g, _parseObjectInString = function _parseObjectInString2(value) {
901  var obj = {}, split = value.substr(1, value.length - 3).split(":"), key = split[0], i = 1, l = split.length, index, val, parsedVal;
902  for (; i < l; i++) {
903    val = split[i];
904    index = i !== l - 1 ? val.lastIndexOf(",") : val.length;
905    parsedVal = val.substr(0, index);
906    obj[key] = isNaN(parsedVal) ? parsedVal.replace(_quotesExp, "").trim() : +parsedVal;
907    key = val.substr(index + 1).trim();
908  }
909  return obj;
910}, _valueInParentheses = function _valueInParentheses2(value) {
911  var open = value.indexOf("(") + 1, close = value.indexOf(")"), nested = value.indexOf("(", open);
912  return value.substring(open, ~nested && nested < close ? value.indexOf(")", close + 1) : close);
913}, _configEaseFromString = function _configEaseFromString2(name) {
914  var split = (name + "").split("("), ease = _easeMap[split[0]];
915  return ease && split.length > 1 && ease.config ? ease.config.apply(null, ~name.indexOf("{") ? [_parseObjectInString(split[1])] : _valueInParentheses(name).split(",").map(_numericIfPossible)) : _easeMap._CE && _customEaseExp.test(name) ? _easeMap._CE("", name) : ease;
916}, _invertEase = function _invertEase2(ease) {
917  return function(p) {
918    return 1 - ease(1 - p);
919  };
920}, _propagateYoyoEase = function _propagateYoyoEase2(timeline2, isYoyo) {
921  var child = timeline2._first, ease;
922  while (child) {
923    if (child instanceof Timeline) {
924      _propagateYoyoEase2(child, isYoyo);
925    } else if (child.vars.yoyoEase && (!child._yoyo || !child._repeat) && child._yoyo !== isYoyo) {
926      if (child.timeline) {
927        _propagateYoyoEase2(child.timeline, isYoyo);
928      } else {
929        ease = child._ease;
930        child._ease = child._yEase;
931        child._yEase = ease;
932        child._yoyo = isYoyo;
933      }
934    }
935    child = child._next;
936  }
937}, _parseEase = function _parseEase2(ease, defaultEase) {
938  return !ease ? defaultEase : (_isFunction(ease) ? ease : _easeMap[ease] || _configEaseFromString(ease)) || defaultEase;
939}, _insertEase = function _insertEase2(names, easeIn, easeOut, easeInOut) {
940  if (easeOut === void 0) {
941    easeOut = function easeOut2(p) {
942      return 1 - easeIn(1 - p);
943    };
944  }
945  if (easeInOut === void 0) {
946    easeInOut = function easeInOut2(p) {
947      return p < 0.5 ? easeIn(p * 2) / 2 : 1 - easeIn((1 - p) * 2) / 2;
948    };
949  }
950  var ease = {
951    easeIn,
952    easeOut,
953    easeInOut
954  }, lowercaseName;

955  _forEachName(names, function(name) {
956    _easeMap[name] = _globals[name] = ease;
957    _easeMap[lowercaseName = name.toLowerCase()] = easeOut;
958    for (var p in ease) {
959      _easeMap[lowercaseName + (p === "easeIn" ? ".in" : p === "easeOut" ? ".out" : ".inOut")] = _easeMap[name + "." + p] = ease[p];
960    }
961  });
962  return ease;
963}, _easeInOutFromOut = function _easeInOutFromOut2(easeOut) {
964  return function(p) {
965    return p < 0.5 ? (1 - easeOut(1 - p * 2)) / 2 : 0.5 + easeOut((p - 0.5) * 2) / 2;
966  };
967}, _configElastic = function _configElastic2(type, amplitude, period) {
968  var p1 = amplitude >= 1 ? amplitude : 1, p2 = (period || (type ? 0.3 : 0.45)) / (amplitude < 1 ? amplitude : 1), p3 = p2 / _2PI * (Math.asin(1 / p1) || 0), easeOut = function easeOut2(p) {
969    return p === 1 ? 1 : p1 * Math.pow(2, -10 * p) * _sin((p - p3) * p2) + 1;
970  }, ease = type === "out" ? easeOut : type === "in" ? function(p) {
971    return 1 - easeOut(1 - p);
972  } : _easeInOutFromOut(easeOut);
973  p2 = _2PI / p2;
974  ease.config = function(amplitude2, period2) {
975    return _configElastic2(type, amplitude2, period2);
976  };
977  return ease;
978}, _configBack = function _configBack2(type, overshoot) {
979  if (overshoot === void 0) {
980    overshoot = 1.70158;
981  }
982  var easeOut = function easeOut2(p) {
983    return p ? --p * p * ((overshoot + 1) * p + overshoot) + 1 : 0;
984  }, ease = type === "out" ? easeOut : type === "in" ? function(p) {
985    return 1 - easeOut(1 - p);
986  } : _easeInOutFromOut(easeOut);
987  ease.config = function(overshoot2) {
988    return _configBack2(type, overshoot2);
989  };
990  return ease;
991};
992_forEachName("Linear,Quad,Cubic,Quart,Quint,Strong", function(name, i) {
993  var power = i < 5 ? i + 1 : i;
994  _insertEase(name + ",Power" + (power - 1), i ? function(p) {
995    return Math.pow(p, power);
996  } : function(p) {
997    return p;
998  }, function(p) {
999    return 1 - Math.pow(1 - p, power);
1000  }, function(p) {
1001    return p < 0.5 ? Math.pow(p * 2, power) / 2 : 1 - Math.pow((1 - p) * 2, power) / 2;
1002  });
1003});
1004_easeMap.Linear.easeNone = _easeMap.none = _easeMap.Linear.easeIn;
1005_insertEase("Elastic", _configElastic("in"), _configElastic("out"), _configElastic());
1006(function(n, c) {
1007  var n1 = 1 / c, n2 = 2 * n1, n3 = 2.5 * n1, easeOut = function easeOut2(p) {
1008    return p < n1 ? n * p * p : p < n2 ? n * Math.pow(p - 1.5 / c, 2) + 0.75 : p < n3 ? n * (p -= 2.25 / c) * p + 0.9375 : n * Math.pow(p - 2.625 / c, 2) + 0.984375;
1009  };
1010  _insertEase("Bounce", function(p) {
1011    return 1 - easeOut(1 - p);
1012  }, easeOut);
1013})(7.5625, 2.75);
1014_insertEase("Expo", function(p) {
1015  return p ? Math.pow(2, 10 * (p - 1)) : 0;
1016});
1017_insertEase("Circ", function(p) {
1018  return -(_sqrt(1 - p * p) - 1);
1019});
1020_insertEase("Sine", function(p) {
1021  return p === 1 ? 1 : -_cos(p * _HALF_PI) + 1;
1022});
1023_insertEase("Back", _configBack("in"), _configBack("out"), _configBack());
1024_easeMap.SteppedEase = _easeMap.steps = _globals.SteppedEase = {
1025  config: function config(steps, immediateStart) {
1026    if (steps === void 0) {
1027      steps = 1;
1028    }
1029    var p1 = 1 / steps, p2 = steps + (immediateStart ? 0 : 1), p3 = immediateStart ? 1 : 0, max = 1 - _tinyNum;
1030    return function(p) {
1031      return ((p2 * _clamp(0, max, p) | 0) + p3) * p1;
1032    };
1033  }
1034};
1035_defaults.ease = _easeMap["quad.out"];
1036_forEachName("onComplete,onUpdate,onStart,onRepeat,onReverseComplete,onInterrupt", function(name) {
1037  return _callbackNames += name + "," + name + "Params,";
1038});
1039var GSCache = function GSCache2(target, harness) {
1040  this.id = _gsID++;
1041  target._gsap = this;
1042  this.target = target;
1043  this.harness = harness;
1044  this.get = harness ? harness.get : _getProperty;
1045  this.set = harness ? harness.getSetter : _getSetter;
1046};
1047var Animation = /* @__PURE__ */ function() {
1048  function Animation2(vars) {
1049    this.vars = vars;
1050    this._delay = +vars.delay || 0;
1051    if (this._repeat = vars.repeat === Infinity ? -2 : vars.repeat || 0) {
1052      this._rDelay = vars.repeatDelay || 0;
1053      this._yoyo = !!vars.yoyo || !!vars.yoyoEase;
1054    }
1055    this._ts = 1;
1056    _setDuration(this, +vars.duration, 1, 1);
1057    this.data = vars.data;
1058    if (_context) {
1059      this._ctx = _context;
1060      _context.data.push(this);
1061    }
1062    _tickerActive || _ticker.wake();
1063  }
1064  var _proto = Animation2.prototype;
1065  _proto.delay = function delay2(value) {
1066    if (value || value === 0) {
1067      this.parent && this.parent.smoothChildTiming && this.startTime(this._start + value - this._delay);

1068      this._delay = value;
1069      return this;
1070    }
1071    return this._delay;
1072  };
1073  _proto.duration = function duration(value) {
1074    return arguments.length ? this.totalDuration(this._repeat > 0 ? value + (value + this._rDelay) * this._repeat : value) : this.totalDuration() && this._dur;
1075  };
1076  _proto.totalDuration = function totalDuration(value) {
1077    if (!arguments.length) {
1078      return this._tDur;
1079    }
1080    this._dirty = 0;
1081    return _setDuration(this, this._repeat < 0 ? value : (value - this._repeat * this._rDelay) / (this._repeat + 1));
1082  };
1083  _proto.totalTime = function totalTime(_totalTime, suppressEvents) {
1084    _wake();
1085    if (!arguments.length) {
1086      return this._tTime;
1087    }
1088    var parent = this._dp;
1089    if (parent && parent.smoothChildTiming && this._ts) {
1090      _alignPlayhead(this, _totalTime);
1091      !parent._dp || parent.parent || _postAddChecks(parent, this);
1092      while (parent && parent.parent) {
1093        if (parent.parent._time !== parent._start + (parent._ts >= 0 ? parent._tTime / parent._ts : (parent.totalDuration() - parent._tTime) / -parent._ts)) {
1094          parent.totalTime(parent._tTime, true);
1095        }
1096        parent = parent.parent;
1097      }
1098      if (!this.parent && this._dp.autoRemoveChildren && (this._ts > 0 && _totalTime < this._tDur || this._ts < 0 && _totalTime > 0 || !this._tDur && !_totalTime)) {
1099        _addToTimeline(this._dp, this, this._start - this._delay);
1100      }
1101    }
1102    if (this._tTime !== _totalTime || !this._dur && !suppressEvents || this._initted && Math.abs(this._zTime) === _tinyNum || !_totalTime && !this._initted && (this.add || this._ptLookup)) {
1103      this._ts || (this._pTime = _totalTime);
1104      _lazySafeRender(this, _totalTime, suppressEvents);
1105    }
1106    return this;
1107  };
1108  _proto.time = function time(value, suppressEvents) {
1109    return arguments.length ? this.totalTime(Math.min(this.totalDuration(), value + _elapsedCycleDuration(this)) % (this._dur + this._rDelay) || (value ? this._dur : 0), suppressEvents) : this._time;
1110  };
1111  _proto.totalProgress = function totalProgress(value, suppressEvents) {
1112    return arguments.length ? this.totalTime(this.totalDuration() * value, suppressEvents) : this.totalDuration() ? Math.min(1, this._tTime / this._tDur) : this.rawTime() > 0 ? 1 : 0;
1113  };
1114  _proto.progress = function progress(value, suppressEvents) {
1115    return arguments.length ? this.totalTime(this.duration() * (this._yoyo && !(this.iteration() & 1) ? 1 - value : value) + _elapsedCycleDuration(this), suppressEvents) : this.duration() ? Math.min(1, this._time / this._dur) : this.rawTime() > 0 ? 1 : 0;
1116  };
1117  _proto.iteration = function iteration(value, suppressEvents) {
1118    var cycleDuration = this.duration() + this._rDelay;
1119    return arguments.length ? this.totalTime(this._time + (value - 1) * cycleDuration, suppressEvents) : this._repeat ? _animationCycle(this._tTime, cycleDuration) + 1 : 1;
1120  };
1121  _proto.timeScale = function timeScale(value, suppressEvents) {
1122    if (!arguments.length) {
1123      return this._rts === -_tinyNum ? 0 : this._rts;
1124    }
1125    if (this._rts === value) {
1126      return this;
1127    }
1128    var tTime = this.parent && this._ts ? _parentToChildTotalTime(this.parent._time, this) : this._tTime;
1129    this._rts = +value || 0;
1130    this._ts = this._ps || value === -_tinyNum ? 0 : this._rts;
1131    this.totalTime(_clamp(-Math.abs(this._delay), this._tDur, tTime), suppressEvents !== false);
1132    _setEnd(this);
1133    return _recacheAncestors(this);
1134  };
1135  _proto.paused = function paused(value) {
1136    if (!arguments.length) {
1137      return this._ps;
1138    }
1139    if (this._ps !== value) {
1140      this._ps = value;
1141      if (value) {
1142        this._pTime = this._tTime || Math.max(-this._delay, this.rawTime());
1143        this._ts = this._act = 0;
1144      } else {
1145        _wake();
1146        this._ts = this._rts;
1147        this.totalTime(this.parent && !this.parent.smoothChildTiming ? this.rawTime() : this._tTime || this._pTime, this.progress() === 1 && Math.abs(this._zTime) !== _tinyNum && (this._tTime -= _tinyNum));
1148      }
1149    }
1150    return this;
1151  };
1152  _proto.startTime = function startTime(value) {
1153    if (arguments.length) {
1154      this._start = value;
1155      var parent = this.parent || this._dp;
1156      parent && (parent._sort || !this.parent) && _addToTimeline(parent, this, value - this._delay);
1157      return this;
1158    }
1159    return this._start;
1160  };
1161  _proto.endTime = function endTime(includeRepeats) {
1162    return this._start + (_isNotFalse(includeRepeats) ? this.totalDuration() : this.duration()) / Math.abs(this._ts || 1);
1163  };
1164  _proto.rawTime = function rawTime(wrapRepeats) {
1165    var parent = this.parent || this._dp;
1166    return !parent ? this._tTime : wrapRepeats && (!this._ts || this._repeat && this._time && this.totalProgress() < 1) ? this._tTime % (this._dur + this._rDelay) : !this._ts ? this._tTime : _parentToChildTotalTime(parent.rawTime(wrapRepeats), this);
1167  };
1168  _proto.revert = function revert(config3) {
1169    if (config3 === void 0) {
1170      config3 = _revertConfig;
1171    }
1172    var prevIsReverting = _reverting$1;
1173    _reverting$1 = config3;
1174    if (this._initted || this._startAt) {
1175      this.timeline && this.timeline.revert(config3);
1176      this.totalTime(-0.01, config3.suppressEvents);
1177    }
1178    this.data !== "nested" && config3.kill !== false && this.kill();
1179    _reverting$1 = prevIsReverting;
1180    return this;
1181  };
1182  _proto.globalTime = function globalTime(rawTime) {
1183    var animation = this, time = arguments.length ? rawTime : animation.rawTime();
1184    while (animation) {
1185      time = animation._start + time / (Math.abs(animation._ts) || 1);
1186      animation = animation._dp;
1187    }
1188    return !this.parent && this._sat ? this._sat.globalTime(rawTime) : time;
1189  };
1190  _proto.repeat = function repeat(value) {
1191    if (arguments.length) {
1192      this._repeat = value === Infinity ? -2 : value;
1193      return _onUpdateTotalDuration(this);
1194    }
1195    return this._repeat === -2 ? Infinity : this._repeat;
1196  };
1197  _proto.repeatDelay = function repeatDelay(value) {
1198    if (arguments.length) {
1199      var time = this._time;
1200      this._rDelay = value;
1201      _onUpdateTotalDuration(this);
1202      return time ? this.time(time) : this;
1203    }
1204    return this._rDelay;
1205  };
1206  _proto.yoyo = function yoyo(value) {
1207    if (arguments.length) {
1208      this._yoyo = value;
1209      return this;
1210    }
1211    return this._yoyo;
1212  };
1213  _proto.seek = function seek(position, suppressEvents) {
1214    return this.totalTime(_parsePosition(this, position), _isNotFalse(suppressEvents));
1215  };
1216  _proto.restart = function restart(includeDelay, suppressEvents) {
1217    return this.play().totalTime(includeDelay ? -this._delay : 0, _isNotFalse(suppressEvents));
1218  };
1219  _proto.play = function play(from, suppressEvents) {
1220    from != null && this.seek(from, suppressEvents);
1221    return this.reversed(false).paused(false);
1222  };
1223  _proto.reverse = function reverse(from, suppressEvents) {
1224    from != null && this.seek(from || this.totalDuration(), suppressEvents);
1225    return this.reversed(true).paused(false);
1226  };
1227  _proto.pause = function pause(atTime, suppressEvents) {
1228    atTime != null && this.seek(atTime, suppressEvents);
1229    return this.paused(true);
1230  };
1231  _proto.resume = function resume() {
1232    return this.paused(false);
1233  };
1234  _proto.reversed = function reversed(value) {
1235    if (arguments.length) {
1236      !!value !== this.reversed() && this.timeScale(-this._rts || (value ? -_tinyNum : 0));
1237      return this;
1238    }
1239    return this._rts < 0;
1240  };
1241  _proto.invalidate = function invalidate() {
1242    this._initted = this._act = 0;
1243    this._zTime = -_tinyNum;
1244    return this;
1245  };
1246  _proto.isActive = function isActive() {
1247    var parent = this.parent || this._dp, start = this._start, rawTime;
1248    return !!(!parent || this._ts && this._initted && parent.isActive() && (rawTime = parent.rawTime(true)) >= start && rawTime < this.endTime(true) - _tinyNum);
1249  };
1250  _proto.eventCallback = function eventCallback(type, callback, params) {
1251    var vars = this.vars;
1252    if (arguments.length > 1) {
1253      if (!callback) {
1254        delete vars[type];
1255      } else {
1256        vars[type] = callback;
1257        params && (vars[type + "Params"] = params);
1258        type === "onUpdate" && (this._onUpdate = callback);
1259      }
1260      return this;
1261    }
1262    return vars[type];
1263  };
1264  _proto.then = function then(onFulfilled) {
1265    var self = this;
1266    return new Promise(function(resolve) {
1267      var f = _isFunction(onFulfilled) ? onFulfilled : _passThrough, _resolve = function _resolve2() {
1268        var _then = self.then;
1269        self.then = null;
1270        _isFunction(f) && (f = f(self)) && (f.then || f === self) && (self.then = _then);
1271        resolve(f);
1272        self.then = _then;
1273      };
1274      if (self._initted && self.totalProgress() === 1 && self._ts >= 0 || !self._tTime && self._ts < 0) {
1275        _resolve();
1276      } else {
1277        self._prom = _resolve;
1278      }
1279    });
1280  };
1281  _proto.kill = function kill() {
1282    _interrupt(this);
1283  };
1284  return Animation2;
1285}();
1286_setDefaults(Animation.prototype, {
1287  _time: 0,
1288  _start: 0,
1289  _end: 0,
1290  _tTime: 0,
1291  _tDur: 0,
1292  _dirty: 0,
1293  _repeat: 0,
1294  _yoyo: false,
1295  parent: null,
1296  _initted: false,
1297  _rDelay: 0,
1298  _ts: 1,
1299  _dp: 0,
1300  ratio: 0,
1301  _zTime: -_tinyNum,
1302  _prom: 0,
1303  _ps: false,
1304  _rts: 1
1305});
1306var Timeline = /* @__PURE__ */ function(_Animation) {
1307  _inheritsLoose(Timeline2, _Animation);
1308  function Timeline2(vars, position) {
1309    var _this;
1310    if (vars === void 0) {
1311      vars = {};
1312    }
1313    _this = _Animation.call(this, vars) || this;
1314    _this.labels = {};
1315    _this.smoothChildTiming = !!vars.smoothChildTiming;
1316    _this.autoRemoveChildren = !!vars.autoRemoveChildren;
1317    _this._sort = _isNotFalse(vars.sortChildren);
1318    _globalTimeline && _addToTimeline(vars.parent || _globalTimeline, _assertThisInitialized(_this), position);
1319    vars.reversed && _this.reverse();
1320    vars.paused && _this.paused(true);
1321    vars.scrollTrigger && _scrollTrigger(_assertThisInitialized(_this), vars.scrollTrigger);
1322    return _this;
1323  }
1324  var _proto2 = Timeline2.prototype;
1325  _proto2.to = function to(targets, vars, position) {
1326    _createTweenType(0, arguments, this);
1327    return this;
1328  };
1329  _proto2.from = function from(targets, vars, position) {
1330    _createTweenType(1, arguments, this);
1331    return this;
1332  };
1333  _proto2.fromTo = function fromTo(targets, fromVars, toVars, position) {
1334    _createTweenType(2, arguments, this);
1335    return this;
1336  };
1337  _proto2.set = function set(targets, vars, position) {
1338    vars.duration = 0;
1339    vars.parent = this;
1340    _inheritDefaults(vars).repeatDelay || (vars.repeat = 0);
1341    vars.immediateRender = !!vars.immediateRender;
1342    new Tween(targets, vars, _parsePosition(this, position), 1);
1343    return this;
1344  };
1345  _proto2.call = function call(callback, params, position) {
1346    return _addToTimeline(this, Tween.delayedCall(0, callback, params), position);
1347  };
1348  _proto2.staggerTo = function staggerTo(targets, duration, vars, stagger, position, onCompleteAll, onCompleteAllParams) {
1349    vars.duration = duration;
1350    vars.stagger = vars.stagger || stagger;
1351    vars.onComplete = onCompleteAll;
1352    vars.onCompleteParams = onCompleteAllParams;
1353    vars.parent = this;
1354    new Tween(targets, vars, _parsePosition(this, position));
1355    return this;
1356  };
1357  _proto2.staggerFrom = function staggerFrom(targets, duration, vars, stagger, position, onCompleteAll, onCompleteAllParams) {
1358    vars.runBackwards = 1;
1359    _inheritDefaults(vars).immediateRender = _isNotFalse(vars.immediateRender);
1360    return this.staggerTo(targets, duration, vars, stagger, position, onCompleteAll, onCompleteAllParams);
1361  };
1362  _proto2.staggerFromTo = function staggerFromTo(targets, duration, fromVars, toVars, stagger, position, onCompleteAll, onCompleteAllParams) {
1363    toVars.startAt = fromVars;
1364    _inheritDefaults(toVars).immediateRender = _isNotFalse(toVars.immediateRender);
1365    return this.staggerTo(targets, duration, toVars, stagger, position, onCompleteAll, onCompleteAllParams);
1366  };
1367  _proto2.render = function render3(totalTime, suppressEvents, force) {
1368    var prevTime = this._time, tDur = this._dirty ? this.totalDuration() : this._tDur, dur = this._dur, tTime = totalTime <= 0 ? 0 : _roundPrecise(totalTime), crossingStart = this._zTime < 0 !== totalTime < 0 && (this._initted || !dur), time, child, next, iteration, cycleDuration, prevPaused, pauseTween, timeScale, prevStart, prevIteration, yoyo, isYoyo;
1369    this !== _globalTimeline && tTime > tDur && totalTime >= 0 && (tTime = tDur);
1370    if (tTime !== this._tTime || force || crossingStart) {
1371      if (prevTime !== this._time && dur) {
1372        tTime += this._time - prevTime;
1373        totalTime += this._time - prevTime;
1374      }
1375      time = tTime;
1376      prevStart = this._start;
1377      timeScale = this._ts;
1378      prevPaused = !timeScale;
1379      if (crossingStart) {
1380        dur || (prevTime = this._zTime);
1381        (totalTime || !suppressEvents) && (this._zTime = totalTime);
1382      }
1383      if (this._repeat) {
1384        yoyo = this._yoyo;
1385        cycleDuration = dur + this._rDelay;
1386        if (this._repeat < -1 && totalTime < 0) {
1387          return this.totalTime(cycleDuration * 100 + totalTime, suppressEvents, force);
1388        }
1389        time = _roundPrecise(tTime % cycleDuration);
1390        if (tTime === tDur) {
1391          iteration = this._repeat;
1392          time = dur;
1393        } else {
1394          iteration = ~~(tTime / cycleDuration);
1395          if (iteration && iteration === tTime / cycleDuration) {
1396            time = dur;
1397            iteration--;
1398          }
1399          time > dur && (time = dur);
1400        }
1401        prevIteration = _animationCycle(this._tTime, cycleDuration);
1402        !prevTime && this._tTime && prevIteration !== iteration && this._tTime - prevIteration * cycleDuration - this._dur <= 0 && (prevIteration = iteration);
1403        if (yoyo && iteration & 1) {
1404          time = dur - time;
1405          isYoyo = 1;
1406        }
1407        if (iteration !== prevIteration && !this._lock) {
1408          var rewinding = yoyo && prevIteration & 1, doesWrap = rewinding === (yoyo && iteration & 1);
1409          iteration < prevIteration && (rewinding = !rewinding);
1410          prevTime = rewinding ? 0 : tTime % dur ? dur : tTime;
1411          this._lock = 1;
1412          this.render(prevTime || (isYoyo ? 0 : _roundPrecise(iteration * cycleDuration)), suppressEvents, !dur)._lock = 0;
1413          this._tTime = tTime;
1414          !suppressEvents && this.parent && _callback(this, "onRepeat");
1415          this.vars.repeatRefresh && !isYoyo && (this.invalidate()._lock = 1);
1416          if (prevTime && prevTime !== this._time || prevPaused !== !this._ts || this.vars.onRepeat && !this.parent && !this._act) {
1417            return this;
1418          }
1419          dur = this._dur;
1420          tDur = this._tDur;
1421          if (doesWrap) {
1422            this._lock = 2;
1423            prevTime = rewinding ? dur : -1e-4;
1424            this.render(prevTime, true);
1425            this.vars.repeatRefresh && !isYoyo && this.invalidate();
1426          }
1427          this._lock = 0;
1428          if (!this._ts && !prevPaused) {
1429            return this;
1430          }
1431          _propagateYoyoEase(this, isYoyo);
1432        }
1433      }
1434      if (this._hasPause && !this._forcing && this._lock < 2) {
1435        pauseTween = _findNextPauseTween(this, _roundPrecise(prevTime), _roundPrecise(time));
1436        if (pauseTween) {
1437          tTime -= time - (time = pauseTween._start);
1438        }
1439      }
1440      this._tTime = tTime;
1441      this._time = time;
1442      this._act = !timeScale;
1443      if (!this._initted) {

1444        this._onUpdate = this.vars.onUpdate;
1445        this._initted = 1;
1446        this._zTime = totalTime;
1447        prevTime = 0;
1448      }
1449      if (!prevTime && time && !suppressEvents && !iteration) {
1450        _callback(this, "onStart");
1451        if (this._tTime !== tTime) {
1452          return this;
1453        }
1454      }
1455      if (time >= prevTime && totalTime >= 0) {
1456        child = this._first;
1457        while (child) {
1458          next = child._next;
1459          if ((child._act || time >= child._start) && child._ts && pauseTween !== child) {
1460            if (child.parent !== this) {
1461              return this.render(totalTime, suppressEvents, force);
1462            }
1463            child.render(child._ts > 0 ? (time - child._start) * child._ts : (child._dirty ? child.totalDuration() : child._tDur) + (time - child._start) * child._ts, suppressEvents, force);
1464            if (time !== this._time || !this._ts && !prevPaused) {
1465              pauseTween = 0;
1466              next && (tTime += this._zTime = -_tinyNum);
1467              break;
1468            }
1469          }
1470          child = next;
1471        }
1472      } else {
1473        child = this._last;
1474        var adjustedTime = totalTime < 0 ? totalTime : time;
1475        while (child) {
1476          next = child._prev;
1477          if ((child._act || adjustedTime <= child._end) && child._ts && pauseTween !== child) {
1478            if (child.parent !== this) {
1479              return this.render(totalTime, suppressEvents, force);
1480            }
1481            child.render(child._ts > 0 ? (adjustedTime - child._start) * child._ts : (child._dirty ? child.totalDuration() : child._tDur) + (adjustedTime - child._start) * child._ts, suppressEvents, force || _reverting$1 && (child._initted || child._startAt));
1482            if (time !== this._time || !this._ts && !prevPaused) {
1483              pauseTween = 0;
1484              next && (tTime += this._zTime = adjustedTime ? -_tinyNum : _tinyNum);
1485              break;
1486            }
1487          }
1488          child = next;
1489        }
1490      }
1491      if (pauseTween && !suppressEvents) {
1492        this.pause();
1493        pauseTween.render(time >= prevTime ? 0 : -_tinyNum)._zTime = time >= prevTime ? 1 : -1;
1494        if (this._ts) {
1495          this._start = prevStart;
1496          _setEnd(this);
1497          return this.render(totalTime, suppressEvents, force);
1498        }
1499      }

1500      this._onUpdate && !suppressEvents && _callback(this, "onUpdate", true);
1501      if (tTime === tDur && this._tTime >= this.totalDuration() || !tTime && prevTime) {
1502        if (prevStart === this._start || Math.abs(timeScale) !== Math.abs(this._ts)) {
1503          if (!this._lock) {
1504            (totalTime || !dur) && (tTime === tDur && this._ts > 0 || !tTime && this._ts < 0) && _removeFromParent(this, 1);
1505            if (!suppressEvents && !(totalTime < 0 && !prevTime) && (tTime || prevTime || !tDur)) {
1506              _callback(this, tTime === tDur && totalTime >= 0 ? "onComplete" : "onReverseComplete", true);
1507              this._prom && !(tTime < tDur && this.timeScale() > 0) && this._prom();
1508            }
1509          }
1510        }
1511      }
1512    }
1513    return this;
1514  };
1515  _proto2.add = function add(child, position) {
1516    var _this2 = this;
1517    _isNumber(position) || (position = _parsePosition(this, position, child));
1518    if (!(child instanceof Animation)) {
1519      if (_isArray(child)) {
1520        child.forEach(function(obj) {
1521          return _this2.add(obj, position);
1522        });
1523        return this;
1524      }
1525      if (_isString(child)) {
1526        return this.addLabel(child, position);
1527      }
1528      if (_isFunction(child)) {
1529        child = Tween.delayedCall(0, child);
1530      } else {
1531        return this;
1532      }
1533    }
1534    return this !== child ? _addToTimeline(this, child, position) : this;
1535  };
1536  _proto2.getChildren = function getChildren(nested, tweens, timelines, ignoreBeforeTime) {
1537    if (nested === void 0) {
1538      nested = true;
1539    }
1540    if (tweens === void 0) {
1541      tweens = true;
1542    }
1543    if (timelines === void 0) {
1544      timelines = true;
1545    }
1546    if (ignoreBeforeTime === void 0) {
1547      ignoreBeforeTime = -_bigNum$1;
1548    }
1549    var a = [], child = this._first;
1550    while (child) {
1551      if (child._start >= ignoreBeforeTime) {
1552        if (child instanceof Tween) {
1553          tweens && a.push(child);
1554        } else {
1555          timelines && a.push(child);
1556          nested && a.push.apply(a, child.getChildren(true, tweens, timelines));
1557        }
1558      }
1559      child = child._next;
1560    }
1561    return a;
1562  };
1563  _proto2.getById = function getById2(id) {
1564    var animations = this.getChildren(1, 1, 1), i = animations.length;
1565    while (i--) {
1566      if (animations[i].vars.id === id) {
1567        return animations[i];
1568      }
1569    }
1570  };
1571  _proto2.remove = function remove(child) {
1572    if (_isString(child)) {
1573      return this.removeLabel(child);
1574    }
1575    if (_isFunction(child)) {
1576      return this.killTweensOf(child);
1577    }
1578    _removeLinkedListItem(this, child);
1579    if (child === this._recent) {
1580      this._recent = this._last;
1581    }
1582    return _uncache(this);
1583  };
1584  _proto2.totalTime = function totalTime(_totalTime2, suppressEvents) {
1585    if (!arguments.length) {
1586      return this._tTime;
1587    }
1588    this._forcing = 1;
1589    if (!this._dp && this._ts) {
1590      this._start = _roundPrecise(_ticker.time - (this._ts > 0 ? _totalTime2 / this._ts : (this.totalDuration() - _totalTime2) / -this._ts));
1591    }
1592    _Animation.prototype.totalTime.call(this, _totalTime2, suppressEvents);
1593    this._forcing = 0;
1594    return this;
1595  };
1596  _proto2.addLabel = function addLabel(label, position) {
1597    this.labels[label] = _parsePosition(this, position);
1598    return this;
1599  };
1600  _proto2.removeLabel = function removeLabel(label) {
1601    delete this.labels[label];
1602    return this;
1603  };
1604  _proto2.addPause = function addPause(position, callback, params) {
1605    var t = Tween.delayedCall(0, callback || _emptyFunc, params);
1606    t.data = "isPause";
1607    this._hasPause = 1;
1608    return _addToTimeline(this, t, _parsePosition(this, position));
1609  };
1610  _proto2.removePause = function removePause(position) {
1611    var child = this._first;
1612    position = _parsePosition(this, position);
1613    while (child) {
1614      if (child._start === position && child.data === "isPause") {
1615        _removeFromParent(child);
1616      }
1617      child = child._next;
1618    }
1619  };
1620  _proto2.killTweensOf = function killTweensOf(targets, props, onlyActive) {
1621    var tweens = this.getTweensOf(targets, onlyActive), i = tweens.length;
1622    while (i--) {
1623      _overwritingTween !== tweens[i] && tweens[i].kill(targets, props);
1624    }
1625    return this;
1626  };
1627  _proto2.getTweensOf = function getTweensOf2(targets, onlyActive) {
1628    var a = [], parsedTargets = toArray(targets), child = this._first, isGlobalTime = _isNumber(onlyActive), children;
1629    while (child) {
1630      if (child instanceof Tween) {
1631        if (_arrayContainsAny(child._targets, parsedTargets) && (isGlobalTime ? (!_overwritingTween || child._initted && child._ts) && child.globalTime(0) <= onlyActive && child.globalTime(child.totalDuration()) > onlyActive : !onlyActive || child.isActive())) {
1632          a.push(child);
1633        }
1634      } else if ((children = child.getTweensOf(parsedTargets, onlyActive)).length) {
1635        a.push.apply(a, children);
1636      }
1637      child = child._next;
1638    }
1639    return a;
1640  };
1641  _proto2.tweenTo = function tweenTo(position, vars) {
1642    vars = vars || {};
1643    var tl = this, endTime = _parsePosition(tl, position), _vars = vars, startAt = _vars.startAt, _onStart = _vars.onStart, onStartParams = _vars.onStartParams, immediateRender = _vars.immediateRender, initted, tween = Tween.to(tl, _setDefaults({
1644      ease: vars.ease || "none",
1645      lazy: false,
1646      immediateRender: false,
1647      time: endTime,
1648      overwrite: "auto",
1649      duration: vars.duration || Math.abs((endTime - (startAt && "time" in startAt ? startAt.time : tl._time)) / tl.timeScale()) || _tinyNum,
1650      onStart: function onStart() {
1651        tl.pause();
1652        if (!initted) {
1653          var duration = vars.duration || Math.abs((endTime - (startAt && "time" in startAt ? startAt.time : tl._time)) / tl.timeScale());
1654          tween._dur !== duration && _setDuration(tween, duration, 0, 1).render(tween._time, true, true);
1655          initted = 1;
1656        }
1657        _onStart && _onStart.apply(tween, onStartParams || []);
1658      }
1659    }, vars));
1660    return immediateRender ? tween.render(0) : tween;
1661  };
1662  _proto2.tweenFromTo = function tweenFromTo(fromPosition, toPosition, vars) {
1663    return this.tweenTo(toPosition, _setDefaults({
1664      startAt: {
1665        time: _parsePosition(this, fromPosition)
1666      }
1667    }, vars));
1668  };
1669  _proto2.recent = function recent() {
1670    return this._recent;
1671  };
1672  _proto2.nextLabel = function nextLabel(afterTime) {
1673    if (afterTime === void 0) {
1674      afterTime = this._time;
1675    }
1676    return _getLabelInDirection(this, _parsePosition(this, afterTime));
1677  };
1678  _proto2.previousLabel = function previousLabel(beforeTime) {
1679    if (beforeTime === void 0) {
1680      beforeTime = this._time;
1681    }
1682    return _getLabelInDirection(this, _parsePosition(this, beforeTime), 1);
1683  };
1684  _proto2.currentLabel = function currentLabel(value) {
1685    return arguments.length ? this.seek(value, true) : this.previousLabel(this._time + _tinyNum);
1686  };
1687  _proto2.shiftChildren = function shiftChildren(amount, adjustLabels, ignoreBeforeTime) {
1688    if (ignoreBeforeTime === void 0) {
1689      ignoreBeforeTime = 0;
1690    }
1691    var child = this._first, labels = this.labels, p;
1692    while (child) {
1693      if (child._start >= ignoreBeforeTime) {
1694        child._start += amount;
1695        child._end += amount;
1696      }
1697      child = child._next;
1698    }
1699    if (adjustLabels) {
1700      for (p in labels) {
1701        if (labels[p] >= ignoreBeforeTime) {
1702          labels[p] += amount;
1703        }
1704      }
1705    }
1706    return _uncache(this);
1707  };

1708  _proto2.invalidate = function invalidate(soft) {
1709    var child = this._first;
1710    this._lock = 0;
1711    while (child) {
1712      child.invalidate(soft);
1713      child = child._next;
1714    }
1715    return _Animation.prototype.invalidate.call(this, soft);
1716  };
1717  _proto2.clear = function clear(includeLabels) {
1718    if (includeLabels === void 0) {
1719      includeLabels = true;
1720    }
1721    var child = this._first, next;
1722    while (child) {
1723      next = child._next;
1724      this.remove(child);
1725      child = next;
1726    }
1727    this._dp && (this._time = this._tTime = this._pTime = 0);
1728    includeLabels && (this.labels = {});
1729    return _uncache(this);
1730  };
1731  _proto2.totalDuration = function totalDuration(value) {
1732    var max = 0, self = this, child = self._last, prevStart = _bigNum$1, prev, start, parent;
1733    if (arguments.length) {
1734      return self.timeScale((self._repeat < 0 ? self.duration() : self.totalDuration()) / (self.reversed() ? -value : value));
1735    }
1736    if (self._dirty) {
1737      parent = self.parent;
1738      while (child) {
1739        prev = child._prev;
1740        child._dirty && child.totalDuration();
1741        start = child._start;
1742        if (start > prevStart && self._sort && child._ts && !self._lock) {
1743          self._lock = 1;
1744          _addToTimeline(self, child, start - child._delay, 1)._lock = 0;
1745        } else {
1746          prevStart = start;
1747        }
1748        if (start < 0 && child._ts) {
1749          max -= start;
1750          if (!parent && !self._dp || parent && parent.smoothChildTiming) {
1751            self._start += start / self._ts;
1752            self._time -= start;
1753            self._tTime -= start;
1754          }
1755          self.shiftChildren(-start, false, -Infinity);
1756          prevStart = 0;
1757        }
1758        child._end > max && child._ts && (max = child._end);
1759        child = prev;
1760      }
1761      _setDuration(self, self === _globalTimeline && self._time > max ? self._time : max, 1, 1);
1762      self._dirty = 0;
1763    }
1764    return self._tDur;
1765  };
1766  Timeline2.updateRoot = function updateRoot(time) {
1767    if (_globalTimeline._ts) {
1768      _lazySafeRender(_globalTimeline, _parentToChildTotalTime(time, _globalTimeline));
1769      _lastRenderedFrame = _ticker.frame;
1770    }
1771    if (_ticker.frame >= _nextGCFrame) {
1772      _nextGCFrame += _config.autoSleep || 120;
1773      var child = _globalTimeline._first;
1774      if (!child || !child._ts) {
1775        if (_config.autoSleep && _ticker._listeners.length < 2) {
1776          while (child && !child._ts) {
1777            child = child._next;
1778          }
1779          child || _ticker.sleep();
1780        }
1781      }
1782    }
1783  };
1784  return Timeline2;
1785}(Animation);
1786_setDefaults(Timeline.prototype, {
1787  _lock: 0,
1788  _hasPause: 0,
1789  _forcing: 0
1790});
1791var _addComplexStringPropTween = function _addComplexStringPropTween2(target, prop, start, end, setter, stringFilter, funcParam) {
1792  var pt = new PropTween(this._pt, target, prop, 0, 1, _renderComplexString, null, setter), index = 0, matchIndex = 0, result, startNums, color, endNum, chunk, startNum, hasRandom, a;
1793  pt.b = start;
1794  pt.e = end;
1795  start += "";
1796  end += "";
1797  if (hasRandom = ~end.indexOf("random(")) {
1798    end = _replaceRandom(end);
1799  }
1800  if (stringFilter) {
1801    a = [start, end];
1802    stringFilter(a, target, prop);
1803    start = a[0];
1804    end = a[1];
1805  }
1806  startNums = start.match(_complexStringNumExp) || [];
1807  while (result = _complexStringNumExp.exec(end)) {
1808    endNum = result[0];
1809    chunk = end.substring(index, result.index);
1810    if (color) {
1811      color = (color + 1) % 5;
1812    } else if (chunk.substr(-5) === "rgba(") {
1813      color = 1;
1814    }
1815    if (endNum !== startNums[matchIndex++]) {
1816      startNum = parseFloat(startNums[matchIndex - 1]) || 0;
1817      pt._pt = {
1818        _next: pt._pt,
1819        p: chunk || matchIndex === 1 ? chunk : ",",
1820        //note: SVG spec allows omission of comma/space when a negative sign is wedged between two numbers, like 2.5-5.3 instead of 2.5,-5.3 but when tweening, the negative value may switch to positive, so we insert the comma just in case.
1821        s: startNum,
1822        c: endNum.charAt(1) === "=" ? _parseRelative(startNum, endNum) - startNum : parseFloat(endNum) - startNum,
1823        m: color && color < 4 ? Math.round : 0
1824      };
1825      index = _complexStringNumExp.lastIndex;
1826    }
1827  }
1828  pt.c = index < end.length ? end.substring(index, end.length) : "";
1829  pt.fp = funcParam;
1830  if (_relExp.test(end) || hasRandom) {
1831    pt.e = 0;
1832  }
1833  this._pt = pt;
1834  return pt;
1835}, _addPropTween = function _addPropTween2(target, prop, start, end, index, targets, modifier, stringFilter, funcParam, optional) {
1836  _isFunction(end) && (end = end(index || 0, target, targets));
1837  var currentValue = target[prop], parsedStart = start !== "get" ? start : !_isFunction(currentValue) ? currentValue : funcParam ? target[prop.indexOf("set") || !_isFunction(target["get" + prop.substr(3)]) ? prop : "get" + prop.substr(3)](funcParam) : target[prop](), setter = !_isFunction(currentValue) ? _setterPlain : funcParam ? _setterFuncWithParam : _setterFunc, pt;
1838  if (_isString(end)) {
1839    if (~end.indexOf("random(")) {
1840      end = _replaceRandom(end);
1841    }
1842    if (end.charAt(1) === "=") {
1843      pt = _parseRelative(parsedStart, end) + (getUnit(parsedStart) || 0);
1844      if (pt || pt === 0) {
1845        end = pt;
1846      }
1847    }
1848  }
1849  if (!optional || parsedStart !== end || _forceAllPropTweens) {
1850    if (!isNaN(parsedStart * end) && end !== "") {
1851      pt = new PropTween(this._pt, target, prop, +parsedStart || 0, end - (parsedStart || 0), typeof currentValue === "boolean" ? _renderBoolean : _renderPlain, 0, setter);
1852      funcParam && (pt.fp = funcParam);
1853      modifier && pt.modifier(modifier, this, target);
1854      return this._pt = pt;
1855    }
1856    !currentValue && !(prop in target) && _missingPlugin(prop, end);
1857    return _addComplexStringPropTween.call(this, target, prop, parsedStart, end, setter, stringFilter || _config.stringFilter, funcParam);
1858  }
1859}, _processVars = function _processVars2(vars, index, target, targets, tween) {
1860  _isFunction(vars) && (vars = _parseFuncOrString(vars, tween, index, target, targets));
1861  if (!_isObject(vars) || vars.style && vars.nodeType || _isArray(vars) || _isTypedArray(vars)) {
1862    return _isString(vars) ? _parseFuncOrString(vars, tween, index, target, targets) : vars;
1863  }
1864  var copy = {}, p;
1865  for (p in vars) {
1866    copy[p] = _parseFuncOrString(vars[p], tween, index, target, targets);
1867  }
1868  return copy;
1869}, _checkPlugin = function _checkPlugin2(property, vars, tween, index, target, targets) {
1870  var plugin, pt, ptLookup, i;
1871  if (_plugins[property] && (plugin = new _plugins[property]()).init(target, plugin.rawVars ? vars[property] : _processVars(vars[property], index, target, targets, tween), tween, index, targets) !== false) {
1872    tween._pt = pt = new PropTween(tween._pt, target, property, 0, 1, plugin.render, plugin, 0, plugin.priority);
1873    if (tween !== _quickTween) {
1874      ptLookup = tween._ptLookup[tween._targets.indexOf(target)];
1875      i = plugin._props.length;
1876      while (i--) {
1877        ptLookup[plugin._props[i]] = pt;
1878      }
1879    }
1880  }
1881  return plugin;
1882}, _overwritingTween, _forceAllPropTweens, _initTween = function _initTween2(tween, time, tTime) {
1883  var vars = tween.vars, ease = vars.ease, startAt = vars.startAt, immediateRender = vars.immediateRender, lazy = vars.lazy, onUpdate = vars.onUpdate, runBackwards = vars.runBackwards, yoyoEase = vars.yoyoEase, keyframes = vars.keyframes, autoRevert = vars.autoRevert, dur = tween._dur, prevStartAt = tween._startAt, targets = tween._targets, parent = tween.parent, fullTargets = parent && parent.data === "nested" ? parent.vars.targets : targets, autoOverwrite = tween._overwrite === "auto" && !_suppressOverwrites, tl = tween.timeline, cleanVars, i, p, pt, target, hasPriority, gsData, harness, plugin, ptLookup, index, harnessVars, overwritten;
1884  tl && (!keyframes || !ease) && (ease = "none");
1885  tween._ease = _parseEase(ease, _defaults.ease);
1886  tween._yEase = yoyoEase ? _invertEase(_parseEase(yoyoEase === true ? ease : yoyoEase, _defaults.ease)) : 0;
1887  if (yoyoEase && tween._yoyo && !tween._repeat) {
1888    yoyoEase = tween._yEase;
1889    tween._yEase = tween._ease;
1890    tween._ease = yoyoEase;
1891  }
1892  tween._from = !tl && !!vars.runBackwards;
1893  if (!tl || keyframes && !vars.stagger) {
1894    harness = targets[0] ? _getCache(targets[0]).harness : 0;
1895    harnessVars = harness && vars[harness.prop];
1896    cleanVars = _copyExcluding(vars, _reservedProps);
1897    if (prevStartAt) {
1898      prevStartAt._zTime < 0 && prevStartAt.progress(1);
1899      time < 0 && runBackwards && immediateRender && !autoRevert ? prevStartAt.render(-1, true) : prevStartAt.revert(runBackwards && dur ? _revertConfigNoKill : _startAtRevertConfig);
1900      prevStartAt._lazy = 0;
1901    }
1902    if (startAt) {
1903      _removeFromParent(tween._startAt = Tween.set(targets, _setDefaults({
1904        data: "isStart",
1905        overwrite: false,
1906        parent,
1907        immediateRender: true,
1908        lazy: !prevStartAt && _isNotFalse(lazy),
1909        startAt: null,
1910        delay: 0,
1911        onUpdate: onUpdate && function() {
1912          return _callback(tween, "onUpdate");
1913        },
1914        stagger: 0
1915      }, startAt)));
1916      tween._startAt._dp = 0;
1917      tween._startAt._sat = tween;
1918      time < 0 && (_reverting$1 || !immediateRender && !autoRevert) && tween._startAt.revert(_revertConfigNoKill);
1919      if (immediateRender) {
1920        if (dur && time <= 0 && tTime <= 0) {
1921          time && (tween._zTime = time);
1922          return;
1923        }
1924      }
1925    } else if (runBackwards && dur) {
1926      if (!prevStartAt) {
1927        time && (immediateRender = false);
1928        p = _setDefaults({
1929          overwrite: false,
1930          data: "isFromStart",
1931          //we tag the tween with as "isFromStart" so that if [inside a plugin] we need to only do something at the very END of a tween, we have a way of identifying this tween as merely the one that's setting the beginning values for a "from()" tween. For example, clearProps in CSSPlugin should only get applied at the very END of a tween and without this tag, from(...{height:100, clearProps:"height", delay:1}) would wipe the height at the beginning of the tween and after 1 second, it'd kick back in.
1932          lazy: immediateRender && !prevStartAt && _isNotFalse(lazy),
1933          immediateRender,
1934          //zero-duration tweens render immediately by default, but if we're not specifically instructed to render this tween immediately, we should skip this and merely _init() to record the starting values (rendering them immediately would push them to completion which is wasteful in that case - we'd have to render(-1) immediately after)
1935          stagger: 0,
1936          parent
1937          //ensures that nested tweens that had a stagger are handled properly, like gsap.from(".class", {y: gsap.utils.wrap([-100,100]), stagger: 0.5}

1937)
1938        }, cleanVars);
1939        harnessVars && (p[harness.prop] = harnessVars);
1940        _removeFromParent(tween._startAt = Tween.set(targets, p));
1941        tween._startAt._dp = 0;
1942        tween._startAt._sat = tween;
1943        time < 0 && (_reverting$1 ? tween._startAt.revert(_revertConfigNoKill) : tween._startAt.render(-1, true));
1944        tween._zTime = time;
1945        if (!immediateRender) {
1946          _initTween2(tween._startAt, _tinyNum, _tinyNum);
1947        } else if (!time) {
1948          return;
1949        }
1950      }
1951    }
1952    tween._pt = tween._ptCache = 0;
1953    lazy = dur && _isNotFalse(lazy) || lazy && !dur;
1954    for (i = 0; i < targets.length; i++) {
1955      target = targets[i];
1956      gsData = target._gsap || _harness(targets)[i]._gsap;
1957      tween._ptLookup[i] = ptLookup = {};
1958      _lazyLookup[gsData.id] && _lazyTweens.length && _lazyRender();
1959      index = fullTargets === targets ? i : fullTargets.indexOf(target);
1960      if (harness && (plugin = new harness()).init(target, harnessVars || cleanVars, tween, index, fullTargets) !== false) {
1961        tween._pt = pt = new PropTween(tween._pt, target, plugin.name, 0, 1, plugin.render, plugin, 0, plugin.priority);
1962        plugin._props.forEach(function(name) {
1963          ptLookup[name] = pt;
1964        });
1965        plugin.priority && (hasPriority = 1);
1966      }
1967      if (!harness || harnessVars) {
1968        for (p in cleanVars) {
1969          if (_plugins[p] && (plugin = _checkPlugin(p, cleanVars, tween, index, target, fullTargets))) {
1970            plugin.priority && (hasPriority = 1);
1971          } else {
1972            ptLookup[p] = pt = _addPropTween.call(tween, target, p, "get", cleanVars[p], index, fullTargets, 0, vars.stringFilter);
1973          }
1974        }
1975      }
1976      tween._op && tween._op[i] && tween.kill(target, tween._op[i]);
1977      if (autoOverwrite && tween._pt) {
1978        _overwritingTween = tween;
1979        _globalTimeline.killTweensOf(target, ptLookup, tween.globalTime(time));
1980        overwritten = !tween.parent;
1981        _overwritingTween = 0;
1982      }
1983      tween._pt && lazy && (_lazyLookup[gsData.id] = 1);
1984    }
1985    hasPriority && _sortPropTweensByPriority(tween);
1986    tween._onInit && tween._onInit(tween);
1987  }
1988  tween._onUpdate = onUpdate;
1989  tween._initted = (!tween._op || tween._pt) && !overwritten;
1990  keyframes && time <= 0 && tl.render(_bigNum$1, true, true);
1991}, _updatePropTweens = function _updatePropTweens2(tween, property, value, start, startIsRelative, ratio, time, skipRecursion) {
1992  var ptCache = (tween._pt && tween._ptCache || (tween._ptCache = {}))[property], pt, rootPT, lookup, i;
1993  if (!ptCache) {
1994    ptCache = tween._ptCache[property] = [];
1995    lookup = tween._ptLookup;
1996    i = tween._targets.length;
1997    while (i--) {
1998      pt = lookup[i][property];
1999      if (pt && pt.d && pt.d._pt) {
2000        pt = pt.d._pt;
2001        while (pt && pt.p !== property && pt.fp !== property) {
2002          pt = pt._next;
2003        }
2004      }
2005      if (!pt) {
2006        _forceAllPropTweens = 1;
2007        tween.vars[property] = "+=0";
2008        _initTween(tween, time);
2009        _forceAllPropTweens = 0;
2010        return skipRecursion ? _warn(property + " not eligible for reset") : 1;
2011      }
2012      ptCache.push(pt);
2013    }
2014  }
2015  i = ptCache.length;
2016  while (i--) {
2017    rootPT = ptCache[i];
2018    pt = rootPT._pt || rootPT;
2019    pt.s = (start || start === 0) && !startIsRelative ? start : pt.s + (start || 0) + ratio * pt.c;
2020    pt.c = value - pt.s;
2021    rootPT.e && (rootPT.e = _round(value) + getUnit(rootPT.e));
2022    rootPT.b && (rootPT.b = pt.s + getUnit(rootPT.b));
2023  }
2024}, _addAliasesToVars = function _addAliasesToVars2(targets, vars) {
2025  var harness = targets[0] ? _getCache(targets[0]).harness : 0, propertyAliases = harness && harness.aliases, copy, p, i, aliases;
2026  if (!propertyAliases) {
2027    return vars;
2028  }
2029  copy = _merge({}, vars);
2030  for (p in propertyAliases) {
2031    if (p in copy) {
2032      aliases = propertyAliases[p].split(",");
2033      i = aliases.length;
2034      while (i--) {
2035        copy[aliases[i]] = copy[p];
2036      }
2037    }
2038  }
2039  return copy;
2040}, _parseKeyframe = function _parseKeyframe2(prop, obj, allProps, easeEach) {
2041  var ease = obj.ease || easeEach || "power1.inOut", p, a;
2042  if (_isArray(obj)) {
2043    a = allProps[prop] || (allProps[prop] = []);
2044    obj.forEach(function(value, i) {
2045      return a.push({
2046        t: i / (obj.length - 1) * 100,
2047        v: value,
2048        e: ease
2049      });
2050    });
2051  } else {
2052    for (p in obj) {
2053      a = allProps[p] || (allProps[p] = []);
2054      p === "ease" || a.push({
2055        t: parseFloat(prop),
2056        v: obj[p],
2057        e: ease
2058      });
2059    }
2060  }
2061}, _parseFuncOrString = function _parseFuncOrString2(value, tween, i, target, targets) {
2062  return _isFunction(value) ? value.call(tween, i, target, targets) : _isString(value) && ~value.indexOf("random(") ? _replaceRandom(value) : value;
2063}, _staggerTweenProps = _callbackNames + "repeat,repeatDelay,yoyo,repeatRefresh,yoyoEase,autoRevert", _staggerPropsToSkip = {};
2064_forEachName(_staggerTweenProps + ",id,stagger,delay,duration,paused,scrollTrigger", function(name) {
2065  return _staggerPropsToSkip[name] = 1;
2066});
2067var Tween = /* @__PURE__ */ function(_Animation2) {
2068  _inheritsLoose(Tween2, _Animation2);
2069  function Tween2(targets, vars, position, skipInherit) {
2070    var _this3;
2071    if (typeof vars === "number") {
2072      position.duration = vars;
2073      vars = position;
2074      position = null;
2075    }
2076    _this3 = _Animation2.call(this, skipInherit ? vars : _inheritDefaults(vars)) || this;
2077    var _this3$vars = _this3.vars, duration = _this3$vars.duration, delay2 = _this3$vars.delay, immediateRender = _this3$vars.immediateRender, stagger = _this3$vars.stagger, overwrite = _this3$vars.overwrite, keyframes = _this3$vars.keyframes, defaults2 = _this3$vars.defaults, scrollTrigger = _this3$vars.scrollTrigger, yoyoEase = _this3$vars.yoyoEase, parent = vars.parent || _globalTimeline, parsedTargets = (_isArray(targets) || _isTypedArray(targets) ? _isNumber(targets[0]) : "length" in vars) ? [targets] : toArray(targets), tl, i, copy, l, p, curTarget, staggerFunc, staggerVarsToMerge;
2078    _this3._targets = parsedTargets.length ? _harness(parsedTargets) : _warn("GSAP target " + targets + " not found. https://gsap.com", !_config.nullTargetWarn) || [];
2079    _this3._ptLookup = [];
2080    _this3._overwrite = overwrite;
2081    if (keyframes || stagger || _isFuncOrString(duration) || _isFuncOrString(delay2)) {
2082      vars = _this3.vars;
2083      tl = _this3.timeline = new Timeline({
2084        data: "nested",
2085        defaults: defaults2 || {},
2086        targets: parent && parent.data === "nested" ? parent.vars.targets : parsedTargets
2087      });
2088      tl.kill();
2089      tl.parent = tl._dp = _assertThisInitialized(_this3);
2090      tl._start = 0;
2091      if (stagger || _isFuncOrString(duration) || _isFuncOrString(delay2)) {
2092        l = parsedTargets.length;
2093        staggerFunc = stagger && distribute(stagger);
2094        if (_isObject(stagger)) {
2095          for (p in stagger) {
2096            if (~_staggerTweenProps.indexOf(p)) {
2097              staggerVarsToMerge || (staggerVarsToMerge = {});
2098              staggerVarsToMerge[p] = stagger[p];
2099            }
2100          }
2101        }
2102        for (i = 0; i < l; i++) {
2103          copy = _copyExcluding(vars, _staggerPropsToSkip);
2104          copy.stagger = 0;
2105          yoyoEase && (copy.yoyoEase = yoyoEase);
2106          staggerVarsToMerge && _merge(copy, staggerVarsToMerge);
2107          curTarget = parsedTargets[i];
2108          copy.duration = +_parseFuncOrString(duration, _assertThisInitialized(_this3), i, curTarget, parsedTargets);
2109          copy.delay = (+_parseFuncOrString(delay2, _assertThisInitialized(_this3), i, curTarget, parsedTargets) || 0) - _this3._delay;
2110          if (!stagger && l === 1 && copy.delay) {
2111            _this3._delay = delay2 = copy.delay;
2112            _this3._start += delay2;
2113            copy.delay = 0;
2114          }
2115          tl.to(curTarget, copy, staggerFunc ? staggerFunc(i, curTarget, parsedTargets) : 0);
2116          tl._ease = _easeMap.none;
2117        }
2118        tl.duration() ? duration = delay2 = 0 : _this3.timeline = 0;
2119      } else if (keyframes) {
2120        _inheritDefaults(_setDefaults(tl.vars.defaults, {
2121          ease: "none"
2122        }));
2123        tl._ease = _parseEase(keyframes.ease || vars.ease || "none");
2124        var time = 0, a, kf, v;
2125        if (_isArray(keyframes)) {

2126          keyframes.forEach(function(frame) {
2127            return tl.to(parsedTargets, frame, ">");
2128          });
2129          tl.duration();
2130        } else {
2131          copy = {};
2132          for (p in keyframes) {
2133            p === "ease" || p === "easeEach" || _parseKeyframe(p, keyframes[p], copy, keyframes.easeEach);
2134          }
2135          for (p in copy) {
2136            a = copy[p].sort(function(a2, b) {
2137              return a2.t - b.t;
2138            });
2139            time = 0;
2140            for (i = 0; i < a.length; i++) {
2141              kf = a[i];
2142              v = {
2143                ease: kf.e,
2144                duration: (kf.t - (i ? a[i - 1].t : 0)) / 100 * duration
2145              };
2146              v[p] = kf.v;
2147              tl.to(parsedTargets, v, time);
2148              time += v.duration;
2149            }
2150          }
2151          tl.duration() < duration && tl.to({}, {
2152            duration: duration - tl.duration()
2153          });
2154        }
2155      }
2156      duration || _this3.duration(duration = tl.duration());
2157    } else {
2158      _this3.timeline = 0;
2159    }
2160    if (overwrite === true && !_suppressOverwrites) {
2161      _overwritingTween = _assertThisInitialized(_this3);
2162      _globalTimeline.killTweensOf(parsedTargets);
2163      _overwritingTween = 0;
2164    }
2165    _addToTimeline(parent, _assertThisInitialized(_this3), position);
2166    vars.reversed && _this3.reverse();
2167    vars.paused && _this3.paused(true);
2168    if (immediateRender || !duration && !keyframes && _this3._start === _roundPrecise(parent._time) && _isNotFalse(immediateRender) && _hasNoPausedAncestors(_assertThisInitialized(_this3)) && parent.data !== "nested") {
2169      _this3._tTime = -_tinyNum;
2170      _this3.render(Math.max(0, -delay2) || 0);
2171    }
2172    scrollTrigger && _scrollTrigger(_assertThisInitialized(_this3), scrollTrigger);
2173    return _this3;
2174  }
2175  var _proto3 = Tween2.prototype;
2176  _proto3.render = function render3(totalTime, suppressEvents, force) {
2177    var prevTime = this._time, tDur = this._tDur, dur = this._dur, isNegative = totalTime < 0, tTime = totalTime > tDur - _tinyNum && !isNegative ? tDur : totalTime < _tinyNum ? 0 : totalTime, time, pt, iteration, cycleDuration, prevIteration, isYoyo, ratio, timeline2, yoyoEase;
2178    if (!dur) {
2179      _renderZeroDurationTween(this, totalTime, suppressEvents, force);
2180    } else if (tTime !== this._tTime || !totalTime || force || !this._initted && this._tTime || this._startAt && this._zTime < 0 !== isNegative) {
2181      time = tTime;
2182      timeline2 = this.timeline;
2183      if (this._repeat) {
2184        cycleDuration = dur + this._rDelay;
2185        if (this._repeat < -1 && isNegative) {
2186          return this.totalTime(cycleDuration * 100 + totalTime, suppressEvents, force);
2187        }
2188        time = _roundPrecise(tTime % cycleDuration);
2189        if (tTime === tDur) {
2190          iteration = this._repeat;
2191          time = dur;
2192        } else {
2193          iteration = ~~(tTime / cycleDuration);
2194          if (iteration && iteration === _roundPrecise(tTime / cycleDuration)) {
2195            time = dur;
2196            iteration--;
2197          }
2198          time > dur && (time = dur);
2199        }
2200        isYoyo = this._yoyo && iteration & 1;
2201        if (isYoyo) {
2202          yoyoEase = this._yEase;
2203          time = dur - time;
2204        }
2205        prevIteration = _animationCycle(this._tTime, cycleDuration);
2206        if (time === prevTime && !force && this._initted && iteration === prevIteration) {
2207          this._tTime = tTime;
2208          return this;
2209        }
2210        if (iteration !== prevIteration) {
2211          timeline2 && this._yEase && _propagateYoyoEase(timeline2, isYoyo);
2212          if (this.vars.repeatRefresh && !isYoyo && !this._lock && this._time !== cycleDuration && this._initted) {
2213            this._lock = force = 1;
2214            this.render(_roundPrecise(cycleDuration * iteration), true).invalidate()._lock = 0;
2215          }
2216        }
2217      }
2218      if (!this._initted) {
2219        if (_attemptInitTween(this, isNegative ? totalTime : time, force, suppressEvents, tTime)) {
2220          this._tTime = 0;
2221          return this;
2222        }
2223        if (prevTime !== this._time && !(force && this.vars.repeatRefresh && iteration !== prevIteration)) {
2224          return this;
2225        }
2226        if (dur !== this._dur) {
2227          return this.render(totalTime, suppressEvents, force);
2228        }
2229      }
2230      this._tTime = tTime;
2231      this._time = time;
2232      if (!this._act && this._ts) {
2233        this._act = 1;
2234        this._lazy = 0;
2235      }
2236      this.ratio = ratio = (yoyoEase || this._ease)(time / dur);
2237      if (this._from) {
2238        this.ratio = ratio = 1 - ratio;
2239      }
2240      if (time && !prevTime && !suppressEvents && !iteration) {
2241        _callback(this, "onStart");
2242        if (this._tTime !== tTime) {
2243          return this;
2244        }
2245      }
2246      pt = this._pt;
2247      while (pt) {
2248        pt.r(ratio, pt.d);
2249        pt = pt._next;
2250      }
2251      timeline2 && timeline2.render(totalTime < 0 ? totalTime : timeline2._dur * timeline2._ease(time / this._dur), suppressEvents, force) || this._startAt && (this._zTime = totalTime);
2252      if (this._onUpdate && !suppressEvents) {
2253        isNegative && _rewindStartAt(this, totalTime, suppressEvents, force);
2254        _callback(this, "onUpdate");
2255      }
2256      this._repeat && iteration !== prevIteration && this.vars.onRepeat && !suppressEvents && this.parent && _callback(this, "onRepeat");
2257      if ((tTime === this._tDur || !tTime) && this._tTime === tTime) {
2258        isNegative && !this._onUpdate && _rewindStartAt(this, totalTime, true, true);
2259        (totalTime || !dur) && (tTime === this._tDur && this._ts > 0 || !tTime && this._ts < 0) && _removeFromParent(this, 1);
2260        if (!suppressEvents && !(isNegative && !prevTime) && (tTime || prevTime || isYoyo)) {
2261          _callback(this, tTime === tDur ? "onComplete" : "onReverseComplete", true);
2262          this._prom && !(tTime < tDur && this.timeScale() > 0) && this._prom();
2263        }
2264      }
2265    }
2266    return this;
2267  };
2268  _proto3.targets = function targets() {
2269    return this._targets;
2270  };

2271  _proto3.invalidate = function invalidate(soft) {
2272    (!soft || !this.vars.runBackwards) && (this._startAt = 0);
2273    this._pt = this._op = this._onUpdate = this._lazy = this.ratio = 0;
2274    this._ptLookup = [];
2275    this.timeline && this.timeline.invalidate(soft);
2276    return _Animation2.prototype.invalidate.call(this, soft);
2277  };
2278  _proto3.resetTo = function resetTo(property, value, start, startIsRelative, skipRecursion) {
2279    _tickerActive || _ticker.wake();
2280    this._ts || this.play();
2281    var time = Math.min(this._dur, (this._dp._time - this._start) * this._ts), ratio;
2282    this._initted || _initTween(this, time);
2283    ratio = this._ease(time / this._dur);
2284    if (_updatePropTweens(this, property, value, start, startIsRelative, ratio, time, skipRecursion)) {
2285      return this.resetTo(property, value, start, startIsRelative, 1);
2286    }
2287    _alignPlayhead(this, 0);
2288    this.parent || _addLinkedListItem(this._dp, this, "_first", "_last", this._dp._sort ? "_start" : 0);
2289    return this.render(0);
2290  };
2291  _proto3.kill = function kill(targets, vars) {
2292    if (vars === void 0) {
2293      vars = "all";
2294    }
2295    if (!targets && (!vars || vars === "all")) {
2296      this._lazy = this._pt = 0;
2297      return this.parent ? _interrupt(this) : this;
2298    }
2299    if (this.timeline) {
2300      var tDur = this.timeline.totalDuration();
2301      this.timeline.killTweensOf(targets, vars, _overwritingTween && _overwritingTween.vars.overwrite !== true)._first || _interrupt(this);
2302      this.parent && tDur !== this.timeline.totalDuration() && _setDuration(this, this._dur * this.timeline._tDur / tDur, 0, 1);
2303      return this;
2304    }
2305    var parsedTargets = this._targets, killingTargets = targets ? toArray(targets) : parsedTargets, propTweenLookup = this._ptLookup, firstPT = this._pt, overwrittenProps, curLookup, curOverwriteProps, props, p, pt, i;
2306    if ((!vars || vars === "all") && _arraysMatch(parsedTargets, killingTargets)) {
2307      vars === "all" && (this._pt = 0);
2308      return _interrupt(this);
2309    }
2310    overwrittenProps = this._op = this._op || [];
2311    if (vars !== "all") {
2312      if (_isString(vars)) {
2313        p = {};
2314        _forEachName(vars, function(name) {
2315          return p[name] = 1;
2316        });
2317        vars = p;
2318      }
2319      vars = _addAliasesToVars(parsedTargets, vars);
2320    }
2321    i = parsedTargets.length;
2322    while (i--) {
2323      if (~killingTargets.indexOf(parsedTargets[i])) {
2324        curLookup = propTweenLookup[i];
2325        if (vars === "all") {
2326          overwrittenProps[i] = vars;
2327          props = curLookup;
2328          curOverwriteProps = {};
2329        } else {
2330          curOverwriteProps = overwrittenProps[i] = overwrittenProps[i] || {};
2331          props = vars;
2332        }
2333        for (p in props) {
2334          pt = curLookup && curLookup[p];
2335          if (pt) {
2336            if (!("kill" in pt.d) || pt.d.kill(p) === true) {
2337              _removeLinkedListItem(this, pt, "_pt");
2338            }
2339            delete curLookup[p];
2340          }
2341          if (curOverwriteProps !== "all") {
2342            curOverwriteProps[p] = 1;
2343          }
2344        }
2345      }
2346    }
2347    this._initted && !this._pt && firstPT && _interrupt(this);
2348    return this;
2349  };
2350  Tween2.to = function to(targets, vars) {
2351    return new Tween2(targets, vars, arguments[2]);
2352  };
2353  Tween2.from = function from(targets, vars) {
2354    return _createTweenType(1, arguments);
2355  };
2356  Tween2.delayedCall = function delayedCall(delay2, callback, params, scope) {
2357    return new Tween2(callback, 0, {
2358      immediateRender: false,
2359      lazy: false,
2360      overwrite: false,
2361      delay: delay2,
2362      onComplete: callback,
2363      onReverseComplete: callback,
2364      onCompleteParams: params,
2365      onReverseCompleteParams: params,
2366      callbackScope: scope
2367    });
2368  };
2369  Tween2.fromTo = function fromTo(targets, fromVars, toVars) {
2370    return _createTweenType(2, arguments);
2371  };
2372  Tween2.set = function set(targets, vars) {
2373    vars.duration = 0;
2374    vars.repeatDelay || (vars.repeat = 0);
2375    return new Tween2(targets, vars);
2376  };
2377  Tween2.killTweensOf = function killTweensOf(targets, props, onlyActive) {
2378    return _globalTimeline.killTweensOf(targets, props, onlyActive);
2379  };
2380  return Tween2;
2381}(Animation);
2382_setDefaults(Tween.prototype, {
2383  _targets: [],
2384  _lazy: 0,
2385  _startAt: 0,
2386  _op: 0,
2387  _onInit: 0
2388});
2389_forEachName("staggerTo,staggerFrom,staggerFromTo", function(name) {
2390  Tween[name] = function() {
2391    var tl = new Timeline(), params = _slice.call(arguments, 0);
2392    params.splice(name === "staggerFromTo" ? 5 : 4, 0, 0);
2393    return tl[name].apply(tl, params);
2394  };
2395});
2396var _setterPlain = function _setterPlain2(target, property, value) {
2397  return target[property] = value;
2398}, _setterFunc = function _setterFunc2(target, property, value) {
2399  return target[property](value);
2400}, _setterFuncWithParam = function _setterFuncWithParam2(target, property, value, data) {
2401  return target[property](data.fp, value);
2402}, _setterAttribute = function _setterAttribute2(target, property, value) {
2403  return target.setAttribute(property, value);
2404}, _getSetter = function _getSetter2(target, property) {
2405  return _isFunction(target[property]) ? _setterFunc : _isUndefined(target[property]) && target.setAttribute ? _setterAttribute : _setterPlain;
2406}, _renderPlain = function _renderPlain2(ratio, data) {
2407  return data.set(data.t, data.p, Math.round((data.s + data.c * ratio) * 1e6) / 1e6, data);
2408}, _renderBoolean = function _renderBoolean2(ratio, data) {
2409  return data.set(data.t, data.p, !!(data.s + data.c * ratio), data);
2410}, _renderComplexString = function _renderComplexString2(ratio, data) {
2411  var pt = data._pt, s = "";
2412  if (!ratio && data.b) {
2413    s = data.b;
2414  } else if (ratio === 1 && data.e) {
2415    s = data.e;
2416  } else {
2417    while (pt) {
2418      s = pt.p + (pt.m ? pt.m(pt.s + pt.c * ratio) : Math.round((pt.s + pt.c * ratio) * 1e4) / 1e4) + s;
2419      pt = pt._next;
2420    }
2421    s += data.c;
2422  }
2423  data.set(data.t, data.p, s, data);
2424}, _renderPropTweens = function _renderPropTweens2(ratio, data) {
2425  var pt = data._pt;
2426  while (pt) {
2427    pt.r(ratio, pt.d);
2428    pt = pt._next;
2429  }
2430}, _addPluginModifier = function _addPluginModifier2(modifier, tween, target, property) {
2431  var pt = this._pt, next;
2432  while (pt) {
2433    next = pt._next;
2434    pt.p === property && pt.modifier(modifier, tween, target);
2435    pt = next;
2436  }
2437}, _killPropTweensOf = function _killPropTweensOf2(property) {
2438  var pt = this._pt, hasNonDependentRemaining, next;
2439  while (pt) {
2440    next = pt._next;
2441    if (pt.p === property && !pt.op || pt.op === property) {
2442      _removeLinkedListItem(this, pt, "_pt");
2443    } else if (!pt.dep) {
2444      hasNonDependentRemaining = 1;
2445    }
2446    pt = next;
2447  }
2448  return !hasNonDependentRemaining;
2449}, _setterWithModifier = function _setterWithModifier2(target, property, value, data) {
2450  data.mSet(target, property, data.m.call(data.tween, value, data.mt), data);
2451}, _sortPropTweensByPriority = function _sortPropTweensByPriority2(parent) {
2452  var pt = parent._pt, next, pt2, first, last;
2453  while (pt) {
2454    next = pt._next;
2455    pt2 = first;
2456    while (pt2 && pt2.pr > pt.pr) {
2457      pt2 = pt2._next;
2458    }
2459    if (pt._prev = pt2 ? pt2._prev : last) {
2460      pt._prev._next = pt;
2461    } else {
2462      first = pt;
2463    }
2464    if (pt._next = pt2) {
2465      pt2._prev = pt;
2466    } else {
2467      last = pt;
2468    }
2469    pt = next;
2470  }
2471  parent._pt = first;
2472};
2473var PropTween = /* @__PURE__ */ function() {
2474  function PropTween2(next, target, prop, start, change, renderer, data, setter, priority) {
2475    this.t = target;
2476    this.s = start;
2477    this.c = change;
2478    this.p = prop;
2479    this.r = renderer || _renderPlain;
2480    this.d = data || this;
2481    this.set = setter || _setterPlain;
2482    this.pr = priority || 0;
2483    this._next = next;
2484    if (next) {
2485      next._prev = this;
2486    }
2487  }
2488  var _proto4 = PropTween2.prototype;
2489  _proto4.modifier = function modifier(func, tween, target) {
2490    this.mSet = this.mSet || this.set;
2491    this.set = _setterWithModifier;
2492    this.m = func;
2493    this.mt = target;
2494    this.tween = tween;
2495  };
2496  return PropTween2;
2497}();
2498_forEachName(_callbackNames + "parent,duration,ease,delay,overwrite,runBackwards,startAt,yoyo,immediateRender,repeat,repeatDelay,data,paused,reversed,lazy,callbackScope,stringFilter,id,yoyoEase,stagger,inherit,repeatRefresh,keyframes,autoRevert,scrollTrigger", function(name) {
2499  return _reservedProps[name] = 1;
2500});
2501_globals.TweenMax = _globals.TweenLite = Tween;
2502_globals.TimelineLite = _globals.TimelineMax = Timeline;
2503_globalTimeline = new Timeline({
2504  sortChildren: false,
2505  defaults: _defaults,
2506  autoRemoveChildren: true,
2507  id: "root",
2508  smoothChildTiming: true
2509});
2510_config.stringFilter = _colorStringFilter;
2511var _media = [], _listeners = {}, _emptyArray = [], _lastMediaTime = 0, _contextID = 0, _dispatch = function _dispatch2(type) {
2512  return (_listeners[type] || _emptyArray).map(function(f) {
2513    return f();
2514  });
2515}, _onMediaChange = function _onMediaChange2() {
2516  var time = Date.now(), matches = [];
2517  if (time - _lastMediaTime > 2) {
2518    _dispatch("matchMediaInit");
2519    _media.forEach(function(c) {
2520      var queries = c.queries, conditions = c.conditions, match, p, anyMatch, toggled;
2521      for (p in queries) {
2522        match = _win$1.matchMedia(queries[p]).matches;
2523        match && (anyMatch = 1);
2524        if (match !== conditions[p]) {
2525          conditions[p] = match;
2526          toggled = 1;
2527        }
2528      }
2529      if (toggled) {
2530        c.revert();
2531        anyMatch && matches.push(c);
2532      }
2533    });
2534    _dispatch("matchMediaRevert");
2535    matches.forEach(function(c) {
2536      return c.onMatch(c, function(func) {
2537        return c.add(null, func);
2538      });
2539    });
2540    _lastMediaTime = time;
2541    _dispatch("matchMedia");
2542  }
2543};
2544var Context = /* @__PURE__ */ function() {
2545  function Context2(func, scope) {
2546    this.selector = scope && selector(scope);
2547    this.data = [];
2548    this._r = [];
2549    this.isReverted = false;
2550    this.id = _contextID++;
2551    func && this.add(func);
2552  }
2553  var _proto5 = Context2.prototype;
2554  _proto5.add = function add(name, func, scope) {
2555    if (_isFunction(name)) {
2556      scope = func;
2557      func = name;
2558      name = _isFunction;
2559    }
2560    var self = this, f = function f2() {
2561      var prev = _context, prevSelector = self.selector, result;
2562      prev && prev !== self && prev.data.push(self);
2563      scope && (self.selector = selector(scope));
2564      _context = self;
2565      result = func.apply(self, arguments);
2566      _isFunction(result) && self._r.push(result);
2567      _context = prev;
2568      self.selector = prevSelector;
2569      self.isReverted = false;
2570      return result;
2571    };
2572    self.last = f;
2573    return name === _isFunction ? f(self, function(func2) {
2574      return self.add(null, func2);
2575    }) : name ? self[name] = f : f;
2576  };
2577  _proto5.ignore = function ignore(func) {
2578    var prev = _context;
2579    _context = null;
2580    func(this);
2581    _context = prev;
2582  };
2583  _proto5.getTweens = function getTweens() {
2584    var a = [];
2585    this.data.forEach(function(e) {
2586      return e instanceof Context2 ? a.push.apply(a, e.getTweens()) : e instanceof Tween && !(e.parent && e.parent.data === "nested") && a.push(e);
2587    });
2588    return a;
2589  };
2590  _proto5.clear = function clear() {
2591    this._r.length = this.data.length = 0;
2592  };
2593  _proto5.kill = function kill(revert, matchMedia2) {
2594    var _this4 = this;
2595    if (revert) {
2596      (function() {
2597        var tweens = _this4.getTweens(), i2 = _this4.data.length, t;
2598        while (i2--) {
2599          t = _this4.data[i2];
2600          if (t.data === "isFlip") {
2601            t.revert();
2602            t.getChildren(true, true, false).forEach(function(tween) {
2603              return tweens.splice(tweens.indexOf(tween), 1);
2604            });
2605          }
2606        }
2607        tweens.map(function(t2) {
2608          return {
2609            g: t2._dur || t2._delay || t2._sat && !t2._sat.vars.immediateRender ? t2.globalTime(0) : -Infinity,
2610            t: t2
2611          };
2612        }).sort(function(a, b) {
2613          return b.g - a.g || -Infinity;
2614        }).forEach(function(o) {
2615          return o.t.revert(revert);
2616        });
2617        i2 = _this4.data.length;
2618        while (i2--) {
2619          t = _this4.data[i2];
2620          if (t instanceof Timeline) {
2621            if (t.data !== "nested") {
2622              t.scrollTrigger && t.scrollTrigger.revert();
2623              t.kill();
2624            }
2625          } else {
2626            !(t instanceof Tween) && t.revert && t.revert(revert);
2627          }
2628        }
2629        _this4._r.forEach(function(f) {
2630          return f(revert, _this4);
2631        });
2632        _this4.isReverted = true;
2633      })();
2634    } else {
2635      this.data.forEach(function(e) {
2636        return e.kill && e.kill();
2637      });
2638    }
2639    this.clear();
2640    if (matchMedia2) {
2641      var i = _media.length;
2642      while (i--) {
2643        _media[i].id === this.id && _media.splice(i, 1);
2644      }
2645    }
2646  };
2647  _proto5.revert = function revert(config3) {
2648    this.kill(config3 || {});
2649  };
2650  return Context2;
2651}();
2652var MatchMedia = /* @__PURE__ */ function() {
2653  function MatchMedia2(scope) {
2654    this.contexts = [];
2655    this.scope = scope;
2656    _context && _context.data.push(this);
2657  }
2658  var _proto6 = MatchMedia2.prototype;
2659  _proto6.add = function add(conditions, func, scope) {
2660    _isObject(conditions) || (conditions = {
2661      matches: conditions
2662    });
2663    var context3 = new Context(0, scope || this.scope), cond = context3.conditions = {}, mq, p, active;
2664    _context && !context3.selector && (context3.selector = _context.selector);
2665    this.contexts.push(context3);
2666    func = context3.add("onMatch", func);
2667    context3.queries = conditions;
2668    for (p in conditions) {
2669      if (p === "all") {
2670        active = 1;
2671      } else {
2672        mq = _win$1.matchMedia(conditions[p]);
2673        if (mq) {
2674          _media.indexOf(context3) < 0 && _media.push(context3);
2675          (cond[p] = mq.matches) && (active = 1);
2676          mq.addListener ? mq.addListener(_onMediaChange) : mq.addEventListener("change", _onMediaChange);
2677        }
2678      }
2679    }
2680    active && func(context3, function(f) {
2681      return context3.add(null, f);
2682    });
2683    return this;
2684  };
2685  _proto6.revert = function revert(config3) {
2686    this.kill(config3 || {});
2687  };
2688  _proto6.kill = function kill(revert) {
2689    this.contexts.forEach(function(c) {
2690      return c.kill(revert, true);
2691    });
2692  };
2693  return MatchMedia2;
2694}();
2695var _gsap = {
2696  registerPlugin: function registerPlugin() {
2697    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
2698      args[_key2] = arguments[_key2];
2699    }
2700    args.forEach(function(config3) {
2701      return _createPlugin(config3);
2702    });
2703  },
2704  timeline: function timeline(vars) {
2705    return new Timeline(vars);
2706  },
2707  getTweensOf: function getTweensOf(targets, onlyActive) {
2708    return _globalTimeline.getTweensOf(targets, onlyActive);
2709  },
2710  getProperty: function getProperty(target, property, unit, uncache) {
2711    _isString(target) && (target = toArray(target)[0]);
2712    var getter = _getCache(target || {}).get, format = unit ? _passThrough : _numericIfPossible;
2713    unit === "native" && (unit = "");
2714    return !target ? target : !property ? function(property2, unit2, uncache2) {
2715      return format((_plugins[property2] && _plugins[property2].get || getter)(target, property2, unit2, uncache2));
2716    } : format((_plugins[property] && _plugins[property].get || getter)(target, property, unit, uncache));
2717  },
2718  quickSetter: function quickSetter(target, property, unit) {
2719    target = toArray(target);
2720    if (target.length > 1) {
2721      var setters = target.map(function(t) {
2722        return gsap.quickSetter(t, property, unit);
2723      }), l = setters.length;
2724      return function(value) {
2725        var i = l;
2726        while (i--) {
2727          setters[i](value);
2728        }
2729      };
2730    }
2731    target = target[0] || {};
2732    var Plugin = _plugins[property], cache = _getCache(target), p = cache.harness && (cache.harness.aliases || {})[property] || property, setter = Plugin ? function(value) {
2733      var p2 = new Plugin();
2734      _quickTween._pt = 0;
2735      p2.init(target, unit ? value + unit : value, _quickTween, 0, [target]);
2736      p2.render(1, p2);
2737      _quickTween._pt && _renderPropTweens(1, _quickTween);
2738    } : cache.set(target, p);
2739    return Plugin ? setter : function(value) {
2740      return setter(target, p, unit ? value + unit : value, cache, 1);
2741    };
2742  },
2743  quickTo: function quickTo(target, property, vars) {
2744    var _merge22;
2745    var tween = gsap.to(target, _merge((_merge22 = {}, _merge22[property] = "+=0.1", _merge22.paused = true, _merge22), vars || {})), func = function func2(value, start, startIsRelative) {
2746      return tween.resetTo(property, value, start, startIsRelative);
2747    };
2748    func.tween = tween;
2749    return func;
2750  },
2751  isTweening: function isTweening(targets) {
2752    return _globalTimeline.getTweensOf(targets, true).length > 0;
2753  },
2754  defaults: function defaults(value) {
2755    value && value.ease && (value.ease = _parseEase(value.ease, _defaults.ease));
2756    return _mergeDeep(_defaults, value || {});
2757  },
2758  config: function config2(value) {
2759    return _mergeDeep(_config, value || {});
2760  },
2761  registerEffect: function registerEffect(_ref3) {
2762    var name = _ref3.name, effect = _ref3.effect, plugins = _ref3.plugins, defaults2 = _ref3.defaults, extendTimeline = _ref3.extendTimeline;
2763    (plugins || "").split(",").forEach(function(pluginName) {
2764      return pluginName && !_plugins[pluginName] && !_globals[pluginName] && _warn(name + " effect requires " + pluginName + " plugin.");
2765    });
2766    _effects[name] = function(targets, vars, tl) {
2767      return effect(toArray(targets), _setDefaults(vars || {}, defaults2), tl);
2768    };
2769    if (extendTimeline) {
2770      Timeline.prototype[name] = function(targets, vars, position) {
2771        return this.add(_effects[name](targets, _isObject(vars) ? vars : (position = vars) && {}, this), position);
2772      };
2773    }
2774  },
2775  registerEase: function registerEase(name, ease) {
2776    _easeMap[name] = _parseEase(ease);
2777  },
2778  parseEase: function parseEase(ease, defaultEase) {
2779    return arguments.length ? _parseEase(ease, defaultEase) : _easeMap;
2780  },
2781  getById: function getById(id) {
2782    return _globalTimeline.getById(id);
2783  },
2784  exportRoot: function exportRoot(vars, includeDelayedCalls) {
2785    if (vars === void 0) {
2786      vars = {};
2787    }
2788    var tl = new Timeline(vars), child, next;
2789    tl.smoothChildTiming = _isNotFalse(vars.smoothChildTiming);
2790    _globalTimeline.remove(tl);
2791    tl._dp = 0;
2792    tl._time = tl._tTime = _globalTimeline._time;
2793    child = _globalTimeline._first;
2794    while (child) {
2795      next = child._next;
2796      if (includeDelayedCalls || !(!child._dur && child instanceof Tween && child.vars.onComplete === child._targets[0])) {