https://mnc-insurance.com/vendors/gsap/gsap.js

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

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

739      return Math.abs(is2D - raw) <= radius ? is2D : raw;
740    } : function (raw) {
741      var x = parseFloat(is2D ? raw.x : raw),
742          y = parseFloat(is2D ? raw.y : 0),
743          min = _bigNum,
744          closest = 0,
745          i = snapTo.length,
746          dx,
747          dy;
748
749      while (i--) {
750        if (is2D) {
751          dx = snapTo[i].x - x;
752          dy = snapTo[i].y - y;
753          dx = dx * dx + dy * dy;
754        } else {
755          dx = Math.abs(snapTo[i] - x);
756        }
757
758        if (dx < min) {
759          min = dx;
760          closest = i;
761        }
762      }
763
764      closest = !radius || min <= radius ? snapTo[closest] : raw;
765      return is2D || closest === raw || _isNumber(raw) ? closest : closest + getUnit(raw);
766    });
767  },
768      random = function random(min, max, roundingIncrement, returnFunction) {
769    return _conditionalReturn(_isArray(min) ? !max : roundingIncrement === true ? !!(roundingIncrement = 0) : !returnFunction, function () {
770      return _isArray(min) ? min[~~(Math.random() * min.length)] : (roundingIncrement = roundingIncrement || 1e-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;
771    });
772  },
773      pipe = function pipe() {
774    for (var _len = arguments.length, functions = new Array(_len), _key = 0; _key < _len; _key++) {
775      functions[_key] = arguments[_key];
776    }
777
778    return function (value) {
779      return functions.reduce(function (v, f) {
780        return f(v);
781      }, value);
782    };
783  },
784      unitize = function unitize(func, unit) {
785    return function (value) {
786      return func(parseFloat(value)) + (unit || getUnit(value));
787    };
788  },
789      normalize = function normalize(min, max, value) {
790    return mapRange(min, max, 0, 1, value);
791  },
792      _wrapArray = function _wrapArray(a, wrapper, value) {
793    return _conditionalReturn(value, function (index) {
794      return a[~~wrapper(index)];
795    });
796  },
797      wrap = function wrap(min, max, value) {
798    var range = max - min;
799    return _isArray(min) ? _wrapArray(min, wrap(0, min.length), max) : _conditionalReturn(value, function (value) {
800      return (range + (value - min) % range) % range + min;
801    });
802  },
803      wrapYoyo = function wrapYoyo(min, max, value) {
804    var range = max - min,
805        total = range * 2;
806    return _isArray(min) ? _wrapArray(min, wrapYoyo(0, min.length - 1), max) : _conditionalReturn(value, function (value) {
807      value = (total + (value - min) % total) % total || 0;
808      return min + (value > range ? total - value : value);
809    });
810  },
811      _replaceRandom = function _replaceRandom(value) {
812    var prev = 0,
813        s = "",
814        i,
815        nums,
816        end,
817        isArray;
818
819    while (~(i = value.indexOf("random(", prev))) {
820      end = value.indexOf(")", i);
821      isArray = value.charAt(i + 7) === "[";
822      nums = value.substr(i + 7, end - i - 7).match(isArray ? _delimitedValueExp : _strictNumExp);
823      s += value.substr(prev, i - prev) + random(isArray ? nums : +nums[0], isArray ? 0 : +nums[1], +nums[2] || 1e-5);
824      prev = end + 1;
825    }
826
827    return s + value.substr(prev, value.length - prev);
828  },
829      mapRange = function mapRange(inMin, inMax, outMin, outMax, value) {
830    var inRange = inMax - inMin,
831        outRange = outMax - outMin;
832    return _conditionalReturn(value, function (value) {
833      return outMin + ((value - inMin) / inRange * outRange || 0);
834    });
835  },
836      interpolate = function interpolate(start, end, progress, mutate) {
837    var func = isNaN(start + end) ? 0 : function (p) {
838      return (1 - p) * start + p * end;
839    };
840
841    if (!func) {
842      var isString = _isString(start),
843          master = {},
844          p,
845          i,
846          interpolators,
847          l,
848          il;
849
850      progress === true && (mutate = 1) && (progress = null);
851
852      if (isString) {
853        start = {
854          p: start
855        };
856        end = {
857          p: end
858        };
859      } else if (_isArray(start) && !_isArray(end)) {
860        interpolators = [];
861        l = start.length;
862        il = l - 2;
863
864        for (i = 1; i < l; i++) {
865          interpolators.push(interpolate(start[i - 1], start[i]));
866        }
867
868        l--;
869
870        func = function func(p) {
871          p *= l;
872          var i = Math.min(il, ~~p);
873          return interpolators[i](p - i);
874        };
875
876        progress = end;
877      } else if (!mutate) {

878        start = _merge(_isArray(start) ? [] : {}, start);
879      }
880
881      if (!interpolators) {
882        for (p in end) {
883          _addPropTween.call(master, start, p, "get", end[p]);
884        }
885
886        func = function func(p) {
887          return _renderPropTweens(p, master) || (isString ? start.p : start);
888        };
889      }
890    }
891
892    return _conditionalReturn(progress, func);
893  },
894      _getLabelInDirection = function _getLabelInDirection(timeline, fromTime, backward) {
895    var labels = timeline.labels,
896        min = _bigNum,
897        p,
898        distance,
899        label;
900
901    for (p in labels) {
902      distance = labels[p] - fromTime;
903
904      if (distance < 0 === !!backward && distance && min > (distance = Math.abs(distance))) {
905        label = p;
906        min = distance;
907      }
908    }
909
910    return label;
911  },
912      _callback = function _callback(animation, type, executeLazyFirst) {
913    var v = animation.vars,
914        callback = v[type],
915        params,
916        scope;
917
918    if (!callback) {
919      return;
920    }
921
922    params = v[type + "Params"];
923    scope = v.callbackScope || animation;
924    executeLazyFirst && _lazyTweens.length && _lazyRender();
925    return params ? callback.apply(scope, params) : callback.call(scope);
926  },
927      _interrupt = function _interrupt(animation) {
928    _removeFromParent(animation);
929
930    animation.scrollTrigger && animation.scrollTrigger.kill(false);
931    animation.progress() < 1 && _callback(animation, "onInterrupt");
932    return animation;
933  },
934      _quickTween,
935      _createPlugin = function _createPlugin(config) {
936    config = !config.name && config["default"] || config;
937
938    var name = config.name,
939        isFunc = _isFunction(config),
940        Plugin = name && !isFunc && config.init ? function () {
941      this._props = [];
942    } : config,
943        instanceDefaults = {
944      init: _emptyFunc,
945      render: _renderPropTweens,
946      add: _addPropTween,
947      kill: _killPropTweensOf,
948      modifier: _addPluginModifier,
949      rawVars: 0
950    },
951        statics = {
952      targetTest: 0,
953      get: 0,
954      getSetter: _getSetter,
955      aliases: {},
956      register: 0
957    };
958
959    _wake();
960
961    if (config !== Plugin) {
962      if (_plugins[name]) {
963        return;
964      }
965
966      _setDefaults(Plugin, _setDefaults(_copyExcluding(config, instanceDefaults), statics));
967
968      _merge(Plugin.prototype, _merge(instanceDefaults, _copyExcluding(config, statics)));
969
970      _plugins[Plugin.prop = name] = Plugin;
971
972      if (config.targetTest) {
973        _harnessPlugins.push(Plugin);
974
975        _reservedProps[name] = 1;
976      }
977
978      name = (name === "css" ? "CSS" : name.charAt(0).toUpperCase() + name.substr(1)) + "Plugin";
979    }
980
981    _addGlobal(name, Plugin);
982
983    config.register && config.register(gsap, Plugin, PropTween);
984  },
985      _255 = 255,
986      _colorLookup = {
987    aqua: [0, _255, _255],
988    lime: [0, _255, 0],
989    silver: [192, 192, 192],
990    black: [0, 0, 0],
991    maroon: [128, 0, 0],
992    teal: [0, 128, 128],
993    blue: [0, 0, _255],
994    navy: [0, 0, 128],
995    white: [_255, _255, _255],
996    olive: [128, 128, 0],
997    yellow: [_255, _255, 0],
998    orange: [_255, 165, 0],
999    gray: [128, 128, 128],
1000    purple: [128, 0, 128],
1001    green: [0, 128, 0],
1002    red: [_255, 0, 0],
1003    pink: [_255, 192, 203],
1004    cyan: [0, _255, _255],
1005    transparent: [_255, _255, _255, 0]
1006  },
1007      _hue = function _hue(h, m1, m2) {
1008    h = h < 0 ? h + 1 : h > 1 ? h - 1 : h;
1009    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;
1010  },
1011      splitColor = function splitColor(v, toHSL, forceAlpha) {
1012    var a = !v ? _colorLookup.black : _isNumber(v) ? [v >> 16, v >> 8 & _255, v & _255] : 0,
1013        r,
1014        g,
1015        b,
1016        h,
1017        s,
1018        l,
1019        max,
1020        min,
1021        d,
1022        wasHSL;
1023
1024    if (!a) {
1025      if (v.substr(-1) === ",") {
1026        v = v.substr(0, v.length - 1);
1027      }
1028
1029      if (_colorLookup[v]) {
1030        a = _colorLookup[v];
1031      } else if (v.charAt(0) === "#") {
1032        if (v.length < 6) {
1033          r = v.charAt(1);
1034          g = v.charAt(2);
1035          b = v.charAt(3);
1036          v = "#" + r + r + g + g + b + b + (v.length === 5 ? v.charAt(4) + v.charAt(4) : "");
1037        }
1038
1039        if (v.length === 9) {
1040          a = parseInt(v.substr(1, 6), 16);
1041          return [a >> 16, a >> 8 & _255, a & _255, parseInt(v.substr(7), 16) / 255];
1042        }
1043
1044        v = parseInt(v.substr(1), 16);
1045        a = [v >> 16, v >> 8 & _255, v & _255];
1046      } else if (v.substr(0, 3) === "hsl") {
1047        a = wasHSL = v.match(_strictNumExp);
1048
1049        if (!toHSL) {
1050          h = +a[0] % 360 / 360;
1051          s = +a[1] / 100;
1052          l = +a[2] / 100;
1053          g = l <= .5 ? l * (s + 1) : l + s - l * s;
1054          r = l * 2 - g;
1055          a.length > 3 && (a[3] *= 1);
1056          a[0] = _hue(h + 1 / 3, r, g);
1057          a[1] = _hue(h, r, g);
1058          a[2] = _hue(h - 1 / 3, r, g);
1059        } else if (~v.indexOf("=")) {
1060          a = v.match(_numExp);
1061          forceAlpha && a.length < 4 && (a[3] = 1);
1062          return a;
1063        }
1064      } else {
1065        a = v.match(_strictNumExp) || _colorLookup.transparent;
1066      }
1067
1068      a = a.map(Number);
1069    }
1070
1071    if (toHSL && !wasHSL) {
1072      r = a[0] / _255;
1073      g = a[1] / _255;
1074      b = a[2] / _255;
1075      max = Math.max(r, g, b);
1076      min = Math.min(r, g, b);
1077      l = (max + min) / 2;
1078
1079      if (max === min) {
1080        h = s = 0;
1081      } else {
1082        d = max - min;
1083        s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
1084        h = max === r ? (g - b) / d + (g < b ? 6 : 0) : max === g ? (b - r) / d + 2 : (r - g) / d + 4;
1085        h *= 60;
1086      }
1087
1088      a[0] = ~~(h + .5);
1089      a[1] = ~~(s * 100 + .5);
1090      a[2] = ~~(l * 100 + .5);
1091    }
1092
1093    forceAlpha && a.length < 4 && (a[3] = 1);
1094    return a;
1095  },
1096      _colorOrderData = function _colorOrderData(v) {
1097    var values = [],
1098        c = [],
1099        i = -1;
1100    v.split(_colorExp).forEach(function (v) {
1101      var a = v.match(_numWithUnitExp) || [];
1102      values.push.apply(values, a);
1103      c.push(i += a.length + 1);
1104    });
1105    values.c = c;
1106    return values;
1107  },
1108      _formatColors = function _formatColors(s, toHSL, orderMatchData) {
1109    var result = "",
1110        colors = (s + result).match(_colorExp),
1111        type = toHSL ? "hsla(" : "rgba(",
1112        i = 0,
1113        c,
1114        shell,
1115        d,
1116        l;
1117
1118    if (!colors) {
1119      return s;
1120    }
1121
1122    colors = colors.map(function (color) {
1123      return (color = splitColor(color, toHSL, 1)) && type + (toHSL ? color[0] + "," + color[1] + "%," + color[2] + "%," + color[3] : color.join(",")) + ")";
1124    });
1125
1126    if (orderMatchData) {
1127      d = _colorOrderData(s);
1128      c = orderMatchData.c;
1129
1130      if (c.join(result) !== d.c.join(result)) {
1131        shell = s.replace(_colorExp, "1").split(_numWithUnitExp);
1132        l = shell.length - 1;
1133
1134        for (; i < l; i++) {
1135          result += shell[i] + (~c.indexOf(i) ? colors.shift() || type + "0,0,0,0)" : (d.length ? d : colors.length ? colors : orderMatchData).shift());
1136        }
1137      }
1138    }
1139
1140    if (!shell) {
1141      shell = s.split(_colorExp);
1142      l = shell.length - 1;
1143
1144      for (; i < l; i++) {
1145        result += shell[i] + colors[i];
1146      }
1147    }
1148
1149    return result + shell[l];
1150  },
1151      _colorExp = function () {
1152    var s = "(?:\\b(?:(?:rgb|rgba|hsl|hsla)\\(.+?\\))|\\B#(?:[0-9a-f]{3,4}){1,2}\\b",
1153        p;
1154
1155    for (p in _colorLookup) {
1156      s += "|" + p + "\\b";
1157    }
1158
1159    return new RegExp(s + ")", "gi");
1160  }(),
1161      _hslExp = /hsl[a]?\(/,
1162      _colorStringFilter = function _colorStringFilter(a) {
1163    var combined = a.join(" "),
1164        toHSL;
1165    _colorExp.lastIndex = 0;
1166
1167    if (_colorExp.test(combined)) {
1168      toHSL = _hslExp.test(combined);
1169      a[1] = _formatColors(a[1], toHSL);
1170      a[0] = _formatColors(a[0], toHSL, _colorOrderData(a[1]));
1171      return true;
1172    }
1173  },
1174      _tickerActive,
1175      _ticker = function () {
1176    var _getTime = Date.now,
1177        _lagThreshold = 500,
1178        _adjustedLag = 33,
1179        _startTime = _getTime(),
1180        _lastUpdate = _startTime,
1181        _gap = 1000 / 240,
1182        _nextTime = _gap,
1183        _listeners = [],
1184        _id,
1185        _req,
1186        _raf,
1187        _self,
1188        _delta,
1189        _i,
1190        _tick = function _tick(v) {

1191      var elapsed = _getTime() - _lastUpdate,
1192          manual = v === true,
1193          overlap,
1194          dispatch,
1195          time,
1196          frame;
1197
1198      elapsed > _lagThreshold && (_startTime += elapsed - _adjustedLag);
1199      _lastUpdate += elapsed;
1200      time = _lastUpdate - _startTime;
1201      overlap = time - _nextTime;
1202
1203      if (overlap > 0 || manual) {
1204        frame = ++_self.frame;
1205        _delta = time - _self.time * 1000;
1206        _self.time = time = time / 1000;
1207        _nextTime += overlap + (overlap >= _gap ? 4 : _gap - overlap);
1208        dispatch = 1;
1209      }
1210
1211      manual || (_id = _req(_tick));
1212
1213      if (dispatch) {
1214        for (_i = 0; _i < _listeners.length; _i++) {
1215          _listeners[_i](time, _delta, frame, v);
1216        }
1217      }
1218    };
1219
1220    _self = {
1221      time: 0,
1222      frame: 0,
1223      tick: function tick() {
1224        _tick(true);
1225      },
1226      deltaRatio: function deltaRatio(fps) {
1227        return _delta / (1000 / (fps || 60));
1228      },
1229      wake: function wake() {
1230        if (_coreReady) {
1231          if (!_coreInitted && _windowExists()) {
1232            _win = _coreInitted = window;
1233            _doc = _win.document || {};
1234            _globals.gsap = gsap;
1235            (_win.gsapVersions || (_win.gsapVersions = [])).push(gsap.version);
1236
1237            _install(_installScope || _win.GreenSockGlobals || !_win.gsap && _win || {});
1238
1239            _raf = _win.requestAnimationFrame;
1240          }
1241
1242          _id && _self.sleep();
1243
1244          _req = _raf || function (f) {
1245            return setTimeout(f, _nextTime - _self.time * 1000 + 1 | 0);
1246          };
1247
1248          _tickerActive = 1;
1249
1250          _tick(2);
1251        }
1252      },
1253      sleep: function sleep() {
1254        (_raf ? _win.cancelAnimationFrame : clearTimeout)(_id);
1255        _tickerActive = 0;
1256        _req = _emptyFunc;
1257      },
1258      lagSmoothing: function lagSmoothing(threshold, adjustedLag) {
1259        _lagThreshold = threshold || 1 / _tinyNum;
1260        _adjustedLag = Math.min(adjustedLag, _lagThreshold, 0);
1261      },
1262      fps: function fps(_fps) {
1263        _gap = 1000 / (_fps || 240);
1264        _nextTime = _self.time * 1000 + _gap;
1265      },
1266      add: function add(callback) {
1267        _listeners.indexOf(callback) < 0 && _listeners.push(callback);
1268
1269        _wake();
1270      },
1271      remove: function remove(callback) {
1272        var i;
1273        ~(i = _listeners.indexOf(callback)) && _listeners.splice(i, 1) && _i >= i && _i--;
1274      },
1275      _listeners: _listeners
1276    };
1277    return _self;
1278  }(),
1279      _wake = function _wake() {
1280    return !_tickerActive && _ticker.wake();
1281  },
1282      _easeMap = {},
1283      _customEaseExp = /^[\d.\-M][\d.\-,\s]/,
1284      _quotesExp = /["']/g,
1285      _parseObjectInString = function _parseObjectInString(value) {
1286    var obj = {},
1287        split = value.substr(1, value.length - 3).split(":"),
1288        key = split[0],
1289        i = 1,
1290        l = split.length,
1291        index,
1292        val,
1293        parsedVal;
1294
1295    for (; i < l; i++) {
1296      val = split[i];
1297      index = i !== l - 1 ? val.lastIndexOf(",") : val.length;
1298      parsedVal = val.substr(0, index);
1299      obj[key] = isNaN(parsedVal) ? parsedVal.replace(_quotesExp, "").trim() : +parsedVal;
1300      key = val.substr(index + 1).trim();
1301    }
1302
1303    return obj;
1304  },
1305      _valueInParentheses = function _valueInParentheses(value) {
1306    var open = value.indexOf("(") + 1,
1307        close = value.indexOf(")"),
1308        nested = value.indexOf("(", open);
1309    return value.substring(open, ~nested && nested < close ? value.indexOf(")", close + 1) : close);
1310  },
1311      _configEaseFromString = function _configEaseFromString(name) {
1312    var split = (name + "").split("("),
1313        ease = _easeMap[split[0]];
1314    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;
1315  },
1316      _invertEase = function _invertEase(ease) {
1317    return function (p) {
1318      return 1 - ease(1 - p);
1319    };
1320  },
1321      _propagateYoyoEase = function _propagateYoyoEase(timeline, isYoyo) {
1322    var child = timeline._first,
1323        ease;
1324
1325    while (child) {
1326      if (child instanceof Timeline) {
1327        _propagateYoyoEase(child, isYoyo);
1328      } else if (child.vars.yoyoEase && (!child._yoyo || !child._repeat) && child._yoyo !== isYoyo) {
1329        if (child.timeline) {
1330          _propagateYoyoEase(child.timeline, isYoyo);
1331        } else {
1332          ease = child._ease;
1333          child._ease = child._yEase;
1334          child._yEase = ease;
1335          child._yoyo = isYoyo;
1336        }
1337      }
1338
1339      child = child._next;
1340    }
1341  },
1342      _parseEase = function _parseEase(ease, defaultEase) {
1343    return !ease ? defaultEase : (_isFunction(ease) ? ease : _easeMap[ease] || _configEaseFromString(ease)) || defaultEase;
1344  },
1345      _insertEase = function _insertEase(names, easeIn, easeOut, easeInOut) {
1346    if (easeOut === void 0) {
1347      easeOut = function easeOut(p) {
1348        return 1 - easeIn(1 - p);
1349      };
1350    }
1351
1352    if (easeInOut === void 0) {
1353      easeInOut = function easeInOut(p) {
1354        return p < .5 ? easeIn(p * 2) / 2 : 1 - easeIn((1 - p) * 2) / 2;
1355      };
1356    }
1357
1358    var ease = {
1359      easeIn: easeIn,
1360      easeOut: easeOut,
1361      easeInOut: easeInOut
1362    },
1363        lowercaseName;
1364

1365    _forEachName(names, function (name) {
1366      _easeMap[name] = _globals[name] = ease;
1367      _easeMap[lowercaseName = name.toLowerCase()] = easeOut;
1368
1369      for (var p in ease) {
1370        _easeMap[lowercaseName + (p === "easeIn" ? ".in" : p === "easeOut" ? ".out" : ".inOut")] = _easeMap[name + "." + p] = ease[p];
1371      }
1372    });
1373
1374    return ease;
1375  },
1376      _easeInOutFromOut = function _easeInOutFromOut(easeOut) {
1377    return function (p) {
1378      return p < .5 ? (1 - easeOut(1 - p * 2)) / 2 : .5 + easeOut((p - .5) * 2) / 2;
1379    };
1380  },
1381      _configElastic = function _configElastic(type, amplitude, period) {
1382    var p1 = amplitude >= 1 ? amplitude : 1,
1383        p2 = (period || (type ? .3 : .45)) / (amplitude < 1 ? amplitude : 1),
1384        p3 = p2 / _2PI * (Math.asin(1 / p1) || 0),
1385        easeOut = function easeOut(p) {
1386      return p === 1 ? 1 : p1 * Math.pow(2, -10 * p) * _sin((p - p3) * p2) + 1;
1387    },
1388        ease = type === "out" ? easeOut : type === "in" ? function (p) {
1389      return 1 - easeOut(1 - p);
1390    } : _easeInOutFromOut(easeOut);
1391
1392    p2 = _2PI / p2;
1393
1394    ease.config = function (amplitude, period) {
1395      return _configElastic(type, amplitude, period);
1396    };
1397
1398    return ease;
1399  },
1400      _configBack = function _configBack(type, overshoot) {
1401    if (overshoot === void 0) {
1402      overshoot = 1.70158;
1403    }
1404
1405    var easeOut = function easeOut(p) {
1406      return p ? --p * p * ((overshoot + 1) * p + overshoot) + 1 : 0;
1407    },
1408        ease = type === "out" ? easeOut : type === "in" ? function (p) {
1409      return 1 - easeOut(1 - p);
1410    } : _easeInOutFromOut(easeOut);
1411
1412    ease.config = function (overshoot) {
1413      return _configBack(type, overshoot);
1414    };
1415
1416    return ease;
1417  };
1418
1419  _forEachName("Linear,Quad,Cubic,Quart,Quint,Strong", function (name, i) {
1420    var power = i < 5 ? i + 1 : i;
1421
1422    _insertEase(name + ",Power" + (power - 1), i ? function (p) {
1423      return Math.pow(p, power);
1424    } : function (p) {
1425      return p;
1426    }, function (p) {
1427      return 1 - Math.pow(1 - p, power);
1428    }, function (p) {
1429      return p < .5 ? Math.pow(p * 2, power) / 2 : 1 - Math.pow((1 - p) * 2, power) / 2;
1430    });
1431  });
1432
1433  _easeMap.Linear.easeNone = _easeMap.none = _easeMap.Linear.easeIn;
1434
1435  _insertEase("Elastic", _configElastic("in"), _configElastic("out"), _configElastic());
1436
1437  (function (n, c) {
1438    var n1 = 1 / c,
1439        n2 = 2 * n1,
1440        n3 = 2.5 * n1,
1441        easeOut = function easeOut(p) {
1442      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;
1443    };
1444
1445    _insertEase("Bounce", function (p) {
1446      return 1 - easeOut(1 - p);
1447    }, easeOut);
1448  })(7.5625, 2.75);
1449
1450  _insertEase("Expo", function (p) {
1451    return p ? Math.pow(2, 10 * (p - 1)) : 0;
1452  });
1453
1454  _insertEase("Circ", function (p) {
1455    return -(_sqrt(1 - p * p) - 1);
1456  });
1457
1458  _insertEase("Sine", function (p) {
1459    return p === 1 ? 1 : -_cos(p * _HALF_PI) + 1;
1460  });
1461
1462  _insertEase("Back", _configBack("in"), _configBack("out"), _configBack());
1463
1464  _easeMap.SteppedEase = _easeMap.steps = _globals.SteppedEase = {
1465    config: function config(steps, immediateStart) {
1466      if (steps === void 0) {
1467        steps = 1;
1468      }
1469
1470      var p1 = 1 / steps,
1471          p2 = steps + (immediateStart ? 0 : 1),
1472          p3 = immediateStart ? 1 : 0,
1473          max = 1 - _tinyNum;
1474      return function (p) {
1475        return ((p2 * _clamp(0, max, p) | 0) + p3) * p1;
1476      };
1477    }
1478  };
1479  _defaults.ease = _easeMap["quad.out"];
1480
1481  _forEachName("onComplete,onUpdate,onStart,onRepeat,onReverseComplete,onInterrupt", function (name) {
1482    return _callbackNames += name + "," + name + "Params,";
1483  });
1484
1485  var GSCache = function GSCache(target, harness) {
1486    this.id = _gsID++;
1487    target._gsap = this;
1488    this.target = target;
1489    this.harness = harness;
1490    this.get = harness ? harness.get : _getProperty;
1491    this.set = harness ? harness.getSetter : _getSetter;
1492  };
1493  var Animation = function () {
1494    function Animation(vars) {
1495      this.vars = vars;

1496      this._delay = +vars.delay || 0;
1497
1498      if (this._repeat = vars.repeat === Infinity ? -2 : vars.repeat || 0) {
1499        this._rDelay = vars.repeatDelay || 0;
1500        this._yoyo = !!vars.yoyo || !!vars.yoyoEase;
1501      }
1502
1503      this._ts = 1;
1504
1505      _setDuration(this, +vars.duration, 1, 1);
1506
1507      this.data = vars.data;
1508      _tickerActive || _ticker.wake();
1509    }
1510
1511    var _proto = Animation.prototype;
1512
1513    _proto.delay = function delay(value) {
1514      if (value || value === 0) {
1515        this.parent && this.parent.smoothChildTiming && this.startTime(this._start + value - this._delay);
1516        this._delay = value;
1517        return this;
1518      }
1519
1520      return this._delay;
1521    };
1522
1523    _proto.duration = function duration(value) {
1524      return arguments.length ? this.totalDuration(this._repeat > 0 ? value + (value + this._rDelay) * this._repeat : value) : this.totalDuration() && this._dur;
1525    };
1526
1527    _proto.totalDuration = function totalDuration(value) {
1528      if (!arguments.length) {
1529        return this._tDur;
1530      }
1531
1532      this._dirty = 0;
1533      return _setDuration(this, this._repeat < 0 ? value : (value - this._repeat * this._rDelay) / (this._repeat + 1));
1534    };
1535
1536    _proto.totalTime = function totalTime(_totalTime, suppressEvents) {
1537      _wake();
1538
1539      if (!arguments.length) {
1540        return this._tTime;
1541      }
1542
1543      var parent = this._dp;
1544
1545      if (parent && parent.smoothChildTiming && this._ts) {
1546        _alignPlayhead(this, _totalTime);
1547
1548        !parent._dp || parent.parent || _postAddChecks(parent, this);
1549
1550        while (parent.parent) {
1551          if (parent.parent._time !== parent._start + (parent._ts >= 0 ? parent._tTime / parent._ts : (parent.totalDuration() - parent._tTime) / -parent._ts)) {
1552            parent.totalTime(parent._tTime, true);
1553          }
1554
1555          parent = parent.parent;
1556        }
1557
1558        if (!this.parent && this._dp.autoRemoveChildren && (this._ts > 0 && _totalTime < this._tDur || this._ts < 0 && _totalTime > 0 || !this._tDur && !_totalTime)) {
1559          _addToTimeline(this._dp, this, this._start - this._delay);
1560        }
1561      }
1562
1563      if (this._tTime !== _totalTime || !this._dur && !suppressEvents || this._initted && Math.abs(this._zTime) === _tinyNum || !_totalTime && !this._initted && (this.add || this._ptLookup)) {
1564        this._ts || (this._pTime = _totalTime);
1565
1566        _lazySafeRender(this, _totalTime, suppressEvents);
1567      }
1568
1569      return this;
1570    };
1571
1572    _proto.time = function time(value, suppressEvents) {
1573      return arguments.length ? this.totalTime(Math.min(this.totalDuration(), value + _elapsedCycleDuration(this)) % (this._dur + this._rDelay) || (value ? this._dur : 0), suppressEvents) : this._time;
1574    };
1575
1576    _proto.totalProgress = function totalProgress(value, suppressEvents) {
1577      return arguments.length ? this.totalTime(this.totalDuration() * value, suppressEvents) : this.totalDuration() ? Math.min(1, this._tTime / this._tDur) : this.ratio;
1578    };
1579
1580    _proto.progress = function progress(value, suppressEvents) {
1581      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;
1582    };
1583
1584    _proto.iteration = function iteration(value, suppressEvents) {
1585      var cycleDuration = this.duration() + this._rDelay;
1586
1587      return arguments.length ? this.totalTime(this._time + (value - 1) * cycleDuration, suppressEvents) : this._repeat ? _animationCycle(this._tTime, cycleDuration) + 1 : 1;
1588    };
1589
1590    _proto.timeScale = function timeScale(value) {
1591      if (!arguments.length) {
1592        return this._rts === -_tinyNum ? 0 : this._rts;
1593      }
1594
1595      if (this._rts === value) {
1596        return this;
1597      }
1598
1599      var tTime = this.parent && this._ts ? _parentToChildTotalTime(this.parent._time, this) : this._tTime;
1600      this._rts = +value || 0;
1601      this._ts = this._ps || value === -_tinyNum ? 0 : this._rts;
1602      return _recacheAncestors(this.totalTime(_clamp(-this._delay, this._tDur, tTime), true));
1603    };
1604
1605    _proto.paused = function paused(value) {
1606      if (!arguments.length) {
1607        return this._ps;
1608      }
1609
1610      if (this._ps !== value) {
1611        this._ps = value;
1612
1613        if (value) {
1614          this._pTime = this._tTime || Math.max(-this._delay, this.rawTime());
1615          this._ts = this._act = 0;
1616        } else {
1617          _wake();
1618
1619          this._ts = this._rts;
1620          this.totalTime(this.parent && !this.parent.smoothChildTiming ? this.rawTime() : this._tTime || this._pTime, this.progress() === 1 && Math.abs(this._zTime) !== _tinyNum && (this._tTime -= _tinyNum));
1621        }
1622      }
1623
1624      return this;
1625    };
1626
1627    _proto.startTime = function startTime(value) {
1628      if (arguments.length) {
1629        this._start = value;
1630        var parent = this.parent || this._dp;

1631        parent && (parent._sort || !this.parent) && _addToTimeline(parent, this, value - this._delay);
1632        return this;
1633      }
1634
1635      return this._start;
1636    };
1637
1638    _proto.endTime = function endTime(includeRepeats) {
1639      return this._start + (_isNotFalse(includeRepeats) ? this.totalDuration() : this.duration()) / Math.abs(this._ts);
1640    };
1641
1642    _proto.rawTime = function rawTime(wrapRepeats) {
1643      var parent = this.parent || this._dp;
1644      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);
1645    };
1646
1647    _proto.globalTime = function globalTime(rawTime) {
1648      var animation = this,
1649          time = arguments.length ? rawTime : animation.rawTime();
1650
1651      while (animation) {
1652        time = animation._start + time / (animation._ts || 1);
1653        animation = animation._dp;
1654      }
1655
1656      return time;
1657    };
1658
1659    _proto.repeat = function repeat(value) {
1660      if (arguments.length) {
1661        this._repeat = value === Infinity ? -2 : value;
1662        return _onUpdateTotalDuration(this);
1663      }
1664
1665      return this._repeat === -2 ? Infinity : this._repeat;
1666    };
1667
1668    _proto.repeatDelay = function repeatDelay(value) {
1669      if (arguments.length) {
1670        var time = this._time;
1671        this._rDelay = value;
1672
1673        _onUpdateTotalDuration(this);
1674
1675        return time ? this.time(time) : this;
1676      }
1677
1678      return this._rDelay;
1679    };
1680
1681    _proto.yoyo = function yoyo(value) {
1682      if (arguments.length) {
1683        this._yoyo = value;
1684        return this;
1685      }
1686
1687      return this._yoyo;
1688    };
1689
1690    _proto.seek = function seek(position, suppressEvents) {
1691      return this.totalTime(_parsePosition(this, position), _isNotFalse(suppressEvents));
1692    };
1693
1694    _proto.restart = function restart(includeDelay, suppressEvents) {
1695      return this.play().totalTime(includeDelay ? -this._delay : 0, _isNotFalse(suppressEvents));
1696    };
1697
1698    _proto.play = function play(from, suppressEvents) {
1699      from != null && this.seek(from, suppressEvents);
1700      return this.reversed(false).paused(false);
1701    };
1702
1703    _proto.reverse = function reverse(from, suppressEvents) {
1704      from != null && this.seek(from || this.totalDuration(), suppressEvents);
1705      return this.reversed(true).paused(false);
1706    };
1707
1708    _proto.pause = function pause(atTime, suppressEvents) {
1709      atTime != null && this.seek(atTime, suppressEvents);
1710      return this.paused(true);
1711    };
1712
1713    _proto.resume = function resume() {
1714      return this.paused(false);
1715    };
1716
1717    _proto.reversed = function reversed(value) {
1718      if (arguments.length) {
1719        !!value !== this.reversed() && this.timeScale(-this._rts || (value ? -_tinyNum : 0));
1720        return this;
1721      }
1722
1723      return this._rts < 0;
1724    };
1725

1726    _proto.invalidate = function invalidate() {
1727      this._initted = this._act = 0;
1728      this._zTime = -_tinyNum;
1729      return this;
1730    };
1731
1732    _proto.isActive = function isActive() {
1733      var parent = this.parent || this._dp,
1734          start = this._start,
1735          rawTime;
1736      return !!(!parent || this._ts && this._initted && parent.isActive() && (rawTime = parent.rawTime(true)) >= start && rawTime < this.endTime(true) - _tinyNum);
1737    };
1738
1739    _proto.eventCallback = function eventCallback(type, callback, params) {
1740      var vars = this.vars;
1741
1742      if (arguments.length > 1) {
1743        if (!callback) {
1744          delete vars[type];
1745        } else {
1746          vars[type] = callback;
1747          params && (vars[type + "Params"] = params);
1748          type === "onUpdate" && (this._onUpdate = callback);
1749        }
1750
1751        return this;
1752      }
1753
1754      return vars[type];
1755    };
1756
1757    _proto.then = function then(onFulfilled) {
1758      var self = this;
1759      return new Promise(function (resolve) {
1760        var f = _isFunction(onFulfilled) ? onFulfilled : _passThrough,
1761            _resolve = function _resolve() {
1762          var _then = self.then;
1763          self.then = null;
1764          _isFunction(f) && (f = f(self)) && (f.then || f === self) && (self.then = _then);
1765          resolve(f);
1766          self.then = _then;
1767        };
1768
1769        if (self._initted && self.totalProgress() === 1 && self._ts >= 0 || !self._tTime && self._ts < 0) {
1770          _resolve();
1771        } else {
1772          self._prom = _resolve;
1773        }
1774      });
1775    };
1776
1777    _proto.kill = function kill() {
1778      _interrupt(this);
1779    };
1780
1781    return Animation;
1782  }();
1783
1784  _setDefaults(Animation.prototype, {
1785    _time: 0,
1786    _start: 0,
1787    _end: 0,
1788    _tTime: 0,
1789    _tDur: 0,
1790    _dirty: 0,
1791    _repeat: 0,
1792    _yoyo: false,
1793    parent: null,
1794    _initted: false,
1795    _rDelay: 0,
1796    _ts: 1,
1797    _dp: 0,
1798    ratio: 0,
1799    _zTime: -_tinyNum,
1800    _prom: 0,
1801    _ps: false,
1802    _rts: 1
1803  });
1804
1805  var Timeline = function (_Animation) {
1806    _inheritsLoose(Timeline, _Animation);
1807
1808    function Timeline(vars, position) {
1809      var _this;
1810
1811      if (vars === void 0) {
1812        vars = {};
1813      }
1814
1815      _this = _Animation.call(this, vars) || this;
1816      _this.labels = {};
1817      _this.smoothChildTiming = !!vars.smoothChildTiming;
1818      _this.autoRemoveChildren = !!vars.autoRemoveChildren;
1819      _this._sort = _isNotFalse(vars.sortChildren);
1820      _globalTimeline && _addToTimeline(vars.parent || _globalTimeline, _assertThisInitialized(_this), position);
1821      vars.reversed && _this.reverse();
1822      vars.paused && _this.paused(true);
1823      vars.scrollTrigger && _scrollTrigger(_assertThisInitialized(_this), vars.scrollTrigger);
1824      return _this;
1825    }
1826
1827    var _proto2 = Timeline.prototype;
1828
1829    _proto2.to = function to(targets, vars, position) {
1830      _createTweenType(0, arguments, this);
1831
1832      return this;
1833    };
1834
1835    _proto2.from = function from(targets, vars, position) {
1836      _createTweenType(1, arguments, this);
1837
1838      return this;
1839    };
1840
1841    _proto2.fromTo = function fromTo(targets, fromVars, toVars, position) {
1842      _createTweenType(2, arguments, this);
1843
1844      return this;
1845    };
1846
1847    _proto2.set = function set(targets, vars, position) {
1848      vars.duration = 0;
1849      vars.parent = this;
1850      _inheritDefaults(vars).repeatDelay || (vars.repeat = 0);
1851      vars.immediateRender = !!vars.immediateRender;
1852      new Tween(targets, vars, _parsePosition(this, position), 1);
1853      return this;
1854    };
1855
1856    _proto2.call = function call(callback, params, position) {
1857      return _addToTimeline(this, Tween.delayedCall(0, callback, params), position);
1858    };
1859
1860    _proto2.staggerTo = function staggerTo(targets, duration, vars, stagger, position, onCompleteAll, onCompleteAllParams) {
1861      vars.duration = duration;
1862      vars.stagger = vars.stagger || stagger;
1863      vars.onComplete = onCompleteAll;
1864      vars.onCompleteParams = onCompleteAllParams;
1865      vars.parent = this;
1866      new Tween(targets, vars, _parsePosition(this, position));
1867      return this;
1868    };
1869
1870    _proto2.staggerFrom = function staggerFrom(targets, duration, vars, stagger, position, onCompleteAll, onCompleteAllParams) {
1871      vars.runBackwards = 1;
1872      _inheritDefaults(vars).immediateRender = _isNotFalse(vars.immediateRender);
1873      return this.staggerTo(targets, duration, vars, stagger, position, onCompleteAll, onCompleteAllParams);
1874    };
1875
1876    _proto2.staggerFromTo = function staggerFromTo(targets, duration, fromVars, toVars, stagger, position, onCompleteAll, onCompleteAllParams) {
1877      toVars.startAt = fromVars;
1878      _inheritDefaults(toVars).immediateRender = _isNotFalse(toVars.immediateRender);
1879      return this.staggerTo(targets, duration, toVars, stagger, position, onCompleteAll, onCompleteAllParams);
1880    };
1881
1882    _proto2.render = function render(totalTime, suppressEvents, force) {
1883      var prevTime = this._time,
1884          tDur = this._dirty ? this.totalDuration() : this._tDur,
1885          dur = this._dur,
1886          tTime = this !== _globalTimeline && totalTime > tDur - _tinyNum && totalTime >= 0 ? tDur : totalTime < _tinyNum ? 0 : totalTime,
1887          crossingStart = this._zTime < 0 !== totalTime < 0 && (this._initted || !dur),
1888          time,
1889          child,
1890          next,
1891          iteration,
1892          cycleDuration,
1893          prevPaused,
1894          pauseTween,
1895          timeScale,
1896          prevStart,
1897          prevIteration,
1898          yoyo,
1899          isYoyo;
1900
1901      if (tTime !== this._tTime || force || crossingStart) {
1902        if (prevTime !== this._time && dur) {
1903          tTime += this._time - prevTime;
1904          totalTime += this._time - prevTime;
1905        }
1906
1907        time = tTime;
1908        prevStart = this._start;
1909        timeScale = this._ts;
1910        prevPaused = !timeScale;
1911
1912        if (crossingStart) {
1913          dur || (prevTime = this._zTime);
1914          (totalTime || !suppressEvents) && (this._zTime = totalTime);
1915        }
1916
1917        if (this._repeat) {
1918          yoyo = this._yoyo;
1919          cycleDuration = dur + this._rDelay;
1920
1921          if (this._repeat < -1 && totalTime < 0) {
1922            return this.totalTime(cycleDuration * 100 + totalTime, suppressEvents, force);
1923          }
1924
1925          time = _round(tTime % cycleDuration);
1926
1927          if (tTime === tDur) {
1928            iteration = this._repeat;
1929            time = dur;
1930          } else {
1931            iteration = ~~(tTime / cycleDuration);
1932
1933            if (iteration && iteration === tTime / cycleDuration) {
1934              time = dur;
1935              iteration--;
1936            }
1937
1938            time > dur && (time = dur);
1939          }
1940
1941          prevIteration = _animationCycle(this._tTime, cycleDuration);
1942          !prevTime && this._tTime && prevIteration !== iteration && (prevIteration = iteration);
1943
1944          if (yoyo && iteration & 1) {
1945            time = dur - time;
1946            isYoyo = 1;
1947          }
1948
1949          if (iteration !== prevIteration && !this._lock) {
1950            var rewinding = yoyo && prevIteration & 1,
1951                doesWrap = rewinding === (yoyo && iteration & 1);
1952            iteration < prevIteration && (rewinding = !rewinding);
1953            prevTime = rewinding ? 0 : dur;
1954            this._lock = 1;
1955            this.render(prevTime || (isYoyo ? 0 : _round(iteration * cycleDuration)), suppressEvents, !dur)._lock = 0;
1956            this._tTime = tTime;
1957            !suppressEvents && this.parent && _callback(this, "onRepeat");
1958            this.vars.repeatRefresh && !isYoyo && (this.invalidate()._lock = 1);
1959
1960            if (prevTime && prevTime !== this._time || prevPaused !== !this._ts || this.vars.onRepeat && !this.parent && !this._act) {
1961              return this;
1962            }
1963
1964            dur = this._dur;
1965            tDur = this._tDur;
1966
1967            if (doesWrap) {
1968              this._lock = 2;
1969              prevTime = rewinding ? dur : -0.0001;
1970              this.render(prevTime, true);
1971              this.vars.repeatRefresh && !isYoyo && this.invalidate();
1972            }
1973
1974            this._lock = 0;
1975
1976            if (!this._ts && !prevPaused) {
1977              return this;
1978            }
1979
1980            _propagateYoyoEase(this, isYoyo);
1981          }
1982        }
1983
1984        if (this._hasPause && !this._forcing && this._lock < 2) {
1985          pauseTween = _findNextPauseTween(this, _round(prevTime), _round(time));
1986
1987          if (pauseTween) {
1988            tTime -= time - (time = pauseTween._start);
1989          }
1990        }
1991
1992        this._tTime = tTime;
1993        this._time = time;
1994        this._act = !timeScale;
1995
1996        if (!this._initted) {
1997          this._onUpdate = this.vars.onUpdate;
1998          this._initted = 1;
1999          this._zTime = totalTime;
2000          prevTime = 0;
2001        }
2002
2003        if (!prevTime && time && !suppressEvents) {
2004          _callback(this, "onStart");
2005
2006          if (this._tTime !== tTime) {
2007            return this;
2008          }
2009        }
2010
2011        if (time >= prevTime && totalTime >= 0) {
2012          child = this._first;
2013
2014          while (child) {
2015            next = child._next;
2016
2017            if ((child._act || time >= child._start) && child._ts && pauseTween !== child) {
2018              if (child.parent !== this) {
2019                return this.render(totalTime, suppressEvents, force);
2020              }
2021
2022              child.render(child._ts > 0 ? (time - child._start) * child._ts : (child._dirty ? child.totalDuration() : child._tDur) + (time - child._start) * child._ts, suppressEvents, force);
2023
2024              if (time !== this._time || !this._ts && !prevPaused) {
2025                pauseTween = 0;
2026                next && (tTime += this._zTime = -_tinyNum);
2027                break;
2028              }
2029            }
2030
2031            child = next;
2032          }
2033        } else {
2034          child = this._last;
2035          var adjustedTime = totalTime < 0 ? totalTime : time;
2036
2037          while (child) {
2038            next = child._prev;
2039
2040            if ((child._act || adjustedTime <= child._end) && child._ts && pauseTween !== child) {
2041              if (child.parent !== this) {
2042                return this.render(totalTime, suppressEvents, force);
2043              }
2044
2045              child.render(child._ts > 0 ? (adjustedTime - child._start) * child._ts : (child._dirty ? child.totalDuration() : child._tDur) + (adjustedTime - child._start) * child._ts, suppressEvents, force);
2046
2047              if (time !== this._time || !this._ts && !prevPaused) {
2048                pauseTween = 0;
2049                next && (tTime += this._zTime = adjustedTime ? -_tinyNum : _tinyNum);
2050                break;
2051              }
2052            }
2053
2054            child = next;
2055          }
2056        }
2057
2058        if (pauseTween && !suppressEvents) {
2059          this.pause();
2060          pauseTween.render(time >= prevTime ? 0 : -_tinyNum)._zTime = time >= prevTime ? 1 : -1;
2061

2062          if (this._ts) {
2063            this._start = prevStart;
2064
2065            _setEnd(this);
2066
2067            return this.render(totalTime, suppressEvents, force);
2068          }
2069        }
2070
2071        this._onUpdate && !suppressEvents && _callback(this, "onUpdate", true);
2072        if (tTime === tDur && tDur >= this.totalDuration() || !tTime && prevTime) if (prevStart === this._start || Math.abs(timeScale) !== Math.abs(this._ts)) if (!this._lock) {
2073          (totalTime || !dur) && (tTime === tDur && this._ts > 0 || !tTime && this._ts < 0) && _removeFromParent(this, 1);
2074
2075          if (!suppressEvents && !(totalTime < 0 && !prevTime) && (tTime || prevTime || !tDur)) {
2076            _callback(this, tTime === tDur && totalTime >= 0 ? "onComplete" : "onReverseComplete", true);
2077
2078            this._prom && !(tTime < tDur && this.timeScale() > 0) && this._prom();
2079          }
2080        }
2081      }
2082
2083      return this;
2084    };
2085
2086    _proto2.add = function add(child, position) {
2087      var _this2 = this;
2088
2089      _isNumber(position) || (position = _parsePosition(this, position, child));
2090
2091      if (!(child instanceof Animation)) {
2092        if (_isArray(child)) {
2093          child.forEach(function (obj) {
2094            return _this2.add(obj, position);
2095          });
2096          return this;
2097        }
2098
2099        if (_isString(child)) {
2100          return this.addLabel(child, position);
2101        }
2102
2103        if (_isFunction(child)) {
2104          child = Tween.delayedCall(0, child);
2105        } else {
2106          return this;
2107        }
2108      }
2109
2110      return this !== child ? _addToTimeline(this, child, position) : this;
2111    };
2112
2113    _proto2.getChildren = function getChildren(nested, tweens, timelines, ignoreBeforeTime) {
2114      if (nested === void 0) {
2115        nested = true;
2116      }
2117
2118      if (tweens === void 0) {
2119        tweens = true;
2120      }
2121
2122      if (timelines === void 0) {
2123        timelines = true;
2124      }
2125
2126      if (ignoreBeforeTime === void 0) {
2127        ignoreBeforeTime = -_bigNum;
2128      }
2129
2130      var a = [],
2131          child = this._first;
2132
2133      while (child) {
2134        if (child._start >= ignoreBeforeTime) {
2135          if (child instanceof Tween) {
2136            tweens && a.push(child);
2137          } else {
2138            timelines && a.push(child);
2139            nested && a.push.apply(a, child.getChildren(true, tweens, timelines));
2140          }
2141        }
2142
2143        child = child._next;
2144      }
2145
2146      return a;
2147    };
2148
2149    _proto2.getById = function getById(id) {
2150      var animations = this.getChildren(1, 1, 1),
2151          i = animations.length;
2152
2153      while (i--) {
2154        if (animations[i].vars.id === id) {
2155          return animations[i];
2156        }
2157      }
2158    };
2159
2160    _proto2.remove = function remove(child) {
2161      if (_isString(child)) {
2162        return this.removeLabel(child);
2163      }
2164
2165      if (_isFunction(child)) {
2166        return this.killTweensOf(child);
2167      }
2168
2169      _removeLinkedListItem(this, child);
2170
2171      if (child === this._recent) {
2172        this._recent = this._last;
2173      }
2174
2175      return _uncache(this);
2176    };
2177
2178    _proto2.totalTime = function totalTime(_totalTime2, suppressEvents) {
2179      if (!arguments.length) {
2180        return this._tTime;
2181      }
2182
2183      this._forcing = 1;
2184
2185      if (!this._dp && this._ts) {
2186        this._start = _round(_ticker.time - (this._ts > 0 ? _totalTime2 / this._ts : (this.totalDuration() - _totalTime2) / -this._ts));
2187      }
2188
2189      _Animation.prototype.totalTime.call(this, _totalTime2, suppressEvents);
2190
2191      this._forcing = 0;
2192      return this;
2193    };
2194
2195    _proto2.addLabel = function addLabel(label, position) {
2196      this.labels[label] = _parsePosition(this, position);
2197      return this;
2198    };
2199
2200    _proto2.removeLabel = function removeLabel(label) {
2201      delete this.labels[label];
2202      return this;
2203    };
2204
2205    _proto2.addPause = function addPause(position, callback, params) {
2206      var t = Tween.delayedCall(0, callback || _emptyFunc, params);
2207      t.data = "isPause";
2208      this._hasPause = 1;
2209      return _addToTimeline(this, t, _parsePosition(this, position));
2210    };
2211
2212    _proto2.removePause = function removePause(position) {
2213      var child = this._first;
2214      position = _parsePosition(this, position);
2215
2216      while (child) {
2217        if (child._start === position && child.data === "isPause") {
2218          _removeFromParent(child);
2219        }
2220
2221        child = child._next;
2222      }
2223    };
2224
2225    _proto2.killTweensOf = function killTweensOf(targets, props, onlyActive) {
2226      var tweens = this.getTweensOf(targets, onlyActive),
2227          i = tweens.length;
2228
2229      while (i--) {
2230        _overwritingTween !== tweens[i] && tweens[i].kill(targets, props);
2231      }
2232
2233      return this;
2234    };
2235
2236    _proto2.getTweensOf = function getTweensOf(targets, onlyActive) {
2237      var a = [],
2238          parsedTargets = toArray(targets),
2239          child = this._first,
2240          isGlobalTime = _isNumber(onlyActive),
2241          children;
2242
2243      while (child) {
2244        if (child instanceof Tween) {
2245          if (_arrayContainsAny(child._targets, parsedTargets) && (isGlobalTime ? (!_overwritingTween || child._initted && child._ts) && child.globalTime(0) <= onlyActive && child.globalTime(child.totalDuration()) > onlyActive : !onlyActive || child.isActive())) {
2246            a.push(child);
2247          }
2248        } else if ((children = child.getTweensOf(parsedTargets, onlyActive)).length) {
2249          a.push.apply(a, children);
2250        }
2251
2252        child = child._next;
2253      }
2254
2255      return a;
2256    };
2257
2258    _proto2.tweenTo = function tweenTo(position, vars) {
2259      vars = vars || {};
2260
2261      var tl = this,
2262          endTime = _parsePosition(tl, position),
2263          _vars = vars,
2264          startAt = _vars.startAt,
2265          _onStart = _vars.onStart,
2266          onStartParams = _vars.onStartParams,
2267          immediateRender = _vars.immediateRender,
2268          initted,
2269          tween = Tween.to(tl, _setDefaults({
2270        ease: vars.ease || "none",
2271        lazy: false,
2272        immediateRender: false,
2273        time: endTime,
2274        overwrite: "auto",
2275        duration: vars.duration || Math.abs((endTime - (startAt && "time" in startAt ? startAt.time : tl._time)) / tl.timeScale()) || _tinyNum,
2276        onStart: function onStart() {
2277          tl.pause();
2278
2279          if (!initted) {
2280            var duration = vars.duration || Math.abs((endTime - (startAt && "time" in startAt ? startAt.time : tl._time)) / tl.timeScale());
2281            tween._dur !== duration && _setDuration(tween, duration, 0, 1).render(tween._time, true, true);
2282            initted = 1;
2283          }
2284
2285          _onStart && _onStart.apply(tween, onStartParams || []);
2286        }
2287      }, vars));
2288
2289      return immediateRender ? tween.render(0) : tween;
2290    };
2291
2292    _proto2.tweenFromTo = function tweenFromTo(fromPosition, toPosition, vars) {
2293      return this.tweenTo(toPosition, _setDefaults({
2294        startAt: {
2295          time: _parsePosition(this, fromPosition)
2296        }
2297      }, vars));
2298    };
2299
2300    _proto2.recent = function recent() {
2301      return this._recent;
2302    };
2303
2304    _proto2.nextLabel = function nextLabel(afterTime) {
2305      if (afterTime === void 0) {
2306        afterTime = this._time;
2307      }
2308
2309      return _getLabelInDirection(this, _parsePosition(this, afterTime));
2310    };
2311
2312    _proto2.previousLabel = function previousLabel(beforeTime) {
2313      if (beforeTime === void 0) {
2314        beforeTime = this._time;
2315      }
2316
2317      return _getLabelInDirection(this, _parsePosition(this, beforeTime), 1);
2318    };
2319
2320    _proto2.currentLabel = function currentLabel(value) {
2321      return arguments.length ? this.seek(value, true) : this.previousLabel(this._time + _tinyNum);
2322    };
2323
2324    _proto2.shiftChildren = function shiftChildren(amount, adjustLabels, ignoreBeforeTime) {
2325      if (ignoreBeforeTime === void 0) {
2326        ignoreBeforeTime = 0;
2327      }
2328
2329      var child = this._first,
2330          labels = this.labels,
2331          p;
2332
2333      while (child) {
2334        if (child._start >= ignoreBeforeTime) {
2335          child._start += amount;
2336          child._end += amount;
2337        }
2338
2339        child = child._next;
2340      }
2341
2342      if (adjustLabels) {
2343        for (p in labels) {
2344          if (labels[p] >= ignoreBeforeTime) {
2345            labels[p] += amount;
2346          }
2347        }
2348      }
2349
2350      return _uncache(this);
2351    };
2352
2353    _proto2.invalidate = function invalidate() {
2354      var child = this._first;
2355      this._lock = 0;
2356
2357      while (child) {
2358        child.invalidate();
2359        child = child._next;
2360      }
2361
2362      return _Animation.prototype.invalidate.call(this);
2363    };
2364
2365    _proto2.clear = function clear(includeLabels) {
2366      if (includeLabels === void 0) {
2367        includeLabels = true;
2368      }
2369
2370      var child = this._first,
2371          next;
2372
2373      while (child) {
2374        next = child._next;
2375        this.remove(child);
2376        child = next;
2377      }
2378
2379      this._dp && (this._time = this._tTime = this._pTime = 0);
2380      includeLabels && (this.labels = {});
2381      return _uncache(this);
2382    };
2383
2384    _proto2.totalDuration = function totalDuration(value) {
2385      var max = 0,
2386          self = this,
2387          child = self._last,
2388          prevStart = _bigNum,
2389          prev,
2390          start,
2391          parent;
2392
2393      if (arguments.length) {
2394        return self.timeScale((self._repeat < 0 ? self.duration() : self.totalDuration()) / (self.reversed() ? -value : value));
2395      }
2396
2397      if (self._dirty) {
2398        parent = self.parent;
2399
2400        while (child) {
2401          prev = child._prev;
2402          child._dirty && child.totalDuration();
2403          start = child._start;
2404
2405          if (start > prevStart && self._sort && child._ts && !self._lock) {
2406            self._lock = 1;
2407            _addToTimeline(self, child, start - child._delay, 1)._lock = 0;
2408          } else {
2409            prevStart = start;
2410          }
2411
2412          if (start < 0 && child._ts) {
2413            max -= start;
2414
2415            if (!parent && !self._dp || parent && parent.smoothChildTiming) {
2416              self._start += start / self._ts;
2417              self._time -= start;
2418              self._tTime -= start;
2419            }
2420
2421            self.shiftChildren(-start, false, -1e999);
2422            prevStart = 0;
2423          }
2424
2425          child._end > max && child._ts && (max = child._end);
2426          child = prev;
2427        }
2428
2429        _setDuration(self, self === _globalTimeline && self._time > max ? self._time : max, 1, 1);
2430
2431        self._dirty = 0;
2432      }
2433
2434      return self._tDur;
2435    };
2436
2437    Timeline.updateRoot = function updateRoot(time) {
2438      if (_globalTimeline._ts) {
2439        _lazySafeRender(_globalTimeline, _parentToChildTotalTime(time, _globalTimeline));
2440
2441        _lastRenderedFrame = _ticker.frame;
2442      }
2443
2444      if (_ticker.frame >= _nextGCFrame) {
2445        _nextGCFrame += _config.autoSleep || 120;
2446        var child = _globalTimeline._first;
2447        if (!child || !child._ts) if (_config.autoSleep && _ticker._listeners.length < 2) {
2448          while (child && !child._ts) {
2449            child = child._next;
2450          }
2451
2452          child || _ticker.sleep();
2453        }
2454      }
2455    };
2456
2457    return Timeline;
2458  }(Animation);
2459
2460  _setDefaults(Timeline.prototype, {
2461    _lock: 0,
2462    _hasPause: 0,
2463    _forcing: 0
2464  });
2465
2466  var _addComplexStringPropTween = function _addComplexStringPropTween(target, prop, start, end, setter, stringFilter, funcParam) {
2467    var pt = new PropTween(this._pt, target, prop, 0, 1, _renderComplexString, null, setter),
2468        index = 0,
2469        matchIndex = 0,
2470        result,
2471        startNums,
2472        color,
2473        endNum,
2474        chunk,
2475        startNum,
2476        hasRandom,
2477        a;
2478    pt.b = start;
2479    pt.e = end;
2480    start += "";
2481    end += "";
2482
2483    if (hasRandom = ~end.indexOf("random(")) {
2484      end = _replaceRandom(end);
2485    }
2486
2487    if (stringFilter) {
2488      a = [start, end];
2489      stringFilter(a, target, prop);
2490      start = a[0];
2491      end = a[1];
2492    }
2493
2494    startNums = start.match(_complexStringNumExp) || [];
2495
2496    while (result = _complexStringNumExp.exec(end)) {
2497      endNum = result[0];
2498      chunk = end.substring(index, result.index);
2499
2500      if (color) {
2501        color = (color + 1) % 5;
2502      } else if (chunk.substr(-5) === "rgba(") {
2503        color = 1;
2504      }
2505
2506      if (endNum !== startNums[matchIndex++]) {
2507        startNum = parseFloat(startNums[matchIndex - 1]) || 0;
2508        pt._pt = {
2509          _next: pt._pt,
2510          p: chunk || matchIndex === 1 ? chunk : ",",
2511          s: startNum,
2512          c: endNum.charAt(1) === "=" ? parseFloat(endNum.substr(2)) * (endNum.charAt(0) === "-" ? -1 : 1) : parseFloat(endNum) - startNum,
2513          m: color && color < 4 ? Math.round : 0
2514        };
2515        index = _complexStringNumExp.lastIndex;
2516      }
2517    }
2518
2519    pt.c = index < end.length ? end.substring(index, end.length) : "";
2520    pt.fp = funcParam;
2521
2522    if (_relExp.test(end) || hasRandom) {
2523      pt.e = 0;
2524    }
2525
2526    this._pt = pt;
2527    return pt;
2528  },
2529      _addPropTween = function _addPropTween(target, prop, start, end, index, targets, modifier, stringFilter, funcParam) {

2530    _isFunction(end) && (end = end(index || 0, target, targets));
2531    var currentValue = target[prop],
2532        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](),
2533        setter = !_isFunction(currentValue) ? _setterPlain : funcParam ? _setterFuncWithParam : _setterFunc,
2534        pt;
2535
2536    if (_isString(end)) {
2537      if (~end.indexOf("random(")) {
2538        end = _replaceRandom(end);
2539      }
2540
2541      if (end.charAt(1) === "=") {
2542        pt = parseFloat(parsedStart) + parseFloat(end.substr(2)) * (end.charAt(0) === "-" ? -1 : 1) + (getUnit(parsedStart) || 0);
2543
2544        if (pt || pt === 0) {
2545          end = pt;
2546        }
2547      }
2548    }
2549
2550    if (parsedStart !== end) {
2551      if (!isNaN(parsedStart * end) && end !== "") {
2552        pt = new PropTween(this._pt, target, prop, +parsedStart || 0, end - (parsedStart || 0), typeof currentValue === "boolean" ? _renderBoolean : _renderPlain, 0, setter);
2553        funcParam && (pt.fp = funcParam);
2554        modifier && pt.modifier(modifier, this, target);
2555        return this._pt = pt;
2556      }
2557
2558      !currentValue && !(prop in target) && _missingPlugin(prop, end);
2559      return _addComplexStringPropTween.call(this, target, prop, parsedStart, end, setter, stringFilter || _config.stringFilter, funcParam);
2560    }
2561  },
2562      _processVars = function _processVars(vars, index, target, targets, tween) {
2563    _isFunction(vars) && (vars = _parseFuncOrString(vars, tween, index, target, targets));
2564
2565    if (!_isObject(vars) || vars.style && vars.nodeType || _isArray(vars) || _isTypedArray(vars)) {
2566      return _isString(vars) ? _parseFuncOrString(vars, tween, index, target, targets) : vars;
2567    }
2568
2569    var copy = {},
2570        p;
2571
2572    for (p in vars) {
2573      copy[p] = _parseFuncOrString(vars[p], tween, index, target, targets);
2574    }
2575
2576    return copy;
2577  },
2578      _checkPlugin = function _checkPlugin(property, vars, tween, index, target, targets) {
2579    var plugin, pt, ptLookup, i;
2580
2581    if (_plugins[property] && (plugin = new _plugins[property]()).init(target, plugin.rawVars ? vars[property] : _processVars(vars[property], index, target, targets, tween), tween, index, targets) !== false) {
2582      tween._pt = pt = new PropTween(tween._pt, target, property, 0, 1, plugin.render, plugin, 0, plugin.priority);
2583
2584      if (tween !== _quickTween) {
2585        ptLookup = tween._ptLookup[tween._targets.indexOf(target)];
2586        i = plugin._props.length;
2587
2588        while (i--) {
2589          ptLookup[plugin._props[i]] = pt;
2590        }
2591      }
2592    }
2593
2594    return plugin;
2595  },
2596      _overwritingTween,
2597      _initTween = function _initTween(tween, time) {
2598    var vars = tween.vars,
2599        ease = vars.ease,
2600        startAt = vars.startAt,
2601        immediateRender = vars.immediateRender,
2602        lazy = vars.lazy,
2603        onUpdate = vars.onUpdate,
2604        onUpdateParams = vars.onUpdateParams,
2605        callbackScope = vars.callbackScope,
2606        runBackwards = vars.runBackwards,
2607        yoyoEase = vars.yoyoEase,
2608        keyframes = vars.keyframes,
2609        autoRevert = vars.autoRevert,
2610        dur = tween._dur,
2611        prevStartAt = tween._startAt,
2612        targets = tween._targets,
2613        parent = tween.parent,
2614        fullTargets = parent && parent.data === "nested" ? parent.parent._targets : targets,
2615        autoOverwrite = tween._overwrite === "auto" && !_suppressOverwrites,
2616        tl = tween.timeline,
2617        cleanVars,
2618        i,
2619        p,
2620        pt,
2621        target,
2622        hasPriority,
2623        gsData,
2624        harness,
2625        plugin,
2626        ptLookup,
2627        index,
2628        harnessVars,
2629        overwritten;
2630    tl && (!keyframes || !ease) && (ease = "none");
2631    tween._ease = _parseEase(ease, _defaults.ease);
2632    tween._yEase = yoyoEase ? _invertEase(_parseEase(yoyoEase === true ? ease : yoyoEase, _defaults.ease)) : 0;
2633
2634    if (yoyoEase && tween._yoyo && !tween._repeat) {
2635      yoyoEase = tween._yEase;
2636      tween._yEase = tween._ease;
2637      tween._ease = yoyoEase;
2638    }
2639
2640    tween._from = !tl && !!vars.runBackwards;
2641
2642    if (!tl) {
2643      harness = targets[0] ? _getCache(targets[0]).harness : 0;
2644      harnessVars = harness && vars[harness.prop];
2645      cleanVars = _copyExcluding(vars, _reservedProps);
2646      prevStartAt && prevStartAt.render(-1, true).kill();
2647
2648      if (startAt) {
2649        _removeFromParent(tween._startAt = Tween.set(targets, _setDefaults({
2650          data: "isStart",
2651          overwrite: false,
2652          parent: parent,
2653          immediateRender: true,
2654          lazy: _isNotFalse(lazy),
2655          startAt: null,
2656          delay: 0,
2657          onUpdate: onUpdate,
2658          onUpdateParams: onUpdateParams,
2659          callbackScope: callbackScope,
2660          stagger: 0
2661        }, startAt)));
2662
2663        time < 0 && !immediateRender && !autoRevert && tween._startAt.render(-1, true);
2664
2665        if (immediateRender) {
2666          time > 0 && !autoRevert && (tween._startAt = 0);
2667
2668          if (dur && time <= 0) {
2669            time && (tween._zTime = time);
2670            return;
2671          }
2672        } else if (autoRevert === false) {
2673          tween._startAt = 0;
2674        }
2675      } else if (runBackwards && dur) {
2676        if (prevStartAt) {
2677          !autoRevert && (tween._startAt = 0);
2678        } else {
2679          time && (immediateRender = false);
2680          p = _setDefaults({
2681            overwrite: false,
2682            data: "isFromStart",
2683            lazy: immediateRender && _isNotFalse(lazy),
2684            immediateRender: immediateRender,
2685            stagger: 0,
2686            parent: parent
2687          }, cleanVars);
2688          harnessVars && (p[harness.prop] = harnessVars);
2689
2690          _removeFromParent(tween._startAt = Tween.set(targets, p));
2691
2692          time < 0 && tween._startAt.render(-1, true);
2693
2694          if (!immediateRender) {
2695            _initTween(tween._startAt, _tinyNum);
2696          } else if (!time) {
2697            return;
2698          }
2699        }
2700      }
2701
2702      tween._pt = 0;
2703      lazy = dur && _isNotFalse(lazy) || lazy && !dur;
2704
2705      for (i = 0; i < targets.length; i++) {
2706        target = targets[i];