https://www.punchdrunk.com/app/themes/Farlo/dist/assets/scripts/app.js?ver=20260901093223

1var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
2
3var gsap = {exports: {}};
4
5(function (module, exports) {
6  (function (global, factory) {
7    factory(exports) ;
8  })(commonjsGlobal, function (exports) {
9
10    function _inheritsLoose(subClass, superClass) {
11      subClass.prototype = Object.create(superClass.prototype);
12      subClass.prototype.constructor = subClass;
13      subClass.__proto__ = superClass;
14    }
15    function _assertThisInitialized(self) {
16      if (self === void 0) {
17        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
18      }
19      return self;
20    }
21
22    /*!
23     * GSAP 3.11.5
24     * https://greensock.com
25     *
26     * @license Copyright 2008-2023, GreenSock. All rights reserved.
27     * Subject to the terms at https://greensock.com/standard-license or for
28     * Club GreenSock members, the agreement issued with that membership.
29     * @author: Jack Doyle, [email protected]
30    */
31    var _config = {
32        autoSleep: 120,
33        force3D: "auto",
34        nullTargetWarn: 1,
35        units: {
36          lineHeight: ""
37        }
38      },
39      _defaults = {
40        duration: .5,
41        overwrite: false,
42        delay: 0
43      },
44      _suppressOverwrites,
45      _reverting,
46      _context,
47      _bigNum = 1e8,
48      _tinyNum = 1 / _bigNum,
49      _2PI = Math.PI * 2,
50      _HALF_PI = _2PI / 4,
51      _gsID = 0,
52      _sqrt = Math.sqrt,
53      _cos = Math.cos,
54      _sin = Math.sin,
55      _isString = function _isString(value) {
56        return typeof value === "string";
57      },
58      _isFunction = function _isFunction(value) {
59        return typeof value === "function";
60      },
61      _isNumber = function _isNumber(value) {
62        return typeof value === "number";
63      },
64      _isUndefined = function _isUndefined(value) {
65        return typeof value === "undefined";
66      },
67      _isObject = function _isObject(value) {
68        return typeof value === "object";
69      },
70      _isNotFalse = function _isNotFalse(value) {
71        return value !== false;
72      },
73      _windowExists = function _windowExists() {
74        return typeof window !== "undefined";
75      },
76      _isFuncOrString = function _isFuncOrString(value) {
77        return _isFunction(value) || _isString(value);
78      },
79      _isTypedArray = typeof ArrayBuffer === "function" && ArrayBuffer.isView || function () {},
80      _isArray = Array.isArray,
81      _strictNumExp = /(?:-?\.?\d|\.)+/gi,
82      _numExp = /[-+=.]*\d+[.e\-+]*\d*[e\-+]*\d*/g,
83      _numWithUnitExp = /[-+=.]*\d+[.e-]*\d*[a-z%]*/g,
84      _complexStringNumExp = /[-+=.]*\d+\.?\d*(?:e-|e\+)?\d*/gi,
85      _relExp = /[+-]=-?[.\d]+/,
86      _delimitedValueExp = /[^,'"\[\]\s]+/gi,
87      _unitExp = /^[+\-=e\s\d]*\d+[.\d]*([a-z]*|%)\s*$/i,
88      _globalTimeline,
89      _win,
90      _coreInitted,
91      _doc,
92      _globals = {},
93      _installScope = {},
94      _coreReady,
95      _install = function _install(scope) {
96        return (_installScope = _merge(scope, _globals)) && gsap;
97      },
98      _missingPlugin = function _missingPlugin(property, value) {
99        return console.warn("Invalid property", property, "set to", value, "Missing plugin? gsap.registerPlugin()");
100      },
101      _warn = function _warn(message, suppress) {
102        return !suppress && console.warn(message);
103      },
104      _addGlobal = function _addGlobal(name, obj) {
105        return name && (_globals[name] = obj) && _installScope && (_installScope[name] = obj) || _globals;
106      },
107      _emptyFunc = function _emptyFunc() {
108        return 0;
109      },
110      _startAtRevertConfig = {
111        suppressEvents: true,
112        isStart: true,
113        kill: false
114      },
115      _revertConfigNoKill = {
116        suppressEvents: true,
117        kill: false
118      },
119      _revertConfig = {
120        suppressEvents: true
121      },
122      _reservedProps = {},
123      _lazyTweens = [],
124      _lazyLookup = {},
125      _lastRenderedFrame,
126      _plugins = {},
127      _effects = {},
128      _nextGCFrame = 30,
129      _harnessPlugins = [],
130      _callbackNames = "",
131      _harness = function _harness(targets) {
132        var target = targets[0],
133          harnessPlugin,
134          i;
135        _isObject(target) || _isFunction(target) || (targets = [targets]);
136        if (!(harnessPlugin = (target._gsap || {}).harness)) {
137          i = _harnessPlugins.length;
138          while (i-- && !_harnessPlugins[i].targetTest(target)) {}
139          harnessPlugin = _harnessPlugins[i];
140        }
141        i = targets.length;
142        while (i--) {
143          targets[i] && (targets[i]._gsap || (targets[i]._gsap = new GSCache(targets[i], harnessPlugin))) || targets.splice(i, 1);
144        }
145        return targets;
146      },
147      _getCache = function _getCache(target) {
148        return target._gsap || _harness(toArray(target))[0]._gsap;
149      },
150      _getProperty = function _getProperty(target, property, v) {
151        return (v = target[property]) && _isFunction(v) ? target[property]() : _isUndefined(v) && target.getAttribute && target.getAttribute(property) || v;
152      },

153      _forEachName = function _forEachName(names, func) {
154        return (names = names.split(",")).forEach(func) || names;
155      },
156      _round = function _round(value) {
157        return Math.round(value * 100000) / 100000 || 0;
158      },
159      _roundPrecise = function _roundPrecise(value) {
160        return Math.round(value * 10000000) / 10000000 || 0;
161      },
162      _parseRelative = function _parseRelative(start, value) {
163        var operator = value.charAt(0),
164          end = parseFloat(value.substr(2));
165        start = parseFloat(start);
166        return operator === "+" ? start + end : operator === "-" ? start - end : operator === "*" ? start * end : start / end;
167      },
168      _arrayContainsAny = function _arrayContainsAny(toSearch, toFind) {
169        var l = toFind.length,
170          i = 0;
171        for (; toSearch.indexOf(toFind[i]) < 0 && ++i < l;) {}
172        return i < l;
173      },
174      _lazyRender = function _lazyRender() {
175        var l = _lazyTweens.length,
176          a = _lazyTweens.slice(0),
177          i,
178          tween;
179        _lazyLookup = {};
180        _lazyTweens.length = 0;
181        for (i = 0; i < l; i++) {
182          tween = a[i];
183          tween && tween._lazy && (tween.render(tween._lazy[0], tween._lazy[1], true)._lazy = 0);
184        }
185      },
186      _lazySafeRender = function _lazySafeRender(animation, time, suppressEvents, force) {
187        _lazyTweens.length && !_reverting && _lazyRender();
188        animation.render(time, suppressEvents, force || _reverting && time < 0 && (animation._initted || animation._startAt));
189        _lazyTweens.length && !_reverting && _lazyRender();
190      },
191      _numericIfPossible = function _numericIfPossible(value) {
192        var n = parseFloat(value);
193        return (n || n === 0) && (value + "").match(_delimitedValueExp).length < 2 ? n : _isString(value) ? value.trim() : value;
194      },
195      _passThrough = function _passThrough(p) {
196        return p;
197      },
198      _setDefaults = function _setDefaults(obj, defaults) {
199        for (var p in defaults) {
200          p in obj || (obj[p] = defaults[p]);
201        }
202        return obj;
203      },
204      _setKeyframeDefaults = function _setKeyframeDefaults(excludeDuration) {
205        return function (obj, defaults) {
206          for (var p in defaults) {
207            p in obj || p === "duration" && excludeDuration || p === "ease" || (obj[p] = defaults[p]);
208          }
209        };
210      },
211      _merge = function _merge(base, toMerge) {
212        for (var p in toMerge) {
213          base[p] = toMerge[p];
214        }
215        return base;
216      },
217      _mergeDeep = function _mergeDeep(base, toMerge) {
218        for (var p in toMerge) {
219          p !== "__proto__" && p !== "constructor" && p !== "prototype" && (base[p] = _isObject(toMerge[p]) ? _mergeDeep(base[p] || (base[p] = {}), toMerge[p]) : toMerge[p]);
220        }
221        return base;
222      },
223      _copyExcluding = function _copyExcluding(obj, excluding) {
224        var copy = {},
225          p;
226        for (p in obj) {
227          p in excluding || (copy[p] = obj[p]);
228        }
229        return copy;
230      },
231      _inheritDefaults = function _inheritDefaults(vars) {
232        var parent = vars.parent || _globalTimeline,
233          func = vars.keyframes ? _setKeyframeDefaults(_isArray(vars.keyframes)) : _setDefaults;
234        if (_isNotFalse(vars.inherit)) {
235          while (parent) {
236            func(vars, parent.vars.defaults);
237            parent = parent.parent || parent._dp;
238          }
239        }
240        return vars;
241      },
242      _arraysMatch = function _arraysMatch(a1, a2) {
243        var i = a1.length,
244          match = i === a2.length;
245        while (match && i-- && a1[i] === a2[i]) {}
246        return i < 0;
247      },
248      _addLinkedListItem = function _addLinkedListItem(parent, child, firstProp, lastProp, sortBy) {
249        if (firstProp === void 0) {
250          firstProp = "_first";
251        }
252        if (lastProp === void 0) {
253          lastProp = "_last";
254        }
255        var prev = parent[lastProp],
256          t;
257        if (sortBy) {
258          t = child[sortBy];
259          while (prev && prev[sortBy] > t) {
260            prev = prev._prev;
261          }
262        }
263        if (prev) {
264          child._next = prev._next;
265          prev._next = child;
266        } else {
267          child._next = parent[firstProp];
268          parent[firstProp] = child;
269        }
270        if (child._next) {
271          child._next._prev = child;
272        } else {
273          parent[lastProp] = child;
274        }
275        child._prev = prev;
276        child.parent = child._dp = parent;
277        return child;
278      },
279      _removeLinkedListItem = function _removeLinkedListItem(parent, child, firstProp, lastProp) {
280        if (firstProp === void 0) {
281          firstProp = "_first";
282        }
283        if (lastProp === void 0) {
284          lastProp = "_last";
285        }
286        var prev = child._prev,
287          next = child._next;
288        if (prev) {
289          prev._next = next;
290        } else if (parent[firstProp] === child) {
291          parent[firstProp] = next;
292        }
293        if (next) {
294          next._prev = prev;
295        } else if (parent[lastProp] === child) {
296          parent[lastProp] = prev;
297        }
298        child._next = child._prev = child.parent = null;
299      },
300      _removeFromParent = function _removeFromParent(child, onlyIfParentHasAutoRemove) {
301        child.parent && (!onlyIfParentHasAutoRemove || child.parent.autoRemoveChildren) && child.parent.remove(child);
302        child._act = 0;
303      },
304      _uncache = function _uncache(animation, child) {
305        if (animation && (!child || child._end > animation._dur || child._start < 0)) {
306          var a = animation;
307          while (a) {
308            a._dirty = 1;
309            a = a.parent;
310          }
311        }
312        return animation;
313      },
314      _recacheAncestors = function _recacheAncestors(animation) {
315        var parent = animation.parent;
316        while (parent && parent.parent) {
317          parent._dirty = 1;
318          parent.totalDuration();
319          parent = parent.parent;
320        }
321        return animation;
322      },
323      _rewindStartAt = function _rewindStartAt(tween, totalTime, suppressEvents, force) {
324        return tween._startAt && (_reverting ? tween._startAt.revert(_revertConfigNoKill) : tween.vars.immediateRender && !tween.vars.autoRevert || tween._startAt.render(totalTime, true, force));
325      },
326      _hasNoPausedAncestors = function _hasNoPausedAncestors(animation) {
327        return !animation || animation._ts && _hasNoPausedAncestors(animation.parent);
328      },
329      _elapsedCycleDuration = function _elapsedCycleDuration(animation) {
330        return animation._repeat ? _animationCycle(animation._tTime, animation = animation.duration() + animation._rDelay) * animation : 0;
331      },
332      _animationCycle = function _animationCycle(tTime, cycleDuration) {
333        var whole = Math.floor(tTime /= cycleDuration);
334        return tTime && whole === tTime ? whole - 1 : whole;
335      },
336      _parentToChildTotalTime = function _parentToChildTotalTime(parentTime, child) {
337        return (parentTime - child._start) * child._ts + (child._ts >= 0 ? 0 : child._dirty ? child.totalDuration() : child._tDur);
338      },
339      _setEnd = function _setEnd(animation) {
340        return animation._end = _roundPrecise(animation._start + (animation._tDur / Math.abs(animation._ts || animation._rts || _tinyNum) || 0));
341      },
342      _alignPlayhead = function _alignPlayhead(animation, totalTime) {
343        var parent = animation._dp;
344        if (parent && parent.smoothChildTiming && animation._ts) {
345          animation._start = _roundPrecise(parent._time - (animation._ts > 0 ? totalTime / animation._ts : ((animation._dirty ? animation.totalDuration() : animation._tDur) - totalTime) / -animation._ts));
346          _setEnd(animation);
347          parent._dirty || _uncache(parent, animation);
348        }
349        return animation;
350      },
351      _postAddChecks = function _postAddChecks(timeline, child) {
352        var t;
353        if (child._time || child._initted && !child._dur) {
354          t = _parentToChildTotalTime(timeline.rawTime(), child);
355          if (!child._dur || _clamp(0, child.totalDuration(), t) - child._tTime > _tinyNum) {
356            child.render(t, true);
357          }
358        }
359        if (_uncache(timeline, child)._dp && timeline._initted && timeline._time >= timeline._dur && timeline._ts) {
360          if (timeline._dur < timeline.duration()) {
361            t = timeline;
362            while (t._dp) {
363              t.rawTime() >= 0 && t.totalTime(t._tTime);
364              t = t._dp;
365            }
366          }
367          timeline._zTime = -_tinyNum;
368        }
369      },
370      _addToTimeline = function _addToTimeline(timeline, child, position, skipChecks) {
371        child.parent && _removeFromParent(child);
372        child._start = _roundPrecise((_isNumber(position) ? position : position || timeline !== _globalTimeline ? _parsePosition(timeline, position, child) : timeline._time) + child._delay);
373        child._end = _roundPrecise(child._start + (child.totalDuration() / Math.abs(child.timeScale()) || 0));
374        _addLinkedListItem(timeline, child, "_first", "_last", timeline._sort ? "_start" : 0);
375        _isFromOrFromStart(child) || (timeline._recent = child);
376        skipChecks || _postAddChecks(timeline, child);
377        timeline._ts < 0 && _alignPlayhead(timeline, timeline._tTime);
378        return timeline;
379      },
380      _scrollTrigger = function _scrollTrigger(animation, trigger) {
381        return (_globals.ScrollTrigger || _missingPlugin("scrollTrigger", trigger)) && _globals.ScrollTrigger.create(trigger, animation);
382      },
383      _attemptInitTween = function _attemptInitTween(tween, time, force, suppressEvents, tTime) {
384        _initTween(tween, time, tTime);
385        if (!tween._initted) {
386          return 1;
387        }
388        if (!force && tween._pt && !_reverting && (tween._dur && tween.vars.lazy !== false || !tween._dur && tween.vars.lazy) && _lastRenderedFrame !== _ticker.frame) {
389          _lazyTweens.push(tween);
390          tween._lazy = [tTime, suppressEvents];
391          return 1;
392        }
393      },
394      _parentPlayheadIsBeforeStart = function _parentPlayheadIsBeforeStart(_ref) {
395        var parent = _ref.parent;
396        return parent && parent._ts && parent._initted && !parent._lock && (parent.rawTime() < 0 || _parentPlayheadIsBeforeStart(parent));
397      },
398      _isFromOrFromStart = function _isFromOrFromStart(_ref2) {
399        var data = _ref2.data;
400        return data === "isFromStart" || data === "isStart";
401      },
402      _renderZeroDurationTween = function _renderZeroDurationTween(tween, totalTime, suppressEvents, force) {
403        var prevRatio = tween.ratio,
404          ratio = totalTime < 0 || !totalTime && (!tween._start && _parentPlayheadIsBeforeStart(tween) && !(!tween._initted && _isFromOrFromStart(tween)) || (tween._ts < 0 || tween._dp._ts < 0) && !_isFromOrFromStart(tween)) ? 0 : 1,
405          repeatDelay = tween._rDelay,
406          tTime = 0,
407          pt,
408          iteration,
409          prevIteration;
410        if (repeatDelay && tween._repeat) {
411          tTime = _clamp(0, tween._tDur, totalTime);
412          iteration = _animationCycle(tTime, repeatDelay);
413          tween._yoyo && iteration & 1 && (ratio = 1 - ratio);
414          if (iteration !== _animationCycle(tween._tTime, repeatDelay)) {
415            prevRatio = 1 - ratio;
416            tween.vars.repeatRefresh && tween._initted && tween.invalidate();
417          }
418        }
419        if (ratio !== prevRatio || _reverting || force || tween._zTime === _tinyNum || !totalTime && tween._zTime) {
420          if (!tween._initted && _attemptInitTween(tween, totalTime, force, suppressEvents, tTime)) {
421            return;
422          }
423          prevIteration = tween._zTime;
424          tween._zTime = totalTime || (suppressEvents ? _tinyNum : 0);
425          suppressEvents || (suppressEvents = totalTime && !prevIteration);
426          tween.ratio = ratio;
427          tween._from && (ratio = 1 - ratio);
428          tween._time = 0;
429          tween._tTime = tTime;
430          pt = tween._pt;
431          while (pt) {
432            pt.r(ratio, pt.d);
433            pt = pt._next;
434          }
435          totalTime < 0 && _rewindStartAt(tween, totalTime, suppressEvents, true);
436          tween._onUpdate && !suppressEvents && _callback(tween, "onUpdate");
437          tTime && tween._repeat && !suppressEvents && tween.parent && _callback(tween, "onRepeat");
438          if ((totalTime >= tween._tDur || totalTime < 0) && tween.ratio === ratio) {
439            ratio && _removeFromParent(tween, 1);
440            if (!suppressEvents && !_reverting) {
441              _callback(tween, ratio ? "onComplete" : "onReverseComplete", true);
442              tween._prom && tween._prom();
443            }
444          }
445        } else if (!tween._zTime) {
446          tween._zTime = totalTime;
447        }
448      },
449      _findNextPauseTween = function _findNextPauseTween(animation, prevTime, time) {
450        var child;
451        if (time > prevTime) {
452          child = animation._first;
453          while (child && child._start <= time) {
454            if (child.data === "isPause" && child._start > prevTime) {
455              return child;
456            }
457            child = child._next;
458          }
459        } else {
460          child = animation._last;
461          while (child && child._start >= time) {
462            if (child.data === "isPause" && child._start < prevTime) {
463              return child;
464            }
465            child = child._prev;
466          }
467        }
468      },
469      _setDuration = function _setDuration(animation, duration, skipUncache, leavePlayhead) {
470        var repeat = animation._repeat,
471          dur = _roundPrecise(duration) || 0,
472          totalProgress = animation._tTime / animation._tDur;
473        totalProgress && !leavePlayhead && (animation._time *= dur / animation._dur);
474        animation._dur = dur;
475        animation._tDur = !repeat ? dur : repeat < 0 ? 1e10 : _roundPrecise(dur * (repeat + 1) + animation._rDelay * repeat);
476        totalProgress > 0 && !leavePlayhead && _alignPlayhead(animation, animation._tTime = animation._tDur * totalProgress);
477        animation.parent && _setEnd(animation);
478        skipUncache || _uncache(animation.parent, animation);
479        return animation;
480      },
481      _onUpdateTotalDuration = function _onUpdateTotalDuration(animation) {
482        return animation instanceof Timeline ? _uncache(animation) : _setDuration(animation, animation._dur);
483      },
484      _zeroPosition = {
485        _start: 0,
486        endTime: _emptyFunc,
487        totalDuration: _emptyFunc
488      },
489      _parsePosition = function _parsePosition(animation, position, percentAnimation) {
490        var labels = animation.labels,
491          recent = animation._recent || _zeroPosition,
492          clippedDuration = animation.duration() >= _bigNum ? recent.endTime(false) : animation._dur,
493          i,
494          offset,
495          isPercent;
496        if (_isString(position) && (isNaN(position) || position in labels)) {
497          offset = position.charAt(0);
498          isPercent = position.substr(-1) === "%";
499          i = position.indexOf("=");
500          if (offset === "<" || offset === ">") {
501            i >= 0 && (position = position.replace(/=/, ""));
502            return (offset === "<" ? recent._start : recent.endTime(recent._repeat >= 0)) + (parseFloat(position.substr(1)) || 0) * (isPercent ? (i < 0 ? recent : percentAnimation).totalDuration() / 100 : 1);
503          }
504          if (i < 0) {
505            position in labels || (labels[position] = clippedDuration);
506            return labels[position];
507          }
508          offset = parseFloat(position.charAt(i - 1) + position.substr(i + 1));
509          if (isPercent && percentAnimation) {
510            offset = offset / 100 * (_isArray(percentAnimation) ? percentAnimation[0] : percentAnimation).totalDuration();
511          }
512          return i > 1 ? _parsePosition(animation, position.substr(0, i - 1), percentAnimation) + offset : clippedDuration + offset;
513        }
514        return position == null ? clippedDuration : +position;
515      },
516      _createTweenType = function _createTweenType(type, params, timeline) {
517        var isLegacy = _isNumber(params[1]),
518          varsIndex = (isLegacy ? 2 : 1) + (type < 2 ? 0 : 1),
519          vars = params[varsIndex],
520          irVars,
521          parent;
522        isLegacy && (vars.duration = params[1]);
523        vars.parent = timeline;
524        if (type) {
525          irVars = vars;
526          parent = timeline;
527          while (parent && !("immediateRender" in irVars)) {
528            irVars = parent.vars.defaults || {};
529            parent = _isNotFalse(parent.vars.inherit) && parent.parent;
530          }
531          vars.immediateRender = _isNotFalse(irVars.immediateRender);
532          type < 2 ? vars.runBackwards = 1 : vars.startAt = params[varsIndex - 1];
533        }
534        return new Tween(params[0], vars, params[varsIndex + 1]);
535      },
536      _conditionalReturn = function _conditionalReturn(value, func) {
537        return value || value === 0 ? func(value) : func;
538      },
539      _clamp = function _clamp(min, max, value) {
540        return value < min ? min : value > max ? max : value;
541      },
542      getUnit = function getUnit(value, v) {
543        return !_isString(value) || !(v = _unitExp.exec(value)) ? "" : v[1];
544      },
545      clamp = function clamp(min, max, value) {
546        return _conditionalReturn(value, function (v) {
547          return _clamp(min, max, v);
548        });
549      },
550      _slice = [].slice,
551      _isArrayLike = function _isArrayLike(value, nonEmpty) {
552        return value && _isObject(value) && "length" in value && (!nonEmpty && !value.length || value.length - 1 in value && _isObject(value[0])) && !value.nodeType && value !== _win;
553      },
554      _flatten = function _flatten(ar, leaveStrings, accumulator) {
555        if (accumulator === void 0) {
556          accumulator = [];
557        }
558        return ar.forEach(function (value) {
559          var _accumulator;
560          return _isString(value) && !leaveStrings || _isArrayLike(value, 1) ? (_accumulator = accumulator).push.apply(_accumulator, toArray(value)) : accumulator.push(value);
561        }) || accumulator;
562      },
563      toArray = function toArray(value, scope, leaveStrings) {
564        return _context && !scope && _context.selector ? _context.selector(value) : _isString(value) && !leaveStrings && (_coreInitted || !_wake()) ? _slice.call((scope || _doc).querySelectorAll(value), 0) : _isArray(value) ? _flatten(value, leaveStrings) : _isArrayLike(value) ? _slice.call(value, 0) : value ? [value] : [];
565      },
566      selector = function selector(value) {
567        value = toArray(value)[0] || _warn("Invalid scope") || {};
568        return function (v) {
569          var el = value.current || value.nativeElement || value;
570          return toArray(v, el.querySelectorAll ? el : el === value ? _warn("Invalid scope") || _doc.createElement("div") : value);
571        };
572      },
573      shuffle = function shuffle(a) {
574        return a.sort(function () {
575          return .5 - Math.random();
576        });
577      },
578      distribute = function distribute(v) {
579        if (_isFunction(v)) {
580          return v;
581        }
582        var vars = _isObject(v) ? v : {
583            each: v
584          },
585          ease = _parseEase(vars.ease),
586          from = vars.from || 0,
587          base = parseFloat(vars.base) || 0,
588          cache = {},
589          isDecimal = from > 0 && from < 1,
590          ratios = isNaN(from) || isDecimal,
591          axis = vars.axis,
592          ratioX = from,
593          ratioY = from;
594        if (_isString(from)) {
595          ratioX = ratioY = {
596            center: .5,
597            edges: .5,
598            end: 1
599          }[from] || 0;
600        } else if (!isDecimal && ratios) {
601          ratioX = from[0];
602          ratioY = from[1];
603        }
604        return function (i, target, a) {
605          var l = (a || vars).length,
606            distances = cache[l],
607            originX,
608            originY,
609            x,
610            y,
611            d,
612            j,
613            max,
614            min,
615            wrapAt;
616          if (!distances) {
617            wrapAt = vars.grid === "auto" ? 0 : (vars.grid || [1, _bigNum])[1];
618            if (!wrapAt) {
619              max = -_bigNum;
620              while (max < (max = a[wrapAt++].getBoundingClientRect().left) && wrapAt < l) {}
621              wrapAt--;
622            }
623            distances = cache[l] = [];
624            originX = ratios ? Math.min(wrapAt, l) * ratioX - .5 : from % wrapAt;
625            originY = wrapAt === _bigNum ? 0 : ratios ? l * ratioY / wrapAt - .5 : from / wrapAt | 0;
626            max = 0;
627            min = _bigNum;
628            for (j = 0; j < l; j++) {
629              x = j % wrapAt - originX;
630              y = originY - (j / wrapAt | 0);
631              distances[j] = d = !axis ? _sqrt(x * x + y * y) : Math.abs(axis === "y" ? y : x);
632              d > max && (max = d);
633              d < min && (min = d);
634            }
635            from === "random" && shuffle(distances);
636            distances.max = max - min;
637            distances.min = min;
638            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);
639            distances.b = l < 0 ? base - l : base;
640            distances.u = getUnit(vars.amount || vars.each) || 0;
641            ease = ease && l < 0 ? _invertEase(ease) : ease;
642          }
643          l = (distances[i] - distances.min) / distances.max || 0;
644          return _roundPrecise(distances.b + (ease ? ease(l) : l) * distances.v) + distances.u;
645        };
646      },
647      _roundModifier = function _roundModifier(v) {
648        var p = Math.pow(10, ((v + "").split(".")[1] || "").length);
649        return function (raw) {
650          var n = _roundPrecise(Math.round(parseFloat(raw) / v) * v * p);
651          return (n - n % 1) / p + (_isNumber(raw) ? 0 : getUnit(raw));
652        };
653      },
654      snap = function snap(snapTo, value) {
655        var isArray = _isArray(snapTo),
656          radius,
657          is2D;
658        if (!isArray && _isObject(snapTo)) {
659          radius = isArray = snapTo.radius || _bigNum;
660          if (snapTo.values) {
661            snapTo = toArray(snapTo.values);
662            if (is2D = !_isNumber(snapTo[0])) {
663              radius *= radius;
664            }
665          } else {
666            snapTo = _roundModifier(snapTo.increment);
667          }
668        }
669        return _conditionalReturn(value, !isArray ? _roundModifier(snapTo) : _isFunction(snapTo) ? function (raw) {
670          is2D = snapTo(raw);
671          return Math.abs(is2D - raw) <= radius ? is2D : raw;
672        } : function (raw) {
673          var x = parseFloat(is2D ? raw.x : raw),
674            y = parseFloat(is2D ? raw.y : 0),
675            min = _bigNum,
676            closest = 0,
677            i = snapTo.length,
678            dx,
679            dy;
680          while (i--) {
681            if (is2D) {
682              dx = snapTo[i].x - x;
683              dy = snapTo[i].y - y;
684              dx = dx * dx + dy * dy;
685            } else {
686              dx = Math.abs(snapTo[i] - x);
687            }
688            if (dx < min) {
689              min = dx;
690              closest = i;
691            }
692          }
693          closest = !radius || min <= radius ? snapTo[closest] : raw;
694          return is2D || closest === raw || _isNumber(raw) ? closest : closest + getUnit(raw);
695        });
696      },
697      random = function random(min, max, roundingIncrement, returnFunction) {
698        return _conditionalReturn(_isArray(min) ? !max : roundingIncrement === true ? !!(roundingIncrement = 0) : !returnFunction, function () {
699          return _isArray(min) ? min[~~(Math.random() * min.length)] : (roundingIncrement = roundingIncrement || 1e

699-5) && (returnFunction = roundingIncrement < 1 ? Math.pow(10, (roundingIncrement + "").length - 2) : 1) && Math.floor(Math.round((min - roundingIncrement / 2 + Math.random() * (max - min + roundingIncrement * .99)) / roundingIncrement) * roundingIncrement * returnFunction) / returnFunction;
700        });
701      },
702      pipe = function pipe() {
703        for (var _len = arguments.length, functions = new Array(_len), _key = 0; _key < _len; _key++) {
704          functions[_key] = arguments[_key];
705        }
706        return function (value) {
707          return functions.reduce(function (v, f) {
708            return f(v);
709          }, value);
710        };
711      },
712      unitize = function unitize(func, unit) {
713        return function (value) {
714          return func(parseFloat(value)) + (unit || getUnit(value));
715        };
716      },
717      normalize = function normalize(min, max, value) {
718        return mapRange(min, max, 0, 1, value);
719      },
720      _wrapArray = function _wrapArray(a, wrapper, value) {
721        return _conditionalReturn(value, function (index) {
722          return a[~~wrapper(index)];
723        });
724      },
725      wrap = function wrap(min, max, value) {
726        var range = max - min;
727        return _isArray(min) ? _wrapArray(min, wrap(0, min.length), max) : _conditionalReturn(value, function (value) {
728          return (range + (value - min) % range) % range + min;
729        });
730      },
731      wrapYoyo = function wrapYoyo(min, max, value) {
732        var range = max - min,
733          total = range * 2;
734        return _isArray(min) ? _wrapArray(min, wrapYoyo(0, min.length - 1), max) : _conditionalReturn(value, function (value) {
735          value = (total + (value - min) % total) % total || 0;
736          return min + (value > range ? total - value : value);
737        });
738      },
739      _replaceRandom = function _replaceRandom(value) {
740        var prev = 0,
741          s = "",
742          i,
743          nums,
744          end,
745          isArray;
746        while (~(i = value.indexOf("random(", prev))) {
747          end = value.indexOf(")", i);
748          isArray = value.charAt(i + 7) === "[";
749          nums = value.substr(i + 7, end - i - 7).match(isArray ? _delimitedValueExp : _strictNumExp);
750          s += value.substr(prev, i - prev) + random(isArray ? nums : +nums[0], isArray ? 0 : +nums[1], +nums[2] || 1e-5);
751          prev = end + 1;
752        }
753        return s + value.substr(prev, value.length - prev);
754      },
755      mapRange = function mapRange(inMin, inMax, outMin, outMax, value) {
756        var inRange = inMax - inMin,
757          outRange = outMax - outMin;
758        return _conditionalReturn(value, function (value) {
759          return outMin + ((value - inMin) / inRange * outRange || 0);
760        });
761      },
762      interpolate = function interpolate(start, end, progress, mutate) {
763        var func = isNaN(start + end) ? 0 : function (p) {
764          return (1 - p) * start + p * end;
765        };
766        if (!func) {
767          var isString = _isString(start),
768            master = {},
769            p,
770            i,
771            interpolators,
772            l,
773            il;
774          progress === true && (mutate = 1) && (progress = null);
775          if (isString) {
776            start = {
777              p: start
778            };
779            end = {
780              p: end
781            };
782          } else if (_isArray(start) && !_isArray(end)) {
783            interpolators = [];
784            l = start.length;
785            il = l - 2;
786            for (i = 1; i < l; i++) {
787              interpolators.push(interpolate(start[i - 1], start[i]));
788            }
789            l--;
790            func = function func(p) {
791              p *= l;
792              var i = Math.min(il, ~~p);
793              return interpolators[i](p - i);
794            };
795            progress = end;
796          } else if (!mutate) {
797            start = _merge(_isArray(start) ? [] : {}, start);
798          }
799          if (!interpolators) {
800            for (p in end) {
801              _addPropTween.call(master, start, p, "get", end[p]);
802            }
803            func = function func(p) {
804              return _renderPropTweens(p, master) || (isString ? start.p : start);
805            };
806          }
807        }
808        return _conditionalReturn(progress, func);
809      },
810      _getLabelInDirection = function _getLabelInDirection(timeline, fromTime, backward) {
811        var labels = timeline.labels,
812          min = _bigNum,
813          p,
814          distance,
815          label;
816        for (p in labels) {
817          distance = labels[p] - fromTime;
818          if (distance < 0 === !!backward && distance && min > (distance = Math.abs(distance))) {
819            label = p;
820            min = distance;
821          }
822        }
823        return label;
824      },
825      _callback = function _callback(animation, type, executeLazyFirst) {
826        var v = animation.vars,
827          callback = v[type],
828          prevContext = _context,
829          context = animation._ctx,
830          params,
831          scope,
832          result;
833        if (!callback) {
834          return;
835        }
836        params = v[type + "Params"];
837        scope = v.callbackScope || animation;
838        executeLazyFirst && _lazyTweens.length && _lazyRender();
839        context && (_context = context);
840        result = params ? callback.apply(scope, params) : callback.call(scope);
841        _context = prevContext;
842        return result;
843      },

844      _interrupt = function _interrupt(animation) {
845        _removeFromParent(animation);
846        animation.scrollTrigger && animation.scrollTrigger.kill(!!_reverting);
847        animation.progress() < 1 && _callback(animation, "onInterrupt");
848        return animation;
849      },
850      _quickTween,
851      _registerPluginQueue = [],
852      _createPlugin = function _createPlugin(config) {
853        if (!_windowExists()) {
854          _registerPluginQueue.push(config);
855          return;
856        }
857        config = !config.name && config["default"] || config;
858        var name = config.name,
859          isFunc = _isFunction(config),
860          Plugin = name && !isFunc && config.init ? function () {
861            this._props = [];
862          } : config,
863          instanceDefaults = {
864            init: _emptyFunc,
865            render: _renderPropTweens,
866            add: _addPropTween,
867            kill: _killPropTweensOf,
868            modifier: _addPluginModifier,
869            rawVars: 0
870          },
871          statics = {
872            targetTest: 0,
873            get: 0,
874            getSetter: _getSetter,
875            aliases: {},
876            register: 0
877          };
878        _wake();
879        if (config !== Plugin) {
880          if (_plugins[name]) {
881            return;
882          }
883          _setDefaults(Plugin, _setDefaults(_copyExcluding(config, instanceDefaults), statics));
884          _merge(Plugin.prototype, _merge(instanceDefaults, _copyExcluding(config, statics)));
885          _plugins[Plugin.prop = name] = Plugin;
886          if (config.targetTest) {
887            _harnessPlugins.push(Plugin);
888            _reservedProps[name] = 1;
889          }
890          name = (name === "css" ? "CSS" : name.charAt(0).toUpperCase() + name.substr(1)) + "Plugin";
891        }
892        _addGlobal(name, Plugin);
893        config.register && config.register(gsap, Plugin, PropTween);
894      },
895      _255 = 255,
896      _colorLookup = {
897        aqua: [0, _255, _255],
898        lime: [0, _255, 0],
899        silver: [192, 192, 192],
900        black: [0, 0, 0],
901        maroon: [128, 0, 0],
902        teal: [0, 128, 128],
903        blue: [0, 0, _255],
904        navy: [0, 0, 128],
905        white: [_255, _255, _255],
906        olive: [128, 128, 0],
907        yellow: [_255, _255, 0],
908        orange: [_255, 165, 0],
909        gray: [128, 128, 128],
910        purple: [128, 0, 128],
911        green: [0, 128, 0],
912        red: [_255, 0, 0],
913        pink: [_255, 192, 203],
914        cyan: [0, _255, _255],
915        transparent: [_255, _255, _255, 0]
916      },
917      _hue = function _hue(h, m1, m2) {
918        h += h < 0 ? 1 : h > 1 ? -1 : 0;
919        return (h * 6 < 1 ? m1 + (m2 - m1) * h * 6 : h < .5 ? m2 : h * 3 < 2 ? m1 + (m2 - m1) * (2 / 3 - h) * 6 : m1) * _255 + .5 | 0;
920      },
921      splitColor = function splitColor(v, toHSL, forceAlpha) {
922        var a = !v ? _colorLookup.black : _isNumber(v) ? [v >> 16, v >> 8 & _255, v & _255] : 0,
923          r,
924          g,
925          b,
926          h,
927          s,
928          l,
929          max,
930          min,
931          d,
932          wasHSL;
933        if (!a) {
934          if (v.substr(-1) === ",") {
935            v = v.substr(0, v.length - 1);
936          }
937          if (_colorLookup[v]) {
938            a = _colorLookup[v];
939          } else if (v.charAt(0) === "#") {
940            if (v.length < 6) {
941              r = v.charAt(1);
942              g = v.charAt(2);
943              b = v.charAt(3);
944              v = "#" + r + r + g + g + b + b + (v.length === 5 ? v.charAt(4) + v.charAt(4) : "");
945            }
946            if (v.length === 9) {
947              a = parseInt(v.substr(1, 6), 16);
948              return [a >> 16, a >> 8 & _255, a & _255, parseInt(v.substr(7), 16) / 255];
949            }
950            v = parseInt(v.substr(1), 16);
951            a = [v >> 16, v >> 8 & _255, v & _255];
952          } else if (v.substr(0, 3) === "hsl") {
953            a = wasHSL = v.match(_strictNumExp);
954            if (!toHSL) {
955              h = +a[0] % 360 / 360;
956              s = +a[1] / 100;
957              l = +a[2] / 100;
958              g = l <= .5 ? l * (s + 1) : l + s - l * s;
959              r = l * 2 - g;
960              a.length > 3 && (a[3] *= 1);
961              a[0] = _hue(h + 1 / 3, r, g);
962              a[1] = _hue(h, r, g);
963              a[2] = _hue(h - 1 / 3, r, g);
964            } else if (~v.indexOf("=")) {
965              a = v.match(_numExp);
966              forceAlpha && a.length < 4 && (a[3] = 1);
967              return a;
968            }
969          } else {
970            a = v.match(_strictNumExp) || _colorLookup.transparent;
971          }
972          a = a.map(Number);
973        }
974        if (toHSL && !wasHSL) {
975          r = a[0] / _255;
976          g = a[1] / _255;
977          b = a[2] / _255;
978          max = Math.max(r, g, b);
979          min = Math.min(r, g, b);
980          l = (max + min) / 2;
981          if (max === min) {
982            h = s = 0;
983          } else {
984            d = max - min;
985            s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
986            h = max === r ? (g - b) / d + (g < b ? 6 : 0) : max === g ? (b - r) / d + 2 : (r - g) / d + 4;
987            h *= 60;
988          }
989          a[0] = ~~(h + .5);
990          a[1] = ~~(s * 100 + .5);
991          a[2] = ~~(l * 100 + .5);
992        }
993        forceAlpha && a.length < 4 && (a[3] = 1);
994        return a;
995      },
996      _colorOrderData = function _colorOrderData(v) {
997        var values = [],
998          c = [],
999          i = -1;
1000        v.split(_colorExp).forEach(function (v) {
1001          var a = v.match(_numWithUnitExp) || [];
1002          values.push.apply(values, a);
1003          c.push(i += a.length + 1);
1004        });
1005        values.c = c;
1006        return values;
1007      },
1008      _formatColors = function _formatColors(s, toHSL, orderMatchData) {
1009        var result = "",
1010          colors = (s + result).match(_colorExp),
1011          type = toHSL ? "hsla(" : "rgba(",
1012          i = 0,
1013          c,
1014          shell,
1015          d,
1016          l;
1017        if (!colors) {
1018          return s;
1019        }
1020        colors = colors.map(function (color) {
1021          return (color = splitColor(color, toHSL, 1)) && type + (toHSL ? color[0] + "," + color[1] + "%," + color[2] + "%," + color[3] : color.join(",")) + ")";
1022        });
1023        if (orderMatchData) {
1024          d = _colorOrderData(s);
1025          c = orderMatchData.c;
1026          if (c.join(result) !== d.c.join(result)) {
1027            shell = s.replace(_colorExp, "1").split(_numWithUnitExp);
1028            l = shell.length - 1;
1029            for (; i < l; i++) {
1030              result += shell[i] + (~c.indexOf(i) ? colors.shift() || type + "0,0,0,0)" : (d.length ? d : colors.length ? colors : orderMatchData).shift());
1031            }
1032          }
1033        }
1034        if (!shell) {
1035          shell = s.split(_colorExp);
1036          l = shell.length - 1;
1037          for (; i < l; i++) {
1038            result += shell[i] + colors[i];
1039          }
1040        }
1041        return result + shell[l];
1042      },
1043      _colorExp = function () {
1044        var s = "(?:\\b(?:(?:rgb|rgba|hsl|hsla)\\(.+?\\))|\\B#(?:[0-9a-f]{3,4}){1,2}\\b",
1045          p;
1046        for (p in _colorLookup) {
1047          s += "|" + p + "\\b";
1048        }
1049        return new RegExp(s + ")", "gi");
1050      }(),
1051      _hslExp = /hsl[a]?\(/,
1052      _colorStringFilter = function _colorStringFilter(a) {
1053        var combined = a.join(" "),
1054          toHSL;
1055        _colorExp.lastIndex = 0;
1056        if (_colorExp.test(combined)) {
1057          toHSL = _hslExp.test(combined);
1058          a[1] = _formatColors(a[1], toHSL);
1059          a[0] = _formatColors(a[0], toHSL, _colorOrderData(a[1]));
1060          return true;
1061        }
1062      },
1063      _tickerActive,
1064      _ticker = function () {
1065        var _getTime = Date.now,
1066          _lagThreshold = 500,
1067          _adjustedLag = 33,
1068          _startTime = _getTime(),
1069          _lastUpdate = _startTime,
1070          _gap = 1000 / 240,
1071          _nextTime = _gap,
1072          _listeners = [],
1073          _id,
1074          _req,
1075          _raf,
1076          _self,
1077          _delta,
1078          _i,
1079          _tick = function _tick(v) {
1080            var elapsed = _getTime() - _lastUpdate,
1081              manual = v === true,
1082              overlap,
1083              dispatch,
1084              time,
1085              frame;
1086            elapsed > _lagThreshold && (_startTime += elapsed - _adjustedLag);
1087            _lastUpdate += elapsed;
1088            time = _lastUpdate - _startTime;
1089            overlap = time - _nextTime;
1090            if (overlap > 0 || manual) {
1091              frame = ++_self.frame;
1092              _delta = time - _self.time * 1000;
1093              _self.time = time = time / 1000;
1094              _nextTime += overlap + (overlap >= _gap ? 4 : _gap - overlap);
1095              dispatch = 1;
1096            }
1097            manual || (_id = _req(_tick));
1098            if (dispatch) {
1099              for (_i = 0; _i < _listeners.length; _i++) {
1100                _listeners[_i](time, _delta, frame, v);
1101              }
1102            }
1103          };
1104        _self = {
1105          time: 0,
1106          frame: 0,
1107          tick: function tick() {
1108            _tick(true);
1109          },
1110          deltaRatio: function deltaRatio(fps) {
1111            return _delta / (1000 / (fps || 60));
1112          },
1113          wake: function wake() {
1114            if (_coreReady) {
1115              if (!_coreInitted && _windowExists()) {
1116                _win = _coreInitted = window;
1117                _doc = _win.document || {};
1118                _globals.gsap = gsap;
1119                (_win.gsapVersions || (_win.gsapVersions = [])).push(gsap.version);
1120                _install(_installScope || _win.GreenSockGlobals || !_win.gsap && _win || {});
1121                _raf = _win.requestAnimationFrame;
1122                _registerPluginQueue.forEach(_createPlugin);
1123              }
1124              _id && _self.sleep();
1125              _req = _raf || function (f) {
1126                return setTimeout(f, _nextTime - _self.time * 1000 + 1 | 0);
1127              };
1128              _tickerActive = 1;
1129              _tick(2);
1130            }
1131          },
1132          sleep: function sleep() {
1133            (_raf ? _win.cancelAnimationFrame : clearTimeout)(_id);
1134            _tickerActive = 0;
1135            _req = _emptyFunc;
1136          },
1137          lagSmoothing: function lagSmoothing(threshold, adjustedLag) {
1138            _lagThreshold = threshold || Infinity;
1139            _adjustedLag = Math.min(adjustedLag || 33, _lagThreshold);
1140          },
1141          fps: function fps(_fps) {
1142            _gap = 1000 / (_fps || 240);
1143            _nextTime = _self.time * 1000 + _gap;
1144          },
1145          add: function add(callback, once, prioritize) {
1146            var func = once ? function (t, d, f, v) {
1147              callback(t, d, f, v);
1148              _self.remove(func);
1149            } : callback;
1150            _self.remove(callback);
1151            _listeners[prioritize ? "unshift" : "push"](func);
1152            _wake();
1153            return func;
1154          },
1155          remove: function remove(callback, i) {
1156            ~(i = _listeners.indexOf(callback)) && _listeners.splice(i, 1) && _i >= i && _i--;
1157          },
1158          _listeners: _listeners
1159        };
1160        return _self;
1161      }(),
1162      _wake = function _wake() {
1163        return !_tickerActive && _ticker.wake();
1164      },
1165      _easeMap = {},
1166      _customEaseExp = /^[\d.\-M][\d.\-,\s]/,
1167      _quotesExp = /["']/g,
1168      _parseObjectInString = function _parseObjectInString(value) {
1169        var obj = {},
1170          split = value.substr(1, value.length - 3).split(":"),
1171          key = split[0],
1172          i = 1,
1173          l = split.length,
1174          index,
1175          val,
1176          parsedVal;
1177        for (; i < l; i++) {
1178          val = split[i];
1179          index = i !== l - 1 ? val.lastIndexOf(",") : val.length;
1180          parsedVal = val.substr(0, index);
1181          obj[key] = isNaN(parsedVal) ? parsedVal.replace(_quotesExp, "").trim() : +parsedVal;
1182          key = val.substr(index + 1).trim();
1183        }
1184        return obj;
1185      },
1186      _valueInParentheses = function _valueInParentheses(value) {
1187        var open = value.indexOf("(") + 1,
1188          close = value.indexOf(")"),
1189          nested = value.indexOf("(", open);
1190        return value.substring(open, ~nested && nested < close ? value.indexOf(")", close + 1) : close);
1191      },
1192      _configEaseFromString = function _configEaseFromString(name) {
1193        var split = (name + "").split("("),
1194          ease = _easeMap[split[0]];
1195        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;
1196      },
1197      _invertEase = function _invertEase(ease) {
1198        return function (p) {
1199          return 1 - ease(1 - p);
1200        };
1201      },
1202      _propagateYoyoEase = function _propagateYoyoEase(timeline, isYoyo) {
1203        var child = timeline._first,
1204          ease;
1205        while (child) {
1206          if (child instanceof Timeline) {
1207            _propagateYoyoEase(child, isYoyo);
1208          } else if (child.vars.yoyoEase && (!child._yoyo || !child._repeat) && child._yoyo !== isYoyo) {
1209            if (child.timeline) {
1210              _propagateYoyoEase(child.timeline, isYoyo);
1211            } else {
1212              ease = child._ease;
1213              child._ease = child._yEase;
1214              child._yEase = ease;
1215              child._yoyo = isYoyo;
1216            }
1217          }
1218          child = child._next;
1219        }
1220      },
1221      _parseEase = function _parseEase(ease, defaultEase) {
1222        return !ease ? defaultEase : (_isFunction(ease) ? ease : _easeMap[ease] || _configEaseFromString(ease)) || defaultEase;
1223      },
1224      _insertEase = function _insertEase(names, easeIn, easeOut, easeInOut) {
1225        if (easeOut === void 0) {
1226          easeOut = function easeOut(p) {
1227            return 1 - easeIn(1 - p);
1228          };
1229        }
1230        if (easeInOut === void 0) {
1231          easeInOut = function easeInOut(p) {
1232            return p < .5 ? easeIn(p * 2) / 2 : 1 - easeIn((1 - p) * 2) / 2;
1233          };
1234        }
1235        var ease = {
1236            easeIn: easeIn,
1237            easeOut: easeOut,
1238            easeInOut: easeInOut
1239          },
1240          lowercaseName;
1241        _forEachName(names, function (name) {
1242          _easeMap[name] = _globals[name] = ease;
1243          _easeMap[lowercaseName = name.toLowerCase()] = easeOut;
1244          for (var p in ease) {
1245            _easeMap[lowercaseName + (p === "easeIn" ? ".in" : p === "easeOut" ? ".out" : ".inOut")] = _easeMap[name + "." + p] = ease[p];
1246          }
1247        });
1248        return ease;
1249      },
1250      _easeInOutFromOut = function _easeInOutFromOut(easeOut) {
1251        return function (p) {
1252          return p < .5 ? (1 - easeOut(1 - p * 2)) / 2 : .5 + easeOut((p - .5) * 2) / 2;
1253        };
1254      },
1255      _configElastic = function _configElastic(type, amplitude, period) {
1256        var p1 = amplitude >= 1 ? amplitude : 1,
1257          p2 = (period || (type ? .3 : .45)) / (amplitude < 1 ? amplitude : 1),
1258          p3 = p2 / _2PI * (Math.asin(1 / p1) || 0),
1259          easeOut = function easeOut(p) {
1260            return p === 1 ? 1 : p1 * Math.pow(2, -10 * p) * _sin((p - p3) * p2) + 1;
1261          },
1262          ease = type === "out" ? easeOut : type === "in" ? function (p) {
1263            return 1 - easeOut(1 - p);
1264          } : _easeInOutFromOut(easeOut);
1265        p2 = _2PI / p2;
1266        ease.config = function (amplitude, period) {
1267          return _configElastic(type, amplitude, period);
1268        };
1269        return ease;
1270      },
1271      _configBack = function _configBack(type, overshoot) {
1272        if (overshoot === void 0) {
1273          overshoot = 1.70158;
1274        }
1275        var easeOut = function easeOut(p) {
1276            return p ? --p * p * ((overshoot + 1) * p + overshoot) + 1 : 0;
1277          },
1278          ease = type === "out" ? easeOut : type === "in" ? function (p) {
1279            return 1 - easeOut(1 - p);
1280          } : _easeInOutFromOut(easeOut);
1281        ease.config = function (overshoot) {
1282          return _configBack(type, overshoot);
1283        };
1284        return ease;
1285      };
1286    _forEachName("Linear,Quad,Cubic,Quart,Quint,Strong", function (name, i) {
1287      var power = i < 5 ? i + 1 : i;
1288      _insertEase(name + ",Power" + (power - 1), i ? function (p) {
1289        return Math.pow(p, power);
1290      } : function (p) {
1291        return p;
1292      }, function (p) {
1293        return 1 - Math.pow(1 - p, power);
1294      }, function (p) {
1295        return p < .5 ? Math.pow(p * 2, power) / 2 : 1 - Math.pow((1 - p) * 2, power) / 2;
1296      });
1297    });
1298    _easeMap.Linear.easeNone = _easeMap.none = _easeMap.Linear.easeIn;
1299    _insertEase("Elastic", _configElastic("in"), _configElastic("out"), _configElastic());
1300    (function (n, c) {
1301      var n1 = 1 / c,
1302        n2 = 2 * n1,
1303        n3 = 2.5 * n1,
1304        easeOut = function easeOut(p) {
1305          return p < n1 ? n * p * p : p < n2 ? n * Math.pow(p - 1.5 / c, 2) + .75 : p < n3 ? n * (p -= 2.25 / c) * p + .9375 : n * Math.pow(p - 2.625 / c, 2) + .984375;
1306        };
1307      _insertEase("Bounce", function (p) {
1308        return 1 - easeOut(1 - p);
1309      }, easeOut);
1310    })(7.5625, 2.75);
1311    _insertEase("Expo", function (p) {
1312      return p ? Math.pow(2, 10 * (p - 1)) : 0;
1313    });
1314    _insertEase("Circ", function (p) {
1315      return -(_sqrt(1 - p * p) - 1);
1316    });
1317    _insertEase("Sine", function (p) {
1318      return p === 1 ? 1 : -_cos(p * _HALF_PI) + 1;
1319    });
1320    _insertEase("Back", _configBack("in"), _configBack("out"), _configBack());
1321    _easeMap.SteppedEase = _easeMap.steps = _globals.SteppedEase = {
1322      config: function config(steps, immediateStart) {
1323        if (steps === void 0) {
1324          steps = 1;
1325        }
1326        var p1 = 1 / steps,
1327          p2 = steps + (immediateStart ? 0 : 1),
1328          p3 = immediateStart ? 1 : 0,
1329          max = 1 - _tinyNum;
1330        return function (p) {
1331          return ((p2 * _clamp(0, max, p) | 0) + p3) * p1;
1332        };
1333      }
1334    };
1335    _defaults.ease = _easeMap["quad.out"];
1336    _forEachName("onComplete,onUpdate,onStart,onRepeat,onReverseComplete,onInterrupt", function (name) {
1337      return _callbackNames += name + "," + name + "Params,";
1338    });
1339    var GSCache = function GSCache(target, harness) {
1340      this.id = _gsID++;
1341      target._gsap = this;
1342      this.target = target;
1343      this.harness = harness;
1344      this.get = harness ? harness.get : _getProperty;
1345      this.set = harness ? harness.getSetter : _getSetter;
1346    };
1347    var Animation = function () {
1348      function Animation(vars) {
1349        this.vars = vars;

1350        this._delay = +vars.delay || 0;
1351        if (this._repeat = vars.repeat === Infinity ? -2 : vars.repeat || 0) {
1352          this._rDelay = vars.repeatDelay || 0;
1353          this._yoyo = !!vars.yoyo || !!vars.yoyoEase;
1354        }
1355        this._ts = 1;
1356        _setDuration(this, +vars.duration, 1, 1);
1357        this.data = vars.data;
1358        if (_context) {
1359          this._ctx = _context;
1360          _context.data.push(this);
1361        }
1362        _tickerActive || _ticker.wake();
1363      }
1364      var _proto = Animation.prototype;
1365      _proto.delay = function delay(value) {
1366        if (value || value === 0) {
1367          this.parent && this.parent.smoothChildTiming && this.startTime(this._start + value - this._delay);
1368          this._delay = value;
1369          return this;
1370        }
1371        return this._delay;
1372      };
1373      _proto.duration = function duration(value) {
1374        return arguments.length ? this.totalDuration(this._repeat > 0 ? value + (value + this._rDelay) * this._repeat : value) : this.totalDuration() && this._dur;
1375      };
1376      _proto.totalDuration = function totalDuration(value) {
1377        if (!arguments.length) {
1378          return this._tDur;
1379        }
1380        this._dirty = 0;
1381        return _setDuration(this, this._repeat < 0 ? value : (value - this._repeat * this._rDelay) / (this._repeat + 1));
1382      };
1383      _proto.totalTime = function totalTime(_totalTime, suppressEvents) {
1384        _wake();
1385        if (!arguments.length) {
1386          return this._tTime;
1387        }
1388        var parent = this._dp;
1389        if (parent && parent.smoothChildTiming && this._ts) {
1390          _alignPlayhead(this, _totalTime);
1391          !parent._dp || parent.parent || _postAddChecks(parent, this);
1392          while (parent && parent.parent) {
1393            if (parent.parent._time !== parent._start + (parent._ts >= 0 ? parent._tTime / parent._ts : (parent.totalDuration() - parent._tTime) / -parent._ts)) {
1394              parent.totalTime(parent._tTime, true);
1395            }
1396            parent = parent.parent;
1397          }
1398          if (!this.parent && this._dp.autoRemoveChildren && (this._ts > 0 && _totalTime < this._tDur || this._ts < 0 && _totalTime > 0 || !this._tDur && !_totalTime)) {
1399            _addToTimeline(this._dp, this, this._start - this._delay);
1400          }
1401        }
1402        if (this._tTime !== _totalTime || !this._dur && !suppressEvents || this._initted && Math.abs(this._zTime) === _tinyNum || !_totalTime && !this._initted && (this.add || this._ptLookup)) {
1403          this._ts || (this._pTime = _totalTime);
1404          _lazySafeRender(this, _totalTime, suppressEvents);
1405        }
1406        return this;
1407      };
1408      _proto.time = function time(value, suppressEvents) {
1409        return arguments.length ? this.totalTime(Math.min(this.totalDuration(), value + _elapsedCycleDuration(this)) % (this._dur + this._rDelay) || (value ? this._dur : 0), suppressEvents) : this._time;
1410      };
1411      _proto.totalProgress = function totalProgress(value, suppressEvents) {
1412        return arguments.length ? this.totalTime(this.totalDuration() * value, suppressEvents) : this.totalDuration() ? Math.min(1, this._tTime / this._tDur) : this.ratio;
1413      };
1414      _proto.progress = function progress(value, suppressEvents) {
1415        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.ratio;
1416      };
1417      _proto.iteration = function iteration(value, suppressEvents) {
1418        var cycleDuration = this.duration() + this._rDelay;
1419        return arguments.length ? this.totalTime(this._time + (value - 1) * cycleDuration, suppressEvents) : this._repeat ? _animationCycle(this._tTime, cycleDuration) + 1 : 1;
1420      };
1421      _proto.timeScale = function timeScale(value) {
1422        if (!arguments.length) {
1423          return this._rts === -_tinyNum ? 0 : this._rts;
1424        }
1425        if (this._rts === value) {
1426          return this;
1427        }
1428        var tTime = this.parent && this._ts ? _parentToChildTotalTime(this.parent._time, this) : this._tTime;
1429        this._rts = +value || 0;
1430        this._ts = this._ps || value === -_tinyNum ? 0 : this._rts;
1431        this.totalTime(_clamp(-Math.abs(this._delay), this._tDur, tTime), true);
1432        _setEnd(this);
1433        return _recacheAncestors(this);
1434      };
1435      _proto.paused = function paused(value) {
1436        if (!arguments.length) {
1437          return this._ps;
1438        }
1439        if (this._ps !== value) {
1440          this._ps = value;
1441          if (value) {
1442            this._pTime = this._tTime || Math.max(-this._delay, this.rawTime());
1443            this._ts = this._act = 0;
1444          } else {
1445            _wake();
1446            this._ts = this._rts;
1447            this.totalTime(this.parent && !this.parent.smoothChildTiming ? this.rawTime() : this._tTime || this._pTime, this.progress() === 1 && Math.abs(this._zTime) !== _tinyNum && (this._tTime -= _tinyNum));
1448          }
1449        }
1450        return this;
1451      };
1452      _proto.startTime = function startTime(value) {
1453        if (arguments.length) {
1454          this._start = value;
1455          var parent = this.parent || this._dp;

1456          parent && (parent._sort || !this.parent) && _addToTimeline(parent, this, value - this._delay);
1457          return this;
1458        }
1459        return this._start;
1460      };
1461      _proto.endTime = function endTime(includeRepeats) {
1462        return this._start + (_isNotFalse(includeRepeats) ? this.totalDuration() : this.duration()) / Math.abs(this._ts || 1);
1463      };
1464      _proto.rawTime = function rawTime(wrapRepeats) {
1465        var parent = this.parent || this._dp;
1466        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);
1467      };
1468      _proto.revert = function revert(config) {
1469        if (config === void 0) {
1470          config = _revertConfig;
1471        }
1472        var prevIsReverting = _reverting;
1473        _reverting = config;
1474        if (this._initted || this._startAt) {
1475          this.timeline && this.timeline.revert(config);
1476          this.totalTime(-0.01, config.suppressEvents);
1477        }
1478        this.data !== "nested" && config.kill !== false && this.kill();
1479        _reverting = prevIsReverting;
1480        return this;
1481      };
1482      _proto.globalTime = function globalTime(rawTime) {
1483        var animation = this,
1484          time = arguments.length ? rawTime : animation.rawTime();
1485        while (animation) {
1486          time = animation._start + time / (animation._ts || 1);
1487          animation = animation._dp;
1488        }
1489        return !this.parent && this._sat ? this._sat.vars.immediateRender ? -1 : this._sat.globalTime(rawTime) : time;
1490      };
1491      _proto.repeat = function repeat(value) {
1492        if (arguments.length) {
1493          this._repeat = value === Infinity ? -2 : value;
1494          return _onUpdateTotalDuration(this);
1495        }
1496        return this._repeat === -2 ? Infinity : this._repeat;
1497      };
1498      _proto.repeatDelay = function repeatDelay(value) {
1499        if (arguments.length) {
1500          var time = this._time;
1501          this._rDelay = value;
1502          _onUpdateTotalDuration(this);
1503          return time ? this.time(time) : this;
1504        }
1505        return this._rDelay;
1506      };
1507      _proto.yoyo = function yoyo(value) {
1508        if (arguments.length) {
1509          this._yoyo = value;
1510          return this;
1511        }
1512        return this._yoyo;
1513      };
1514      _proto.seek = function seek(position, suppressEvents) {
1515        return this.totalTime(_parsePosition(this, position), _isNotFalse(suppressEvents));
1516      };
1517      _proto.restart = function restart(includeDelay, suppressEvents) {
1518        return this.play().totalTime(includeDelay ? -this._delay : 0, _isNotFalse(suppressEvents));
1519      };
1520      _proto.play = function play(from, suppressEvents) {
1521        from != null && this.seek(from, suppressEvents);
1522        return this.reversed(false).paused(false);
1523      };
1524      _proto.reverse = function reverse(from, suppressEvents) {
1525        from != null && this.seek(from || this.totalDuration(), suppressEvents);
1526        return this.reversed(true).paused(false);
1527      };
1528      _proto.pause = function pause(atTime, suppressEvents) {
1529        atTime != null && this.seek(atTime, suppressEvents);
1530        return this.paused(true);
1531      };
1532      _proto.resume = function resume() {
1533        return this.paused(false);
1534      };
1535      _proto.reversed = function reversed(value) {
1536        if (arguments.length) {
1537          !!value !== this.reversed() && this.timeScale(-this._rts || (value ? -_tinyNum : 0));
1538          return this;
1539        }
1540        return this._rts < 0;
1541      };

1542      _proto.invalidate = function invalidate() {
1543        this._initted = this._act = 0;
1544        this._zTime = -_tinyNum;
1545        return this;
1546      };
1547      _proto.isActive = function isActive() {
1548        var parent = this.parent || this._dp,
1549          start = this._start,
1550          rawTime;
1551        return !!(!parent || this._ts && this._initted && parent.isActive() && (rawTime = parent.rawTime(true)) >= start && rawTime < this.endTime(true) - _tinyNum);
1552      };
1553      _proto.eventCallback = function eventCallback(type, callback, params) {
1554        var vars = this.vars;
1555        if (arguments.length > 1) {
1556          if (!callback) {
1557            delete vars[type];
1558          } else {
1559            vars[type] = callback;
1560            params && (vars[type + "Params"] = params);
1561            type === "onUpdate" && (this._onUpdate = callback);
1562          }
1563          return this;
1564        }
1565        return vars[type];
1566      };
1567      _proto.then = function then(onFulfilled) {
1568        var self = this;
1569        return new Promise(function (resolve) {
1570          var f = _isFunction(onFulfilled) ? onFulfilled : _passThrough,
1571            _resolve = function _resolve() {
1572              var _then = self.then;
1573              self.then = null;
1574              _isFunction(f) && (f = f(self)) && (f.then || f === self) && (self.then = _then);
1575              resolve(f);
1576              self.then = _then;
1577            };
1578          if (self._initted && self.totalProgress() === 1 && self._ts >= 0 || !self._tTime && self._ts < 0) {
1579            _resolve();
1580          } else {
1581            self._prom = _resolve;
1582          }
1583        });
1584      };
1585      _proto.kill = function kill() {
1586        _interrupt(this);
1587      };
1588      return Animation;
1589    }();
1590    _setDefaults(Animation.prototype, {
1591      _time: 0,
1592      _start: 0,
1593      _end: 0,
1594      _tTime: 0,
1595      _tDur: 0,
1596      _dirty: 0,
1597      _repeat: 0,
1598      _yoyo: false,
1599      parent: null,
1600      _initted: false,
1601      _rDelay: 0,
1602      _ts: 1,
1603      _dp: 0,
1604      ratio: 0,
1605      _zTime: -_tinyNum,
1606      _prom: 0,
1607      _ps: false,
1608      _rts: 1
1609    });
1610    var Timeline = function (_Animation) {
1611      _inheritsLoose(Timeline, _Animation);
1612      function Timeline(vars, position) {
1613        var _this;
1614        if (vars === void 0) {
1615          vars = {};
1616        }
1617        _this = _Animation.call(this, vars) || this;
1618        _this.labels = {};
1619        _this.smoothChildTiming = !!vars.smoothChildTiming;
1620        _this.autoRemoveChildren = !!vars.autoRemoveChildren;
1621        _this._sort = _isNotFalse(vars.sortChildren);
1622        _globalTimeline && _addToTimeline(vars.parent || _globalTimeline, _assertThisInitialized(_this), position);
1623        vars.reversed && _this.reverse();
1624        vars.paused && _this.paused(true);
1625        vars.scrollTrigger && _scrollTrigger(_assertThisInitialized(_this), vars.scrollTrigger);
1626        return _this;
1627      }
1628      var _proto2 = Timeline.prototype;
1629      _proto2.to = function to(targets, vars, position) {
1630        _createTweenType(0, arguments, this);
1631        return this;
1632      };
1633      _proto2.from = function from(targets, vars, position) {
1634        _createTweenType(1, arguments, this);
1635        return this;
1636      };
1637      _proto2.fromTo = function fromTo(targets, fromVars, toVars, position) {
1638        _createTweenType(2, arguments, this);
1639        return this;
1640      };
1641      _proto2.set = function set(targets, vars, position) {
1642        vars.duration = 0;
1643        vars.parent = this;
1644        _inheritDefaults(vars).repeatDelay || (vars.repeat = 0);
1645        vars.immediateRender = !!vars.immediateRender;
1646        new Tween(targets, vars, _parsePosition(this, position), 1);
1647        return this;
1648      };
1649      _proto2.call = function call(callback, params, position) {
1650        return _addToTimeline(this, Tween.delayedCall(0, callback, params), position);
1651      };
1652      _proto2.staggerTo = function staggerTo(targets, duration, vars, stagger, position, onCompleteAll, onCompleteAllParams) {
1653        vars.duration = duration;
1654        vars.stagger = vars.stagger || stagger;
1655        vars.onComplete = onCompleteAll;
1656        vars.onCompleteParams = onCompleteAllParams;
1657        vars.parent = this;
1658        new Tween(targets, vars, _parsePosition(this, position));
1659        return this;
1660      };
1661      _proto2.staggerFrom = function staggerFrom(targets, duration, vars, stagger, position, onCompleteAll, onCompleteAllParams) {
1662        vars.runBackwards = 1;
1663        _inheritDefaults(vars).immediateRender = _isNotFalse(vars.immediateRender);
1664        return this.staggerTo(targets, duration, vars, stagger, position, onCompleteAll, onCompleteAllParams);
1665      };
1666      _proto2.staggerFromTo = function staggerFromTo(targets, duration, fromVars, toVars, stagger, position, onCompleteAll, onCompleteAllParams) {
1667        toVars.startAt = fromVars;
1668        _inheritDefaults(toVars).immediateRender = _isNotFalse(toVars.immediateRender);
1669        return this.staggerTo(targets, duration, toVars, stagger, position, onCompleteAll, onCompleteAllParams);
1670      };
1671      _proto2.render = function render(totalTime, suppressEvents, force) {
1672        var prevTime = this._time,
1673          tDur = this._dirty ? this.totalDuration() : this._tDur,
1674          dur = this._dur,
1675          tTime = totalTime <= 0 ? 0 : _roundPrecise(totalTime),
1676          crossingStart = this._zTime < 0 !== totalTime < 0 && (this._initted || !dur),
1677          time,
1678          child,
1679          next,
1680          iteration,
1681          cycleDuration,
1682          prevPaused,
1683          pauseTween,
1684          timeScale,
1685          prevStart,
1686          prevIteration,
1687          yoyo,
1688          isYoyo;
1689        this !== _globalTimeline && tTime > tDur && totalTime >= 0 && (tTime = tDur);
1690        if (tTime !== this._tTime || force || crossingStart) {
1691          if (prevTime !== this._time && dur) {
1692            tTime += this._time - prevTime;
1693            totalTime += this._time - prevTime;
1694          }
1695          time = tTime;
1696          prevStart = this._start;
1697          timeScale = this._ts;
1698          prevPaused = !timeScale;
1699          if (crossingStart) {
1700            dur || (prevTime = this._zTime);
1701            (totalTime || !suppressEvents) && (this._zTime = totalTime);
1702          }
1703          if (this._repeat) {
1704            yoyo = this._yoyo;
1705            cycleDuration = dur + this._rDelay;
1706            if (this._repeat < -1 && totalTime < 0) {
1707              return this.totalTime(cycleDuration * 100 + totalTime, suppressEvents, force);
1708            }
1709            time = _roundPrecise(tTime % cycleDuration);
1710            if (tTime === tDur) {
1711              iteration = this._repeat;
1712              time = dur;
1713            } else {
1714              iteration = ~~(tTime / cycleDuration);
1715              if (iteration && iteration === tTime / cycleDuration) {
1716                time = dur;
1717                iteration--;
1718              }
1719              time > dur && (time = dur);
1720            }
1721            prevIteration = _animationCycle(this._tTime, cycleDuration);
1722            !prevTime && this._tTime && prevIteration !== iteration && this._tTime - prevIteration * cycleDuration - this._dur <= 0 && (prevIteration = iteration);
1723            if (yoyo && iteration & 1) {
1724              time = dur - time;
1725              isYoyo = 1;
1726            }
1727            if (iteration !== prevIteration && !this._lock) {
1728              var rewinding = yoyo && prevIteration & 1,
1729                doesWrap = rewinding === (yoyo && iteration & 1);
1730              iteration < prevIteration && (rewinding = !rewinding);
1731              prevTime = rewinding ? 0 : dur;
1732              this._lock = 1;
1733              this.render(prevTime || (isYoyo ? 0 : _roundPrecise(iteration * cycleDuration)), suppressEvents, !dur)._lock = 0;
1734              this._tTime = tTime;
1735              !suppressEvents && this.parent && _callback(this, "onRepeat");
1736              this.vars.repeatRefresh && !isYoyo && (this.invalidate()._lock = 1);
1737              if (prevTime && prevTime !== this._time || prevPaused !== !this._ts || this.vars.onRepeat && !this.parent && !this._act) {
1738                return this;
1739              }
1740              dur = this._dur;
1741              tDur = this._tDur;
1742              if (doesWrap) {
1743                this._lock = 2;
1744                prevTime = rewinding ? dur : -0.0001;
1745                this.render(prevTime, true);
1746                this.vars.repeatRefresh && !isYoyo && this.invalidate();
1747              }
1748              this._lock = 0;
1749              if (!this._ts && !prevPaused) {
1750                return this;
1751              }
1752              _propagateYoyoEase(this, isYoyo);
1753            }
1754          }
1755          if (this._hasPause && !this._forcing && this._lock < 2) {
1756            pauseTween = _findNextPauseTween(this, _roundPrecise(prevTime), _roundPrecise(time));
1757            if (pauseTween) {
1758              tTime -= time - (time = pauseTween._start);
1759            }
1760          }
1761          this._tTime = tTime;
1762          this._time = time;
1763          this._act = !timeScale;
1764          if (!this._initted) {

1765            this._onUpdate = this.vars.onUpdate;
1766            this._initted = 1;
1767            this._zTime = totalTime;
1768            prevTime = 0;
1769          }
1770          if (!prevTime && time && !suppressEvents && !iteration) {
1771            _callback(this, "onStart");
1772            if (this._tTime !== tTime) {
1773              return this;
1774            }
1775          }
1776          if (time >= prevTime && totalTime >= 0) {
1777            child = this._first;
1778            while (child) {
1779              next = child._next;
1780              if ((child._act || time >= child._start) && child._ts && pauseTween !== child) {
1781                if (child.parent !== this) {
1782                  return this.render(totalTime, suppressEvents, force);
1783                }
1784                child.render(child._ts > 0 ? (time - child._start) * child._ts : (child._dirty ? child.totalDuration() : child._tDur) + (time - child._start) * child._ts, suppressEvents, force);
1785                if (time !== this._time || !this._ts && !prevPaused) {
1786                  pauseTween = 0;
1787                  next && (tTime += this._zTime = -_tinyNum);
1788                  break;
1789                }
1790              }
1791              child = next;
1792            }
1793          } else {
1794            child = this._last;
1795            var adjustedTime = totalTime < 0 ? totalTime : time;
1796            while (child) {
1797              next = child._prev;
1798              if ((child._act || adjustedTime <= child._end) && child._ts && pauseTween !== child) {
1799                if (child.parent !== this) {
1800                  return this.render(totalTime, suppressEvents, force);
1801                }
1802                child.render(child._ts > 0 ? (adjustedTime - child._start) * child._ts : (child._dirty ? child.totalDuration() : child._tDur) + (adjustedTime - child._start) * child._ts, suppressEvents, force || _reverting && (child._initted || child._startAt));
1803                if (time !== this._time || !this._ts && !prevPaused) {
1804                  pauseTween = 0;
1805                  next && (tTime += this._zTime = adjustedTime ? -_tinyNum : _tinyNum);
1806                  break;
1807                }
1808              }
1809              child = next;
1810            }
1811          }
1812          if (pauseTween && !suppressEvents) {
1813            this.pause();
1814            pauseTween.render(time >= prevTime ? 0 : -_tinyNum)._zTime = time >= prevTime ? 1 : -1;
1815            if (this._ts) {
1816              this._start = prevStart;
1817              _setEnd(this);
1818              return this.render(totalTime, suppressEvents, force);
1819            }
1820          }
1821          this._onUpdate && !suppressEvents && _callback(this, "onUpdate", true);
1822          if (tTime === tDur && this._tTime >= this.totalDuration() || !tTime && prevTime) if (prevStart === this._start || Math.abs(timeScale) !== Math.abs(this._ts)) if (!this._lock) {
1823            (totalTime || !dur) && (tTime === tDur && this._ts > 0 || !tTime && this._ts < 0) && _removeFromParent(this, 1);
1824            if (!suppressEvents && !(totalTime < 0 && !prevTime) && (tTime || prevTime || !tDur)) {
1825              _callback(this, tTime === tDur && totalTime >= 0 ? "onComplete" : "onReverseComplete", true);
1826              this._prom && !(tTime < tDur && this.timeScale() > 0) && this._prom();
1827            }
1828          }
1829        }
1830        return this;
1831      };
1832      _proto2.add = function add(child, position) {
1833        var _this2 = this;
1834        _isNumber(position) || (position = _parsePosition(this, position, child));
1835        if (!(child instanceof Animation)) {
1836          if (_isArray(child)) {
1837            child.forEach(function (obj) {
1838              return _this2.add(obj, position);
1839            });
1840            return this;
1841          }
1842          if (_isString(child)) {
1843            return this.addLabel(child, position);
1844          }
1845          if (_isFunction(child)) {
1846            child = Tween.delayedCall(0, child);
1847          } else {
1848            return this;
1849          }
1850        }
1851        return this !== child ? _addToTimeline(this, child, position) : this;
1852      };
1853      _proto2.getChildren = function getChildren(nested, tweens, timelines, ignoreBeforeTime) {
1854        if (nested === void 0) {
1855          nested = true;
1856        }
1857        if (tweens === void 0) {
1858          tweens = true;
1859        }
1860        if (timelines === void 0) {
1861          timelines = true;
1862        }
1863        if (ignoreBeforeTime === void 0) {
1864          ignoreBeforeTime = -_bigNum;
1865        }
1866        var a = [],
1867          child = this._first;
1868        while (child) {
1869          if (child._start >= ignoreBeforeTime) {
1870            if (child instanceof Tween) {
1871              tweens && a.push(child);
1872            } else {
1873              timelines && a.push(child);
1874              nested && a.push.apply(a, child.getChildren(true, tweens, timelines));
1875            }
1876          }
1877          child = child._next;
1878        }
1879        return a;
1880      };
1881      _proto2.getById = function getById(id) {
1882        var animations = this.getChildren(1, 1, 1),
1883          i = animations.length;
1884        while (i--) {
1885          if (animations[i].vars.id === id) {
1886            return animations[i];
1887          }
1888        }
1889      };
1890      _proto2.remove = function remove(child) {
1891        if (_isString(child)) {
1892          return this.removeLabel(child);
1893        }
1894        if (_isFunction(child)) {
1895          return this.killTweensOf(child);
1896        }
1897        _removeLinkedListItem(this, child);
1898        if (child === this._recent) {
1899          this._recent = this._last;
1900        }
1901        return _uncache(this);
1902      };
1903      _proto2.totalTime = function totalTime(_totalTime2, suppressEvents) {
1904        if (!arguments.length) {
1905          return this._tTime;
1906        }
1907        this._forcing = 1;
1908        if (!this._dp && this._ts) {
1909          this._start = _roundPrecise(_ticker.time - (this._ts > 0 ? _totalTime2 / this._ts : (this.totalDuration() - _totalTime2) / -this._ts));
1910        }
1911        _Animation.prototype.totalTime.call(this, _totalTime2, suppressEvents);
1912        this._forcing = 0;
1913        return this;
1914      };
1915      _proto2.addLabel = function addLabel(label, position) {
1916        this.labels[label] = _parsePosition(this, position);
1917        return this;
1918      };
1919      _proto2.removeLabel = function removeLabel(label) {
1920        delete this.labels[label];
1921        return this;
1922      };
1923      _proto2.addPause = function addPause(position, callback, params) {
1924        var t = Tween.delayedCall(0, callback || _emptyFunc, params);
1925        t.data = "isPause";
1926        this._hasPause = 1;
1927        return _addToTimeline(this, t, _parsePosition(this, position));
1928      };
1929      _proto2.removePause = function removePause(position) {
1930        var child = this._first;
1931        position = _parsePosition(this, position);
1932        while (child) {
1933          if (child._start === position && child.data === "isPause") {
1934            _removeFromParent(child);
1935          }
1936          child = child._next;
1937        }
1938      };
1939      _proto2.killTweensOf = function killTweensOf(targets, props, onlyActive) {
1940        var tweens = this.getTweensOf(targets, onlyActive),
1941          i = tweens.length;
1942        while (i--) {
1943          _overwritingTween !== tweens[i] && tweens[i].kill(targets, props);
1944        }
1945        return this;
1946      };
1947      _proto2.getTweensOf = function getTweensOf(targets, onlyActive) {
1948        var a = [],
1949          parsedTargets = toArray(targets),
1950          child = this._first,
1951          isGlobalTime = _isNumber(onlyActive),
1952          children;
1953        while (child) {
1954          if (child instanceof Tween) {
1955            if (_arrayContainsAny(child._targets, parsedTargets) && (isGlobalTime ? (!_overwritingTween || child._initted && child._ts) && child.globalTime(0) <= onlyActive && child.globalTime(child.totalDuration()) > onlyActive : !onlyActive || child.isActive())) {
1956              a.push(child);
1957            }
1958          } else if ((children = child.getTweensOf(parsedTargets, onlyActive)).length) {
1959            a.push.apply(a, children);
1960          }
1961          child = child._next;
1962        }
1963        return a;
1964      };
1965      _proto2.tweenTo = function tweenTo(position, vars) {
1966        vars = vars || {};
1967        var tl = this,
1968          endTime = _parsePosition(tl, position),
1969          _vars = vars,
1970          startAt = _vars.startAt,
1971          _onStart = _vars.onStart,
1972          onStartParams = _vars.onStartParams,
1973          immediateRender = _vars.immediateRender,
1974          initted,
1975          tween = Tween.to(tl, _setDefaults({
1976            ease: vars.ease || "none",
1977            lazy: false,
1978            immediateRender: false,
1979            time: endTime,
1980            overwrite: "auto",
1981            duration: vars.duration || Math.abs((endTime - (startAt && "time" in startAt ? startAt.time : tl._time)) / tl.timeScale()) || _tinyNum,
1982            onStart: function onStart() {
1983              tl.pause();
1984              if (!initted) {
1985                var duration = vars.duration || Math.abs((endTime - (startAt && "time" in startAt ? startAt.time : tl._time)) / tl.timeScale());
1986                tween._dur !== duration && _setDuration(tween, duration, 0, 1).render(tween._time, true, true);
1987                initted = 1;
1988              }
1989              _onStart && _onStart.apply(tween, onStartParams || []);
1990            }
1991          }, vars));
1992        return immediateRender ? tween.render(0) : tween;
1993      };
1994      _proto2.tweenFromTo = function tweenFromTo(fromPosition, toPosition, vars) {
1995        return this.tweenTo(toPosition, _setDefaults({
1996          startAt: {
1997            time: _parsePosition(this, fromPosition)
1998          }
1999        }, vars));
2000      };
2001      _proto2.recent = function recent() {
2002        return this._recent;
2003      };
2004      _proto2.nextLabel = function nextLabel(afterTime) {
2005        if (afterTime === void 0) {
2006          afterTime = this._time;
2007        }
2008        return _getLabelInDirection(this, _parsePosition(this, afterTime));
2009      };
2010      _proto2.previousLabel = function previousLabel(beforeTime) {
2011        if (beforeTime === void 0) {
2012          beforeTime = this._time;
2013        }
2014        return _getLabelInDirection(this, _parsePosition(this, beforeTime), 1);
2015      };
2016      _proto2.currentLabel = function currentLabel(value) {
2017        return arguments.length ? this.seek(value, true) : this.previousLabel(this._time + _tinyNum);
2018      };
2019      _proto2.shiftChildren = function shiftChildren(amount, adjustLabels, ignoreBeforeTime) {
2020        if (ignoreBeforeTime === void 0) {
2021          ignoreBeforeTime = 0;
2022        }
2023        var child = this._first,
2024          labels = this.labels,
2025          p;
2026        while (child) {
2027          if (child._start >= ignoreBeforeTime) {
2028            child._start += amount;
2029            child._end += amount;
2030          }
2031          child = child._next;
2032        }
2033        if (adjustLabels) {
2034          for (p in labels) {
2035            if (labels[p] >= ignoreBeforeTime) {
2036              labels[p] += amount;
2037            }
2038          }
2039        }
2040        return _uncache(this);
2041      };
2042      _proto2.invalidate = function invalidate(soft) {
2043        var child = this._first;
2044        this._lock = 0;
2045        while (child) {
2046          child.invalidate(soft);
2047          child = child._next;
2048        }
2049        return _Animation.prototype.invalidate.call(this, soft);
2050      };
2051      _proto2.clear = function clear(includeLabels) {
2052        if (includeLabels === void 0) {
2053          includeLabels = true;
2054        }
2055        var child = this._first,
2056          next;
2057        while (child) {
2058          next = child._next;
2059          this.remove(child);
2060          child = next;
2061        }
2062        this._dp && (this._time = this._tTime = this._pTime = 0);
2063        includeLabels && (this.labels = {});
2064        return _uncache(this);
2065      };
2066      _proto2.totalDuration = function totalDuration(value) {
2067        var max = 0,
2068          self = this,
2069          child = self._last,
2070          prevStart = _bigNum,
2071          prev,
2072          start,
2073          parent;
2074        if (arguments.length) {
2075          return self.timeScale((self._repeat < 0 ? self.duration() : self.totalDuration()) / (self.reversed() ? -value : value));
2076        }
2077        if (self._dirty) {
2078          parent = self.parent;
2079          while (child) {
2080            prev = child._prev;
2081            child._dirty && child.totalDuration();
2082            start = child._start;
2083            if (start > prevStart && self._sort && child._ts && !self._lock) {
2084              self._lock = 1;
2085              _addToTimeline(self, child, start - child._delay, 1)._lock = 0;
2086            } else {
2087              prevStart = start;
2088            }
2089            if (start < 0 && child._ts) {
2090              max -= start;
2091              if (!parent && !self._dp || parent && parent.smoothChildTiming) {
2092                self._start += start / self._ts;
2093                self._time -= start;
2094                self._tTime -= start;
2095              }
2096              self.shiftChildren(-start, false, -1e999);
2097              prevStart = 0;
2098            }
2099            child._end > max && child._ts && (max = child._end);
2100            child = prev;
2101          }
2102          _setDuration(self, self === _globalTimeline && self._time > max ? self._time : max, 1, 1);
2103          self._dirty = 0;
2104        }
2105        return self._tDur;
2106      };
2107      Timeline.updateRoot = function updateRoot(time) {
2108        if (_globalTimeline._ts) {
2109          _lazySafeRender(_globalTimeline, _parentToChildTotalTime(time, _globalTimeline));
2110          _lastRenderedFrame = _ticker.frame;
2111        }
2112        if (_ticker.frame >= _nextGCFrame) {
2113          _nextGCFrame += _config.autoSleep || 120;
2114          var child = _globalTimeline._first;
2115          if (!child || !child._ts) if (_config.autoSleep && _ticker._listeners.length < 2) {
2116            while (child && !child._ts) {
2117              child = child._next;
2118            }
2119            child || _ticker.sleep();
2120          }
2121        }
2122      };
2123      return Timeline;
2124    }(Animation);
2125    _setDefaults(Timeline.prototype, {
2126      _lock: 0,
2127      _hasPause: 0,
2128      _forcing: 0
2129    });
2130    var _addComplexStringPropTween = function _addComplexStringPropTween(target, prop, start, end, setter, stringFilter, funcParam) {
2131        var pt = new PropTween(this._pt, target, prop, 0, 1, _renderComplexString, null, setter),
2132          index = 0,
2133          matchIndex = 0,
2134          result,
2135          startNums,
2136          color,
2137          endNum,
2138          chunk,
2139          startNum,
2140          hasRandom,
2141          a;
2142        pt.b = start;
2143        pt.e = end;
2144        start += "";
2145        end += "";
2146        if (hasRandom = ~end.indexOf("random(")) {
2147          end = _replaceRandom(end);
2148        }
2149        if (stringFilter) {
2150          a = [start, end];
2151          stringFilter(a, target, prop);
2152          start = a[0];
2153          end = a[1];
2154        }
2155        startNums = start.match(_complexStringNumExp) || [];
2156        while (result = _complexStringNumExp.exec(end)) {
2157          endNum = result[0];
2158          chunk = end.substring(index, result.index);
2159          if (color) {
2160            color = (color + 1) % 5;
2161          } else if (chunk.substr(-5) === "rgba(") {
2162            color = 1;
2163          }
2164          if (endNum !== startNums[matchIndex++]) {
2165            startNum = parseFloat(startNums[matchIndex - 1]) || 0;
2166            pt._pt = {
2167              _next: pt._pt,
2168              p: chunk || matchIndex === 1 ? chunk : ",",
2169              s: startNum,
2170              c: endNum.charAt(1) === "=" ? _parseRelative(startNum, endNum) - startNum : parseFloat(endNum) - startNum,
2171              m: color && color < 4 ? Math.round : 0
2172            };
2173            index = _complexStringNumExp.lastIndex;
2174          }
2175        }
2176        pt.c = index < end.length ? end.substring(index, end.length) : "";
2177        pt.fp = funcParam;
2178        if (_relExp.test(end) || hasRandom) {
2179          pt.e = 0;
2180        }
2181        this._pt = pt;
2182        return pt;
2183      },
2184      _addPropTween = function _addPropTween(target, prop, start, end, index, targets, modifier, stringFilter, funcParam, optional) {
2185        _isFunction(end) && (end = end(index || 0, target, targets));
2186        var currentValue = target[prop],
2187          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](),
2188          setter = !_isFunction(currentValue) ? _setterPlain : funcParam ? _setterFuncWithParam : _setterFunc,
2189          pt;
2190        if (_isString(end)) {
2191          if (~end.indexOf("random(")) {
2192            end = _replaceRandom(end);
2193          }
2194          if (end.charAt(1) === "=") {
2195            pt = _parseRelative(parsedStart, end) + (getUnit(parsedStart) || 0);
2196            if (pt || pt === 0) {
2197              end = pt;
2198            }
2199          }
2200        }
2201        if (!optional || parsedStart !== end || _forceAllPropTweens) {
2202          if (!isNaN(parsedStart * end) && end !== "") {
2203            pt = new PropTween(this._pt, target, prop, +parsedStart || 0, end - (parsedStart || 0), typeof currentValue === "boolean" ? _renderBoolean : _renderPlain, 0, setter);
2204            funcParam && (pt.fp = funcParam);
2205            modifier && pt.modifier(modifier, this, target);
2206            return this._pt = pt;
2207          }
2208          !currentValue && !(prop in target) && _missingPlugin(prop, end);
2209          return _addComplexStringPropTween.call(this, target, prop, parsedStart, end, setter, stringFilter || _config.stringFilter, funcParam);
2210        }
2211      },
2212      _processVars = function _processVars(vars, index, target, targets, tween) {
2213        _isFunction(vars) && (vars = _parseFuncOrString(vars, tween, index, target, targets));
2214        if (!_isObject(vars) || vars.style && vars.nodeType || _isArray(vars) || _isTypedArray(vars)) {
2215          return _isString(vars) ? _parseFuncOrString(vars, tween, index, target, targets) : vars;
2216        }
2217        var copy = {},
2218          p;
2219        for (p in vars) {
2220          copy[p] = _parseFuncOrString(vars[p], tween, index, target, targets);
2221        }
2222        return copy;
2223      },
2224      _checkPlugin = function _checkPlugin(property, vars, tween, index, target, targets) {
2225        var plugin, pt, ptLookup, i;
2226        if (_plugins[property] && (plugin = new _plugins[property]()).init(target, plugin.rawVars ? vars[property] : _processVars(vars[property], index, target, targets, tween), tween, index, targets) !== false) {
2227          tween._pt = pt = new PropTween(tween._pt, target, property, 0, 1, plugin.render, plugin, 0, plugin.priority);
2228          if (tween !== _quickTween) {
2229            ptLookup = tween._ptLookup[tween._targets.indexOf(target)];
2230            i = plugin._props.length;
2231            while (i--) {
2232              ptLookup[plugin._props[i]] = pt;
2233            }
2234          }
2235        }
2236        return plugin;
2237      },
2238      _overwritingTween,
2239      _forceAllPropTweens,
2240      _initTween = function _initTween(tween, time, tTime) {
2241        var vars = tween.vars,
2242          ease = vars.ease,
2243          startAt = vars.startAt,
2244          immediateRender = vars.immediateRender,
2245          lazy = vars.lazy,
2246          onUpdate = vars.onUpdate,
2247          onUpdateParams = vars.onUpdateParams,
2248          callbackScope = vars.callbackScope,
2249          runBackwards = vars.runBackwards,
2250          yoyoEase = vars.yoyoEase,
2251          keyframes = vars.keyframes,
2252          autoRevert = vars.autoRevert,
2253          dur = tween._dur,
2254          prevStartAt = tween._startAt,
2255          targets = tween._targets,
2256          parent = tween.parent,
2257          fullTargets = parent && parent.data === "nested" ? parent.vars.targets : targets,
2258          autoOverwrite = tween._overwrite === "auto" && !_suppressOverwrites,
2259          tl = tween.timeline,
2260          cleanVars,
2261          i,
2262          p,
2263          pt,
2264          target,
2265          hasPriority,
2266          gsData,
2267          harness,
2268          plugin,
2269          ptLookup,
2270          index,
2271          harnessVars,
2272          overwritten;
2273        tl && (!keyframes || !ease) && (ease = "none");
2274        tween._ease = _parseEase(ease, _defaults.ease);
2275        tween._yEase = yoyoEase ? _invertEase(_parseEase(yoyoEase === true ? ease : yoyoEase, _defaults.ease)) : 0;
2276        if (yoyoEase && tween._yoyo && !tween._repeat) {
2277          yoyoEase = tween._yEase;
2278          tween._yEase = tween._ease;
2279          tween._ease = yoyoEase;
2280        }
2281        tween._from = !tl && !!vars.runBackwards;
2282        if (!tl || keyframes && !vars.stagger) {
2283          harness = targets[0] ? _getCache(targets[0]).harness : 0;
2284          harnessVars = harness && vars[harness.prop];
2285          cleanVars = _copyExcluding(vars, _reservedProps);
2286          if (prevStartAt) {
2287            prevStartAt._zTime < 0 && prevStartAt.progress(1);
2288            time < 0 && runBackwards && immediateRender && !autoRevert ? prevStartAt.render(-1, true) : prevStartAt.revert(runBackwards && dur ? _revertConfigNoKill : _startAtRevertConfig);
2289            prevStartAt._lazy = 0;
2290          }
2291          if (startAt) {
2292            _removeFromParent(tween._startAt = Tween.set(targets, _setDefaults({
2293              data: "isStart",
2294              overwrite: false,
2295              parent: parent,
2296              immediateRender: true,
2297              lazy: !prevStartAt && _isNotFalse(lazy),
2298              startAt: null,
2299              delay: 0,
2300              onUpdate: onUpdate,
2301              onUpdateParams: onUpdateParams,
2302              callbackScope: callbackScope,
2303              stagger: 0
2304            }, startAt)));
2305            tween._startAt._dp = 0;
2306            tween._startAt._sat = tween;
2307            time < 0 && (_reverting || !immediateRender && !autoRevert) && tween._startAt.revert(_revertConfigNoKill);
2308            if (immediateRender) {
2309              if (dur && time <= 0 && tTime <= 0) {
2310                time && (tween._zTime = time);
2311                return;
2312              }
2313            }
2314          } else if (runBackwards && dur) {
2315            if (!prevStartAt) {
2316              time && (immediateRender = false);
2317              p = _setDefaults({
2318                overwrite: false,
2319                data: "isFromStart",
2320                lazy: immediateRender && !prevStartAt && _isNotFalse(lazy),
2321                immediateRender: immediateRender,
2322                stagger: 0,
2323                parent: parent
2324              }, cleanVars);
2325              harnessVars && (p[harness.prop] = harnessVars);
2326              _removeFromParent(tween._startAt = Tween.set(targets, p));
2327              tween._startAt._dp = 0;
2328              tween._startAt._sat = tween;
2329              time < 0 && (_reverting ? tween._startAt.revert(_revertConfigNoKill) : tween._startAt.render(-1, true));
2330              tween._zTime = time;
2331              if (!immediateRender) {
2332                _initTween(tween._startAt, _tinyNum, _tinyNum);
2333              } else if (!time) {
2334                return;
2335              }
2336            }
2337          }
2338          tween._pt = tween._ptCache = 0;
2339          lazy = dur && _isNotFalse(lazy) || lazy && !dur;
2340          for (i = 0; i < targets.length; i++) {
2341            target = targets[i];
2342            gsData = target._gsap || _harness(targets)[i]._gsap;
2343            tween._ptLookup[i] = ptLookup = {};
2344            _lazyLookup[gsData.id] && _lazyTweens.length && _lazyRender();
2345            index = fullTargets === targets ? i : fullTargets.indexOf(target);
2346            if (harness && (plugin = new harness()).init(target, harnessVars || cleanVars, tween, index, fullTargets) !== false) {
2347              tween._pt = pt = new PropTween(tween._pt, target, plugin.name, 0, 1, plugin.render, plugin, 0, plugin.priority);
2348              plugin._props.forEach(function (name) {
2349                ptLookup[name] = pt;
2350              });
2351              plugin.priority && (hasPriority = 1);
2352            }
2353            if (!harness || harnessVars) {
2354              for (p in cleanVars) {
2355                if (_plugins[p] && (plugin = _checkPlugin(p, cleanVars, tween, index, target, fullTargets))) {
2356                  plugin.priority && (hasPriority = 1);
2357                } else {
2358                  ptLookup[p] = pt = _addPropTween.call(tween, target, p, "get", cleanVars[p], index, fullTargets, 0, vars.stringFilter);
2359                }
2360              }
2361            }
2362            tween._op && tween._op[i] && tween.kill(target, tween._op[i]);
2363            if (autoOverwrite && tween._pt) {
2364              _overwritingTween = tween;
2365              _globalTimeline.killTweensOf(target, ptLookup, tween.globalTime(time));
2366              overwritten = !tween.parent;
2367              _overwritingTween = 0;
2368            }
2369            tween._pt && lazy && (_lazyLookup[gsData.id] = 1);
2370          }
2371          hasPriority && _sortPropTweensByPriority(tween);
2372          tween._onInit && tween._onInit(tween);
2373        }
2374        tween._onUpdate = onUpdate;
2375        tween._initted = (!tween._op || tween._pt) && !overwritten;
2376        keyframes && time <= 0 && tl.render(_bigNum, true, true);
2377      },
2378      _updatePropTweens = function _updatePropTweens(tween, property, value, start, startIsRelative, ratio, time) {
2379        var ptCache = (tween._pt && tween._ptCache || (tween._ptCache = {}))[property],
2380          pt,
2381          rootPT,
2382          lookup,
2383          i;
2384        if (!ptCache) {
2385          ptCache = tween._ptCache[property] = [];
2386          lookup = tween._ptLookup;
2387          i = tween._targets.length;
2388          while (i--) {
2389            pt = lookup[i][property];
2390            if (pt && pt.d && pt.d._pt) {
2391              pt = pt.d._pt;
2392              while (pt && pt.p !== property && pt.fp !== property) {
2393                pt = pt._next;
2394              }
2395            }
2396            if (!pt) {
2397              _forceAllPropTweens = 1;
2398              tween.vars[property] = "+=0";
2399              _initTween(tween, time);
2400              _forceAllPropTweens = 0;
2401              return 1;
2402            }
2403            ptCache.push(pt);
2404          }
2405        }
2406        i = ptCache.length;
2407        while (i--) {
2408          rootPT = ptCache[i];
2409          pt = rootPT._pt || rootPT;
2410          pt.s = (start || start === 0) && !startIsRelative ? start : pt.s + (start || 0) + ratio * pt.c;
2411          pt.c = value - pt.s;
2412          rootPT.e && (rootPT.e = _round(value) + getUnit(rootPT.e));
2413          rootPT.b && (rootPT.b = pt.s + getUnit(rootPT.b));
2414        }
2415      },
2416      _addAliasesToVars = function _addAliasesToVars(targets, vars) {
2417        var harness = targets[0] ? _getCache(targets[0]).harness : 0,
2418          propertyAliases = harness && harness.aliases,
2419          copy,
2420          p,
2421          i,
2422          aliases;
2423        if (!propertyAliases) {
2424          return vars;
2425        }
2426        copy = _merge({}, vars);
2427        for (p in propertyAliases) {
2428          if (p in copy) {
2429            aliases = propertyAliases[p].split(",");
2430            i = aliases.length;
2431            while (i--) {
2432              copy[aliases[i]] = copy[p];
2433            }
2434          }
2435        }
2436        return copy;
2437      },
2438      _parseKeyframe = function _parseKeyframe(prop, obj, allProps, easeEach) {
2439        var ease = obj.ease || easeEach || "power1.inOut",
2440          p,
2441          a;
2442        if (_isArray(obj)) {
2443          a = allProps[prop] || (allProps[prop] = []);
2444          obj.forEach(function (value, i) {
2445            return a.push({
2446              t: i / (obj.length - 1) * 100,
2447              v: value,
2448              e: ease
2449            });
2450          });
2451        } else {
2452          for (p in obj) {
2453            a = allProps[p] || (allProps[p] = []);
2454            p === "ease" || a.push({
2455              t: parseFloat(prop),
2456              v: obj[p],
2457              e: ease
2458            });
2459          }
2460        }
2461      },
2462      _parseFuncOrString = function _parseFuncOrString(value, tween, i, target, targets) {
2463        return _isFunction(value) ? value.call(tween, i, target, targets) : _isString(value) && ~value.indexOf("random(") ? _replaceRandom(value) : value;
2464      },
2465      _staggerTweenProps = _callbackNames + "repeat,repeatDelay,yoyo,repeatRefresh,yoyoEase,autoRevert",
2466      _staggerPropsToSkip = {};
2467    _forEachName(_staggerTweenProps + ",id,stagger,delay,duration,paused,scrollTrigger", function (name) {
2468      return _staggerPropsToSkip[name] = 1;
2469    });
2470    var Tween = function (_Animation2) {
2471      _inheritsLoose(Tween, _Animation2);
2472      function Tween(targets, vars, position, skipInherit) {
2473        var _this3;
2474        if (typeof vars === "number") {
2475          position.duration = vars;
2476          vars = position;
2477          position = null;
2478        }
2479        _this3 = _Animation2.call(this, skipInherit ? vars : _inheritDefaults(vars)) || this;
2480        var _this3$vars = _this3.vars,
2481          duration = _this3$vars.duration,
2482          delay = _this3$vars.delay,
2483          immediateRender = _this3$vars.immediateRender,
2484          stagger = _this3$vars.stagger,
2485          overwrite = _this3$vars.overwrite,
2486          keyframes = _this3$vars.keyframes,
2487          defaults = _this3$vars.defaults,
2488          scrollTrigger = _this3$vars.scrollTrigger,
2489          yoyoEase = _this3$vars.yoyoEase,
2490          parent = vars.parent || _globalTimeline,
2491          parsedTargets = (_isArray(targets) || _isTypedArray(targets) ? _isNumber(targets[0]) : "length" in vars) ? [targets] : toArray(targets),
2492          tl,
2493          i,
2494          copy,
2495          l,
2496          p,
2497          curTarget,
2498          staggerFunc,
2499          staggerVarsToMerge;
2500        _this3._targets = parsedTargets.length ? _harness(parsedTargets) : _warn("GSAP target " + targets + " not found. https://greensock.com", !_config.nullTargetWarn) || [];
2501        _this3._ptLookup = [];
2502        _this3._overwrite = overwrite;
2503        if (keyframes || stagger || _isFuncOrString(duration) || _isFuncOrString(delay)) {
2504          vars = _this3.vars;
2505          tl = _this3.timeline = new Timeline({
2506            data: "nested",
2507            defaults: defaults || {},
2508            targets: parent && parent.data === "nested" ? parent.vars.targets : parsedTargets
2509          });
2510          tl.kill();
2511          tl.parent = tl._dp = _assertThisInitialized(_this3);
2512          tl._start = 0;
2513          if (stagger || _isFuncOrString(duration) || _isFuncOrString(delay)) {
2514            l = parsedTargets.length;
2515            staggerFunc = stagger && distribute(stagger);
2516            if (_isObject(stagger)) {
2517              for (p in stagger) {
2518                if (~_staggerTweenProps.indexOf(p)) {
2519                  staggerVarsToMerge || (staggerVarsToMerge = {});
2520                  staggerVarsToMerge[p] = stagger[p];
2521                }
2522              }
2523            }
2524            for (i = 0; i < l; i++) {
2525              copy = _copyExcluding(vars, _staggerPropsToSkip);
2526              copy.stagger = 0;
2527              yoyoEase && (copy.yoyoEase = yoyoEase);
2528              staggerVarsToMerge && _merge(copy, staggerVarsToMerge);
2529              curTarget = parsedTargets[i];
2530              copy.duration = +_parseFuncOrString(duration, _assertThisInitialized(_this3), i, curTarget, parsedTargets);
2531              copy.delay = (+_parseFuncOrString(delay, _assertThisInitialized(_this3), i, curTarget, parsedTargets) || 0) - _this3._delay;
2532              if (!stagger && l === 1 && copy.delay) {
2533                _this3._delay = delay = copy.delay;
2534                _this3._start += delay;
2535                copy.delay = 0;
2536              }
2537              tl.to(curTarget, copy, staggerFunc ? staggerFunc(i, curTarget, parsedTargets) : 0);
2538              tl._ease = _easeMap.none;
2539            }
2540            tl.duration() ? duration = delay = 0 : _this3.timeline = 0;
2541          } else if (keyframes) {
2542            _inheritDefaults(_setDefaults(tl.vars.defaults, {
2543              ease: "none"
2544            }));
2545            tl._ease = _parseEase(keyframes.ease || vars.ease || "none");
2546            var time = 0,
2547              a,
2548              kf,
2549              v;
2550            if (_isArray(keyframes)) {

2551              keyframes.forEach(function (frame) {
2552                return tl.to(parsedTargets, frame, ">");
2553              });
2554              tl.duration();
2555            } else {
2556              copy = {};
2557              for (p in keyframes) {
2558                p === "ease" || p === "easeEach" || _parseKeyframe(p, keyframes[p], copy, keyframes.easeEach);
2559              }
2560              for (p in copy) {
2561                a = copy[p].sort(function (a, b) {
2562                  return a.t - b.t;
2563                });
2564                time = 0;
2565                for (i = 0; i < a.length; i++) {
2566                  kf = a[i];
2567                  v = {
2568                    ease: kf.e,
2569                    duration: (kf.t - (i ? a[i - 1].t : 0)) / 100 * duration
2570                  };
2571                  v[p] = kf.v;
2572                  tl.to(parsedTargets, v, time);
2573                  time += v.duration;
2574                }
2575              }
2576              tl.duration() < duration && tl.to({}, {
2577                duration: duration - tl.duration()
2578              });
2579            }
2580          }
2581          duration || _this3.duration(duration = tl.duration());
2582        } else {
2583          _this3.timeline = 0;
2584        }
2585        if (overwrite === true && !_suppressOverwrites) {
2586          _overwritingTween = _assertThisInitialized(_this3);
2587          _globalTimeline.killTweensOf(parsedTargets);
2588          _overwritingTween = 0;
2589        }
2590        _addToTimeline(parent, _assertThisInitialized(_this3), position);
2591        vars.reversed && _this3.reverse();
2592        vars.paused && _this3.paused(true);
2593        if (immediateRender || !duration && !keyframes && _this3._start === _roundPrecise(parent._time) && _isNotFalse(immediateRender) && _hasNoPausedAncestors(_assertThisInitialized(_this3)) && parent.data !== "nested") {
2594          _this3._tTime = -_tinyNum;
2595          _this3.render(Math.max(0, -delay) || 0);
2596        }
2597        scrollTrigger && _scrollTrigger(_assertThisInitialized(_this3), scrollTrigger);
2598        return _this3;
2599      }
2600      var _proto3 = Tween.prototype;
2601      _proto3.render = function render(totalTime, suppressEvents, force) {
2602        var prevTime = this._time,
2603          tDur = this._tDur,
2604          dur = this._dur,
2605          isNegative = totalTime < 0,
2606          tTime = totalTime > tDur - _tinyNum && !isNegative ? tDur : totalTime < _tinyNum ? 0 : totalTime,
2607          time,
2608          pt,
2609          iteration,
2610          cycleDuration,
2611          prevIteration,
2612          isYoyo,
2613          ratio,
2614          timeline,
2615          yoyoEase;
2616        if (!dur) {
2617          _renderZeroDurationTween(this, totalTime, suppressEvents, force);
2618        } else if (tTime !== this._tTime || !totalTime || force || !this._initted && this._tTime || this._startAt && this._zTime < 0 !== isNegative) {
2619          time = tTime;
2620          timeline = this.timeline;
2621          if (this._repeat) {
2622            cycleDuration = dur + this._rDelay;
2623            if (this._repeat < -1 && isNegative) {
2624              return this.totalTime(cycleDuration * 100 + totalTime, suppressEvents, force);
2625            }
2626            time = _roundPrecise(tTime % cycleDuration);
2627            if (tTime === tDur) {
2628              iteration = this._repeat;
2629              time = dur;
2630            } else {
2631              iteration = ~~(tTime / cycleDuration);
2632              if (iteration && iteration === tTime / cycleDuration) {
2633                time = dur;
2634                iteration--;
2635              }
2636              time > dur && (time = dur);
2637            }
2638            isYoyo = this._yoyo && iteration & 1;
2639            if (isYoyo) {
2640              yoyoEase = this._yEase;
2641              time = dur - time;
2642            }
2643            prevIteration = _animationCycle(this._tTime, cycleDuration);
2644            if (time === prevTime && !force && this._initted) {
2645              this._tTime = tTime;
2646              return this;
2647            }
2648            if (iteration !== prevIteration) {
2649              timeline && this._yEase && _propagateYoyoEase(timeline, isYoyo);
2650              if (this.vars.repeatRefresh && !isYoyo && !this._lock) {
2651                this._lock = force = 1;
2652                this.render(_roundPrecise(cycleDuration * iteration), true).invalidate()._lock = 0;
2653              }
2654            }
2655          }
2656          if (!this._initted) {
2657            if (_attemptInitTween(this, isNegative ? totalTime : time, force, suppressEvents, tTime)) {
2658              this._tTime = 0;
2659              return this;
2660            }
2661            if (prevTime !== this._time) {
2662              return this;
2663            }
2664            if (dur !== this._dur) {
2665              return this.render(totalTime, suppressEvents, force);
2666            }
2667          }
2668          this._tTime = tTime;
2669          this._time = time;
2670          if (!this._act && this._ts) {
2671            this._act = 1;
2672            this._lazy = 0;
2673          }
2674          this.ratio = ratio = (yoyoEase || this._ease)(time / dur);
2675          if (this._from) {
2676            this.ratio = ratio = 1 - ratio;
2677          }
2678          if (time && !prevTime && !suppressEvents && !iteration) {
2679            _callback(this, "onStart");
2680            if (this._tTime !== tTime) {
2681              return this;
2682            }
2683          }
2684          pt = this._pt;
2685          while (pt) {
2686            pt.r(ratio, pt.d);
2687            pt = pt._next;
2688          }
2689          timeline && timeline.render(totalTime < 0 ? totalTime : !time && isYoyo ? -_tinyNum : timeline._dur * timeline._ease(time / this._dur), suppressEvents, force) || this._startAt && (this._zTime = totalTime);
2690          if (this._onUpdate && !suppressEvents) {
2691            isNegative && _rewindStartAt(this, totalTime, suppressEvents, force);
2692            _callback(this, "onUpdate");
2693          }
2694          this._repeat && iteration !== prevIteration && this.vars.onRepeat && !suppressEvents && this.parent && _callback(this, "onRepeat");
2695          if ((tTime === this._tDur || !tTime) && this._tTime === tTime) {
2696            isNegative && !this._onUpdate && _rewindStartAt(this, totalTime, true, true);
2697            (totalTime || !dur) && (tTime === this._tDur && this._ts > 0 || !tTime && this._ts < 0) && _removeFromParent(this, 1);
2698            if (!suppressEvents && !(isNegative && !prevTime) && (tTime || prevTime || isYoyo)) {
2699              _callback(this, tTime === tDur ? "onComplete" : "onReverseComplete", true);
2700              this._prom && !(tTime < tDur && this.timeScale() > 0) && this._prom();
2701            }
2702          }
2703        }
2704        return this;
2705      };
2706      _proto3.targets = function targets() {
2707        return this._targets;
2708      };