https://iguales.cl/wp-content/themes/uncode/library/js/plugins.js?ver=1064322736

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

148      _forEachName = function _forEachName(names, func) {
149    return (names = names.split(",")).forEach(func) || names;
150  },
151      _round = function _round(value) {
152    return Math.round(value * 100000) / 100000 || 0;
153  },
154      _arrayContainsAny = function _arrayContainsAny(toSearch, toFind) {
155    var l = toFind.length,
156        i = 0;
157
158    for (; toSearch.indexOf(toFind[i]) < 0 && ++i < l;) {}
159
160    return i < l;
161  },
162      _parseVars = function _parseVars(params, type, parent) {
163    var isLegacy = _isNumber(params[1]),
164        varsIndex = (isLegacy ? 2 : 1) + (type < 2 ? 0 : 1),
165        vars = params[varsIndex],
166        irVars;
167
168    isLegacy && (vars.duration = params[1]);
169    vars.parent = parent;
170
171    if (type) {
172      irVars = vars;
173
174      while (parent && !("immediateRender" in irVars)) {
175        irVars = parent.vars.defaults || {};
176        parent = _isNotFalse(parent.vars.inherit) && parent.parent;
177      }
178
179      vars.immediateRender = _isNotFalse(irVars.immediateRender);
180      type < 2 ? vars.runBackwards = 1 : vars.startAt = params[varsIndex - 1];
181    }
182
183    return vars;
184  },
185      _lazyRender = function _lazyRender() {
186    var l = _lazyTweens.length,
187        a = _lazyTweens.slice(0),
188        i,
189        tween;
190
191    _lazyLookup = {};
192    _lazyTweens.length = 0;
193
194    for (i = 0; i < l; i++) {
195      tween = a[i];
196      tween && tween._lazy && (tween.render(tween._lazy[0], tween._lazy[1], true)._lazy = 0);
197    }
198  },
199      _lazySafeRender = function _lazySafeRender(animation, time, suppressEvents, force) {
200    _lazyTweens.length && _lazyRender();
201    animation.render(time, suppressEvents, force);
202    _lazyTweens.length && _lazyRender();
203  },
204      _numericIfPossible = function _numericIfPossible(value) {
205    var n = parseFloat(value);
206    return (n || n === 0) && (value + "").match(_delimitedValueExp).length < 2 ? n : _isString(value) ? value.trim() : value;
207  },
208      _passThrough = function _passThrough(p) {
209    return p;
210  },
211      _setDefaults = function _setDefaults(obj, defaults) {
212    for (var p in defaults) {
213      p in obj || (obj[p] = defaults[p]);
214    }
215
216    return obj;
217  },
218      _setKeyframeDefaults = function _setKeyframeDefaults(obj, defaults) {
219    for (var p in defaults) {
220      p in obj || p === "duration" || p === "ease" || (obj[p] = defaults[p]);
221    }
222  },
223      _merge = function _merge(base, toMerge) {
224    for (var p in toMerge) {
225      base[p] = toMerge[p];
226    }
227
228    return base;
229  },
230      _mergeDeep = function _mergeDeep(base, toMerge) {
231    for (var p in toMerge) {
232      p !== "__proto__" && p !== "constructor" && p !== "prototype" && (base[p] = _isObject(toMerge[p]) ? _mergeDeep(base[p] || (base[p] = {}), toMerge[p]) : toMerge[p]);
233    }
234
235    return base;
236  },
237      _copyExcluding = function _copyExcluding(obj, excluding) {
238    var copy = {},
239        p;
240
241    for (p in obj) {
242      p in excluding || (copy[p] = obj[p]);
243    }
244
245    return copy;
246  },
247      _inheritDefaults = function _inheritDefaults(vars) {
248    var parent = vars.parent || _globalTimeline,
249        func = vars.keyframes ? _setKeyframeDefaults : _setDefaults;
250
251    if (_isNotFalse(vars.inherit)) {
252      while (parent) {
253        func(vars, parent.vars.defaults);
254        parent = parent.parent || parent._dp;
255      }
256    }
257
258    return vars;
259  },
260      _arraysMatch = function _arraysMatch(a1, a2) {
261    var i = a1.length,
262        match = i === a2.length;
263
264    while (match && i-- && a1[i] === a2[i]) {}
265
266    return i < 0;
267  },
268      _addLinkedListItem = function _addLinkedListItem(parent, child, firstProp, lastProp, sortBy) {
269    if (firstProp === void 0) {
270      firstProp = "_first";
271    }
272
273    if (lastProp === void 0) {
274      lastProp = "_last";
275    }
276
277    var prev = parent[lastProp],
278        t;
279
280    if (sortBy) {
281      t = child[sortBy];
282
283      while (prev && prev[sortBy] > t) {
284        prev = prev._prev;
285      }
286    }
287
288    if (prev) {
289      child._next = prev._next;
290      prev._next = child;
291    } else {
292      child._next = parent[firstProp];
293      parent[firstProp] = child;
294    }
295
296    if (child._next) {
297      child._next._prev = child;
298    } else {
299      parent[lastProp] = child;
300    }
301
302    child._prev = prev;
303    child.parent = child._dp = parent;
304    return child;
305  },
306      _removeLinkedListItem = function _removeLinkedListItem(parent, child, firstProp, lastProp) {
307    if (firstProp === void 0) {
308      firstProp = "_first";
309    }
310
311    if (lastProp === void 0) {
312      lastProp = "_last";
313    }
314
315    var prev = child._prev,
316        next = child._next;
317
318    if (prev) {
319      prev._next = next;
320    } else if (parent[firstProp] === child) {
321      parent[firstProp] = next;
322    }
323
324    if (next) {
325      next._prev = prev;
326    } else if (parent[lastProp] === child) {
327      parent[lastProp] = prev;
328    }
329
330    child._next = child._prev = child.parent = null;
331  },
332      _removeFromParent = function _removeFromParent(child, onlyIfParentHasAutoRemove) {
333    child.parent && (!onlyIfParentHasAutoRemove || child.parent.autoRemoveChildren) && child.parent.remove(child);
334    child._act = 0;
335  },
336      _uncache = function _uncache(animation, child) {
337    if (animation && (!child || child._end > animation._dur || child._start < 0)) {
338      var a = animation;
339
340      while (a) {
341        a._dirty = 1;
342        a = a.parent;
343      }
344    }
345
346    return animation;
347  },
348      _recacheAncestors = function _recacheAncestors(animation) {
349    var parent = animation.parent;
350
351    while (parent && parent.parent) {
352      parent._dirty = 1;
353      parent.totalDuration();
354      parent = parent.parent;
355    }
356
357    return animation;
358  },
359      _hasNoPausedAncestors = function _hasNoPausedAncestors(animation) {
360    return !animation || animation._ts && _hasNoPausedAncestors(animation.parent);
361  },
362      _elapsedCycleDuration = function _elapsedCycleDuration(animation) {
363    return animation._repeat ? _animationCycle(animation._tTime, animation = animation.duration() + animation._rDelay) * animation : 0;
364  },
365      _animationCycle = function _animationCycle(tTime, cycleDuration) {
366    var whole = Math.floor(tTime /= cycleDuration);
367    return tTime && whole === tTime ? whole - 1 : whole;
368  },
369      _parentToChildTotalTime = function _parentToChildTotalTime(parentTime, child) {
370    return (parentTime - child._start) * child._ts + (child._ts >= 0 ? 0 : child._dirty ? child.totalDuration() : child._tDur);
371  },
372      _setEnd = function _setEnd(animation) {
373    return animation._end = _round(animation._start + (animation._tDur / Math.abs(animation._ts || animation._rts || _tinyNum) || 0));
374  },
375      _alignPlayhead = function _alignPlayhead(animation, totalTime) {
376    var parent = animation._dp;
377
378    if (parent && parent.smoothChildTiming && animation._ts) {
379      animation._start = _round(parent._time - (animation._ts > 0 ? totalTime / animation._ts : ((animation._dirty ? animation.totalDuration() : animation._tDur) - totalTime) / -animation._ts));
380
381      _setEnd(animation);
382
383      parent._dirty || _uncache(parent, animation);
384    }
385
386    return animation;
387  },
388      _postAddChecks = function _postAddChecks(timeline, child) {
389    var t;
390
391    if (child._time || child._initted && !child._dur) {
392      t = _parentToChildTotalTime(timeline.rawTime(), child);
393
394      if (!child._dur || _clamp(0, child.totalDuration(), t) - child._tTime > _tinyNum) {
395        child.render(t, true);
396      }
397    }
398
399    if (_uncache(timeline, child)._dp && timeline._initted && timeline._time >= timeline._dur && timeline._ts) {
400      if (timeline._dur < timeline.duration()) {
401        t = timeline;
402
403        while (t._dp) {
404          t.rawTime() >= 0 && t.totalTime(t._tTime);
405          t = t._dp;
406        }
407      }
408
409      timeline._zTime = -_tinyNum;
410    }
411  },

485      tween._onUpdate && !suppressEvents && _callback(tween, "onUpdate");
486      tTime && tween._repeat && !suppressEvents && tween.parent && _callback(tween, "onRepeat");
487
488      if ((totalTime >= tween._tDur || totalTime < 0) && tween.ratio === ratio) {
489        ratio && _removeFromParent(tween, 1);
490
491        if (!suppressEvents) {
492          _callback(tween, ratio ? "onComplete" : "onReverseComplete", true);
493
494          tween._prom && tween._prom();
495        }
496      }
497    } else if (!tween._zTime) {
498      tween._zTime = totalTime;
499    }
500  },
501      _findNextPauseTween = function _findNextPauseTween(animation, prevTime, time) {
502    var child;
503
504    if (time > prevTime) {
505      child = animation._first;
506
507      while (child && child._start <= time) {
508        if (!child._dur && child.data === "isPause" && child._start > prevTime) {
509          return child;
510        }
511
512        child = child._next;
513      }
514    } else {
515      child = animation._last;
516
517      while (child && child._start >= time) {
518        if (!child._dur && child.data === "isPause" && child._start < prevTime) {
519          return child;
520        }
521
522        child = child._prev;
523      }
524    }
525  },
526      _setDuration = function _setDuration(animation, duration, skipUncache, leavePlayhead) {
527    var repeat = animation._repeat,
528        dur = _round(duration) || 0,
529        totalProgress = animation._tTime / animation._tDur;
530    totalProgress && !leavePlayhead && (animation._time *= dur / animation._dur);
531    animation._dur = dur;
532    animation._tDur = !repeat ? dur : repeat < 0 ? 1e10 : _round(dur * (repeat + 1) + animation._rDelay * repeat);
533    totalProgress && !leavePlayhead ? _alignPlayhead(animation, animation._tTime = animation._tDur * totalProgress) : animation.parent && _setEnd(animation);
534    skipUncache || _uncache(animation.parent, animation);
535    return animation;
536  },
537      _onUpdateTotalDuration = function _onUpdateTotalDuration(animation) {
538    return animation instanceof Timeline ? _uncache(animation) : _setDuration(animation, animation._dur);
539  },
540      _zeroPosition = {
541    _start: 0,
542    endTime: _emptyFunc
543  },
544      _parsePosition = function _parsePosition(animation, position) {
545    var labels = animation.labels,
546        recent = animation._recent || _zeroPosition,
547        clippedDuration = animation.duration() >= _bigNum ? recent.endTime(false) : animation._dur,
548        i,
549        offset;
550
551    if (_isString(position) && (isNaN(position) || position in labels)) {
552      i = position.charAt(0);
553
554      if (i === "<" || i === ">") {
555        return (i === "<" ? recent._start : recent.endTime(recent._repeat >= 0)) + (parseFloat(position.substr(1)) || 0);
556      }
557
558      i = position.indexOf("=");
559
560      if (i < 0) {
561        position in labels || (labels[position] = clippedDuration);
562        return labels[position];
563      }
564
565      offset = +(position.charAt(i - 1) + position.substr(i + 1));
566      return i > 1 ? _parsePosition(animation, position.substr(0, i - 1)) + offset : clippedDuration + offset;
567    }
568
569    return position == null ? clippedDuration : +position;
570  },
571      _conditionalReturn = function _conditionalReturn(value, func) {
572    return value || value === 0 ? func(value) : func;
573  },
574      _clamp = function _clamp(min, max, value) {
575    return value < min ? min : value > max ? max : value;
576  },
577      getUnit = function getUnit(value) {
578    if (typeof value !== "string") {
579      return "";
580    }
581
582    var v = _unitExp.exec(value);
583
584    return v ? value.substr(v.index + v[0].length) : "";
585  },
586      clamp = function clamp(min, max, value) {
587    return _conditionalReturn(value, function (v) {
588      return _clamp(min, max, v);
589    });
590  },
591      _slice = [].slice,
592      _isArrayLike = function _isArrayLike(value, nonEmpty) {
593    return value && _isObject(value) && "length" in value && (!nonEmpty && !value.length || value.length - 1 in value && _isObject(value[0])) && !value.nodeType && value !== _win;
594  },
595      _flatten = function _flatten(ar, leaveStrings, accumulator) {
596    if (accumulator === void 0) {
597      accumulator = [];
598    }
599
600    return ar.forEach(function (value) {
601      var _accumulator;
602
603      return _isString(value) && !leaveStrings || _isArrayLike(value, 1) ? (_accumulator = accumulator).push.apply(_accumulator, toArray(value)) : accumulator.push(value);
604    }) || accumulator;
605  },
606      toArray = function toArray(value, leaveStrings) {
607    return _isString(value) && !leaveStrings && (_coreInitted || !_wake()) ? _slice.call(_doc.querySelectorAll(value), 0) : _isArray(value) ? _flatten(value, leaveStrings) : _isArrayLike(value) ? _slice.call(value, 0) : value ? [value] : [];
608  },
609      shuffle = function shuffle(a) {
610    return a.sort(function () {
611      return .5 - Math.random();
612    });
613  },
614      distribute = function distribute(v) {
615    if (_isFunction(v)) {
616      return v;
617    }
618
619    var vars = _isObject(v) ? v : {
620      each: v
621    },
622        ease = _parseEase(vars.ease),
623        from = vars.from || 0,
624        base = parseFloat(vars.base) || 0,
625        cache = {},
626        isDecimal = from > 0 && from < 1,
627        ratios = isNaN(from) || isDecimal,
628        axis = vars.axis,
629        ratioX = from,
630        ratioY = from;
631
632    if (_isString(from)) {
633      ratioX = ratioY = {
634        center: .5,
635        edges: .5,
636        end: 1
637      }[from] || 0;
638    } else if (!isDecimal && ratios) {
639      ratioX = from[0];
640      ratioY = from[1];
641    }
642
643    return function (i, target, a) {
644      var l = (a || vars).length,
645          distances = cache[l],
646          originX,
647          originY,
648          x,
649          y,
650          d,
651          j,
652          max,
653          min,
654          wrapAt;
655
656      if (!distances) {
657        wrapAt = vars.grid === "auto" ? 0 : (vars.grid || [1, _bigNum])[1];
658
659        if (!wrapAt) {
660          max = -_bigNum;
661
662          while (max < (max = a[wrapAt++].getBoundingClientRect().left) && wrapAt < l) {}
663
664          wrapAt--;
665        }
666
667        distances = cache[l] = [];
668        originX = ratios ? Math.min(wrapAt, l) * ratioX - .5 : from % wrapAt;
669        originY = ratios ? l * ratioY / wrapAt - .5 : from / wrapAt | 0;
670        max = 0;
671        min = _bigNum;
672
673        for (j = 0; j < l; j++) {
674          x = j % wrapAt - originX;
675          y = originY - (j / wrapAt | 0);
676          distances[j] = d = !axis ? _sqrt(x * x + y * y) : Math.abs(axis === "y" ? y : x);
677          d > max && (max = d);
678          d < min && (min = d);
679        }
680
681        from === "random" && shuffle(distances);
682        distances.max = max - min;
683        distances.min = min;
684        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);
685        distances.b = l < 0 ? base - l : base;
686        distances.u = getUnit(vars.amount || vars.each) || 0;
687        ease = ease && l < 0 ? _invertEase(ease) : ease;
688      }
689
690      l = (distances[i] - distances.min) / distances.max || 0;
691      return _round(distances.b + (ease ? ease(l) : l) * distances.v) + distances.u;
692    };
693  },
694      _roundModifier = function _roundModifier(v) {
695    var p = v < 1 ? Math.pow(10, (v + "").length - 2) : 1;
696    return function (raw) {
697      var n = Math.round(parseFloat(raw) / v) * v * p;
698      return (n - n % 1) / p + (_isNumber(raw) ? 0 : getUnit(raw));
699    };
700  },
701      snap = function snap(snapTo, value) {
702    var isArray = _isArray(snapTo),
703        radius,
704        is2D;
705
706    if (!isArray && _isObject(snapTo)) {
707      radius = isArray = snapTo.radius || _bigNum;
708
709      if (snapTo.values) {
710        snapTo = toArray(snapTo.values);
711
712        if (is2D = !_isNumber(snapTo[0])) {
713          radius *= radius;
714        }
715      } else {
716        snapTo = _roundModifier(snapTo.increment);
717      }
718    }
719
720    return _conditionalReturn(value, !isArray ? _roundModifier(snapTo) : _isFunction(snapTo) ? function (raw) {
721      is2D = snapTo(raw);
722      return Math.abs(is2D - raw) <= radius ? is2D : raw;
723    } : function (raw) {
724      var x = parseFloat(is2D ? raw.x : raw),
725          y = parseFloat(is2D ? raw.y : 0),
726          min = _bigNum,
727          closest = 0,
728          i = snapTo.length,
729          dx,
730          dy;
731
732      while (i--) {
733        if (is2D) {
734          dx = snapTo[i].x - x;
735          dy = snapTo[i].y - y;
736          dx = dx * dx + dy * dy;
737        } else {
738          dx = Math.abs(snapTo[i] - x);
739        }
740
741        if (dx < min) {
742          min = dx;
743          closest = i;
744        }
745      }
746
747      closest = !radius || min <= radius ? snapTo[closest] : raw;
748      return is2D || closest === raw || _isNumber(raw) ? closest : closest + getUnit(raw);
749    });
750  },
751      random = function random(min, max, roundingIncrement, returnFunction) {
752    return _conditionalReturn(_isArray(min) ? !max : roundingIncrement === true ? !!(roundingIncrement = 0) : !returnFunction, function () {
753      return _isArray(min) ? min[~~(Math.random() * min.length)] : (roundingIncrement = roundingIncrement || 1e

753-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;
754    });
755  },
756      pipe = function pipe() {
757    for (var _len = arguments.length, functions = new Array(_len), _key = 0; _key < _len; _key++) {
758      functions[_key] = arguments[_key];
759    }
760
761    return function (value) {
762      return functions.reduce(function (v, f) {
763        return f(v);
764      }, value);
765    };
766  },
767      unitize = function unitize(func, unit) {
768    return function (value) {
769      return func(parseFloat(value)) + (unit || getUnit(value));
770    };
771  },
772      normalize = function normalize(min, max, value) {
773    return mapRange(min, max, 0, 1, value);
774  },
775      _wrapArray = function _wrapArray(a, wrapper, value) {
776    return _conditionalReturn(value, function (index) {
777      return a[~~wrapper(index)];
778    });
779  },
780      wrap = function wrap(min, max, value) {
781    var range = max - min;
782    return _isArray(min) ? _wrapArray(min, wrap(0, min.length), max) : _conditionalReturn(value, function (value) {
783      return (range + (value - min) % range) % range + min;
784    });
785  },
786      wrapYoyo = function wrapYoyo(min, max, value) {
787    var range = max - min,
788        total = range * 2;
789    return _isArray(min) ? _wrapArray(min, wrapYoyo(0, min.length - 1), max) : _conditionalReturn(value, function (value) {
790      value = (total + (value - min) % total) % total || 0;
791      return min + (value > range ? total - value : value);
792    });
793  },
794      _replaceRandom = function _replaceRandom(value) {
795    var prev = 0,
796        s = "",
797        i,
798        nums,
799        end,
800        isArray;
801
802    while (~(i = value.indexOf("random(", prev))) {
803      end = value.indexOf(")", i);
804      isArray = value.charAt(i + 7) === "[";
805      nums = value.substr(i + 7, end - i - 7).match(isArray ? _delimitedValueExp : _strictNumExp);
806      s += value.substr(prev, i - prev) + random(isArray ? nums : +nums[0], isArray ? 0 : +nums[1], +nums[2] || 1e-5);
807      prev = end + 1;
808    }
809
810    return s + value.substr(prev, value.length - prev);
811  },
812      mapRange = function mapRange(inMin, inMax, outMin, outMax, value) {
813    var inRange = inMax - inMin,
814        outRange = outMax - outMin;
815    return _conditionalReturn(value, function (value) {
816      return outMin + ((value - inMin) / inRange * outRange || 0);
817    });
818  },
819      interpolate = function interpolate(start, end, progress, mutate) {
820    var func = isNaN(start + end) ? 0 : function (p) {
821      return (1 - p) * start + p * end;
822    };
823
824    if (!func) {
825      var isString = _isString(start),
826          master = {},
827          p,
828          i,
829          interpolators,
830          l,
831          il;
832
833      progress === true && (mutate = 1) && (progress = null);
834
835      if (isString) {
836        start = {
837          p: start
838        };
839        end = {
840          p: end
841        };
842      } else if (_isArray(start) && !_isArray(end)) {
843        interpolators = [];
844        l = start.length;
845        il = l - 2;
846
847        for (i = 1; i < l; i++) {
848          interpolators.push(interpolate(start[i - 1], start[i]));
849        }
850
851        l--;
852
853        func = function func(p) {
854          p *= l;
855          var i = Math.min(il, ~~p);
856          return interpolators[i](p - i);
857        };
858
859        progress = end;
860      } else if (!mutate) {
861        start = _merge(_isArray(start) ? [] : {}, start);
862      }
863
864      if (!interpolators) {
865        for (p in end) {
866          _addPropTween.call(master, start, p, "get", end[p]);
867        }
868
869        func = function func(p) {
870          return _renderPropTweens(p, master) || (isString ? start.p : start);
871        };
872      }
873    }
874
875    return _conditionalReturn(progress, func);
876  },
877      _getLabelInDirection = function _getLabelInDirection(timeline, fromTime, backward) {
878    var labels = timeline.labels,
879        min = _bigNum,
880        p,
881        distance,
882        label;
883
884    for (p in labels) {
885      distance = labels[p] - fromTime;
886
887      if (distance < 0 === !!backward && distance && min > (distance = Math.abs(distance))) {
888        label = p;
889        min = distance;
890      }
891    }
892
893    return label;
894  },
895      _callback = function _callback(animation, type, executeLazyFirst) {
896    var v = animation.vars,
897        callback = v[type],
898        params,
899        scope;
900
901    if (!callback) {
902      return;
903    }
904
905    params = v[type + "Params"];
906    scope = v.callbackScope || animation;
907    executeLazyFirst && _lazyTweens.length && _lazyRender();
908    return params ? callback.apply(scope, params) : callback.call(scope);
909  },

910      _interrupt = function _interrupt(animation) {
911    _removeFromParent(animation);
912
913    animation.scrollTrigger && animation.scrollTrigger.kill(false);
914    animation.progress() < 1 && _callback(animation, "onInterrupt");
915    return animation;
916  },
917      _quickTween,
918      _createPlugin = function _createPlugin(config) {
919    config = !config.name && config["default"] || config;
920
921    var name = config.name,
922        isFunc = _isFunction(config),
923        Plugin = name && !isFunc && config.init ? function () {
924      this._props = [];
925    } : config,
926        instanceDefaults = {
927      init: _emptyFunc,
928      render: _renderPropTweens,
929      add: _addPropTween,
930      kill: _killPropTweensOf,
931      modifier: _addPluginModifier,
932      rawVars: 0
933    },
934        statics = {
935      targetTest: 0,
936      get: 0,
937      getSetter: _getSetter,
938      aliases: {},
939      register: 0
940    };
941
942    _wake();
943
944    if (config !== Plugin) {
945      if (_plugins[name]) {
946        return;
947      }
948
949      _setDefaults(Plugin, _setDefaults(_copyExcluding(config, instanceDefaults), statics));
950
951      _merge(Plugin.prototype, _merge(instanceDefaults, _copyExcluding(config, statics)));
952
953      _plugins[Plugin.prop = name] = Plugin;
954
955      if (config.targetTest) {
956        _harnessPlugins.push(Plugin);
957
958        _reservedProps[name] = 1;
959      }
960
961      name = (name === "css" ? "CSS" : name.charAt(0).toUpperCase() + name.substr(1)) + "Plugin";
962    }
963
964    _addGlobal(name, Plugin);
965
966    config.register && config.register(gsap, Plugin, PropTween);
967  },
968      _255 = 255,
969      _colorLookup = {
970    aqua: [0, _255, _255],
971    lime: [0, _255, 0],
972    silver: [192, 192, 192],
973    black: [0, 0, 0],
974    maroon: [128, 0, 0],
975    teal: [0, 128, 128],
976    blue: [0, 0, _255],
977    navy: [0, 0, 128],
978    white: [_255, _255, _255],
979    olive: [128, 128, 0],
980    yellow: [_255, _255, 0],
981    orange: [_255, 165, 0],
982    gray: [128, 128, 128],
983    purple: [128, 0, 128],
984    green: [0, 128, 0],
985    red: [_255, 0, 0],
986    pink: [_255, 192, 203],
987    cyan: [0, _255, _255],
988    transparent: [_255, _255, _255, 0]
989  },
990      _hue = function _hue(h, m1, m2) {
991    h = h < 0 ? h + 1 : h > 1 ? h - 1 : h;
992    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;
993  },
994      splitColor = function splitColor(v, toHSL, forceAlpha) {
995    var a = !v ? _colorLookup.black : _isNumber(v) ? [v >> 16, v >> 8 & _255, v & _255] : 0,
996        r,
997        g,
998        b,
999        h,
1000        s,
1001        l,
1002        max,
1003        min,
1004        d,
1005        wasHSL;
1006
1007    if (!a) {
1008      if (v.substr(-1) === ",") {
1009        v = v.substr(0, v.length - 1);
1010      }
1011
1012      if (_colorLookup[v]) {
1013        a = _colorLookup[v];
1014      } else if (v.charAt(0) === "#") {
1015        if (v.length < 6) {
1016          r = v.charAt(1);
1017          g = v.charAt(2);
1018          b = v.charAt(3);
1019          v = "#" + r + r + g + g + b + b + (v.length === 5 ? v.charAt(4) + v.charAt(4) : "");
1020        }
1021
1022        if (v.length === 9) {
1023          a = parseInt(v.substr(1, 6), 16);
1024          return [a >> 16, a >> 8 & _255, a & _255, parseInt(v.substr(7), 16) / 255];
1025        }
1026
1027        v = parseInt(v.substr(1), 16);
1028        a = [v >> 16, v >> 8 & _255, v & _255];
1029      } else if (v.substr(0, 3) === "hsl") {
1030        a = wasHSL = v.match(_strictNumExp);
1031
1032        if (!toHSL) {
1033          h = +a[0] % 360 / 360;
1034          s = +a[1] / 100;
1035          l = +a[2] / 100;
1036          g = l <= .5 ? l * (s + 1) : l + s - l * s;
1037          r = l * 2 - g;
1038          a.length > 3 && (a[3] *= 1);
1039          a[0] = _hue(h + 1 / 3, r, g);
1040          a[1] = _hue(h, r, g);
1041          a[2] = _hue(h - 1 / 3, r, g);
1042        } else if (~v.indexOf("=")) {
1043          a = v.match(_numExp);
1044          forceAlpha && a.length < 4 && (a[3] = 1);
1045          return a;
1046        }
1047      } else {
1048        a = v.match(_strictNumExp) || _colorLookup.transparent;
1049      }
1050
1051      a = a.map(Number);
1052    }
1053
1054    if (toHSL && !wasHSL) {
1055      r = a[0] / _255;
1056      g = a[1] / _255;
1057      b = a[2] / _255;
1058      max = Math.max(r, g, b);
1059      min = Math.min(r, g, b);
1060      l = (max + min) / 2;
1061
1062      if (max === min) {
1063        h = s = 0;
1064      } else {
1065        d = max - min;
1066        s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
1067        h = max === r ? (g - b) / d + (g < b ? 6 : 0) : max === g ? (b - r) / d + 2 : (r - g) / d + 4;
1068        h *= 60;
1069      }
1070
1071      a[0] = ~~(h + .5);
1072      a[1] = ~~(s * 100 + .5);
1073      a[2] = ~~(l * 100 + .5);
1074    }
1075
1076    forceAlpha && a.length < 4 && (a[3] = 1);
1077    return a;
1078  },
1079      _colorOrderData = function _colorOrderData(v) {
1080    var values = [],
1081        c = [],
1082        i = -1;
1083    v.split(_colorExp).forEach(function (v) {
1084      var a = v.match(_numWithUnitExp) || [];
1085      values.push.apply(values, a);
1086      c.push(i += a.length + 1);
1087    });
1088    values.c = c;
1089    return values;
1090  },
1091      _formatColors = function _formatColors(s, toHSL, orderMatchData) {
1092    var result = "",
1093        colors = (s + result).match(_colorExp),
1094        type = toHSL ? "hsla(" : "rgba(",
1095        i = 0,
1096        c,
1097        shell,
1098        d,
1099        l;
1100
1101    if (!colors) {
1102      return s;
1103    }
1104
1105    colors = colors.map(function (color) {
1106      return (color = splitColor(color, toHSL, 1)) && type + (toHSL ? color[0] + "," + color[1] + "%," + color[2] + "%," + color[3] : color.join(",")) + ")";
1107    });
1108
1109    if (orderMatchData) {
1110      d = _colorOrderData(s);
1111      c = orderMatchData.c;
1112
1113      if (c.join(result) !== d.c.join(result)) {
1114        shell = s.replace(_colorExp, "1").split(_numWithUnitExp);
1115        l = shell.length - 1;
1116
1117        for (; i < l; i++) {
1118          result += shell[i] + (~c.indexOf(i) ? colors.shift() || type + "0,0,0,0)" : (d.length ? d : colors.length ? colors : orderMatchData).shift());
1119        }
1120      }
1121    }
1122
1123    if (!shell) {
1124      shell = s.split(_colorExp);
1125      l = shell.length - 1;
1126
1127      for (; i < l; i++) {
1128        result += shell[i] + colors[i];
1129      }
1130    }
1131
1132    return result + shell[l];
1133  },
1134      _colorExp = function () {
1135    var s = "(?:\\b(?:(?:rgb|rgba|hsl|hsla)\\(.+?\\))|\\B#(?:[0-9a-f]{3,4}){1,2}\\b",
1136        p;
1137
1138    for (p in _colorLookup) {
1139      s += "|" + p + "\\b";
1140    }
1141
1142    return new RegExp(s + ")", "gi");
1143  }(),
1144      _hslExp = /hsl[a]?\(/,
1145      _colorStringFilter = function _colorStringFilter(a) {
1146    var combined = a.join(" "),
1147        toHSL;
1148    _colorExp.lastIndex = 0;
1149
1150    if (_colorExp.test(combined)) {
1151      toHSL = _hslExp.test(combined);
1152      a[1] = _formatColors(a[1], toHSL);
1153      a[0] = _formatColors(a[0], toHSL, _colorOrderData(a[1]));
1154      return true;
1155    }
1156  },
1157      _tickerActive,
1158      _ticker = function () {
1159    var _getTime = Date.now,
1160        _lagThreshold = 500,
1161        _adjustedLag = 33,
1162        _startTime = _getTime(),
1163        _lastUpdate = _startTime,
1164        _gap = 1000 / 240,
1165        _nextTime = _gap,
1166        _listeners = [],
1167        _id,
1168        _req,
1169        _raf,
1170        _self,
1171        _delta,
1172        _i,
1173        _tick = function _tick(v) {
1174      var elapsed = _getTime() - _lastUpdate,
1175          manual = v === true,
1176          overlap,
1177          dispatch,
1178          time,
1179          frame;
1180
1181      elapsed > _lagThreshold && (_startTime += elapsed - _adjustedLag);
1182      _lastUpdate += elapsed;
1183      time = _lastUpdate - _startTime;
1184      overlap = time - _nextTime;
1185
1186      if (overlap > 0 || manual) {
1187        frame = ++_self.frame;
1188        _delta = time - _self.time * 1000;
1189        _self.time = time = time / 1000;
1190        _nextTime += overlap + (overlap >= _gap ? 4 : _gap - overlap);
1191        dispatch = 1;
1192      }
1193
1194      manual || (_id = _req(_tick));
1195
1196      if (dispatch) {
1197        for (_i = 0; _i < _listeners.length; _i++) {
1198          _listeners[_i](time, _delta, frame, v);
1199        }
1200      }
1201    };
1202
1203    _self = {
1204      time: 0,
1205      frame: 0,
1206      tick: function tick() {
1207        _tick(true);
1208      },
1209      deltaRatio: function deltaRatio(fps) {
1210        return _delta / (1000 / (fps || 60));
1211      },
1212      wake: function wake() {
1213        if (_coreReady) {
1214          if (!_coreInitted && _windowExists()) {
1215            _win = _coreInitted = window;
1216            _doc = _win.document || {};
1217            _globals.gsap = gsap;
1218            (_win.gsapVersions || (_win.gsapVersions = [])).push(gsap.version);
1219
1220            _install(_installScope || _win.GreenSockGlobals || !_win.gsap && _win || {});
1221
1222            _raf = _win.requestAnimationFrame;
1223          }
1224
1225          _id && _self.sleep();
1226
1227          _req = _raf || function (f) {
1228            return setTimeout(f, _nextTime - _self.time * 1000 + 1 | 0);
1229          };
1230
1231          _tickerActive = 1;
1232
1233          _tick(2);
1234        }
1235      },
1236      sleep: function sleep() {
1237        (_raf ? _win.cancelAnimationFrame : clearTimeout)(_id);
1238        _tickerActive = 0;
1239        _req = _emptyFunc;
1240      },
1241      lagSmoothing: function lagSmoothing(threshold, adjustedLag) {
1242        _lagThreshold = threshold || 1 / _tinyNum;
1243        _adjustedLag = Math.min(adjustedLag, _lagThreshold, 0);
1244      },
1245      fps: function fps(_fps) {
1246        _gap = 1000 / (_fps || 240);
1247        _nextTime = _self.time * 1000 + _gap;
1248      },
1249      add: function add(callback) {
1250        _listeners.indexOf(callback) < 0 && _listeners.push(callback);
1251
1252        _wake();
1253      },
1254      remove: function remove(callback) {
1255        var i;
1256        ~(i = _listeners.indexOf(callback)) && _listeners.splice(i, 1) && _i >= i && _i--;
1257      },
1258      _listeners: _listeners
1259    };
1260    return _self;
1261  }(),
1262      _wake = function _wake() {
1263    return !_tickerActive && _ticker.wake();
1264  },
1265      _easeMap = {},
1266      _customEaseExp = /^[\d.\-M][\d.\-,\s]/,
1267      _quotesExp = /["']/g,
1268      _parseObjectInString = function _parseObjectInString(value) {
1269    var obj = {},
1270        split = value.substr(1, value.length - 3).split(":"),
1271        key = split[0],
1272        i = 1,
1273        l = split.length,
1274        index,
1275        val,
1276        parsedVal;
1277
1278    for (; i < l; i++) {
1279      val = split[i];
1280      index = i !== l - 1 ? val.lastIndexOf(",") : val.length;
1281      parsedVal = val.substr(0, index);
1282      obj[key] = isNaN(parsedVal) ? parsedVal.replace(_quotesExp, "").trim() : +parsedVal;
1283      key = val.substr(index + 1).trim();
1284    }
1285
1286    return obj;
1287  },
1288      _valueInParentheses = function _valueInParentheses(value) {
1289    var open = value.indexOf("(") + 1,
1290        close = value.indexOf(")"),
1291        nested = value.indexOf("(", open);
1292    return value.substring(open, ~nested && nested < close ? value.indexOf(")", close + 1) : close);
1293  },
1294      _configEaseFromString = function _configEaseFromString(name) {
1295    var split = (name + "").split("("),
1296        ease = _easeMap[split[0]];
1297    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;
1298  },
1299      _invertEase = function _invertEase(ease) {
1300    return function (p) {
1301      return 1 - ease(1 - p);
1302    };
1303  },
1304      _propagateYoyoEase = function _propagateYoyoEase(timeline, isYoyo) {
1305    var child = timeline._first,
1306        ease;
1307
1308    while (child) {
1309      if (child instanceof Timeline) {
1310        _propagateYoyoEase(child, isYoyo);
1311      } else if (child.vars.yoyoEase && (!child._yoyo || !child._repeat) && child._yoyo !== isYoyo) {
1312        if (child.timeline) {
1313          _propagateYoyoEase(child.timeline, isYoyo);
1314        } else {
1315          ease = child._ease;
1316          child._ease = child._yEase;
1317          child._yEase = ease;
1318          child._yoyo = isYoyo;
1319        }
1320      }
1321
1322      child = child._next;
1323    }

1323
1324  },
1325      _parseEase = function _parseEase(ease, defaultEase) {
1326    return !ease ? defaultEase : (_isFunction(ease) ? ease : _easeMap[ease] || _configEaseFromString(ease)) || defaultEase;
1327  },
1328      _insertEase = function _insertEase(names, easeIn, easeOut, easeInOut) {
1329    if (easeOut === void 0) {
1330      easeOut = function easeOut(p) {
1331        return 1 - easeIn(1 - p);
1332      };
1333    }
1334
1335    if (easeInOut === void 0) {
1336      easeInOut = function easeInOut(p) {
1337        return p < .5 ? easeIn(p * 2) / 2 : 1 - easeIn((1 - p) * 2) / 2;
1338      };
1339    }
1340
1341    var ease = {
1342      easeIn: easeIn,
1343      easeOut: easeOut,
1344      easeInOut: easeInOut
1345    },
1346        lowercaseName;
1347
1348    _forEachName(names, function (name) {
1349      _easeMap[name] = _globals[name] = ease;
1350      _easeMap[lowercaseName = name.toLowerCase()] = easeOut;
1351
1352      for (var p in ease) {
1353        _easeMap[lowercaseName + (p === "easeIn" ? ".in" : p === "easeOut" ? ".out" : ".inOut")] = _easeMap[name + "." + p] = ease[p];
1354      }
1355    });
1356
1357    return ease;
1358  },
1359      _easeInOutFromOut = function _easeInOutFromOut(easeOut) {
1360    return function (p) {
1361      return p < .5 ? (1 - easeOut(1 - p * 2)) / 2 : .5 + easeOut((p - .5) * 2) / 2;
1362    };
1363  },
1364      _configElastic = function _configElastic(type, amplitude, period) {
1365    var p1 = amplitude >= 1 ? amplitude : 1,
1366        p2 = (period || (type ? .3 : .45)) / (amplitude < 1 ? amplitude : 1),
1367        p3 = p2 / _2PI * (Math.asin(1 / p1) || 0),
1368        easeOut = function easeOut(p) {
1369      return p === 1 ? 1 : p1 * Math.pow(2, -10 * p) * _sin((p - p3) * p2) + 1;
1370    },
1371        ease = type === "out" ? easeOut : type === "in" ? function (p) {
1372      return 1 - easeOut(1 - p);
1373    } : _easeInOutFromOut(easeOut);
1374
1375    p2 = _2PI / p2;
1376
1377    ease.config = function (amplitude, period) {
1378      return _configElastic(type, amplitude, period);
1379    };
1380
1381    return ease;
1382  },
1383      _configBack = function _configBack(type, overshoot) {
1384    if (overshoot === void 0) {
1385      overshoot = 1.70158;
1386    }
1387
1388    var easeOut = function easeOut(p) {
1389      return p ? --p * p * ((overshoot + 1) * p + overshoot) + 1 : 0;
1390    },
1391        ease = type === "out" ? easeOut : type === "in" ? function (p) {
1392      return 1 - easeOut(1 - p);
1393    } : _easeInOutFromOut(easeOut);
1394
1395    ease.config = function (overshoot) {
1396      return _configBack(type, overshoot);
1397    };
1398
1399    return ease;
1400  };
1401
1402  _forEachName("Linear,Quad,Cubic,Quart,Quint,Strong", function (name, i) {
1403    var power = i < 5 ? i + 1 : i;
1404
1405    _insertEase(name + ",Power" + (power - 1), i ? function (p) {
1406      return Math.pow(p, power);
1407    } : function (p) {
1408      return p;
1409    }, function (p) {
1410      return 1 - Math.pow(1 - p, power);
1411    }, function (p) {
1412      return p < .5 ? Math.pow(p * 2, power) / 2 : 1 - Math.pow((1 - p) * 2, power) / 2;
1413    });
1414  });
1415
1416  _easeMap.Linear.easeNone = _easeMap.none = _easeMap.Linear.easeIn;
1417
1418  _insertEase("Elastic", _configElastic("in"), _configElastic("out"), _configElastic());
1419
1420  (function (n, c) {
1421    var n1 = 1 / c,
1422        n2 = 2 * n1,
1423        n3 = 2.5 * n1,
1424        easeOut = function easeOut(p) {
1425      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;
1426    };
1427
1428    _insertEase("Bounce", function (p) {
1429      return 1 - easeOut(1 - p);
1430    }, easeOut);
1431  })(7.5625, 2.75);
1432
1433  _insertEase("Expo", function (p) {
1434    return 

1434p ? Math.pow(2, 10 * (p - 1)) : 0;
1435  });
1436
1437  _insertEase("Circ", function (p) {
1438    return -(_sqrt(1 - p * p) - 1);
1439  });
1440
1441  _insertEase("Sine", function (p) {
1442    return p === 1 ? 1 : -_cos(p * _HALF_PI) + 1;
1443  });
1444
1445  _insertEase("Back", _configBack("in"), _configBack("out"), _configBack());
1446
1447  _easeMap.SteppedEase = _easeMap.steps = _globals.SteppedEase = {
1448    config: function config(steps, immediateStart) {
1449      if (steps === void 0) {
1450        steps = 1;
1451      }
1452
1453      var p1 = 1 / steps,
1454          p2 = steps + (immediateStart ? 0 : 1),
1455          p3 = immediateStart ? 1 : 0,
1456          max = 1 - _tinyNum;
1457      return function (p) {
1458        return ((p2 * _clamp(0, max, p) | 0) + p3) * p1;
1459      };
1460    }
1461  };
1462  _defaults.ease = _easeMap["quad.out"];
1463
1464  _forEachName("onComplete,onUpdate,onStart,onRepeat,onReverseComplete,onInterrupt", function (name) {
1465    return _callbackNames += name + "," + name + "Params,";
1466  });
1467
1468  var GSCache = function GSCache(target, harness) {
1469    this.id = _gsID++;
1470    target._gsap = this;
1471    this.target = target;
1472    this.harness = harness;
1473    this.get = harness ? harness.get : _getProperty;
1474    this.set = harness ? harness.getSetter : _getSetter;
1475  };
1476  var Animation = function () {
1477    function Animation(vars, time) {
1478      var parent = vars.parent || _globalTimeline;
1479      this.vars = vars;
1480      this._delay = +vars.delay || 0;
1481
1482      if (this._repeat = vars.repeat === Infinity ? -2 : vars.repeat || 0) {
1483        this._rDelay = vars.repeatDelay || 0;
1484        this._yoyo = !!vars.yoyo || !!vars.yoyoEase;
1485      }
1486
1487      this._ts = 1;
1488
1489      _setDuration(this, +vars.duration, 1, 1);
1490
1491      this.data = vars.data;
1492      _tickerActive || _ticker.wake();
1493      parent && _addToTimeline(parent, this, time || time === 0 ? time : parent._time, 1);
1494      vars.reversed && this.reverse();
1495      vars.paused && this.paused(true);
1496    }
1497
1498    var _proto = Animation.prototype;
1499
1500    _proto.delay = function delay(value) {
1501      if (value || value === 0) {
1502        this.parent && this.parent.smoothChildTiming && this.startTime(this._start + value - this._delay);
1503        this._delay = value;
1504        return this;
1505      }
1506
1507      return this._delay;
1508    };
1509
1510    _proto.duration = function duration(value) {
1511      return arguments.length ? this.totalDuration(this._repeat > 0 ? value + (value + this._rDelay) * this._repeat : value) : this.totalDuration() && this._dur;
1512    };
1513
1514    _proto.totalDuration = function totalDuration(value) {
1515      if (!arguments.length) {
1516        return this._tDur;
1517      }
1518
1519      this._dirty = 0;
1520      return _setDuration(this, this._repeat < 0 ? value : (value - this._repeat * this._rDelay) / (this._repeat + 1));
1521    };
1522
1523    _proto.totalTime = function totalTime(_totalTime, suppressEvents) {
1524      _wake();
1525
1526      if (!arguments.length) {
1527        return this._tTime;
1528      }
1529
1530      var parent = this._dp;
1531
1532      if (parent && parent.smoothChildTiming && this._ts) {
1533        _alignPlayhead(this, _totalTime);
1534
1535        !parent._dp || parent.parent || _postAddChecks(parent, this);
1536
1537        while (parent.parent) {
1538          if (parent.parent._time !== parent._start + (parent._ts >= 0 ? parent._tTime / parent._ts : (parent.totalDuration() - parent._tTime) / -parent._ts)) {
1539            parent.totalTime(parent._tTime, true);
1540          }
1541
1542          parent = parent.parent;
1543        }
1544
1545        if (!this.parent && this._dp.autoRemoveChildren && (this._ts > 0 && _totalTime < this._tDur || this._ts < 0 && _totalTime > 0 || !this._tDur && !_totalTime)) {
1546          _addToTimeline(this._dp, this, this._start - this._delay);
1547        }
1548      }
1549
1550      if (this._tTime !== _totalTime || !this._dur && !suppressEvents || this._initted && Math.abs(this._zTime) === _tinyNum || !_totalTime && !this._initted && (this.add || this._ptLookup)) {
1551        this._ts || (this._pTime = _totalTime);
1552
1553        _lazySafeRender(this, _totalTime, suppressEvents);
1554      }
1555
1556      return this;
1557    };
1558
1559    _proto.time = function time(value, suppressEvents) {
1560      return arguments.length ? this.totalTime(Math.min(this.totalDuration(), value + _elapsedCycleDuration(this)) % this._dur || (value ? this._dur : 0), suppressEvents) : this._time;
1561    };
1562
1563    _proto.totalProgress = function totalProgress(value, suppressEvents) {
1564      return arguments.length ? this.totalTime(this.totalDuration() * value, suppressEvents) : this.totalDuration() ? Math.min(1, this._tTime / this._tDur) : this.ratio;
1565    };
1566
1567    _proto.progress = function progress(value, suppressEvents) {
1568      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;
1569    };
1570
1571    _proto.iteration = function iteration(value, suppressEvents) {
1572      var cycleDuration = this.duration() + this._rDelay;
1573
1574      return arguments.length ? this.totalTime(this._time + (value - 1) * cycleDuration, suppressEvents) : this._repeat ? _animationCycle(this._tTime, cycleDuration) + 1 : 1;
1575    };
1576
1577    _proto.timeScale = function timeScale(value) {
1578      if (!arguments.length) {
1579        return this._rts === -_tinyNum ? 0 : this._rts;
1580      }
1581
1582      if (this._rts === value) {
1583        return this;
1584      }
1585
1586      var tTime = this.parent && this._ts ? _parentToChildTotalTime(this.parent._time, this) : this._tTime;
1587      this._rts = +value || 0;
1588      this._ts = this._ps || value === -_tinyNum ? 0 : this._rts;
1589      return _recacheAncestors(this.totalTime(_clamp(-this._delay, this._tDur, tTime), true));
1590    };
1591
1592    _proto.paused = function paused(value) {
1593      if (!arguments.length) {
1594        return this._ps;
1595      }
1596
1597      if (this._ps !== value) {
1598        this._ps = value;
1599
1600        if (value) {
1601          this._pTime = this._tTime || Math.max(-this._delay, this.rawTime());
1602          this._ts = this._act = 0;
1603        } else {
1604          _wake();
1605
1606          this._ts = this._rts;
1607          this.totalTime(this.parent && !this.parent.smoothChildTiming ? this.rawTime() : this._tTime || this._pTime, this.progress() === 1 && (this._tTime -= _tinyNum) && Math.abs(this._zTime) !== _tinyNum);
1608        }
1609      }
1610
1611      return this;
1612    };
1613
1614    _proto.startTime = function startTime(value) {
1615      if (arguments.length) {
1616        this._start = value;
1617        var parent = this.parent || this._dp;

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

1709    _proto.invalidate = function invalidate() {
1710      this._initted = this._act = 0;
1711      this._zTime = -_tinyNum;
1712      return this;
1713    };
1714
1715    _proto.isActive = function isActive() {
1716      var parent = this.parent || this._dp,
1717          start = this._start,
1718          rawTime;
1719      return !!(!parent || this._ts && this._initted && parent.isActive() && (rawTime = parent.rawTime(true)) >= start && rawTime < this.endTime(true) - _tinyNum);
1720    };
1721
1722    _proto.eventCallback = function eventCallback(type, callback, params) {
1723      var vars = this.vars;
1724
1725      if (arguments.length > 1) {
1726        if (!callback) {
1727          delete vars[type];
1728        } else {
1729          vars[type] = callback;
1730          params && (vars[type + "Params"] = params);
1731          type === "onUpdate" && (this._onUpdate = callback);
1732        }
1733
1734        return this;
1735      }
1736
1737      return vars[type];
1738    };
1739
1740    _proto.then = function then(onFulfilled) {
1741      var self = this;
1742      return new Promise(function (resolve) {
1743        var f = _isFunction(onFulfilled) ? onFulfilled : _passThrough,
1744            _resolve = function _resolve() {
1745          var _then = self.then;
1746          self.then = null;
1747          _isFunction(f) && (f = f(self)) && (f.then || f === self) && (self.then = _then);
1748          resolve(f);
1749          self.then = _then;
1750        };
1751
1752        if (self._initted && self.totalProgress() === 1 && self._ts >= 0 || !self._tTime && self._ts < 0) {
1753          _resolve();
1754        } else {
1755          self._prom = _resolve;
1756        }
1757      });
1758    };
1759
1760    _proto.kill = function kill() {
1761      _interrupt(this);
1762    };
1763
1764    return Animation;
1765  }();
1766
1767  _setDefaults(Animation.prototype, {
1768    _time: 0,
1769    _start: 0,
1770    _end: 0,
1771    _tTime: 0,
1772    _tDur: 0,
1773    _dirty: 0,
1774    _repeat: 0,
1775    _yoyo: false,
1776    parent: null,
1777    _initted: false,
1778    _rDelay: 0,
1779    _ts: 1,
1780    _dp: 0,
1781    ratio: 0,
1782    _zTime: -_tinyNum,
1783    _prom: 0,
1784    _ps: false,
1785    _rts: 1
1786  });
1787
1788  var Timeline = function (_Animation) {
1789    _inheritsLoose(Timeline, _Animation);
1790
1791    function Timeline(vars, time) {
1792      var _this;
1793
1794      if (vars === void 0) {
1795        vars = {};
1796      }
1797
1798      _this = _Animation.call(this, vars, time) || this;
1799      _this.labels = {};
1800      _this.smoothChildTiming = !!vars.smoothChildTiming;
1801      _this.autoRemoveChildren = !!vars.autoRemoveChildren;
1802      _this._sort = _isNotFalse(vars.sortChildren);
1803      _this.parent && _postAddChecks(_this.parent, _assertThisInitialized(_this));
1804      vars.scrollTrigger && _scrollTrigger(_assertThisInitialized(_this), vars.scrollTrigger);
1805      return _this;
1806    }
1807
1808    var _proto2 = Timeline.prototype;
1809
1810    _proto2.to = function to(targets, vars, position) {
1811      new Tween(targets, _parseVars(arguments, 0, this), _parsePosition(this, _isNumber(vars) ? arguments[3] : position));
1812      return this;
1813    };
1814
1815    _proto2.from = function from(targets, vars, position) {
1816      new Tween(targets, _parseVars(arguments, 1, this), _parsePosition(this, _isNumber(vars) ? arguments[3] : position));
1817      return this;
1818    };
1819
1820    _proto2.fromTo = function fromTo(targets, fromVars, toVars, position) {
1821      new Tween(targets, _parseVars(arguments, 2, this), _parsePosition(this, _isNumber(fromVars) ? arguments[4] : position));
1822      return this;
1823    };
1824
1825    _proto2.set = function set(targets, vars, position) {
1826      vars.duration = 0;
1827      vars.parent = this;
1828      _inheritDefaults(vars).repeatDelay || (vars.repeat = 0);
1829      vars.immediateRender = !!vars.immediateRender;
1830      new Tween(targets, vars, _parsePosition(this, position), 1);
1831      return this;
1832    };
1833
1834    _proto2.call = function call(callback, params, position) {
1835      return _addToTimeline(this, Tween.delayedCall(0, callback, params), _parsePosition(this, position));
1836    };
1837
1838    _proto2.staggerTo = function staggerTo(targets, duration, vars, stagger, position, onCompleteAll, onCompleteAllParams) {
1839      vars.duration = duration;
1840      vars.stagger = vars.stagger || stagger;
1841      vars.onComplete = onCompleteAll;
1842      vars.onCompleteParams = onCompleteAllParams;
1843      vars.parent = this;
1844      new Tween(targets, vars, _parsePosition(this, position));
1845      return this;
1846    };
1847
1848    _proto2.staggerFrom = function staggerFrom(targets, duration, vars, stagger, position, onCompleteAll, onCompleteAllParams) {
1849      vars.runBackwards = 1;
1850      _inheritDefaults(vars).immediateRender = _isNotFalse(vars.immediateRender);
1851      return this.staggerTo(targets, duration, vars, stagger, position, onCompleteAll, onCompleteAllParams);
1852    };
1853
1854    _proto2.staggerFromTo = function staggerFromTo(targets, duration, fromVars, toVars, stagger, position, onCompleteAll, onCompleteAllParams) {
1855      toVars.startAt = fromVars;
1856      _inheritDefaults(toVars).immediateRender = _isNotFalse(toVars.immediateRender);
1857      return this.staggerTo(targets, duration, toVars, stagger, position, onCompleteAll, onCompleteAllParams);
1858    };
1859
1860    _proto2.render = function render(totalTime, suppressEvents, force) {
1861      var prevTime = this._time,
1862          tDur = this._dirty ? this.totalDuration() : this._tDur,
1863          dur = this._dur,
1864          tTime = this !== _globalTimeline && totalTime > tDur - _tinyNum && totalTime >= 0 ? tDur : totalTime < _tinyNum ? 0 : totalTime,
1865          crossingStart = this._zTime < 0 !== totalTime < 0 && (this._initted || !dur),
1866          time,
1867          child,
1868          next,
1869          iteration,
1870          cycleDuration,
1871          prevPaused,
1872          pauseTween,
1873          timeScale,
1874          prevStart,
1875          prevIteration,
1876          yoyo,
1877          isYoyo;
1878
1879      if (tTime !== this._tTime || force || crossingStart) {
1880        if (prevTime !== this._time && dur) {
1881          tTime += this._time - prevTime;
1882          totalTime += this._time - prevTime;
1883        }
1884
1885        time = tTime;
1886        prevStart = this._start;
1887        timeScale = this._ts;
1888        prevPaused = !timeScale;
1889
1890        if (crossingStart) {
1891          dur || (prevTime = this._zTime);
1892          (totalTime || !suppressEvents) && (this._zTime = totalTime);
1893        }
1894
1895        if (this._repeat) {
1896          yoyo = this._yoyo;
1897          cycleDuration = dur + this._rDelay;
1898
1899          if (this._repeat < -1 && totalTime < 0) {
1900            return this.totalTime(cycleDuration * 100 + totalTime, suppressEvents, force);
1901          }
1902
1903          time = _round(tTime % cycleDuration);
1904
1905          if (tTime === tDur) {
1906            iteration = this._repeat;
1907            time = dur;
1908          } else {
1909            iteration = ~~(tTime / cycleDuration);
1910
1911            if (iteration && iteration === tTime / cycleDuration) {
1912              time = dur;
1913              iteration--;
1914            }
1915
1916            time > dur && (time = dur);
1917          }
1918
1919          prevIteration = _animationCycle(this._tTime, cycleDuration);
1920          !prevTime && this._tTime && prevIteration !== iteration && (prevIteration = iteration);
1921
1922          if (yoyo && iteration & 1) {
1923            time = dur - time;
1924            isYoyo = 1;
1925          }
1926
1927          if (iteration !== prevIteration && !this._lock) {
1928            var rewinding = yoyo && prevIteration & 1,
1929                doesWrap = rewinding === (yoyo && iteration & 1);
1930            iteration < prevIteration && (rewinding = !rewinding);
1931            prevTime = rewinding ? 0 : dur;
1932            this._lock = 1;
1933            this.render(prevTime || (isYoyo ? 0 : _round(iteration * cycleDuration)), suppressEvents, !dur)._lock = 0;
1934            !suppressEvents && this.parent && _callback(this, "onRepeat");
1935            this.vars.repeatRefresh && !isYoyo && (this.invalidate()._lock = 1);
1936
1937            if (prevTime && prevTime !== this._time || prevPaused !== !this._ts || this.vars.onRepeat && !this.parent && !this._act) {
1938              return this;
1939            }
1940
1941            dur = this._dur;
1942            tDur = this._tDur;
1943
1944            if (doesWrap) {
1945              this._lock = 2;
1946              prevTime = rewinding ? dur : -0.0001;
1947              this.render(prevTime, true);
1948            }
1949
1950            this._lock = 0;
1951
1952            if (!this._ts && !prevPaused) {
1953              return this;
1954            }
1955
1956            _propagateYoyoEase(this, isYoyo);
1957          }
1958        }
1959
1960        if (this._hasPause && !this._forcing && this._lock < 2) {
1961          pauseTween = _findNextPauseTween(this, _round(prevTime), _round(time));
1962
1963          if (pauseTween) {
1964            tTime -= time - (time = pauseTween._start);
1965          }
1966        }
1967
1968        this._tTime = tTime;
1969        this._time = time;
1970        this._act = !timeScale;
1971
1972        if (!this._initted) {

1973          this._onUpdate = this.vars.onUpdate;
1974          this._initted = 1;
1975          this._zTime = totalTime;
1976          prevTime = 0;
1977        }
1978
1979        !prevTime && time && !suppressEvents && _callback(this, "onStart");
1980
1981        if (time >= prevTime && totalTime >= 0) {
1982          child = this._first;
1983
1984          while (child) {
1985            next = child._next;
1986
1987            if ((child._act || time >= child._start) && child._ts && pauseTween !== child) {
1988              if (child.parent !== this) {
1989                return this.render(totalTime, suppressEvents, force);
1990              }
1991
1992              child.render(child._ts > 0 ? (time - child._start) * child._ts : (child._dirty ? child.totalDuration() : child._tDur) + (time - child._start) * child._ts, suppressEvents, force);
1993
1994              if (time !== this._time || !this._ts && !prevPaused) {
1995                pauseTween = 0;
1996                next && (tTime += this._zTime = -_tinyNum);
1997                break;
1998              }
1999            }
2000
2001            child = next;
2002          }
2003        } else {
2004          child = this._last;
2005          var adjustedTime = totalTime < 0 ? totalTime : time;
2006
2007          while (child) {
2008            next = child._prev;
2009
2010            if ((child._act || adjustedTime <= child._end) && child._ts && pauseTween !== child) {
2011              if (child.parent !== this) {
2012                return this.render(totalTime, suppressEvents, force);
2013              }
2014
2015              child.render(child._ts > 0 ? (adjustedTime - child._start) * child._ts : (child._dirty ? child.totalDuration() : child._tDur) + (adjustedTime - child._start) * child._ts, suppressEvents, force);
2016
2017              if (time !== this._time || !this._ts && !prevPaused) {
2018                pauseTween = 0;
2019                next && (tTime += this._zTime = adjustedTime ? -_tinyNum : _tinyNum);
2020                break;
2021              }
2022            }
2023
2024            child = next;
2025          }
2026        }
2027
2028        if (pauseTween && !suppressEvents) {
2029          this.pause();
2030          pauseTween.render(time >= prevTime ? 0 : -_tinyNum)._zTime = time >= prevTime ? 1 : -1;
2031
2032          if (this._ts) {
2033            this._start = prevStart;
2034
2035            _setEnd(this);
2036
2037            return this.render(totalTime, suppressEvents, force);
2038          }
2039        }
2040
2041        this._onUpdate && !suppressEvents && _callback(this, "onUpdate", true);
2042        if (tTime === tDur && tDur >= this.totalDuration() || !tTime && prevTime) if (prevStart === this._start || Math.abs(timeScale) !== Math.abs(this._ts)) if (!this._lock) {
2043          (totalTime || !dur) && (tTime === tDur && this._ts > 0 || !tTime && this._ts < 0) && _removeFromParent(this, 1);
2044
2045          if (!suppressEvents && !(totalTime < 0 && !prevTime) && (tTime || prevTime)) {
2046            _callback(this, tTime === tDur ? "onComplete" : "onReverseComplete", true);
2047
2048            this._prom && !(tTime < tDur && this.timeScale() > 0) && this._prom();
2049          }
2050        }
2051      }
2052
2053      return this;
2054    };
2055
2056    _proto2.add = function add(child, position) {
2057      var _this2 = this;
2058
2059      _isNumber(position) || (position = _parsePosition(this, position));
2060
2061      if (!(child instanceof Animation)) {
2062        if (_isArray(child)) {
2063          child.forEach(function (obj) {
2064            return _this2.add(obj, position);
2065          });
2066          return this;
2067        }
2068
2069        if (_isString(child)) {
2070          return this.addLabel(child, position);
2071        }
2072
2073        if (_isFunction(child)) {
2074          child = Tween.delayedCall(0, child);
2075        } else {
2076          return this;
2077        }
2078      }
2079
2080      return this !== child ? _addToTimeline(this, child, position) : this;
2081    };
2082
2083    _proto2.getChildren = function getChildren(nested, tweens, timelines, ignoreBeforeTime) {
2084      if (nested === void 0) {
2085        nested = true;
2086      }
2087
2088      if (tweens === void 0) {
2089        tweens = true;
2090      }
2091
2092      if (timelines === void 0) {
2093        timelines = true;
2094      }
2095
2096      if (ignoreBeforeTime === void 0) {
2097        ignoreBeforeTime = -_bigNum;
2098      }
2099
2100      var a = [],
2101          child = this._first;
2102
2103      while (child) {
2104        if (child._start >= ignoreBeforeTime) {
2105          if (child instanceof Tween) {
2106            tweens && a.push(child);
2107          } else {
2108            timelines && a.push(child);
2109            nested && a.push.apply(a, child.getChildren(true, tweens, timelines));
2110          }
2111        }
2112
2113        child = child._next;
2114      }
2115
2116      return a;
2117    };
2118
2119    _proto2.getById = function getById(id) {
2120      var animations = this.getChildren(1, 1, 1),
2121          i = animations.length;
2122
2123      while (i--) {
2124        if (animations[i].vars.id === id) {
2125          return animations[i];
2126        }
2127      }
2128    };
2129
2130    _proto2.remove = function remove(child) {
2131      if (_isString(child)) {
2132        return this.removeLabel(child);
2133      }
2134
2135      if (_isFunction(child)) {
2136        return this.killTweensOf(child);
2137      }
2138
2139      _removeLinkedListItem(this, child);
2140
2141      if (child === this._recent) {
2142        this._recent = this._last;
2143      }
2144
2145      return _uncache(this);
2146    };
2147
2148    _proto2.totalTime = function totalTime(_totalTime2, suppressEvents) {
2149      if (!arguments.length) {
2150        return this._tTime;
2151      }
2152
2153      this._forcing = 1;
2154
2155      if (!this._dp && this._ts) {
2156        this._start = _round(_ticker.time - (this._ts > 0 ? _totalTime2 / this._ts : (this.totalDuration() - _totalTime2) / -this._ts));
2157      }
2158
2159      _Animation.prototype.totalTime.call(this, _totalTime2, suppressEvents);
2160
2161      this._forcing = 0;
2162      return this;
2163    };
2164
2165    _proto2.addLabel = function addLabel(label, position) {
2166      this.labels[label] = _parsePosition(this, position);
2167      return this;
2168    };
2169
2170    _proto2.removeLabel = function removeLabel(label) {
2171      delete this.labels[label];
2172      return this;
2173    };
2174
2175    _proto2.addPause = function addPause(position, callback, params) {
2176      var t = Tween.delayedCall(0, callback || _emptyFunc, params);
2177      t.data = "isPause";
2178      this._hasPause = 1;
2179      return _addToTimeline(this, t, _parsePosition(this, position));
2180    };
2181
2182    _proto2.removePause = function removePause(position) {
2183      var child = this._first;
2184      position = _parsePosition(this, position);
2185
2186      while (child) {
2187        if (child._start === position && child.data === "isPause") {
2188          _removeFromParent(child);
2189        }
2190
2191        child = child._next;
2192      }
2193    };
2194
2195    _proto2.killTweensOf = function killTweensOf(targets, props, onlyActive) {
2196      var tweens = this.getTweensOf(targets, onlyActive),
2197          i = tweens.length;
2198
2199      while (i--) {
2200        _overwritingTween !== tweens[i] && tweens[i].kill(targets, props);
2201      }
2202
2203      return this;
2204    };
2205
2206    _proto2.getTweensOf = function getTweensOf(targets, onlyActive) {
2207      var a = [],
2208          parsedTargets = toArray(targets),
2209          child = this._first,
2210          isGlobalTime = _isNumber(onlyActive),
2211          children;
2212
2213      while (child) {
2214        if (child instanceof Tween) {
2215          if (_arrayContainsAny(child._targets, parsedTargets) && (isGlobalTime ? (!_overwritingTween || child._initted && child._ts) && child.globalTime(0) <= onlyActive && child.globalTime(child.totalDuration()) > onlyActive : !onlyActive || child.isActive())) {
2216            a.push(child);
2217          }
2218        } else if ((children = child.getTweensOf(parsedTargets, onlyActive)).length) {
2219          a.push.apply(a, children);
2220        }
2221
2222        child = child._next;
2223      }
2224
2225      return a;
2226    };
2227
2228    _proto2.tweenTo = function tweenTo(position, vars) {
2229      vars = vars || {};
2230
2231      var tl = this,
2232          endTime = _parsePosition(tl, position),
2233          _vars = vars,
2234          startAt = _vars.startAt,
2235          _onStart = _vars.onStart,
2236          onStartParams = _vars.onStartParams,
2237          immediateRender = _vars.immediateRender,
2238          tween = Tween.to(tl, _setDefaults({
2239        ease: vars.ease || "none",
2240        lazy: false,
2241        immediateRender: false,
2242        time: endTime,
2243        overwrite: "auto",
2244        duration: vars.duration || Math.abs((endTime - (startAt && "time" in startAt ? startAt.time : tl._time)) / tl.timeScale()) || _tinyNum,
2245        onStart: function onStart() {
2246          tl.pause();
2247          var duration = vars.duration || Math.abs((endTime - tl._time) / tl.timeScale());
2248          tween._dur !== duration && _setDuration(tween, duration, 0, 1).render(tween._time, true, true);
2249          _onStart && _onStart.apply(tween, onStartParams || []);
2250        }
2251      }, vars));
2252
2253      return immediateRender ? tween.render(0) : tween;
2254    };
2255
2256    _proto2.tweenFromTo = function tweenFromTo(fromPosition, toPosition, vars) {
2257      return this.tweenTo(toPosition, _setDefaults({
2258        startAt: {
2259          time: _parsePosition(this, fromPosition)
2260        }
2261      }, vars));
2262    };
2263
2264    _proto2.recent = function recent() {
2265      return this._recent;
2266    };
2267
2268    _proto2.nextLabel = function nextLabel(afterTime) {
2269      if (afterTime === void 0) {
2270        afterTime = this._time;
2271      }
2272
2273      return _getLabelInDirection(this, _parsePosition(this, afterTime));
2274    };
2275
2276    _proto2.previousLabel = function previousLabel(beforeTime) {
2277      if (beforeTime === void 0) {
2278        beforeTime = this._time;
2279      }
2280
2281      return _getLabelInDirection(this, _parsePosition(this, beforeTime), 1);
2282    };
2283
2284    _proto2.currentLabel = function currentLabel(value) {
2285      return arguments.length ? this.seek(value, true) : this.previousLabel(this._time + _tinyNum);
2286    };
2287
2288    _proto2.shiftChildren = function shiftChildren(amount, adjustLabels, ignoreBeforeTime) {
2289      if (ignoreBeforeTime === void 0) {
2290        ignoreBeforeTime = 0;
2291      }
2292
2293      var child = this._first,
2294          labels = this.labels,
2295          p;
2296
2297      while (child) {
2298        if (child._start >= ignoreBeforeTime) {
2299          child._start += amount;
2300          child._end += amount;
2301        }
2302
2303        child = child._next;
2304      }
2305
2306      if (adjustLabels) {
2307        for (p in labels) {
2308          if (labels[p] >= ignoreBeforeTime) {
2309            labels[p] += amount;
2310          }
2311        }
2312      }
2313
2314      return _uncache(this);
2315    };
2316
2317    _proto2.invalidate = function invalidate() {
2318      var child = this._first;
2319      this._lock = 0;
2320
2321      while (child) {
2322        child.invalidate();
2323        child = child._next;
2324      }
2325
2326      return _Animation.prototype.invalidate.call(this);
2327    };
2328
2329    _proto2.clear = function clear(includeLabels) {
2330      if (includeLabels === void 0) {
2331        includeLabels = true;
2332      }
2333
2334      var child = this._first,
2335          next;
2336
2337      while (child) {
2338        next = child._next;
2339        this.remove(child);
2340        child = next;
2341      }
2342
2343      this._dp && (this._time = this._tTime = this._pTime = 0);
2344      includeLabels && (this.labels = {});
2345      return _uncache(this);
2346    };
2347
2348    _proto2.totalDuration = function totalDuration(value) {
2349      var max = 0,
2350          self = this,
2351          child = self._last,
2352          prevStart = _bigNum,
2353          prev,
2354          start,
2355          parent;
2356
2357      if (arguments.length) {
2358        return self.timeScale((self._repeat < 0 ? self.duration() : self.totalDuration()) / (self.reversed() ? -value : value));
2359      }
2360
2361      if (self._dirty) {
2362        parent = self.parent;
2363
2364        while (child) {
2365          prev = child._prev;
2366          child._dirty && child.totalDuration();
2367          start = child._start;
2368
2369          if (start > prevStart && self._sort && child._ts && !self._lock) {
2370            self._lock = 1;
2371            _addToTimeline(self, child, start - child._delay, 1)._lock = 0;
2372          } else {
2373            prevStart = start;
2374          }
2375
2376          if (start < 0 && child._ts) {
2377            max -= start;
2378
2379            if (!parent && !self._dp || parent && parent.smoothChildTiming) {
2380              self._start += start / self._ts;
2381              self._time -= start;
2382              self._tTime -= start;
2383            }
2384
2385            self.shiftChildren(-start, false, -1e999);
2386            prevStart = 0;
2387          }
2388
2389          child._end > max && child._ts && (max = child._end);
2390          child = prev;
2391        }
2392
2393        _setDuration(self, self === _globalTimeline && self._time > max ? self._time : max, 1, 1);
2394
2395        self._dirty = 0;
2396      }
2397
2398      return self._tDur;
2399    };
2400
2401    Timeline.updateRoot = function updateRoot(time) {
2402      if (_globalTimeline._ts) {
2403        _lazySafeRender(_globalTimeline, _parentToChildTotalTime(time, _globalTimeline));
2404
2405        _lastRenderedFrame = _ticker.frame;
2406      }
2407
2408      if (_ticker.frame >= _nextGCFrame) {
2409        _nextGCFrame += _config.autoSleep || 120;
2410        var child = _globalTimeline._first;
2411        if (!child || !child._ts) if (_config.autoSleep && _ticker._listeners.length < 2) {
2412          while (child && !child._ts) {
2413            child = child._next;
2414          }
2415
2416          child || _ticker.sleep();
2417        }
2418      }
2419    };
2420
2421    return Timeline;
2422  }(Animation);
2423
2424  _setDefaults(Timeline.prototype, {
2425    _lock: 0,
2426    _hasPause: 0,
2427    _forcing: 0
2428  });
2429
2430  var _addComplexStringPropTween = function _addComplexStringPropTween(target, prop, start, end, setter, stringFilter, funcParam) {
2431    var pt = new PropTween(this._pt, target, prop, 0, 1, _renderComplexString, null, setter),
2432        index = 0,
2433        matchIndex = 0,
2434        result,
2435        startNums,
2436        color,
2437        endNum,
2438        chunk,
2439        startNum,
2440        hasRandom,
2441        a;
2442    pt.b = start;
2443    pt.e = end;
2444    start += "";
2445    end += "";
2446
2447    if (hasRandom = ~end.indexOf("random(")) {
2448      end = _replaceRandom(end);
2449    }
2450
2451    if (stringFilter) {
2452      a = [start, end];
2453      stringFilter(a, target, prop);
2454      start = a[0];
2455      end = a[1];
2456    }
2457
2458    startNums = start.match(_complexStringNumExp) || [];
2459
2460    while (result = _complexStringNumExp.exec(end)) {
2461      endNum = result[0];
2462      chunk = end.substring(index, result.index);
2463
2464      if (color) {
2465        color = (color + 1) % 5;
2466      } else if (chunk.substr(-5) === "rgba(") {
2467        color = 1;
2468      }
2469
2470      if (endNum !== startNums[matchIndex++]) {
2471        startNum = parseFloat(startNums[matchIndex - 1]) || 0;
2472        pt._pt = {
2473          _next: pt._pt,
2474          p: chunk || matchIndex === 1 ? chunk : ",",
2475          s: startNum,
2476          c: endNum.charAt(1) === "=" ? parseFloat(endNum.substr(2)) * (endNum.charAt(0) === "-" ? -1 : 1) : parseFloat(endNum) - startNum,
2477          m: color && color < 4 ? Math.round : 0
2478        };
2479        index = _complexStringNumExp.lastIndex;
2480      }
2481    }
2482
2483    pt.c = index < end.length ? end.substring(index, end.length) : "";
2484    pt.fp = funcParam;
2485
2486    if (_relExp.test(end) || hasRandom) {
2487      pt.e = 0;
2488    }
2489
2490    this._pt = pt;
2491    return pt;
2492  },
2493      _addPropTween = function _addPropTween(target, prop, start, end, index, targets, modifier, stringFilter, funcParam) {
2494    _isFunction(end) && (end = end(index || 0, target, targets));
2495    var currentValue = target[prop],
2496        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](),
2497        setter = !_isFunction(currentValue) ? _setterPlain : funcParam ? _setterFuncWithParam : _setterFunc,
2498        pt;
2499
2500    if (_isString(end)) {
2501      if (~end.indexOf("random(")) {
2502        end = _replaceRandom(end);
2503      }
2504
2505      if (end.charAt(1) === "=") {
2506        end = parseFloat(parsedStart) + parseFloat(end.substr(2)) * (end.charAt(0) === "-" ? -1 : 1) + (getUnit(parsedStart) || 0);
2507      }
2508    }
2509
2510    if (parsedStart !== end) {
2511      if (!isNaN(parsedStart * end)) {
2512        pt = new PropTween(this._pt, target, prop, +parsedStart || 0, end - (parsedStart || 0), typeof currentValue === "boolean" ? _renderBoolean : _renderPlain, 0, setter);
2513        funcParam && (pt.fp = funcParam);
2514        modifier && pt.modifier(modifier, this, target);
2515        return this._pt = pt;
2516      }
2517
2518      !currentValue && !(prop in target) && _missingPlugin(prop, end);
2519      return _addComplexStringPropTween.call(this, target, prop, parsedStart, end, setter, stringFilter || _config.stringFilter, funcParam);
2520    }
2521  },
2522      _processVars = function _processVars(vars, index, target, targets, tween) {
2523    _isFunction(vars) && (vars = _parseFuncOrString(vars, tween, index, target, targets));
2524
2525    if (!_isObject(vars) || vars.style && vars.nodeType || _isArray(vars) || _isTypedArray(vars)) {
2526      return _isString(vars) ? _parseFuncOrString(vars, tween, index, target, targets) : vars;
2527    }
2528
2529    var copy = {},
2530        p;
2531
2532    for (p in vars) {
2533      copy[p] = _parseFuncOrString(vars[p], tween, index, target, targets);
2534    }
2535
2536    return copy;
2537  },
2538      _checkPlugin = function _checkPlugin(property, vars, tween, index, target, targets) {
2539    var plugin, pt, ptLookup, i;
2540
2541    if (_plugins[property] && (plugin = new _plugins[property]()).init(target, plugin.rawVars ? vars[property] : _processVars(vars[property], index, target, targets, tween), tween, index, targets) !== false) {
2542      tween._pt = pt = new PropTween(tween._pt, target, property, 0, 1, plugin.render, plugin, 0, plugin.priority);
2543
2544      if (tween !== _quickTween) {
2545        ptLookup = tween._ptLookup[tween._targets.indexOf(target)];
2546        i = plugin._props.length;
2547
2548        while (i--) {
2549          ptLookup[plugin._props[i]] = pt;
2550        }
2551      }
2552    }
2553
2554    return plugin;
2555  },
2556      _overwritingTween,
2557      _initTween = function _initTween(tween, time) {
2558    var vars = tween.vars,
2559        ease = vars.ease,
2560        startAt = vars.startAt,
2561        immediateRender = vars.immediateRender,
2562        lazy = vars.lazy,
2563        onUpdate = vars.onUpdate,
2564        onUpdateParams = vars.onUpdateParams,
2565        callbackScope = vars.callbackScope,
2566        runBackwards = vars.runBackwards,
2567        yoyoEase = vars.yoyoEase,
2568        keyframes = vars.keyframes,
2569        autoRevert = vars.autoRevert,
2570        dur = tween._dur,
2571        prevStartAt = tween._startAt,
2572        targets = tween._targets,
2573        parent = tween.parent,
2574        fullTargets = parent && parent.data === "nested" ? parent.parent._targets : targets,
2575        autoOverwrite = tween._overwrite === "auto" && !_suppressOverwrites,
2576        tl = tween.timeline,
2577        cleanVars,
2578        i,
2579        p,
2580        pt,
2581        target,
2582        hasPriority,
2583        gsData,
2584        harness,
2585        plugin,
2586        ptLookup,
2587        index,
2588        harnessVars,
2589        overwritten;
2590    tl && (!keyframes || !ease) && (ease = "none");
2591    tween._ease = _parseEase(ease, _defaults.ease);
2592    tween._yEase = yoyoEase ? _invertEase(_parseEase(yoyoEase === true ? ease : yoyoEase, _defaults.ease)) : 0;
2593
2594    if (yoyoEase && tween._yoyo && !tween._repeat) {
2595      yoyoEase = tween._yEase;
2596      tween._yEase = tween._ease;
2597      tween._ease = yoyoEase;
2598    }
2599
2600    if (!tl) {
2601      harness = targets[0] ? _getCache(targets[0]).harness : 0;
2602      harnessVars = harness && vars[harness.prop];
2603      cleanVars = _copyExcluding(vars, _reservedProps);
2604      prevStartAt && prevStartAt.render(-1, true).kill();
2605
2606      if (startAt) {
2607        _removeFromParent(tween._startAt = Tween.set(targets, _setDefaults({
2608          data: "isStart",
2609          overwrite: false,
2610          parent: parent,
2611          immediateRender: true,
2612          lazy: _isNotFalse(lazy),
2613          startAt: null,
2614          delay: 0,
2615          onUpdate: onUpdate,
2616          onUpdateParams: onUpdateParams,
2617          callbackScope: callbackScope,
2618          stagger: 0
2619        }, startAt)));
2620
2621        if (immediateRender) {
2622          if (time > 0) {
2623            autoRevert || (tween._startAt = 0);
2624          } else if (dur && !(time < 0 && prevStartAt)) {
2625            time && (tween._zTime = time);
2626            return;
2627          }
2628        } else if (autoRevert === false) {
2629          tween._startAt = 0;
2630        }
2631      } else if (runBackwards && dur) {
2632        if (prevStartAt) {
2633          !autoRevert && (tween._startAt = 0);
2634        } else {
2635          time && (immediateRender = false);
2636          p = _setDefaults({
2637            overwrite: false,
2638            data: "isFromStart",
2639            lazy: immediateRender && _isNotFalse(lazy),
2640            immediateRender: immediateRender,
2641            stagger: 0,
2642            parent: parent
2643          }, cleanVars);
2644          harnessVars && (p[harness.prop] = harnessVars);
2645
2646          _removeFromParent(tween._startAt = Tween.set(targets, p));
2647
2648          if (!immediateRender) {
2649            _initTween(tween._startAt, _tinyNum);
2650          } else if (!time) {
2651            return;
2652          }
2653        }
2654      }
2655
2656      tween._pt = 0;
2657      lazy = dur && _isNotFalse(lazy) || lazy && !dur;
2658
2659      for (i = 0; i < targets.length; i++) {
2660        target = targets[i];
2661        gsData = target._gsap || _harness(targets)[i]._gsap;
2662        tween._ptLookup[i] = ptLookup = {};
2663        _lazyLookup[gsData.id] && _lazyTweens.length && _lazyRender();
2664        index = fullTargets === targets ? i : fullTargets.indexOf(target);
2665
2666        if (harness && (plugin = new harness()).init(target, harnessVars || cleanVars, tween, index, fullTargets) !== false) {
2667          tween._pt = pt = new PropTween(tween._pt, target, plugin.name, 0, 1, plugin.render, plugin, 0, plugin.priority);
2668
2669          plugin._props.forEach(function (name) {
2670            ptLookup[name] = pt;
2671          });
2672
2673          plugin.priority && (hasPriority = 1);
2674        }
2675
2676        if (!harness || harnessVars) {
2677          for (p in cleanVars) {
2678            if (_plugins[p] && (plugin = _checkPlugin(p, cleanVars, tween, index, target, fullTargets))) {
2679              plugin.priority && (hasPriority = 1);
2680            } else {
2681              ptLookup[p] = pt = _addPropTween.call(tween, target, p, "get", cleanVars[p], index, fullTargets, 0, vars.stringFilter);
2682            }
2683          }
2684        }
2685
2686        tween._op && tween._op[i] && tween.kill(target, tween._op[i]);
2687
2688        if (autoOverwrite && tween._pt) {
2689          _overwritingTween = tween;
2690
2691          _globalTimeline.killTweensOf(target, ptLookup, tween.globalTime(0));
2692
2693          overwritten = !tween.parent;
2694          _overwritingTween = 0;
2695        }
2696
2697        tween._pt && lazy && (_lazyLookup[gsData.id] = 1);
2698      }
2699
2700      hasPriority && _sortPropTweensByPriority(tween);
2701      tween._onInit && tween._onInit(tween);
2702    }
2703
2704    tween._from = !tl && !!vars.runBackwards;
2705    tween._onUpdate = onUpdate;
2706    tween._initted = (!tween._op || tween._pt) && !overwritten;
2707  },
2708      _addAliasesToVars = function _addAliasesToVars(targets, vars) {
2709    var harness = targets[0] ? _getCache(targets[0]).harness : 0,
2710        propertyAliases = harness && harness.aliases,
2711        copy,
2712        p,
2713        i,
2714        aliases;
2715
2716    if (!propertyAliases) {
2717      return vars;
2718    }
2719