all.js

js lamaisonanilondon.com collected 2026-10-06 20:43:10 UTC 803,964 bytes, 24,882 lines download raw bytes

vendor: 5,425 bytes, lines 1-173

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

vendor: 6,338 bytes, lines 174-383

174      _forEachName = function _forEachName(names, func) {
175    return (names = names.split(",")).forEach(func) || names;
176  },
177      _round = function _round(value) {
178    return Math.round(value * 100000) / 100000 || 0;
179  },
180      _roundPrecise = function _roundPrecise(value) {
181    return Math.round(value * 10000000) / 10000000 || 0;
182  },
183      _parseRelative = function _parseRelative(start, value) {
184    var operator = value.charAt(0),
185        end = parseFloat(value.substr(2));
186    start = parseFloat(start);
187    return operator === "+" ? start + end : operator === "-" ? start - end : operator === "*" ? start * end : start / end;
188  },
189      _arrayContainsAny = function _arrayContainsAny(toSearch, toFind) {
190    var l = toFind.length,
191        i = 0;
192
193    for (; toSearch.indexOf(toFind[i]) < 0 && ++i < l;) {}
194
195    return i < l;
196  },
197      _lazyRender = function _lazyRender() {
198    var l = _lazyTweens.length,
199        a = _lazyTweens.slice(0),
200        i,
201        tween;
202
203    _lazyLookup = {};
204    _lazyTweens.length = 0;
205
206    for (i = 0; i < l; i++) {
207      tween = a[i];
208      tween && tween._lazy && (tween.render(tween._lazy[0], tween._lazy[1], true)._lazy = 0);
209    }
210  },
211      _lazySafeRender = function _lazySafeRender(animation, time, suppressEvents, force) {
212    _lazyTweens.length && !_reverting && _lazyRender();
213    animation.render(time, suppressEvents, force || _reverting && time < 0 && (animation._initted || animation._startAt));
214    _lazyTweens.length && !_reverting && _lazyRender();
215  },
216      _numericIfPossible = function _numericIfPossible(value) {
217    var n = parseFloat(value);
218    return (n || n === 0) && (value + "").match(_delimitedValueExp).length < 2 ? n : _isString(value) ? value.trim() : value;
219  },
220      _passThrough = function _passThrough(p) {
221    return p;
222  },
223      _setDefaults = function _setDefaults(obj, defaults) {
224    for (var p in defaults) {
225      p in obj || (obj[p] = defaults[p]);
226    }
227
228    return obj;
229  },
230      _setKeyframeDefaults = function _setKeyframeDefaults(excludeDuration) {
231    return function (obj, defaults) {
232      for (var p in defaults) {
233        p in obj || p === "duration" && excludeDuration || p === "ease" || (obj[p] = defaults[p]);
234      }
235    };
236  },
237      _merge = function _merge(base, toMerge) {
238    for (var p in toMerge) {
239      base[p] = toMerge[p];
240    }
241
242    return base;
243  },
244      _mergeDeep = function _mergeDeep(base, toMerge) {
245    for (var p in toMerge) {
246      p !== "__proto__" && p !== "constructor" && p !== "prototype" && (base[p] = _isObject(toMerge[p]) ? _mergeDeep(base[p] || (base[p] = {}), toMerge[p]) : toMerge[p]);
247    }
248
249    return base;
250  },
251      _copyExcluding = function _copyExcluding(obj, excluding) {
252    var copy = {},
253        p;
254
255    for (p in obj) {
256      p in excluding || (copy[p] = obj[p]);
257    }
258
259    return copy;
260  },
261      _inheritDefaults = function _inheritDefaults(vars) {
262    var parent = vars.parent || _globalTimeline,
263        func = vars.keyframes ? _setKeyframeDefaults(_isArray(vars.keyframes)) : _setDefaults;
264
265    if (_isNotFalse(vars.inherit)) {
266      while (parent) {
267        func(vars, parent.vars.defaults);
268        parent = parent.parent || parent._dp;
269      }
270    }
271
272    return vars;
273  },
274      _arraysMatch = function _arraysMatch(a1, a2) {
275    var i = a1.length,
276        match = i === a2.length;
277
278    while (match && i-- && a1[i] === a2[i]) {}
279
280    return i < 0;
281  },
282      _addLinkedListItem = function _addLinkedListItem(parent, child, firstProp, lastProp, sortBy) {
283    if (firstProp === void 0) {
284      firstProp = "_first";
285    }
286
287    if (lastProp === void 0) {
288      lastProp = "_last";
289    }
290
291    var prev = parent[lastProp],
292        t;
293
294    if (sortBy) {
295      t = child[sortBy];
296
297      while (prev && prev[sortBy] > t) {
298        prev = prev._prev;
299      }
300    }
301
302    if (prev) {
303      child._next = prev._next;
304      prev._next = child;
305    } else {
306      child._next = parent[firstProp];
307      parent[firstProp] = child;
308    }
309
310    if (child._next) {
311      child._next._prev = child;
312    } else {
313      parent[lastProp] = child;
314    }
315
316    child._prev = prev;
317    child.parent = child._dp = parent;
318    return child;
319  },
320      _removeLinkedListItem = function _removeLinkedListItem(parent, child, firstProp, lastProp) {
321    if (firstProp === void 0) {
322      firstProp = "_first";
323    }
324
325    if (lastProp === void 0) {
326      lastProp = "_last";
327    }
328
329    var prev = child._prev,
330        next = child._next;
331
332    if (prev) {
333      prev._next = next;
334    } else if (parent[firstProp] === child) {
335      parent[firstProp] = next;
336    }
337
338    if (next) {
339      next._prev = prev;
340    } else if (parent[lastProp] === child) {
341      parent[lastProp] = prev;
342    }
343
344    child._next = child._prev = child.parent = null;
345  },
346      _removeFromParent = function _removeFromParent(child, onlyIfParentHasAutoRemove) {
347    child.parent && (!onlyIfParentHasAutoRemove || child.parent.autoRemoveChildren) && child.parent.remove && child.parent.remove(child);
348    child._act = 0;
349  },
350      _uncache = function _uncache(animation, child) {
351    if (animation && (!child || child._end > animation._dur || child._start < 0)) {
352      var a = animation;
353
354      while (a) {
355        a._dirty = 1;
356        a = a.parent;
357      }
358    }
359
360    return animation;
361  },
362      _recacheAncestors = function _recacheAncestors(animation) {
363    var parent = animation.parent;
364
365    while (parent && parent.parent) {
366      parent._dirty = 1;
367      parent.totalDuration();
368      parent = parent.parent;
369    }
370
371    return animation;
372  },
373      _rewindStartAt = function _rewindStartAt(tween, totalTime, suppressEvents, force) {
374    return tween._startAt && (_reverting ? tween._startAt.revert(_revertConfigNoKill) : tween.vars.immediateRender && !tween.vars.autoRevert || tween._startAt.render(totalTime, true, force));
375  },
376      _hasNoPausedAncestors = function _hasNoPausedAncestors(animation) {
377    return !animation || animation._ts && _hasNoPausedAncestors(animation.parent);
378  },
379      _elapsedCycleDuration = function _elapsedCycleDuration(animation) {
380    return animation._repeat ? _animationCycle(animation._tTime, animation = animation.duration() + animation._rDelay) * animation : 0;
381  },
382      _animationCycle = function _animationCycle(tTime, cycleDuration) {
383    var whole = Math.floor(tTime /= cycleDuration

vendor: 17,487 bytes, lines 383-851

383);
384    return tTime && whole === tTime ? whole - 1 : whole;
385  },
386      _parentToChildTotalTime = function _parentToChildTotalTime(parentTime, child) {
387    return (parentTime - child._start) * child._ts + (child._ts >= 0 ? 0 : child._dirty ? child.totalDuration() : child._tDur);
388  },
389      _setEnd = function _setEnd(animation) {
390    return animation._end = _roundPrecise(animation._start + (animation._tDur / Math.abs(animation._ts || animation._rts || _tinyNum) || 0));
391  },
392      _alignPlayhead = function _alignPlayhead(animation, totalTime) {
393    var parent = animation._dp;
394
395    if (parent && parent.smoothChildTiming && animation._ts) {
396      animation._start = _roundPrecise(parent._time - (animation._ts > 0 ? totalTime / animation._ts : ((animation._dirty ? animation.totalDuration() : animation._tDur) - totalTime) / -animation._ts));
397
398      _setEnd(animation);
399
400      parent._dirty || _uncache(parent, animation);
401    }
402
403    return animation;
404  },
405      _postAddChecks = function _postAddChecks(timeline, child) {
406    var t;
407
408    if (child._time || !child._dur && child._initted || child._start < timeline._time && (child._dur || !child.add)) {
409      t = _parentToChildTotalTime(timeline.rawTime(), child);
410
411      if (!child._dur || _clamp(0, child.totalDuration(), t) - child._tTime > _tinyNum) {
412        child.render(t, true);
413      }
414    }
415
416    if (_uncache(timeline, child)._dp && timeline._initted && timeline._time >= timeline._dur && timeline._ts) {
417      if (timeline._dur < timeline.duration()) {
418        t = timeline;
419
420        while (t._dp) {
421          t.rawTime() >= 0 && t.totalTime(t._tTime);
422          t = t._dp;
423        }
424      }
425
426      timeline._zTime = -_tinyNum;
427    }
428  },
429      _addToTimeline = function _addToTimeline(timeline, child, position, skipChecks) {
430    child.parent && _removeFromParent(child);
431    child._start = _roundPrecise((_isNumber(position) ? position : position || timeline !== _globalTimeline ? _parsePosition(timeline, position, child) : timeline._time) + child._delay);
432    child._end = _roundPrecise(child._start + (child.totalDuration() / Math.abs(child.timeScale()) || 0));
433
434    _addLinkedListItem(timeline, child, "_first", "_last", timeline._sort ? "_start" : 0);
435
436    _isFromOrFromStart(child) || (timeline._recent = child);
437    skipChecks || _postAddChecks(timeline, child);
438    timeline._ts < 0 && _alignPlayhead(timeline, timeline._tTime);
439    return timeline;
440  },
441      _scrollTrigger = function _scrollTrigger(animation, trigger) {
442    return (_globals.ScrollTrigger || _missingPlugin("scrollTrigger", trigger)) && _globals.ScrollTrigger.create(trigger, animation);
443  },
444      _attemptInitTween = function _attemptInitTween(tween, time, force, suppressEvents, tTime) {
445    _initTween(tween, time, tTime);
446
447    if (!tween._initted) {
448      return 1;
449    }
450
451    if (!force && tween._pt && !_reverting && (tween._dur && tween.vars.lazy !== false || !tween._dur && tween.vars.lazy) && _lastRenderedFrame !== _ticker.frame) {
452      _lazyTweens.push(tween);
453
454      tween._lazy = [tTime, suppressEvents];
455      return 1;
456    }
457  },
458      _parentPlayheadIsBeforeStart = function _parentPlayheadIsBeforeStart(_ref) {
459    var parent = _ref.parent;
460    return parent && parent._ts && parent._initted && !parent._lock && (parent.rawTime() < 0 || _parentPlayheadIsBeforeStart(parent));
461  },
462      _isFromOrFromStart = function _isFromOrFromStart(_ref2) {
463    var data = _ref2.data;
464    return data === "isFromStart" || data === "isStart";
465  },
466      _renderZeroDurationTween = function _renderZeroDurationTween(tween, totalTime, suppressEvents, force) {
467    var prevRatio = tween.ratio,
468        ratio = totalTime < 0 || !totalTime && (!tween._start && _parentPlayheadIsBeforeStart(tween) && !(!tween._initted && _isFromOrFromStart(tween)) || (tween._ts < 0 || tween._dp._ts < 0) && !_isFromOrFromStart(tween)) ? 0 : 1,
469        repeatDelay = tween._rDelay,
470        tTime = 0,
471        pt,
472        iteration,
473        prevIteration;
474
475    if (repeatDelay && tween._repeat) {
476      tTime = _clamp(0, tween._tDur, totalTime);
477      iteration = _animationCycle(tTime, repeatDelay);
478      tween._yoyo && iteration & 1 && (ratio = 1 - ratio);
479
480      if (iteration !== _animationCycle(tween._tTime, repeatDelay)) {
481        prevRatio = 1 - ratio;
482        tween.vars.repeatRefresh && tween._initted && tween.invalidate();
483      }
484    }
485
486    if (ratio !== prevRatio || _reverting || force || tween._zTime === _tinyNum || !totalTime && tween._zTime) {
487      if (!tween._initted && _attemptInitTween(tween, totalTime, force, suppressEvents, tTime)) {
488        return;
489      }
490
491      prevIteration = tween._zTime;
492      tween._zTime = totalTime || (suppressEvents ? _tinyNum : 0);
493      suppressEvents || (suppressEvents = totalTime && !prevIteration);
494      tween.ratio = ratio;
495      tween._from && (ratio = 1 - ratio);
496      tween._time = 0;
497      tween._tTime = tTime;
498      pt = tween._pt;
499
500      while (pt) {
501        pt.r(ratio, pt.d);
502        pt = pt._next;
503      }
504
505      totalTime < 0 && _rewindStartAt(tween, totalTime, suppressEvents, true);
506      tween._onUpdate && !suppressEvents && _callback(tween, "onUpdate");
507      tTime && tween._repeat && !suppressEvents && tween.parent && _callback(tween, "onRepeat");
508
509      if ((totalTime >= tween._tDur || totalTime < 0) && tween.ratio === ratio) {
510        ratio && _removeFromParent(tween, 1);
511
512        if (!suppressEvents && !_reverting) {
513          _callback(tween, ratio ? "onComplete" : "onReverseComplete", true);
514
515          tween._prom && tween._prom();
516        }
517      }
518    } else if (!tween._zTime) {
519      tween._zTime = totalTime;
520    }
521  },
522      _findNextPauseTween = function _findNextPauseTween(animation, prevTime, time) {
523    var child;
524
525    if (time > prevTime) {
526      child = animation._first;
527
528      while (child && child._start <= time) {
529        if (child.data === "isPause" && child._start > prevTime) {
530          return child;
531        }
532
533        child = child._next;
534      }
535    } else {
536      child = animation._last;
537
538      while (child && child._start >= time) {
539        if (child.data === "isPause" && child._start < prevTime) {
540          return child;
541        }
542
543        child = child._prev;
544      }
545    }
546  },
547      _setDuration = function _setDuration(animation, duration, skipUncache, leavePlayhead) {
548    var repeat = animation._repeat,
549        dur = _roundPrecise(duration) || 0,
550        totalProgress = animation._tTime / animation._tDur;
551    totalProgress && !leavePlayhead && (animation._time *= dur / animation._dur);
552    animation._dur = dur;
553    animation._tDur = !repeat ? dur : repeat < 0 ? 1e10 : _roundPrecise(dur * (repeat + 1) + animation._rDelay * repeat);
554    totalProgress > 0 && !leavePlayhead && _alignPlayhead(animation, animation._tTime = animation._tDur * totalProgress);
555    animation.parent && _setEnd(animation);
556    skipUncache || _uncache(animation.parent, animation);
557    return animation;
558  },
559      _onUpdateTotalDuration = function _onUpdateTotalDuration(animation) {
560    return animation instanceof Timeline ? _uncache(animation) : _setDuration(animation, animation._dur);
561  },
562      _zeroPosition = {
563    _start: 0,
564    endTime: _emptyFunc,
565    totalDuration: _emptyFunc
566  },
567      _parsePosition = function _parsePosition(animation, position, percentAnimation) {
568    var labels = animation.labels,
569        recent = animation._recent || _zeroPosition,
570        clippedDuration = animation.duration() >= _bigNum ? recent.endTime(false) : animation._dur,
571        i,
572        offset,
573        isPercent;
574
575    if (_isString(position) && (isNaN(position) || position in labels)) {
576      offset = position.charAt(0);
577      isPercent = position.substr(-1) === "%";
578      i = position.indexOf("=");
579
580      if (offset === "<" || offset === ">") {
581        i >= 0 && (position = position.replace(/=/, ""));
582        return (offset === "<" ? recent._start : recent.endTime(recent._repeat >= 0)) + (parseFloat(position.substr(1)) || 0) * (isPercent ? (i < 0 ? recent : percentAnimation).totalDuration() / 100 : 1);
583      }
584
585      if (i < 0) {
586        position in labels || (labels[position] = clippedDuration);
587        return labels[position];
588      }
589
590      offset = parseFloat(position.charAt(i - 1) + position.substr(i + 1));
591
592      if (isPercent && percentAnimation) {
593        offset = offset / 100 * (_isArray(percentAnimation) ? percentAnimation[0] : percentAnimation).totalDuration();
594      }
595
596      return i > 1 ? _parsePosition(animation, position.substr(0, i - 1), percentAnimation) + offset : clippedDuration + offset;
597    }
598
599    return position == null ? clippedDuration : +position;
600  },
601      _createTweenType = function _createTweenType(type, params, timeline) {
602    var isLegacy = _isNumber(params[1]),
603        varsIndex = (isLegacy ? 2 : 1) + (type < 2 ? 0 : 1),
604        vars = params[varsIndex],
605        irVars,
606        parent;
607
608    isLegacy && (vars.duration = params[1]);
609    vars.parent = timeline;
610
611    if (type) {
612      irVars = vars;
613      parent = timeline;
614
615      while (parent && !("immediateRender" in irVars)) {
616        irVars = parent.vars.defaults || {};
617        parent = _isNotFalse(parent.vars.inherit) && parent.parent;
618      }
619
620      vars.immediateRender = _isNotFalse(irVars.immediateRender);
621      type < 2 ? vars.runBackwards = 1 : vars.startAt = params[varsIndex - 1];
622    }
623
624    return new Tween(params[0], vars, params[varsIndex + 1]);
625  },
626      _conditionalReturn = function _conditionalReturn(value, func) {
627    return value || value === 0 ? func(value) : func;
628  },
629      _clamp = function _clamp(min, max, value) {
630    return value < min ? min : value > max ? max : value;
631  },
632      getUnit = function getUnit(value, v) {
633    return !_isString(value) || !(v = _unitExp.exec(value)) ? "" : v[1];
634  },
635      clamp = function clamp(min, max, value) {
636    return _conditionalReturn(value, function (v) {
637      return _clamp(min, max, v);
638    });
639  },
640      _slice = [].slice,
641      _isArrayLike = function _isArrayLike(value, nonEmpty) {
642    return value && _isObject(value) && "length" in value && (!nonEmpty && !value.length || value.length - 1 in value && _isObject(value[0])) && !value.nodeType && value !== _win;
643  },
644      _flatten = function _flatten(ar, leaveStrings, accumulator) {
645    if (accumulator === void 0) {
646      accumulator = [];
647    }
648
649    return ar.forEach(function (value) {
650      var _accumulator;
651
652      return _isString(value) && !leaveStrings || _isArrayLike(value, 1) ? (_accumulator = accumulator).push.apply(_accumulator, toArray(value)) : accumulator.push(value);
653    }) || accumulator;
654  },
655      toArray = function toArray(value, scope, leaveStrings) {
656    return _context && !scope && _context.selector ? _context.selector(value) : _isString(value) && !leaveStrings && (_coreInitted || !_wake()) ? _slice.call((scope || _doc).querySelectorAll(value), 0) : _isArray(value) ? _flatten(value, leaveStrings) : _isArrayLike(value) ? _slice.call(value, 0) : value ? [value] : [];
657  },
658      selector = function selector(value) {
659    value = toArray(value)[0] || _warn("Invalid scope") || {};
660    return function (v) {
661      var el = value.current || value.nativeElement || value;
662      return toArray(v, el.querySelectorAll ? el : el === value ? _warn("Invalid scope") || _doc.createElement("div") : value);
663    };
664  },
665      shuffle = function shuffle(a) {
666    return a.sort(function () {
667      return .5 - Math.random();
668    });
669  },
670      distribute = function distribute(v) {
671    if (_isFunction(v)) {
672      return v;
673    }
674
675    var vars = _isObject(v) ? v : {
676      each: v
677    },
678        ease = _parseEase(vars.ease),
679        from = vars.from || 0,
680        base = parseFloat(vars.base) || 0,
681        cache = {},
682        isDecimal = from > 0 && from < 1,
683        ratios = isNaN(from) || isDecimal,
684        axis = vars.axis,
685        ratioX = from,
686        ratioY = from;
687
688    if (_isString(from)) {
689      ratioX = ratioY = {
690        center: .5,
691        edges: .5,
692        end: 1
693      }[from] || 0;
694    } else if (!isDecimal && ratios) {
695      ratioX = from[0];
696      ratioY = from[1];
697    }
698
699    return function (i, target, a) {
700      var l = (a || vars).length,
701          distances = cache[l],
702          originX,
703          originY,
704          x,
705          y,
706          d,
707          j,
708          max,
709          min,
710          wrapAt;
711
712      if (!distances) {
713        wrapAt = vars.grid === "auto" ? 0 : (vars.grid || [1, _bigNum])[1];
714
715        if (!wrapAt) {
716          max = -_bigNum;
717
718          while (max < (max = a[wrapAt++].getBoundingClientRect().left) && wrapAt < l) {}
719
720          wrapAt < l && wrapAt--;
721        }
722
723        distances = cache[l] = [];
724        originX = ratios ? Math.min(wrapAt, l) * ratioX - .5 : from % wrapAt;
725        originY = wrapAt === _bigNum ? 0 : ratios ? l * ratioY / wrapAt - .5 : from / wrapAt | 0;
726        max = 0;
727        min = _bigNum;
728
729        for (j = 0; j < l; j++) {
730          x = j % wrapAt - originX;
731          y = originY - (j / wrapAt | 0);
732          distances[j] = d = !axis ? _sqrt(x * x + y * y) : Math.abs(axis === "y" ? y : x);
733          d > max && (max = d);
734          d < min && (min = d);
735        }
736
737        from === "random" && shuffle(distances);
738        distances.max = max - min;
739        distances.min = min;
740        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);
741        distances.b = l < 0 ? base - l : base;
742        distances.u = getUnit(vars.amount || vars.each) || 0;
743        ease = ease && l < 0 ? _invertEase(ease) : ease;
744      }
745
746      l = (distances[i] - distances.min) / distances.max || 0;
747      return _roundPrecise(distances.b + (ease ? ease(l) : l) * distances.v) + distances.u;
748    };
749  },
750      _roundModifier = function _roundModifier(v) {
751    var p = Math.pow(10, ((v + "").split(".")[1] || "").length);
752    return function (raw) {
753      var n = _roundPrecise(Math.round(parseFloat(raw) / v) * v * p);
754
755      return (n - n % 1) / p + (_isNumber(raw) ? 0 : getUnit(raw));
756    };
757  },
758      snap = function snap(snapTo, value) {
759    var isArray = _isArray(snapTo),
760        radius,
761        is2D;
762
763    if (!isArray && _isObject(snapTo)) {
764      radius = isArray = snapTo.radius || _bigNum;
765
766      if (snapTo.values) {
767        snapTo = toArray(snapTo.values);
768
769        if (is2D = !_isNumber(snapTo[0])) {
770          radius *= radius;
771        }
772      } else {
773        snapTo = _roundModifier(snapTo.increment);
774      }
775    }
776
777    return _conditionalReturn(value, !isArray ? _roundModifier(snapTo) : _isFunction(snapTo) ? function (raw) {
778      is2D = snapTo(raw);
779      return Math.abs(is2D - raw) <= radius ? is2D : raw;
780    } : function (raw) {
781      var x = parseFloat(is2D ? raw.x : raw),
782          y = parseFloat(is2D ? raw.y : 0),
783          min = _bigNum,
784          closest = 0,
785          i = snapTo.length,
786          dx,
787          dy;
788
789      while (i--) {
790        if (is2D) {
791          dx = snapTo[i].x - x;
792          dy = snapTo[i].y - y;
793          dx = dx * dx + dy * dy;
794        } else {
795          dx = Math.abs(snapTo[i] - x);
796        }
797
798        if (dx < min) {
799          min = dx;
800          closest = i;
801        }
802      }
803
804      closest = !radius || min <= radius ? snapTo[closest] : raw;
805      return is2D || closest === raw || _isNumber(raw) ? closest : closest + getUnit(raw);
806    });
807  },
808      random = function random(min, max, roundingIncrement, returnFunction) {
809    return _conditionalReturn(_isArray(min) ? !max : roundingIncrement === true ? !!(roundingIncrement = 0) : !returnFunction, function () {
810      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;
811    });
812  },
813      pipe = function pipe() {
814    for (var _len = arguments.length, functions = new Array(_len), _key = 0; _key < _len; _key++) {
815      functions[_key] = arguments[_key];
816    }
817
818    return function (value) {
819      return functions.reduce(function (v, f) {
820        return f(v);
821      }, value);
822    };
823  },
824      unitize = function unitize(func, unit) {
825    return function (value) {
826      return func(parseFloat(value)) + (unit || getUnit(value));
827    };
828  },
829      normalize = function normalize(min, max, value) {
830    return mapRange(min, max, 0, 1, value);
831  },
832      _wrapArray = function _wrapArray(a, wrapper, value) {
833    return _conditionalReturn(value, function (index) {
834      return a[~~wrapper(index)];
835    });
836  },
837      wrap = function wrap(min, max, value) {
838    var range = max - min;
839    return _isArray(min) ? _wrapArray(min, wrap(0, min.length), max) : _conditionalReturn(value, function (value) {
840      return (range + (value - min) % range) % range + min;
841    });
842  },
843      wrapYoyo = function wrapYoyo(min, max, value) {
844    var range = max - min,
845        total = range * 2;
846    return _isArray(min) ? _wrapArray(min, wrapYoyo(0, min.length - 1), max) : _conditionalReturn(value, function (value) {
847      value = (total + (value - min) % total) % total || 0;
848      return min + (value > range ? total - value : value);
849    });
850  },
851      _replaceRandom = function _replaceRandom(

vendor: 531 bytes, lines 851-867

851value) {
852    var prev = 0,
853        s = "",
854        i,
855        nums,
856        end,
857        isArray;
858
859    while (~(i = value.indexOf("random(", prev))) {
860      end = value.indexOf(")", i);
861      isArray = value.charAt(i + 7) === "[";
862      nums = value.substr(i + 7, end - i - 7).match(isArray ? _delimitedValueExp : _strictNumExp);
863      s += value.substr(prev, i - prev) + random(isArray ? nums : +nums[0], isArray ? 0 : +nums[1], +nums[2] || 1e-5);
864      prev = end + 1;
865    }
866
867    return s + value.substr(prev, value.length - prev

vendor: 14,290 bytes, lines 867-1383

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

1383ropagateYoyoEase = function _propagateYoyoEase(timeline, isYoyo) {
1384    var child = timeline._first,
1385        ease;
1386
1387    while (child) {
1388      if (child instanceof Timeline) {
1389        _propagateYoyoEase(child, isYoyo);
1390      } else if (child.vars.yoyoEase && (!child._yoyo || !child._repeat) && child._yoyo !== isYoyo) {
1391        if (child.timeline) {
1392          _propagateYoyoEase(child.timeline, isYoyo);
1393        } else {
1394          ease = child._ease;
1395          child._ease = child._yEase;
1396          child._yEase = ease;
1397          child._yoyo = isYoyo;
1398        }
1399      }
1400
1401      child = child._next;
1402    }

vendor: 3,445 bytes, lines 1402-1513

1402
1403  },
1404      _parseEase = function _parseEase(ease, defaultEase) {
1405    return !ease ? defaultEase : (_isFunction(ease) ? ease : _easeMap[ease] || _configEaseFromString(ease)) || defaultEase;
1406  },
1407      _insertEase = function _insertEase(names, easeIn, easeOut, easeInOut) {
1408    if (easeOut === void 0) {
1409      easeOut = function easeOut(p) {
1410        return 1 - easeIn(1 - p);
1411      };
1412    }
1413
1414    if (easeInOut === void 0) {
1415      easeInOut = function easeInOut(p) {
1416        return p < .5 ? easeIn(p * 2) / 2 : 1 - easeIn((1 - p) * 2) / 2;
1417      };
1418    }
1419
1420    var ease = {
1421      easeIn: easeIn,
1422      easeOut: easeOut,
1423      easeInOut: easeInOut
1424    },
1425        lowercaseName;
1426
1427    _forEachName(names, function (name) {
1428      _easeMap[name] = _globals[name] = ease;
1429      _easeMap[lowercaseName = name.toLowerCase()] = easeOut;
1430
1431      for (var p in ease) {
1432        _easeMap[lowercaseName + (p === "easeIn" ? ".in" : p === "easeOut" ? ".out" : ".inOut")] = _easeMap[name + "." + p] = ease[p];
1433      }
1434    });
1435
1436    return ease;
1437  },
1438      _easeInOutFromOut = function _easeInOutFromOut(easeOut) {
1439    return function (p) {
1440      return p < .5 ? (1 - easeOut(1 - p * 2)) / 2 : .5 + easeOut((p - .5) * 2) / 2;
1441    };
1442  },
1443      _configElastic = function _configElastic(type, amplitude, period) {
1444    var p1 = amplitude >= 1 ? amplitude : 1,
1445        p2 = (period || (type ? .3 : .45)) / (amplitude < 1 ? amplitude : 1),
1446        p3 = p2 / _2PI * (Math.asin(1 / p1) || 0),
1447        easeOut = function easeOut(p) {
1448      return p === 1 ? 1 : p1 * Math.pow(2, -10 * p) * _sin((p - p3) * p2) + 1;
1449    },
1450        ease = type === "out" ? easeOut : type === "in" ? function (p) {
1451      return 1 - easeOut(1 - p);
1452    } : _easeInOutFromOut(easeOut);
1453
1454    p2 = _2PI / p2;
1455
1456    ease.config = function (amplitude, period) {
1457      return _configElastic(type, amplitude, period);
1458    };
1459
1460    return ease;
1461  },
1462      _configBack = function _configBack(type, overshoot) {
1463    if (overshoot === void 0) {
1464      overshoot = 1.70158;
1465    }
1466
1467    var easeOut = function easeOut(p) {
1468      return p ? --p * p * ((overshoot + 1) * p + overshoot) + 1 : 0;
1469    },
1470        ease = type === "out" ? easeOut : type === "in" ? function (p) {
1471      return 1 - easeOut(1 - p);
1472    } : _easeInOutFromOut(easeOut);
1473
1474    ease.config = function (overshoot) {
1475      return _configBack(type, overshoot);
1476    };
1477
1478    return ease;
1479  };
1480
1481  _forEachName("Linear,Quad,Cubic,Quart,Quint,Strong", function (name, i) {
1482    var power = i < 5 ? i + 1 : i;
1483
1484    _insertEase(name + ",Power" + (power - 1), i ? function (p) {
1485      return Math.pow(p, power);
1486    } : function (p) {
1487      return p;
1488    }, function (p) {
1489      return 1 - Math.pow(1 - p, power);
1490    }, function (p) {
1491      return p < .5 ? Math.pow(p * 2, power) / 2 : 1 - Math.pow((1 - p) * 2, power) / 2;
1492    });
1493  });
1494
1495  _easeMap.Linear.easeNone = _easeMap.none = _easeMap.Linear.easeIn;
1496
1497  _insertEase("Elastic", _configElastic("in"), _configElastic("out"), _configElastic());
1498
1499  (function (n, c) {
1500    var n1 = 1 / c,
1501        n2 = 2 * n1,
1502        n3 = 2.5 * n1,
1503        easeOut = function easeOut(p) {
1504      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;
1505    };
1506
1507    _insertEase("Bounce", function (p) {
1508      return 1 - easeOut(1 - p);
1509    }, easeOut);
1510  })(7.5625, 2.75);
1511
1512  _insertEase("Expo", function (p) {
1513    return

vendor: 18,509 bytes, lines 1513-2088

1513p ? Math.pow(2, 10 * (p - 1)) : 0;
1514  });
1515
1516  _insertEase("Circ", function (p) {
1517    return -(_sqrt(1 - p * p) - 1);
1518  });
1519
1520  _insertEase("Sine", function (p) {
1521    return p === 1 ? 1 : -_cos(p * _HALF_PI) + 1;
1522  });
1523
1524  _insertEase("Back", _configBack("in"), _configBack("out"), _configBack());
1525
1526  _easeMap.SteppedEase = _easeMap.steps = _globals.SteppedEase = {
1527    config: function config(steps, immediateStart) {
1528      if (steps === void 0) {
1529        steps = 1;
1530      }
1531
1532      var p1 = 1 / steps,
1533          p2 = steps + (immediateStart ? 0 : 1),
1534          p3 = immediateStart ? 1 : 0,
1535          max = 1 - _tinyNum;
1536      return function (p) {
1537        return ((p2 * _clamp(0, max, p) | 0) + p3) * p1;
1538      };
1539    }
1540  };
1541  _defaults.ease = _easeMap["quad.out"];
1542
1543  _forEachName("onComplete,onUpdate,onStart,onRepeat,onReverseComplete,onInterrupt", function (name) {
1544    return _callbackNames += name + "," + name + "Params,";
1545  });
1546
1547  var GSCache = function GSCache(target, harness) {
1548    this.id = _gsID++;
1549    target._gsap = this;
1550    this.target = target;
1551    this.harness = harness;
1552    this.get = harness ? harness.get : _getProperty;
1553    this.set = harness ? harness.getSetter : _getSetter;
1554  };
1555  var Animation = function () {
1556    function Animation(vars) {
1557      this.vars = vars;
1558      this._delay = +vars.delay || 0;
1559
1560      if (this._repeat = vars.repeat === Infinity ? -2 : vars.repeat || 0) {
1561        this._rDelay = vars.repeatDelay || 0;
1562        this._yoyo = !!vars.yoyo || !!vars.yoyoEase;
1563      }
1564
1565      this._ts = 1;
1566
1567      _setDuration(this, +vars.duration, 1, 1);
1568
1569      this.data = vars.data;
1570
1571      if (_context) {
1572        this._ctx = _context;
1573
1574        _context.data.push(this);
1575      }
1576
1577      _tickerActive || _ticker.wake();
1578    }
1579
1580    var _proto = Animation.prototype;
1581
1582    _proto.delay = function delay(value) {
1583      if (value || value === 0) {
1584        this.parent && this.parent.smoothChildTiming && this.startTime(this._start + value - this._delay);
1585        this._delay = value;
1586        return this;
1587      }
1588
1589      return this._delay;
1590    };
1591
1592    _proto.duration = function duration(value) {
1593      return arguments.length ? this.totalDuration(this._repeat > 0 ? value + (value + this._rDelay) * this._repeat : value) : this.totalDuration() && this._dur;
1594    };
1595
1596    _proto.totalDuration = function totalDuration(value) {
1597      if (!arguments.length) {
1598        return this._tDur;
1599      }
1600
1601      this._dirty = 0;
1602      return _setDuration(this, this._repeat < 0 ? value : (value - this._repeat * this._rDelay) / (this._repeat + 1));
1603    };
1604
1605    _proto.totalTime = function totalTime(_totalTime, suppressEvents) {
1606      _wake();
1607
1608      if (!arguments.length) {
1609        return this._tTime;
1610      }
1611
1612      var parent = this._dp;
1613
1614      if (parent && parent.smoothChildTiming && this._ts) {
1615        _alignPlayhead(this, _totalTime);
1616
1617        !parent._dp || parent.parent || _postAddChecks(parent, this);
1618
1619        while (parent && parent.parent) {
1620          if (parent.parent._time !== parent._start + (parent._ts >= 0 ? parent._tTime / parent._ts : (parent.totalDuration() - parent._tTime) / -parent._ts)) {
1621            parent.totalTime(parent._tTime, true);
1622          }
1623
1624          parent = parent.parent;
1625        }
1626
1627        if (!this.parent && this._dp.autoRemoveChildren && (this._ts > 0 && _totalTime < this._tDur || this._ts < 0 && _totalTime > 0 || !this._tDur && !_totalTime)) {
1628          _addToTimeline(this._dp, this, this._start - this._delay);
1629        }
1630      }
1631
1632      if (this._tTime !== _totalTime || !this._dur && !suppressEvents || this._initted && Math.abs(this._zTime) === _tinyNum || !_totalTime && !this._initted && (this.add || this._ptLookup)) {
1633        this._ts || (this._pTime = _totalTime);
1634
1635        _lazySafeRender(this, _totalTime, suppressEvents);
1636      }
1637
1638      return this;
1639    };
1640
1641    _proto.time = function time(value, suppressEvents) {
1642      return arguments.length ? this.totalTime(Math.min(this.totalDuration(), value + _elapsedCycleDuration(this)) % (this._dur + this._rDelay) || (value ? this._dur : 0), suppressEvents) : this._time;
1643    };
1644
1645    _proto.totalProgress = function totalProgress(value, suppressEvents) {
1646      return arguments.length ? this.totalTime(this.totalDuration() * value, suppressEvents) : this.totalDuration() ? Math.min(1, this._tTime / this._tDur) : this.rawTime() > 0 ? 1 : 0;
1647    };
1648
1649    _proto.progress = function progress(value, suppressEvents) {
1650      return arguments.length ? this.totalTime(this.duration() * (this._yoyo && !(this.iteration() & 1) ? 1 - value : value) + _elapsedCycleDuration(this), suppressEvents) : this.duration() ? Math.min(1, this._time / this._dur) : this.rawTime() > 0 ? 1 : 0;
1651    };
1652
1653    _proto.iteration = function iteration(value, suppressEvents) {
1654      var cycleDuration = this.duration() + this._rDelay;
1655
1656      return arguments.length ? this.totalTime(this._time + (value - 1) * cycleDuration, suppressEvents) : this._repeat ? _animationCycle(this._tTime, cycleDuration) + 1 : 1;
1657    };
1658
1659    _proto.timeScale = function timeScale(value, suppressEvents) {
1660      if (!arguments.length) {
1661        return this._rts === -_tinyNum ? 0 : this._rts;
1662      }
1663
1664      if (this._rts === value) {
1665        return this;
1666      }
1667
1668      var tTime = this.parent && this._ts ? _parentToChildTotalTime(this.parent._time, this) : this._tTime;
1669      this._rts = +value || 0;
1670      this._ts = this._ps || value === -_tinyNum ? 0 : this._rts;
1671      this.totalTime(_clamp(-Math.abs(this._delay), this._tDur, tTime), suppressEvents !== false);
1672
1673      _setEnd(this);
1674
1675      return _recacheAncestors(this);
1676    };
1677
1678    _proto.paused = function paused(value) {
1679      if (!arguments.length) {
1680        return this._ps;
1681      }
1682
1683      if (this._ps !== value) {
1684        this._ps = value;
1685
1686        if (value) {
1687          this._pTime = this._tTime || Math.max(-this._delay, this.rawTime());
1688          this._ts = this._act = 0;
1689        } else {
1690          _wake();
1691
1692          this._ts = this._rts;
1693          this.totalTime(this.parent && !this.parent.smoothChildTiming ? this.rawTime() : this._tTime || this._pTime, this.progress() === 1 && Math.abs(this._zTime) !== _tinyNum && (this._tTime -= _tinyNum));
1694        }
1695      }
1696
1697      return this;
1698    };
1699
1700    _proto.startTime = function startTime(value) {
1701      if (arguments.length) {
1702        this._start = value;
1703        var parent = this.parent || this._dp;
1704        parent && (parent._sort || !this.parent) && _addToTimeline(parent, this, value - this._delay);
1705        return this;
1706      }
1707
1708      return this._start;
1709    };
1710
1711    _proto.endTime = function endTime(includeRepeats) {
1712      return this._start + (_isNotFalse(includeRepeats) ? this.totalDuration() : this.duration()) / Math.abs(this._ts || 1);
1713    };
1714
1715    _proto.rawTime = function rawTime(wrapRepeats) {
1716      var parent = this.parent || this._dp;
1717      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);
1718    };
1719
1720    _proto.revert = function revert(config) {
1721      if (config === void 0) {
1722        config = _revertConfig;
1723      }
1724
1725      var prevIsReverting = _reverting;
1726      _reverting = config;
1727
1728      if (this._initted || this._startAt) {
1729        this.timeline && this.timeline.revert(config);
1730        this.totalTime(-0.01, config.suppressEvents);
1731      }
1732
1733      this.data !== "nested" && config.kill !== false && this.kill();
1734      _reverting = prevIsReverting;
1735      return this;
1736    };
1737
1738    _proto.globalTime = function globalTime(rawTime) {
1739      var animation = this,
1740          time = arguments.length ? rawTime : animation.rawTime();
1741
1742      while (animation) {
1743        time = animation._start + time / (Math.abs(animation._ts) || 1);
1744        animation = animation._dp;
1745      }
1746
1747      return !this.parent && this._sat ? this._sat.globalTime(rawTime) : time;
1748    };
1749
1750    _proto.repeat = function repeat(value) {
1751      if (arguments.length) {
1752        this._repeat = value === Infinity ? -2 : value;
1753        return _onUpdateTotalDuration(this);
1754      }
1755
1756      return this._repeat === -2 ? Infinity : this._repeat;
1757    };
1758
1759    _proto.repeatDelay = function repeatDelay(value) {
1760      if (arguments.length) {
1761        var time = this._time;
1762        this._rDelay = value;
1763
1764        _onUpdateTotalDuration(this);
1765
1766        return time ? this.time(time) : this;
1767      }
1768
1769      return this._rDelay;
1770    };
1771
1772    _proto.yoyo = function yoyo(value) {
1773      if (arguments.length) {
1774        this._yoyo = value;
1775        return this;
1776      }
1777
1778      return this._yoyo;
1779    };
1780
1781    _proto.seek = function seek(position, suppressEvents) {
1782      return this.totalTime(_parsePosition(this, position), _isNotFalse(suppressEvents));
1783    };
1784
1785    _proto.restart = function restart(includeDelay, suppressEvents) {
1786      return this.play().totalTime(includeDelay ? -this._delay : 0, _isNotFalse(suppressEvents));
1787    };
1788
1789    _proto.play = function play(from, suppressEvents) {
1790      from != null && this.seek(from, suppressEvents);
1791      return this.reversed(false).paused(false);
1792    };
1793
1794    _proto.reverse = function reverse(from, suppressEvents) {
1795      from != null && this.seek(from || this.totalDuration(), suppressEvents);
1796      return this.reversed(true).paused(false);
1797    };
1798
1799    _proto.pause = function pause(atTime, suppressEvents) {
1800      atTime != null && this.seek(atTime, suppressEvents);
1801      return this.paused(true);
1802    };
1803
1804    _proto.resume = function resume() {
1805      return this.paused(false);
1806    };
1807
1808    _proto.reversed = function reversed(value) {
1809      if (arguments.length) {
1810        !!value !== this.reversed() && this.timeScale(-this._rts || (value ? -_tinyNum : 0));
1811        return this;
1812      }
1813
1814      return this._rts < 0;
1815    };
1816
1817    _proto.invalidate = function invalidate() {
1818      this._initted = this._act = 0;
1819      this._zTime = -_tinyNum;
1820      return this;
1821    };
1822
1823    _proto.isActive = function isActive() {
1824      var parent = this.parent || this._dp,
1825          start = this._start,
1826          rawTime;
1827      return !!(!parent || this._ts && this._initted && parent.isActive() && (rawTime = parent.rawTime(true)) >= start && rawTime < this.endTime(true) - _tinyNum);
1828    };
1829
1830    _proto.eventCallback = function eventCallback(type, callback, params) {
1831      var vars = this.vars;
1832
1833      if (arguments.length > 1) {
1834        if (!callback) {
1835          delete vars[type];
1836        } else {
1837          vars[type] = callback;
1838          params && (vars[type + "Params"] = params);
1839          type === "onUpdate" && (this._onUpdate = callback);
1840        }
1841
1842        return this;
1843      }
1844
1845      return vars[type];
1846    };
1847
1848    _proto.then = function then(onFulfilled) {
1849      var self = this;
1850      return new Promise(function (resolve) {
1851        var f = _isFunction(onFulfilled) ? onFulfilled : _passThrough,
1852            _resolve = function _resolve() {
1853          var _then = self.then;
1854          self.then = null;
1855          _isFunction(f) && (f = f(self)) && (f.then || f === self) && (self.then = _then);
1856          resolve(f);
1857          self.then = _then;
1858        };
1859
1860        if (self._initted && self.totalProgress() === 1 && self._ts >= 0 || !self._tTime && self._ts < 0) {
1861          _resolve();
1862        } else {
1863          self._prom = _resolve;
1864        }
1865      });
1866    };
1867
1868    _proto.kill = function kill() {
1869      _interrupt(this);
1870    };
1871
1872    return Animation;
1873  }();
1874
1875  _setDefaults(Animation.prototype, {
1876    _time: 0,
1877    _start: 0,
1878    _end: 0,
1879    _tTime: 0,
1880    _tDur: 0,
1881    _dirty: 0,
1882    _repeat: 0,
1883    _yoyo: false,
1884    parent: null,
1885    _initted: false,
1886    _rDelay: 0,
1887    _ts: 1,
1888    _dp: 0,
1889    ratio: 0,
1890    _zTime: -_tinyNum,
1891    _prom: 0,
1892    _ps: false,
1893    _rts: 1
1894  });
1895
1896  var Timeline = function (_Animation) {
1897    _inheritsLoose(Timeline, _Animation);
1898
1899    function Timeline(vars, position) {
1900      var _this;
1901
1902      if (vars === void 0) {
1903        vars = {};
1904      }
1905
1906      _this = _Animation.call(this, vars) || this;
1907      _this.labels = {};
1908      _this.smoothChildTiming = !!vars.smoothChildTiming;
1909      _this.autoRemoveChildren = !!vars.autoRemoveChildren;
1910      _this._sort = _isNotFalse(vars.sortChildren);
1911      _globalTimeline && _addToTimeline(vars.parent || _globalTimeline, _assertThisInitialized(_this), position);
1912      vars.reversed && _this.reverse();
1913      vars.paused && _this.paused(true);
1914      vars.scrollTrigger && _scrollTrigger(_assertThisInitialized(_this), vars.scrollTrigger);
1915      return _this;
1916    }
1917
1918    var _proto2 = Timeline.prototype;
1919
1920    _proto2.to = function to(targets, vars, position) {
1921      _createTweenType(0, arguments, this);
1922
1923      return this;
1924    };
1925
1926    _proto2.from = function from(targets, vars, position) {
1927      _createTweenType(1, arguments, this);
1928
1929      return this;
1930    };
1931
1932    _proto2.fromTo = function fromTo(targets, fromVars, toVars, position) {
1933      _createTweenType(2, arguments, this);
1934
1935      return this;
1936    };
1937
1938    _proto2.set = function set(targets, vars, position) {
1939      vars.duration = 0;
1940      vars.parent = this;
1941      _inheritDefaults(vars).repeatDelay || (vars.repeat = 0);
1942      vars.immediateRender = !!vars.immediateRender;
1943      new Tween(targets, vars, _parsePosition(this, position), 1);
1944      return this;
1945    };
1946
1947    _proto2.call = function call(callback, params, position) {
1948      return _addToTimeline(this, Tween.delayedCall(0, callback, params), position);
1949    };
1950
1951    _proto2.staggerTo = function staggerTo(targets, duration, vars, stagger, position, onCompleteAll, onCompleteAllParams) {
1952      vars.duration = duration;
1953      vars.stagger = vars.stagger || stagger;
1954      vars.onComplete = onCompleteAll;
1955      vars.onCompleteParams = onCompleteAllParams;
1956      vars.parent = this;
1957      new Tween(targets, vars, _parsePosition(this, position));
1958      return this;
1959    };
1960
1961    _proto2.staggerFrom = function staggerFrom(targets, duration, vars, stagger, position, onCompleteAll, onCompleteAllParams) {
1962      vars.runBackwards = 1;
1963      _inheritDefaults(vars).immediateRender = _isNotFalse(vars.immediateRender);
1964      return this.staggerTo(targets, duration, vars, stagger, position, onCompleteAll, onCompleteAllParams);
1965    };
1966
1967    _proto2.staggerFromTo = function staggerFromTo(targets, duration, fromVars, toVars, stagger, position, onCompleteAll, onCompleteAllParams) {
1968      toVars.startAt = fromVars;
1969      _inheritDefaults(toVars).immediateRender = _isNotFalse(toVars.immediateRender);
1970      return this.staggerTo(targets, duration, toVars, stagger, position, onCompleteAll, onCompleteAllParams);
1971    };
1972
1973    _proto2.render = function render(totalTime, suppressEvents, force) {
1974      var prevTime = this._time,
1975          tDur = this._dirty ? this.totalDuration() : this._tDur,
1976          dur = this._dur,
1977          tTime = totalTime <= 0 ? 0 : _roundPrecise(totalTime),
1978          crossingStart = this._zTime < 0 !== totalTime < 0 && (this._initted || !dur),
1979          time,
1980          child,
1981          next,
1982          iteration,
1983          cycleDuration,
1984          prevPaused,
1985          pauseTween,
1986          timeScale,
1987          prevStart,
1988          prevIteration,
1989          yoyo,
1990          isYoyo;
1991      this !== _globalTimeline && tTime > tDur && totalTime >= 0 && (tTime = tDur);
1992
1993      if (tTime !== this._tTime || force || crossingStart) {
1994        if (prevTime !== this._time && dur) {
1995          tTime += this._time - prevTime;
1996          totalTime += this._time - prevTime;
1997        }
1998
1999        time = tTime;
2000        prevStart = this._start;
2001        timeScale = this._ts;
2002        prevPaused = !timeScale;
2003
2004        if (crossingStart) {
2005          dur || (prevTime = this._zTime);
2006          (totalTime || !suppressEvents) && (this._zTime = totalTime);
2007        }
2008
2009        if (this._repeat) {
2010          yoyo = this._yoyo;
2011          cycleDuration = dur + this._rDelay;
2012
2013          if (this._repeat < -1 && totalTime < 0) {
2014            return this.totalTime(cycleDuration * 100 + totalTime, suppressEvents, force);
2015          }
2016
2017          time = _roundPrecise(tTime % cycleDuration);
2018
2019          if (tTime === tDur) {
2020            iteration = this._repeat;
2021            time = dur;
2022          } else {
2023            iteration = ~~(tTime / cycleDuration);
2024
2025            if (iteration && iteration === tTime / cycleDuration) {
2026              time = dur;
2027              iteration--;
2028            }
2029
2030            time > dur && (time = dur);
2031          }
2032
2033          prevIteration = _animationCycle(this._tTime, cycleDuration);
2034          !prevTime && this._tTime && prevIteration !== iteration && this._tTime - prevIteration * cycleDuration - this._dur <= 0 && (prevIteration = iteration);
2035
2036          if (yoyo && iteration & 1) {
2037            time = dur - time;
2038            isYoyo = 1;
2039          }
2040
2041          if (iteration !== prevIteration && !this._lock) {
2042            var rewinding = yoyo && prevIteration & 1,
2043                doesWrap = rewinding === (yoyo && iteration & 1);
2044            iteration < prevIteration && (rewinding = !rewinding);
2045            prevTime = rewinding ? 0 : tTime % dur ? dur : tTime;
2046            this._lock = 1;
2047            this.render(prevTime || (isYoyo ? 0 : _roundPrecise(iteration * cycleDuration)), suppressEvents, !dur)._lock = 0;
2048            this._tTime = tTime;
2049            !suppressEvents && this.parent && _callback(this, "onRepeat");
2050            this.vars.repeatRefresh && !isYoyo && (this.invalidate()._lock = 1);
2051
2052            if (prevTime && prevTime !== this._time || prevPaused !== !this._ts || this.vars.onRepeat && !this.parent && !this._act) {
2053              return this;
2054            }
2055
2056            dur = this._dur;
2057            tDur = this._tDur;
2058
2059            if (doesWrap) {
2060              this._lock = 2;
2061              prevTime = rewinding ? dur : -0.0001;
2062              this.render(prevTime, true);
2063              this.vars.repeatRefresh && !isYoyo && this.invalidate();
2064            }
2065
2066            this._lock = 0;
2067
2068            if (!this._ts && !prevPaused) {
2069              return this;
2070            }
2071
2072            _propagateYoyoEase(this, isYoyo);
2073          }
2074        }
2075
2076        if (this._hasPause && !this._forcing && this._lock < 2) {
2077          pauseTween = _findNextPauseTween(this, _roundPrecise(prevTime), _roundPrecise(time));
2078
2079          if (pauseTween) {
2080            tTime -= time - (time = pauseTween._start);
2081          }
2082        }
2083
2084        this._tTime = tTime;
2085        this._time = time;
2086        this._act = !timeScale;
2087
2088        if (!this._initted) {

vendor: 15,202 bytes, lines 2089-2621

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

vendor: 9,840 bytes, lines 2622-2908

2622    _isFunction(end) && (end = end(index || 0, target, targets));
2623    var currentValue = target[prop],
2624        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](),
2625        setter = !_isFunction(currentValue) ? _setterPlain : funcParam ? _setterFuncWithParam : _setterFunc,
2626        pt;
2627
2628    if (_isString(end)) {
2629      if (~end.indexOf("random(")) {
2630        end = _replaceRandom(end);
2631      }
2632
2633      if (end.charAt(1) === "=") {
2634        pt = _parseRelative(parsedStart, end) + (getUnit(parsedStart) || 0);
2635
2636        if (pt || pt === 0) {
2637          end = pt;
2638        }
2639      }
2640    }
2641
2642    if (!optional || parsedStart !== end || _forceAllPropTweens) {
2643      if (!isNaN(parsedStart * end) && end !== "") {
2644        pt = new PropTween(this._pt, target, prop, +parsedStart || 0, end - (parsedStart || 0), typeof currentValue === "boolean" ? _renderBoolean : _renderPlain, 0, setter);
2645        funcParam && (pt.fp = funcParam);
2646        modifier && pt.modifier(modifier, this, target);
2647        return this._pt = pt;
2648      }
2649
2650      !currentValue && !(prop in target) && _missingPlugin(prop, end);
2651      return _addComplexStringPropTween.call(this, target, prop, parsedStart, end, setter, stringFilter || _config.stringFilter, funcParam);
2652    }
2653  },
2654      _processVars = function _processVars(vars, index, target, targets, tween) {
2655    _isFunction(vars) && (vars = _parseFuncOrString(vars, tween, index, target, targets));
2656
2657    if (!_isObject(vars) || vars.style && vars.nodeType || _isArray(vars) || _isTypedArray(vars)) {
2658      return _isString(vars) ? _parseFuncOrString(vars, tween, index, target, targets) : vars;
2659    }
2660
2661    var copy = {},
2662        p;
2663
2664    for (p in vars) {
2665      copy[p] = _parseFuncOrString(vars[p], tween, index, target, targets);
2666    }
2667
2668    return copy;
2669  },
2670      _checkPlugin = function _checkPlugin(property, vars, tween, index, target, targets) {
2671    var plugin, pt, ptLookup, i;
2672
2673    if (_plugins[property] && (plugin = new _plugins[property]()).init(target, plugin.rawVars ? vars[property] : _processVars(vars[property], index, target, targets, tween), tween, index, targets) !== false) {
2674      tween._pt = pt = new PropTween(tween._pt, target, property, 0, 1, plugin.render, plugin, 0, plugin.priority);
2675
2676      if (tween !== _quickTween) {
2677        ptLookup = tween._ptLookup[tween._targets.indexOf(target)];
2678        i = plugin._props.length;
2679
2680        while (i--) {
2681          ptLookup[plugin._props[i]] = pt;
2682        }
2683      }
2684    }
2685
2686    return plugin;
2687  },
2688      _overwritingTween,
2689      _forceAllPropTweens,
2690      _initTween = function _initTween(tween, time, tTime) {
2691    var vars = tween.vars,
2692        ease = vars.ease,
2693        startAt = vars.startAt,
2694        immediateRender = vars.immediateRender,
2695        lazy = vars.lazy,
2696        onUpdate = vars.onUpdate,
2697        runBackwards = vars.runBackwards,
2698        yoyoEase = vars.yoyoEase,
2699        keyframes = vars.keyframes,
2700        autoRevert = vars.autoRevert,
2701        dur = tween._dur,
2702        prevStartAt = tween._startAt,
2703        targets = tween._targets,
2704        parent = tween.parent,
2705        fullTargets = parent && parent.data === "nested" ? parent.vars.targets : targets,
2706        autoOverwrite = tween._overwrite === "auto" && !_suppressOverwrites,
2707        tl = tween.timeline,
2708        cleanVars,
2709        i,
2710        p,
2711        pt,
2712        target,
2713        hasPriority,
2714        gsData,
2715        harness,
2716        plugin,
2717        ptLookup,
2718        index,
2719        harnessVars,
2720        overwritten;
2721    tl && (!keyframes || !ease) && (ease = "none");
2722    tween._ease = _parseEase(ease, _defaults.ease);
2723    tween._yEase = yoyoEase ? _invertEase(_parseEase(yoyoEase === true ? ease : yoyoEase, _defaults.ease)) : 0;
2724
2725    if (yoyoEase && tween._yoyo && !tween._repeat) {
2726      yoyoEase = tween._yEase;
2727      tween._yEase = tween._ease;
2728      tween._ease = yoyoEase;
2729    }
2730
2731    tween._from = !tl && !!vars.runBackwards;
2732
2733    if (!tl || keyframes && !vars.stagger) {
2734      harness = targets[0] ? _getCache(targets[0]).harness : 0;
2735      harnessVars = harness && vars[harness.prop];
2736      cleanVars = _copyExcluding(vars, _reservedProps);
2737
2738      if (prevStartAt) {
2739        prevStartAt._zTime < 0 && prevStartAt.progress(1);
2740        time < 0 && runBackwards && immediateRender && !autoRevert ? prevStartAt.render(-1, true) : prevStartAt.revert(runBackwards && dur ? _revertConfigNoKill : _startAtRevertConfig);
2741        prevStartAt._lazy = 0;
2742      }
2743
2744      if (startAt) {
2745        _removeFromParent(tween._startAt = Tween.set(targets, _setDefaults({
2746          data: "isStart",
2747          overwrite: false,
2748          parent: parent,
2749          immediateRender: true,
2750          lazy: !prevStartAt && _isNotFalse(lazy),
2751          startAt: null,
2752          delay: 0,
2753          onUpdate: onUpdate && function () {
2754            return _callback(tween, "onUpdate");
2755          },
2756          stagger: 0
2757        }, startAt)));
2758
2759        tween._startAt._dp = 0;
2760        tween._startAt._sat = tween;
2761        time < 0 && (_reverting || !immediateRender && !autoRevert) && tween._startAt.revert(_revertConfigNoKill);
2762
2763        if (immediateRender) {
2764          if (dur && time <= 0 && tTime <= 0) {
2765            time && (tween._zTime = time);
2766            return;
2767          }
2768        }
2769      } else if (runBackwards && dur) {
2770        if (!prevStartAt) {
2771          time && (immediateRender = false);
2772          p = _setDefaults({
2773            overwrite: false,
2774            data: "isFromStart",
2775            lazy: immediateRender && !prevStartAt && _isNotFalse(lazy),
2776            immediateRender: immediateRender,
2777            stagger: 0,
2778            parent: parent
2779          }, cleanVars);
2780          harnessVars && (p[harness.prop] = harnessVars);
2781
2782          _removeFromParent(tween._startAt = Tween.set(targets, p));
2783
2784          tween._startAt._dp = 0;
2785          tween._startAt._sat = tween;
2786          time < 0 && (_reverting ? tween._startAt.revert(_revertConfigNoKill) : tween._startAt.render(-1, true));
2787          tween._zTime = time;
2788
2789          if (!immediateRender) {
2790            _initTween(tween._startAt, _tinyNum, _tinyNum);
2791          } else if (!time) {
2792            return;
2793          }
2794        }
2795      }
2796
2797      tween._pt = tween._ptCache = 0;
2798      lazy = dur && _isNotFalse(lazy) || lazy && !dur;
2799
2800      for (i = 0; i < targets.length; i++) {
2801        target = targets[i];
2802        gsData = target._gsap || _harness(targets)[i]._gsap;
2803        tween._ptLookup[i] = ptLookup = {};
2804        _lazyLookup[gsData.id] && _lazyTweens.length && _lazyRender();
2805        index = fullTargets === targets ? i : fullTargets.indexOf(target);
2806
2807        if (harness && (plugin = new harness()).init(target, harnessVars || cleanVars, tween, index, fullTargets) !== false) {
2808          tween._pt = pt = new PropTween(tween._pt, target, plugin.name, 0, 1, plugin.render, plugin, 0, plugin.priority);
2809
2810          plugin._props.forEach(function (name) {
2811            ptLookup[name] = pt;
2812          });
2813
2814          plugin.priority && (hasPriority = 1);
2815        }
2816
2817        if (!harness || harnessVars) {
2818          for (p in cleanVars) {
2819            if (_plugins[p] && (plugin = _checkPlugin(p, cleanVars, tween, index, target, fullTargets))) {
2820              plugin.priority && (hasPriority = 1);
2821            } else {
2822              ptLookup[p] = pt = _addPropTween.call(tween, target, p, "get", cleanVars[p], index, fullTargets, 0, vars.stringFilter);
2823            }
2824          }
2825        }
2826
2827        tween._op && tween._op[i] && tween.kill(target, tween._op[i]);
2828
2829        if (autoOverwrite && tween._pt) {
2830          _overwritingTween = tween;
2831
2832          _globalTimeline.killTweensOf(target, ptLookup, tween.globalTime(time));
2833
2834          overwritten = !tween.parent;
2835          _overwritingTween = 0;
2836        }
2837
2838        tween._pt && lazy && (_lazyLookup[gsData.id] = 1);
2839      }
2840
2841      hasPriority && _sortPropTweensByPriority(tween);
2842      tween._onInit && tween._onInit(tween);
2843    }
2844
2845    tween._onUpdate = onUpdate;
2846    tween._initted = (!tween._op || tween._pt) && !overwritten;
2847    keyframes && time <= 0 && tl.render(_bigNum, true, true);
2848  },
2849      _updatePropTweens = function _updatePropTweens(tween, property, value, start, startIsRelative, ratio, time, skipRecursion) {
2850    var ptCache = (tween._pt && tween._ptCache || (tween._ptCache = {}))[property],
2851        pt,
2852        rootPT,
2853        lookup,
2854        i;
2855
2856    if (!ptCache) {
2857      ptCache = tween._ptCache[property] = [];
2858      lookup = tween._ptLookup;
2859      i = tween._targets.length;
2860
2861      while (i--) {
2862        pt = lookup[i][property];
2863
2864        if (pt && pt.d && pt.d._pt) {
2865          pt = pt.d._pt;
2866
2867          while (pt && pt.p !== property && pt.fp !== property) {
2868            pt = pt._next;
2869          }
2870        }
2871
2872        if (!pt) {
2873          _forceAllPropTweens = 1;
2874          tween.vars[property] = "+=0";
2875
2876          _initTween(tween, time);
2877
2878          _forceAllPropTweens = 0;
2879          return skipRecursion ? _warn(property + " not eligible for reset") : 1;
2880        }
2881
2882        ptCache.push(pt);
2883      }
2884    }
2885
2886    i = ptCache.length;
2887
2888    while (i--) {
2889      rootPT = ptCache[i];
2890      pt = rootPT._pt || rootPT;
2891      pt.s = (start || start === 0) && !startIsRelative ? start : pt.s + (start || 0) + ratio * pt.c;
2892      pt.c = value - pt.s;
2893      rootPT.e && (rootPT.e = _round(value) + getUnit(rootPT.e));
2894      rootPT.b && (rootPT.b = pt.s + getUnit(rootPT.b));
2895    }
2896  },
2897      _addAliasesToVars = function _addAliasesToVars(targets, vars) {
2898    var harness = targets[0] ? _getCache(targets[0]).harness : 0,
2899        propertyAliases = harness && harness.aliases,
2900        copy,
2901        p,
2902        i,
2903        aliases;
2904
2905    if (!propertyAliases) {
2906      return vars;
2907    }
2908

vendor: 4,984 bytes, lines 2909-3051

2909    copy = _merge({}, vars);
2910
2911    for (p in propertyAliases) {
2912      if (p in copy) {
2913        aliases = propertyAliases[p].split(",");
2914        i = aliases.length;
2915
2916        while (i--) {
2917          copy[aliases[i]] = copy[p];
2918        }
2919      }
2920    }
2921
2922    return copy;
2923  },
2924      _parseKeyframe = function _parseKeyframe(prop, obj, allProps, easeEach) {
2925    var ease = obj.ease || easeEach || "power1.inOut",
2926        p,
2927        a;
2928
2929    if (_isArray(obj)) {
2930      a = allProps[prop] || (allProps[prop] = []);
2931      obj.forEach(function (value, i) {
2932        return a.push({
2933          t: i / (obj.length - 1) * 100,
2934          v: value,
2935          e: ease
2936        });
2937      });
2938    } else {
2939      for (p in obj) {
2940        a = allProps[p] || (allProps[p] = []);
2941        p === "ease" || a.push({
2942          t: parseFloat(prop),
2943          v: obj[p],
2944          e: ease
2945        });
2946      }
2947    }
2948  },
2949      _parseFuncOrString = function _parseFuncOrString(value, tween, i, target, targets) {
2950    return _isFunction(value) ? value.call(tween, i, target, targets) : _isString(value) && ~value.indexOf("random(") ? _replaceRandom(value) : value;
2951  },
2952      _staggerTweenProps = _callbackNames + "repeat,repeatDelay,yoyo,repeatRefresh,yoyoEase,autoRevert",
2953      _staggerPropsToSkip = {};
2954
2955  _forEachName(_staggerTweenProps + ",id,stagger,delay,duration,paused,scrollTrigger", function (name) {
2956    return _staggerPropsToSkip[name] = 1;
2957  });
2958
2959  var Tween = function (_Animation2) {
2960    _inheritsLoose(Tween, _Animation2);
2961
2962    function Tween(targets, vars, position, skipInherit) {
2963      var _this3;
2964
2965      if (typeof vars === "number") {
2966        position.duration = vars;
2967        vars = position;
2968        position = null;
2969      }
2970
2971      _this3 = _Animation2.call(this, skipInherit ? vars : _inheritDefaults(vars)) || this;
2972      var _this3$vars = _this3.vars,
2973          duration = _this3$vars.duration,
2974          delay = _this3$vars.delay,
2975          immediateRender = _this3$vars.immediateRender,
2976          stagger = _this3$vars.stagger,
2977          overwrite = _this3$vars.overwrite,
2978          keyframes = _this3$vars.keyframes,
2979          defaults = _this3$vars.defaults,
2980          scrollTrigger = _this3$vars.scrollTrigger,
2981          yoyoEase = _this3$vars.yoyoEase,
2982          parent = vars.parent || _globalTimeline,
2983          parsedTargets = (_isArray(targets) || _isTypedArray(targets) ? _isNumber(targets[0]) : "length" in vars) ? [targets] : toArray(targets),
2984          tl,
2985          i,
2986          copy,
2987          l,
2988          p,
2989          curTarget,
2990          staggerFunc,
2991          staggerVarsToMerge;
2992      _this3._targets = parsedTargets.length ? _harness(parsedTargets) : _warn("GSAP target " + targets + " not found. https://gsap.com", !_config.nullTargetWarn) || [];
2993      _this3._ptLookup = [];
2994      _this3._overwrite = overwrite;
2995
2996      if (keyframes || stagger || _isFuncOrString(duration) || _isFuncOrString(delay)) {
2997        vars = _this3.vars;
2998        tl = _this3.timeline = new Timeline({
2999          data: "nested",
3000          defaults: defaults || {},
3001          targets: parent && parent.data === "nested" ? parent.vars.targets : parsedTargets
3002        });
3003        tl.kill();
3004        tl.parent = tl._dp = _assertThisInitialized(_this3);
3005        tl._start = 0;
3006
3007        if (stagger || _isFuncOrString(duration) || _isFuncOrString(delay)) {
3008          l = parsedTargets.length;
3009          staggerFunc = stagger && distribute(stagger);
3010
3011          if (_isObject(stagger)) {
3012            for (p in stagger) {
3013              if (~_staggerTweenProps.indexOf(p)) {
3014                staggerVarsToMerge || (staggerVarsToMerge = {});
3015                staggerVarsToMerge[p] = stagger[p];
3016              }
3017            }
3018          }
3019
3020          for (i = 0; i < l; i++) {
3021            copy = _copyExcluding(vars, _staggerPropsToSkip);
3022            copy.stagger = 0;
3023            yoyoEase && (copy.yoyoEase = yoyoEase);
3024            staggerVarsToMerge && _merge(copy, staggerVarsToMerge);
3025            curTarget = parsedTargets[i];
3026            copy.duration = +_parseFuncOrString(duration, _assertThisInitialized(_this3), i, curTarget, parsedTargets);
3027            copy.delay = (+_parseFuncOrString(delay, _assertThisInitialized(_this3), i, curTarget, parsedTargets) || 0) - _this3._delay;
3028
3029            if (!stagger && l === 1 && copy.delay) {
3030              _this3._delay = delay = copy.delay;
3031              _this3._start += delay;
3032              copy.delay = 0;
3033            }
3034
3035            tl.to(curTarget, copy, staggerFunc ? staggerFunc(i, curTarget, parsedTargets) : 0);
3036            tl._ease = _easeMap.none;
3037          }
3038
3039          tl.duration() ? duration = delay = 0 : _this3.timeline = 0;
3040        } else if (keyframes) {
3041          _inheritDefaults(_setDefaults(tl.vars.defaults, {
3042            ease: "none"
3043          }));
3044
3045          tl._ease = _parseEase(keyframes.ease || vars.ease || "none");
3046          var time = 0,
3047              a,
3048              kf,
3049              v;
3050
3051          if (_isArray(keyframes)) {

vendor: 6,477 bytes, lines 3052-3258

3052            keyframes.forEach(function (frame) {
3053              return tl.to(parsedTargets, frame, ">");
3054            });
3055            tl.duration();
3056          } else {
3057            copy = {};
3058
3059            for (p in keyframes) {
3060              p === "ease" || p === "easeEach" || _parseKeyframe(p, keyframes[p], copy, keyframes.easeEach);
3061            }
3062
3063            for (p in copy) {
3064              a = copy[p].sort(function (a, b) {
3065                return a.t - b.t;
3066              });
3067              time = 0;
3068
3069              for (i = 0; i < a.length; i++) {
3070                kf = a[i];
3071                v = {
3072                  ease: kf.e,
3073                  duration: (kf.t - (i ? a[i - 1].t : 0)) / 100 * duration
3074                };
3075                v[p] = kf.v;
3076                tl.to(parsedTargets, v, time);
3077                time += v.duration;
3078              }
3079            }
3080
3081            tl.duration() < duration && tl.to({}, {
3082              duration: duration - tl.duration()
3083            });
3084          }
3085        }
3086
3087        duration || _this3.duration(duration = tl.duration());
3088      } else {
3089        _this3.timeline = 0;
3090      }
3091
3092      if (overwrite === true && !_suppressOverwrites) {
3093        _overwritingTween = _assertThisInitialized(_this3);
3094
3095        _globalTimeline.killTweensOf(parsedTargets);
3096
3097        _overwritingTween = 0;
3098      }
3099
3100      _addToTimeline(parent, _assertThisInitialized(_this3), position);
3101
3102      vars.reversed && _this3.reverse();
3103      vars.paused && _this3.paused(true);
3104
3105      if (immediateRender || !duration && !keyframes && _this3._start === _roundPrecise(parent._time) && _isNotFalse(immediateRender) && _hasNoPausedAncestors(_assertThisInitialized(_this3)) && parent.data !== "nested") {
3106        _this3._tTime = -_tinyNum;
3107
3108        _this3.render(Math.max(0, -delay) || 0);
3109      }
3110
3111      scrollTrigger && _scrollTrigger(_assertThisInitialized(_this3), scrollTrigger);
3112      return _this3;
3113    }
3114
3115    var _proto3 = Tween.prototype;
3116
3117    _proto3.render = function render(totalTime, suppressEvents, force) {
3118      var prevTime = this._time,
3119          tDur = this._tDur,
3120          dur = this._dur,
3121          isNegative = totalTime < 0,
3122          tTime = totalTime > tDur - _tinyNum && !isNegative ? tDur : totalTime < _tinyNum ? 0 : totalTime,
3123          time,
3124          pt,
3125          iteration,
3126          cycleDuration,
3127          prevIteration,
3128          isYoyo,
3129          ratio,
3130          timeline,
3131          yoyoEase;
3132
3133      if (!dur) {
3134        _renderZeroDurationTween(this, totalTime, suppressEvents, force);
3135      } else if (tTime !== this._tTime || !totalTime || force || !this._initted && this._tTime || this._startAt && this._zTime < 0 !== isNegative) {
3136        time = tTime;
3137        timeline = this.timeline;
3138
3139        if (this._repeat) {
3140          cycleDuration = dur + this._rDelay;
3141
3142          if (this._repeat < -1 && isNegative) {
3143            return this.totalTime(cycleDuration * 100 + totalTime, suppressEvents, force);
3144          }
3145
3146          time = _roundPrecise(tTime % cycleDuration);
3147
3148          if (tTime === tDur) {
3149            iteration = this._repeat;
3150            time = dur;
3151          } else {
3152            iteration = ~~(tTime / cycleDuration);
3153
3154            if (iteration && iteration === _roundPrecise(tTime / cycleDuration)) {
3155              time = dur;
3156              iteration--;
3157            }
3158
3159            time > dur && (time = dur);
3160          }
3161
3162          isYoyo = this._yoyo && iteration & 1;
3163
3164          if (isYoyo) {
3165            yoyoEase = this._yEase;
3166            time = dur - time;
3167          }
3168
3169          prevIteration = _animationCycle(this._tTime, cycleDuration);
3170
3171          if (time === prevTime && !force && this._initted && iteration === prevIteration) {
3172            this._tTime = tTime;
3173            return this;
3174          }
3175
3176          if (iteration !== prevIteration) {
3177            timeline && this._yEase && _propagateYoyoEase(timeline, isYoyo);
3178
3179            if (this.vars.repeatRefresh && !isYoyo && !this._lock && this._time !== cycleDuration && this._initted) {
3180              this._lock = force = 1;
3181              this.render(_roundPrecise(cycleDuration * iteration), true).invalidate()._lock = 0;
3182            }
3183          }
3184        }
3185
3186        if (!this._initted) {
3187          if (_attemptInitTween(this, isNegative ? totalTime : time, force, suppressEvents, tTime)) {
3188            this._tTime = 0;
3189            return this;
3190          }
3191
3192          if (prevTime !== this._time && !(force && this.vars.repeatRefresh && iteration !== prevIteration)) {
3193            return this;
3194          }
3195
3196          if (dur !== this._dur) {
3197            return this.render(totalTime, suppressEvents, force);
3198          }
3199        }
3200
3201        this._tTime = tTime;
3202        this._time = time;
3203
3204        if (!this._act && this._ts) {
3205          this._act = 1;
3206          this._lazy = 0;
3207        }
3208
3209        this.ratio = ratio = (yoyoEase || this._ease)(time / dur);
3210
3211        if (this._from) {
3212          this.ratio = ratio = 1 - ratio;
3213        }
3214
3215        if (time && !prevTime && !suppressEvents && !iteration) {
3216          _callback(this, "onStart");
3217
3218          if (this._tTime !== tTime) {
3219            return this;
3220          }
3221        }
3222
3223        pt = this._pt;
3224
3225        while (pt) {
3226          pt.r(ratio, pt.d);
3227          pt = pt._next;
3228        }
3229
3230        timeline && timeline.render(totalTime < 0 ? totalTime : timeline._dur * timeline._ease(time / this._dur), suppressEvents, force) || this._startAt && (this._zTime = totalTime);
3231
3232        if (this._onUpdate && !suppressEvents) {
3233          isNegative && _rewindStartAt(this, totalTime, suppressEvents, force);
3234
3235          _callback(this, "onUpdate");
3236        }
3237
3238        this._repeat && iteration !== prevIteration && this.vars.onRepeat && !suppressEvents && this.parent && _callback(this, "onRepeat");
3239
3240        if ((tTime === this._tDur || !tTime) && this._tTime === tTime) {
3241          isNegative && !this._onUpdate && _rewindStartAt(this, totalTime, true, true);
3242          (totalTime || !dur) && (tTime === this._tDur && this._ts > 0 || !tTime && this._ts < 0) && _removeFromParent(this, 1);
3243
3244          if (!suppressEvents && !(isNegative && !prevTime) && (tTime || prevTime || isYoyo)) {
3245            _callback(this, tTime === tDur ? "onComplete" : "onReverseComplete", true);
3246
3247            this._prom && !(tTime < tDur && this.timeScale() > 0) && this._prom();
3248          }
3249        }
3250      }
3251
3252      return this;
3253    };
3254
3255    _proto3.targets = function targets() {
3256      return this._targets;
3257    };
3258

vendor: 1,310 bytes, lines 3259-3292

3259    _proto3.invalidate = function invalidate(soft) {
3260      (!soft || !this.vars.runBackwards) && (this._startAt = 0);
3261      this._pt = this._op = this._onUpdate = this._lazy = this.ratio = 0;
3262      this._ptLookup = [];
3263      this.timeline && this.timeline.invalidate(soft);
3264      return _Animation2.prototype.invalidate.call(this, soft);
3265    };
3266
3267    _proto3.resetTo = function resetTo(property, value, start, startIsRelative, skipRecursion) {
3268      _tickerActive || _ticker.wake();
3269      this._ts || this.play();
3270      var time = Math.min(this._dur, (this._dp._time - this._start) * this._ts),
3271          ratio;
3272      this._initted || _initTween(this, time);
3273      ratio = this._ease(time / this._dur);
3274
3275      if (_updatePropTweens(this, property, value, start, startIsRelative, ratio, time, skipRecursion)) {
3276        return this.resetTo(property, value, start, startIsRelative, 1);
3277      }
3278
3279      _alignPlayhead(this, 0);
3280
3281      this.parent || _addLinkedListItem(this._dp, this, "_first", "_last", this._dp._sort ? "_start" : 0);
3282      return this.render(0);
3283    };
3284
3285    _proto3.kill = function kill(targets, vars) {
3286      if (vars === void 0) {
3287        vars = "all";
3288      }
3289
3290      if (!targets && (!vars || vars === "all")) {
3291        this._lazy = this._pt = 0;
3292        return this.parent ? _interrupt(this) :

vendor: 16,527 bytes, lines 3292-3894

3292 this;
3293      }
3294
3295      if (this.timeline) {
3296        var tDur = this.timeline.totalDuration();
3297        this.timeline.killTweensOf(targets, vars, _overwritingTween && _overwritingTween.vars.overwrite !== true)._first || _interrupt(this);
3298        this.parent && tDur !== this.timeline.totalDuration() && _setDuration(this, this._dur * this.timeline._tDur / tDur, 0, 1);
3299        return this;
3300      }
3301
3302      var parsedTargets = this._targets,
3303          killingTargets = targets ? toArray(targets) : parsedTargets,
3304          propTweenLookup = this._ptLookup,
3305          firstPT = this._pt,
3306          overwrittenProps,
3307          curLookup,
3308          curOverwriteProps,
3309          props,
3310          p,
3311          pt,
3312          i;
3313
3314      if ((!vars || vars === "all") && _arraysMatch(parsedTargets, killingTargets)) {
3315        vars === "all" && (this._pt = 0);
3316        return _interrupt(this);
3317      }
3318
3319      overwrittenProps = this._op = this._op || [];
3320
3321      if (vars !== "all") {
3322        if (_isString(vars)) {
3323          p = {};
3324
3325          _forEachName(vars, function (name) {
3326            return p[name] = 1;
3327          });
3328
3329          vars = p;
3330        }
3331
3332        vars = _addAliasesToVars(parsedTargets, vars);
3333      }
3334
3335      i = parsedTargets.length;
3336
3337      while (i--) {
3338        if (~killingTargets.indexOf(parsedTargets[i])) {
3339          curLookup = propTweenLookup[i];
3340
3341          if (vars === "all") {
3342            overwrittenProps[i] = vars;
3343            props = curLookup;
3344            curOverwriteProps = {};
3345          } else {
3346            curOverwriteProps = overwrittenProps[i] = overwrittenProps[i] || {};
3347            props = vars;
3348          }
3349
3350          for (p in props) {
3351            pt = curLookup && curLookup[p];
3352
3353            if (pt) {
3354              if (!("kill" in pt.d) || pt.d.kill(p) === true) {
3355                _removeLinkedListItem(this, pt, "_pt");
3356              }
3357
3358              delete curLookup[p];
3359            }
3360
3361            if (curOverwriteProps !== "all") {
3362              curOverwriteProps[p] = 1;
3363            }
3364          }
3365        }
3366      }
3367
3368      this._initted && !this._pt && firstPT && _interrupt(this);
3369      return this;
3370    };
3371
3372    Tween.to = function to(targets, vars) {
3373      return new Tween(targets, vars, arguments[2]);
3374    };
3375
3376    Tween.from = function from(targets, vars) {
3377      return _createTweenType(1, arguments);
3378    };
3379
3380    Tween.delayedCall = function delayedCall(delay, callback, params, scope) {
3381      return new Tween(callback, 0, {
3382        immediateRender: false,
3383        lazy: false,
3384        overwrite: false,
3385        delay: delay,
3386        onComplete: callback,
3387        onReverseComplete: callback,
3388        onCompleteParams: params,
3389        onReverseCompleteParams: params,
3390        callbackScope: scope
3391      });
3392    };
3393
3394    Tween.fromTo = function fromTo(targets, fromVars, toVars) {
3395      return _createTweenType(2, arguments);
3396    };
3397
3398    Tween.set = function set(targets, vars) {
3399      vars.duration = 0;
3400      vars.repeatDelay || (vars.repeat = 0);
3401      return new Tween(targets, vars);
3402    };
3403
3404    Tween.killTweensOf = function killTweensOf(targets, props, onlyActive) {
3405      return _globalTimeline.killTweensOf(targets, props, onlyActive);
3406    };
3407
3408    return Tween;
3409  }(Animation);
3410
3411  _setDefaults(Tween.prototype, {
3412    _targets: [],
3413    _lazy: 0,
3414    _startAt: 0,
3415    _op: 0,
3416    _onInit: 0
3417  });
3418
3419  _forEachName("staggerTo,staggerFrom,staggerFromTo", function (name) {
3420    Tween[name] = function () {
3421      var tl = new Timeline(),
3422          params = _slice.call(arguments, 0);
3423
3424      params.splice(name === "staggerFromTo" ? 5 : 4, 0, 0);
3425      return tl[name].apply(tl, params);
3426    };
3427  });
3428
3429  var _setterPlain = function _setterPlain(target, property, value) {
3430    return target[property] = value;
3431  },
3432      _setterFunc = function _setterFunc(target, property, value) {
3433    return target[property](value);
3434  },
3435      _setterFuncWithParam = function _setterFuncWithParam(target, property, value, data) {
3436    return target[property](data.fp, value);
3437  },
3438      _setterAttribute = function _setterAttribute(target, property, value) {
3439    return target.setAttribute(property, value);
3440  },
3441      _getSetter = function _getSetter(target, property) {
3442    return _isFunction(target[property]) ? _setterFunc : _isUndefined(target[property]) && target.setAttribute ? _setterAttribute : _setterPlain;
3443  },
3444      _renderPlain = function _renderPlain(ratio, data) {
3445    return data.set(data.t, data.p, Math.round((data.s + data.c * ratio) * 1000000) / 1000000, data);
3446  },
3447      _renderBoolean = function _renderBoolean(ratio, data) {
3448    return data.set(data.t, data.p, !!(data.s + data.c * ratio), data);
3449  },
3450      _renderComplexString = function _renderComplexString(ratio, data) {
3451    var pt = data._pt,
3452        s = "";
3453
3454    if (!ratio && data.b) {
3455      s = data.b;
3456    } else if (ratio === 1 && data.e) {
3457      s = data.e;
3458    } else {
3459      while (pt) {
3460        s = pt.p + (pt.m ? pt.m(pt.s + pt.c * ratio) : Math.round((pt.s + pt.c * ratio) * 10000) / 10000) + s;
3461        pt = pt._next;
3462      }
3463
3464      s += data.c;
3465    }
3466
3467    data.set(data.t, data.p, s, data);
3468  },
3469      _renderPropTweens = function _renderPropTweens(ratio, data) {
3470    var pt = data._pt;
3471
3472    while (pt) {
3473      pt.r(ratio, pt.d);
3474      pt = pt._next;
3475    }
3476  },
3477      _addPluginModifier = function _addPluginModifier(modifier, tween, target, property) {
3478    var pt = this._pt,
3479        next;
3480
3481    while (pt) {
3482      next = pt._next;
3483      pt.p === property && pt.modifier(modifier, tween, target);
3484      pt = next;
3485    }
3486  },
3487      _killPropTweensOf = function _killPropTweensOf(property) {
3488    var pt = this._pt,
3489        hasNonDependentRemaining,
3490        next;
3491
3492    while (pt) {
3493      next = pt._next;
3494
3495      if (pt.p === property && !pt.op || pt.op === property) {
3496        _removeLinkedListItem(this, pt, "_pt");
3497      } else if (!pt.dep) {
3498        hasNonDependentRemaining = 1;
3499      }
3500
3501      pt = next;
3502    }
3503
3504    return !hasNonDependentRemaining;
3505  },
3506      _setterWithModifier = function _setterWithModifier(target, property, value, data) {
3507    data.mSet(target, property, data.m.call(data.tween, value, data.mt), data);
3508  },
3509      _sortPropTweensByPriority = function _sortPropTweensByPriority(parent) {
3510    var pt = parent._pt,
3511        next,
3512        pt2,
3513        first,
3514        last;
3515
3516    while (pt) {
3517      next = pt._next;
3518      pt2 = first;
3519
3520      while (pt2 && pt2.pr > pt.pr) {
3521        pt2 = pt2._next;
3522      }
3523
3524      if (pt._prev = pt2 ? pt2._prev : last) {
3525        pt._prev._next = pt;
3526      } else {
3527        first = pt;
3528      }
3529
3530      if (pt._next = pt2) {
3531        pt2._prev = pt;
3532      } else {
3533        last = pt;
3534      }
3535
3536      pt = next;
3537    }
3538
3539    parent._pt = first;
3540  };
3541
3542  var PropTween = function () {
3543    function PropTween(next, target, prop, start, change, renderer, data, setter, priority) {
3544      this.t = target;
3545      this.s = start;
3546      this.c = change;
3547      this.p = prop;
3548      this.r = renderer || _renderPlain;
3549      this.d = data || this;
3550      this.set = setter || _setterPlain;
3551      this.pr = priority || 0;
3552      this._next = next;
3553
3554      if (next) {
3555        next._prev = this;
3556      }
3557    }
3558
3559    var _proto4 = PropTween.prototype;
3560
3561    _proto4.modifier = function modifier(func, tween, target) {
3562      this.mSet = this.mSet || this.set;
3563      this.set = _setterWithModifier;
3564      this.m = func;
3565      this.mt = target;
3566      this.tween = tween;
3567    };
3568
3569    return PropTween;
3570  }();
3571
3572  _forEachName(_callbackNames + "parent,duration,ease,delay,overwrite,runBackwards,startAt,yoyo,immediateRender,repeat,repeatDelay,data,paused,reversed,lazy,callbackScope,stringFilter,id,yoyoEase,stagger,inherit,repeatRefresh,keyframes,autoRevert,scrollTrigger", function (name) {
3573    return _reservedProps[name] = 1;
3574  });
3575
3576  _globals.TweenMax = _globals.TweenLite = Tween;
3577  _globals.TimelineLite = _globals.TimelineMax = Timeline;
3578  _globalTimeline = new Timeline({
3579    sortChildren: false,
3580    defaults: _defaults,
3581    autoRemoveChildren: true,
3582    id: "root",
3583    smoothChildTiming: true
3584  });
3585  _config.stringFilter = _colorStringFilter;
3586
3587  var _media = [],
3588      _listeners = {},
3589      _emptyArray = [],
3590      _lastMediaTime = 0,
3591      _contextID = 0,
3592      _dispatch = function _dispatch(type) {
3593    return (_listeners[type] || _emptyArray).map(function (f) {
3594      return f();
3595    });
3596  },
3597      _onMediaChange = function _onMediaChange() {
3598    var time = Date.now(),
3599        matches = [];
3600
3601    if (time - _lastMediaTime > 2) {
3602      _dispatch("matchMediaInit");
3603
3604      _media.forEach(function (c) {
3605        var queries = c.queries,
3606            conditions = c.conditions,
3607            match,
3608            p,
3609            anyMatch,
3610            toggled;
3611
3612        for (p in queries) {
3613          match = _win.matchMedia(queries[p]).matches;
3614          match && (anyMatch = 1);
3615
3616          if (match !== conditions[p]) {
3617            conditions[p] = match;
3618            toggled = 1;
3619          }
3620        }
3621
3622        if (toggled) {
3623          c.revert();
3624          anyMatch && matches.push(c);
3625        }
3626      });
3627
3628      _dispatch("matchMediaRevert");
3629
3630      matches.forEach(function (c) {
3631        return c.onMatch(c, function (func) {
3632          return c.add(null, func);
3633        });
3634      });
3635      _lastMediaTime = time;
3636
3637      _dispatch("matchMedia");
3638    }
3639  };
3640
3641  var Context = function () {
3642    function Context(func, scope) {
3643      this.selector = scope && selector(scope);
3644      this.data = [];
3645      this._r = [];
3646      this.isReverted = false;
3647      this.id = _contextID++;
3648      func && this.add(func);
3649    }
3650
3651    var _proto5 = Context.prototype;
3652
3653    _proto5.add = function add(name, func, scope) {
3654      if (_isFunction(name)) {
3655        scope = func;
3656        func = name;
3657        name = _isFunction;
3658      }
3659
3660      var self = this,
3661          f = function f() {
3662        var prev = _context,
3663            prevSelector = self.selector,
3664            result;
3665        prev && prev !== self && prev.data.push(self);
3666        scope && (self.selector = selector(scope));
3667        _context = self;
3668        result = func.apply(self, arguments);
3669        _isFunction(result) && self._r.push(result);
3670        _context = prev;
3671        self.selector = prevSelector;
3672        self.isReverted = false;
3673        return result;
3674      };
3675
3676      self.last = f;
3677      return name === _isFunction ? f(self, function (func) {
3678        return self.add(null, func);
3679      }) : name ? self[name] = f : f;
3680    };
3681
3682    _proto5.ignore = function ignore(func) {
3683      var prev = _context;
3684      _context = null;
3685      func(this);
3686      _context = prev;
3687    };
3688
3689    _proto5.getTweens = function getTweens() {
3690      var a = [];
3691      this.data.forEach(function (e) {
3692        return e instanceof Context ? a.push.apply(a, e.getTweens()) : e instanceof Tween && !(e.parent && e.parent.data === "nested") && a.push(e);
3693      });
3694      return a;
3695    };
3696
3697    _proto5.clear = function clear() {
3698      this._r.length = this.data.length = 0;
3699    };
3700
3701    _proto5.kill = function kill(revert, matchMedia) {
3702      var _this4 = this;
3703
3704      if (revert) {
3705        (function () {
3706          var tweens = _this4.getTweens(),
3707              i = _this4.data.length,
3708              t;
3709
3710          while (i--) {
3711            t = _this4.data[i];
3712
3713            if (t.data === "isFlip") {
3714              t.revert();
3715              t.getChildren(true, true, false).forEach(function (tween) {
3716                return tweens.splice(tweens.indexOf(tween), 1);
3717              });
3718            }
3719          }
3720
3721          tweens.map(function (t) {
3722            return {
3723              g: t._dur || t._delay || t._sat && !t._sat.vars.immediateRender ? t.globalTime(0) : -Infinity,
3724              t: t
3725            };
3726          }).sort(function (a, b) {
3727            return b.g - a.g || -Infinity;
3728          }).forEach(function (o) {
3729            return o.t.revert(revert);
3730          });
3731          i = _this4.data.length;
3732
3733          while (i--) {
3734            t = _this4.data[i];
3735
3736            if (t instanceof Timeline) {
3737              if (t.data !== "nested") {
3738                t.scrollTrigger && t.scrollTrigger.revert();
3739                t.kill();
3740              }
3741            } else {
3742              !(t instanceof Tween) && t.revert && t.revert(revert);
3743            }
3744          }
3745
3746          _this4._r.forEach(function (f) {
3747            return f(revert, _this4);
3748          });
3749
3750          _this4.isReverted = true;
3751        })();
3752      } else {
3753        this.data.forEach(function (e) {
3754          return e.kill && e.kill();
3755        });
3756      }
3757
3758      this.clear();
3759
3760      if (matchMedia) {
3761        var i = _media.length;
3762
3763        while (i--) {
3764          _media[i].id === this.id && _media.splice(i, 1);
3765        }
3766      }
3767    };
3768
3769    _proto5.revert = function revert(config) {
3770      this.kill(config || {});
3771    };
3772
3773    return Context;
3774  }();
3775
3776  var MatchMedia = function () {
3777    function MatchMedia(scope) {
3778      this.contexts = [];
3779      this.scope = scope;
3780      _context && _context.data.push(this);
3781    }
3782
3783    var _proto6 = MatchMedia.prototype;
3784
3785    _proto6.add = function add(conditions, func, scope) {
3786      _isObject(conditions) || (conditions = {
3787        matches: conditions
3788      });
3789      var context = new Context(0, scope || this.scope),
3790          cond = context.conditions = {},
3791          mq,
3792          p,
3793          active;
3794      _context && !context.selector && (context.selector = _context.selector);
3795      this.contexts.push(context);
3796      func = context.add("onMatch", func);
3797      context.queries = conditions;
3798
3799      for (p in conditions) {
3800        if (p === "all") {
3801          active = 1;
3802        } else {
3803          mq = _win.matchMedia(conditions[p]);
3804
3805          if (mq) {
3806            _media.indexOf(context) < 0 && _media.push(context);
3807            (cond[p] = mq.matches) && (active = 1);
3808            mq.addListener ? mq.addListener(_onMediaChange) : mq.addEventListener("change", _onMediaChange);
3809          }
3810        }
3811      }
3812
3813      active && func(context, function (f) {
3814        return context.add(null, f);
3815      });
3816      return this;
3817    };
3818
3819    _proto6.revert = function revert(config) {
3820      this.kill(config || {});
3821    };
3822
3823    _proto6.kill = function kill(revert) {
3824      this.contexts.forEach(function (c) {
3825        return c.kill(revert, true);
3826      });
3827    };
3828
3829    return MatchMedia;
3830  }();
3831
3832  var _gsap = {
3833    registerPlugin: function registerPlugin() {
3834      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
3835        args[_key2] = arguments[_key2];
3836      }
3837
3838      args.forEach(function (config) {
3839        return _createPlugin(config);
3840      });
3841    },
3842    timeline: function timeline(vars) {
3843      return new Timeline(vars);
3844    },
3845    getTweensOf: function getTweensOf(targets, onlyActive) {
3846      return _globalTimeline.getTweensOf(targets, onlyActive);
3847    },
3848    getProperty: function getProperty(target, property, unit, uncache) {
3849      _isString(target) && (target = toArray(target)[0]);
3850
3851      var getter = _getCache(target || {}).get,
3852          format = unit ? _passThrough : _numericIfPossible;
3853
3854      unit === "native" && (unit = "");
3855      return !target ? target : !property ? function (property, unit, uncache) {
3856        return format((_plugins[property] && _plugins[property].get || getter)(target, property, unit, uncache));
3857      } : format((_plugins[property] && _plugins[property].get || getter)(target, property, unit, uncache));
3858    },
3859    quickSetter: function quickSetter(target, property, unit) {
3860      target = toArray(target);
3861
3862      if (target.length > 1) {
3863        var setters = target.map(function (t) {
3864          return gsap.quickSetter(t, property, unit);
3865        }),
3866            l = setters.length;
3867        return function (value) {
3868          var i = l;
3869
3870          while (i--) {
3871            setters[i](value);
3872          }
3873        };
3874      }
3875
3876      target = target[0] || {};
3877
3878      var Plugin = _plugins[property],
3879          cache = _getCache(target),
3880          p = cache.harness && (cache.harness.aliases || {})[property] || property,
3881          setter = Plugin ? function (value) {
3882        var p = new Plugin();
3883        _quickTween._pt = 0;
3884        p.init(target, unit ? value + unit : value, _quickTween, 0, [target]);
3885        p.render(1, p);
3886        _quickTween._pt && _renderPropTweens(1, _quickTween);
3887      } : cache.set(target, p);
3888
3889      return Plugin ? setter : function (value) {
3890        return setter(target, p, unit ? value + unit : value, cache, 1);
3891      };
3892    },
3893    quickTo: function quickTo(target, property, vars) {
3894      var _

3894merge2;
3895
3896      var tween = gsap.to(target, _merge((_merge2 = {}, _merge2[property] = "+=0.1", _merge2.paused = true, _merge

vendor: 5,649 bytes, lines 3896-4098

38962), vars || {})),
3897          func = function func(value, start, startIsRelative) {
3898        return tween.resetTo(property, value, start, startIsRelative);
3899      };
3900
3901      func.tween = tween;
3902      return func;
3903    },
3904    isTweening: function isTweening(targets) {
3905      return _globalTimeline.getTweensOf(targets, true).length > 0;
3906    },
3907    defaults: function defaults(value) {
3908      value && value.ease && (value.ease = _parseEase(value.ease, _defaults.ease));
3909      return _mergeDeep(_defaults, value || {});
3910    },
3911    config: function config(value) {
3912      return _mergeDeep(_config, value || {});
3913    },
3914    registerEffect: function registerEffect(_ref3) {
3915      var name = _ref3.name,
3916          effect = _ref3.effect,
3917          plugins = _ref3.plugins,
3918          defaults = _ref3.defaults,
3919          extendTimeline = _ref3.extendTimeline;
3920      (plugins || "").split(",").forEach(function (pluginName) {
3921        return pluginName && !_plugins[pluginName] && !_globals[pluginName] && _warn(name + " effect requires " + pluginName + " plugin.");
3922      });
3923
3924      _effects[name] = function (targets, vars, tl) {
3925        return effect(toArray(targets), _setDefaults(vars || {}, defaults), tl);
3926      };
3927
3928      if (extendTimeline) {
3929        Timeline.prototype[name] = function (targets, vars, position) {
3930          return this.add(_effects[name](targets, _isObject(vars) ? vars : (position = vars) && {}, this), position);
3931        };
3932      }
3933    },
3934    registerEase: function registerEase(name, ease) {
3935      _easeMap[name] = _parseEase(ease);
3936    },
3937    parseEase: function parseEase(ease, defaultEase) {
3938      return arguments.length ? _parseEase(ease, defaultEase) : _easeMap;
3939    },
3940    getById: function getById(id) {
3941      return _globalTimeline.getById(id);
3942    },
3943    exportRoot: function exportRoot(vars, includeDelayedCalls) {
3944      if (vars === void 0) {
3945        vars = {};
3946      }
3947
3948      var tl = new Timeline(vars),
3949          child,
3950          next;
3951      tl.smoothChildTiming = _isNotFalse(vars.smoothChildTiming);
3952
3953      _globalTimeline.remove(tl);
3954
3955      tl._dp = 0;
3956      tl._time = tl._tTime = _globalTimeline._time;
3957      child = _globalTimeline._first;
3958
3959      while (child) {
3960        next = child._next;
3961
3962        if (includeDelayedCalls || !(!child._dur && child instanceof Tween && child.vars.onComplete === child._targets[0])) {
3963          _addToTimeline(tl, child, child._start - child._delay);
3964        }
3965
3966        child = next;
3967      }
3968
3969      _addToTimeline(_globalTimeline, tl, 0);
3970
3971      return tl;
3972    },
3973    context: function context(func, scope) {
3974      return func ? new Context(func, scope) : _context;
3975    },
3976    matchMedia: function matchMedia(scope) {
3977      return new MatchMedia(scope);
3978    },
3979    matchMediaRefresh: function matchMediaRefresh() {
3980      return _media.forEach(function (c) {
3981        var cond = c.conditions,
3982            found,
3983            p;
3984
3985        for (p in cond) {
3986          if (cond[p]) {
3987            cond[p] = false;
3988            found = 1;
3989          }
3990        }
3991
3992        found && c.revert();
3993      }) || _onMediaChange();
3994    },
3995    addEventListener: function addEventListener(type, callback) {
3996      var a = _listeners[type] || (_listeners[type] = []);
3997      ~a.indexOf(callback) || a.push(callback);
3998    },
3999    removeEventListener: function removeEventListener(type, callback) {
4000      var a = _listeners[type],
4001          i = a && a.indexOf(callback);
4002      i >= 0 && a.splice(i, 1);
4003    },
4004    utils: {
4005      wrap: wrap,
4006      wrapYoyo: wrapYoyo,
4007      distribute: distribute,
4008      random: random,
4009      snap: snap,
4010      normalize: normalize,
4011      getUnit: getUnit,
4012      clamp: clamp,
4013      splitColor: splitColor,
4014      toArray: toArray,
4015      selector: selector,
4016      mapRange: mapRange,
4017      pipe: pipe,
4018      unitize: unitize,
4019      interpolate: interpolate,
4020      shuffle: shuffle
4021    },
4022    install: _install,
4023    effects: _effects,
4024    ticker: _ticker,
4025    updateRoot: Timeline.updateRoot,
4026    plugins: _plugins,
4027    globalTimeline: _globalTimeline,
4028    core: {
4029      PropTween: PropTween,
4030      globals: _addGlobal,
4031      Tween: Tween,
4032      Timeline: Timeline,
4033      Animation: Animation,
4034      getCache: _getCache,
4035      _removeLinkedListItem: _removeLinkedListItem,
4036      reverting: function reverting() {
4037        return _reverting;
4038      },
4039      context: function context(toAdd) {
4040        if (toAdd && _context) {
4041          _context.data.push(toAdd);
4042
4043          toAdd._ctx = _context;
4044        }
4045
4046        return _context;
4047      },
4048      suppressOverwrites: function suppressOverwrites(value) {
4049        return _suppressOverwrites = value;
4050      }
4051    }
4052  };
4053
4054  _forEachName("to,from,fromTo,delayedCall,set,killTweensOf", function (name) {
4055    return _gsap[name] = Tween[name];
4056  });
4057
4058  _ticker.add(Timeline.updateRoot);
4059
4060  _quickTween = _gsap.to({}, {
4061    duration: 0
4062  });
4063
4064  var _getPluginPropTween = function _getPluginPropTween(plugin, prop) {
4065    var pt = plugin._pt;
4066
4067    while (pt && pt.p !== prop && pt.op !== prop && pt.fp !== prop) {
4068      pt = pt._next;
4069    }
4070
4071    return pt;
4072  },
4073      _addModifiers = function _addModifiers(tween, modifiers) {
4074    var targets = tween._targets,
4075        p,
4076        i,
4077        pt;
4078
4079    for (p in modifiers) {
4080      i = targets.length;
4081
4082      while (i--) {
4083        pt = tween._ptLookup[i][p];
4084
4085        if (pt && (pt = pt.d)) {
4086          if (pt._pt) {
4087            pt = _getPluginPropTween(pt, p);
4088          }
4089
4090          pt && pt.modifier && pt.modifier(modifiers[p], tween, targets[i], p);
4091        }
4092      }
4093    }
4094  },
4095      _buildModifierPlugin = function _buildModifierPlugin(name, modifier) {
4096    return {
4097      name: name,
4098

vendor: 21,125 bytes, lines 4098-4749

4098rawVars: 1,
4099      init: function init(target, vars, tween) {
4100        tween._onInit = function (tween) {
4101          var temp, p;
4102
4103          if (_isString(vars)) {
4104            temp = {};
4105
4106            _forEachName(vars, function (name) {
4107              return temp[name] = 1;
4108            });
4109
4110            vars = temp;
4111          }
4112
4113          if (modifier) {
4114            temp = {};
4115
4116            for (p in vars) {
4117              temp[p] = modifier(vars[p]);
4118            }
4119
4120            vars = temp;
4121          }
4122
4123          _addModifiers(tween, vars);
4124        };
4125      }
4126    };
4127  };
4128
4129  var gsap = _gsap.registerPlugin({
4130    name: "attr",
4131    init: function init(target, vars, tween, index, targets) {
4132      var p, pt, v;
4133      this.tween = tween;
4134
4135      for (p in vars) {
4136        v = target.getAttribute(p) || "";
4137        pt = this.add(target, "setAttribute", (v || 0) + "", vars[p], index, targets, 0, 0, p);
4138        pt.op = p;
4139        pt.b = v;
4140
4141        this._props.push(p);
4142      }
4143    },
4144    render: function render(ratio, data) {
4145      var pt = data._pt;
4146
4147      while (pt) {
4148        _reverting ? pt.set(pt.t, pt.p, pt.b, pt) : pt.r(ratio, pt.d);
4149        pt = pt._next;
4150      }
4151    }
4152  }, {
4153    name: "endArray",
4154    init: function init(target, value) {
4155      var i = value.length;
4156
4157      while (i--) {
4158        this.add(target, i, target[i] || 0, value[i], 0, 0, 0, 0, 0, 1);
4159      }
4160    }
4161  }, _buildModifierPlugin("roundProps", _roundModifier), _buildModifierPlugin("modifiers"), _buildModifierPlugin("snap", snap)) || _gsap;
4162  Tween.version = Timeline.version = gsap.version = "3.12.5";
4163  _coreReady = 1;
4164  _windowExists() && _wake();
4165  var Power0 = _easeMap.Power0,
4166      Power1 = _easeMap.Power1,
4167      Power2 = _easeMap.Power2,
4168      Power3 = _easeMap.Power3,
4169      Power4 = _easeMap.Power4,
4170      Linear = _easeMap.Linear,
4171      Quad = _easeMap.Quad,
4172      Cubic = _easeMap.Cubic,
4173      Quart = _easeMap.Quart,
4174      Quint = _easeMap.Quint,
4175      Strong = _easeMap.Strong,
4176      Elastic = _easeMap.Elastic,
4177      Back = _easeMap.Back,
4178      SteppedEase = _easeMap.SteppedEase,
4179      Bounce = _easeMap.Bounce,
4180      Sine = _easeMap.Sine,
4181      Expo = _easeMap.Expo,
4182      Circ = _easeMap.Circ;
4183
4184  var _win$1,
4185      _doc$1,
4186      _docElement,
4187      _pluginInitted,
4188      _tempDiv,
4189      _tempDivStyler,
4190      _recentSetterPlugin,
4191      _reverting$1,
4192      _windowExists$1 = function _windowExists() {
4193    return typeof window !== "undefined";
4194  },
4195      _transformProps = {},
4196      _RAD2DEG = 180 / Math.PI,
4197      _DEG2RAD = Math.PI / 180,
4198      _atan2 = Math.atan2,
4199      _bigNum$1 = 1e8,
4200      _capsExp = /([A-Z])/g,
4201      _horizontalExp = /(left|right|width|margin|padding|x)/i,
4202      _complexExp = /[\s,\(]\S/,
4203      _propertyAliases = {
4204    autoAlpha: "opacity,visibility",
4205    scale: "scaleX,scaleY",
4206    alpha: "opacity"
4207  },
4208      _renderCSSProp = function _renderCSSProp(ratio, data) {
4209    return data.set(data.t, data.p, Math.round((data.s + data.c * ratio) * 10000) / 10000 + data.u, data);
4210  },
4211      _renderPropWithEnd = function _renderPropWithEnd(ratio, data) {
4212    return data.set(data.t, data.p, ratio === 1 ? data.e : Math.round((data.s + data.c * ratio) * 10000) / 10000 + data.u, data);
4213  },
4214      _renderCSSPropWithBeginning = function _renderCSSPropWithBeginning(ratio, data) {
4215    return data.set(data.t, data.p, ratio ? Math.round((data.s + data.c * ratio) * 10000) / 10000 + data.u : data.b, data);
4216  },
4217      _renderRoundedCSSProp = function _renderRoundedCSSProp(ratio, data) {
4218    var value = data.s + data.c * ratio;
4219    data.set(data.t, data.p, ~~(value + (value < 0 ? -.5 : .5)) + data.u, data);
4220  },
4221      _renderNonTweeningValue = function _renderNonTweeningValue(ratio, data) {
4222    return data.set(data.t, data.p, ratio ? data.e : data.b, data);
4223  },
4224      _renderNonTweeningValueOnlyAtEnd = function _renderNonTweeningValueOnlyAtEnd(ratio, data) {
4225    return data.set(data.t, data.p, ratio !== 1 ? data.b : data.e, data);
4226  },
4227      _setterCSSStyle = function _setterCSSStyle(target, property, value) {
4228    return target.style[property] = value;
4229  },
4230      _setterCSSProp = function _setterCSSProp(target, property, value) {
4231    return target.style.setProperty(property, value);
4232  },
4233      _setterTransform = function _setterTransform(target, property, value) {
4234    return target._gsap[property] = value;
4235  },
4236      _setterScale = function _setterScale(target, property, value) {
4237    return target._gsap.scaleX = target._gsap.scaleY = value;
4238  },
4239      _setterScaleWithRender = function _setterScaleWithRender(target, property, value, data, ratio) {
4240    var cache = target._gsap;
4241    cache.scaleX = cache.scaleY = value;
4242    cache.renderTransform(ratio, cache);
4243  },
4244      _setterTransformWithRender = function _setterTransformWithRender(target, property, value, data, ratio) {
4245    var cache = target._gsap;
4246    cache[property] = value;
4247    cache.renderTransform(ratio, cache);
4248  },
4249      _transformProp = "transform",
4250      _transformOriginProp = _transformProp + "Origin",
4251      _saveStyle = function _saveStyle(property, isNotCSS) {
4252    var _this = this;
4253
4254    var target = this.target,
4255        style = target.style,
4256        cache = target._gsap;
4257
4258    if (property in _transformProps && style) {
4259      this.tfm = this.tfm || {};
4260
4261      if (property !== "transform") {
4262        property = _propertyAliases[property] || property;
4263        ~property.indexOf(",") ? property.split(",").forEach(function (a) {
4264          return _this.tfm[a] = _get(target, a);
4265        }) : this.tfm[property] = cache.x ? cache[property] : _get(target, property);
4266        property === _transformOriginProp && (this.tfm.zOrigin = cache.zOrigin);
4267      } else {
4268        return _propertyAliases.transform.split(",").forEach(function (p) {
4269          return _saveStyle.call(_this, p, isNotCSS);
4270        });
4271      }
4272
4273      if (this.props.indexOf(_transformProp) >= 0) {
4274        return;
4275      }
4276
4277      if (cache.svg) {
4278        this.svgo = target.getAttribute("data-svg-origin");
4279        this.props.push(_transformOriginProp, isNotCSS, "");
4280      }
4281
4282      property = _transformProp;
4283    }
4284
4285    (style || isNotCSS) && this.props.push(property, isNotCSS, style[property]);
4286  },
4287      _removeIndependentTransforms = function _removeIndependentTransforms(style) {
4288    if (style.translate) {
4289      style.removeProperty("translate");
4290      style.removeProperty("scale");
4291      style.removeProperty("rotate");
4292    }
4293  },
4294      _revertStyle = function _revertStyle() {
4295    var props = this.props,
4296        target = this.target,
4297        style = target.style,
4298        cache = target._gsap,
4299        i,
4300        p;
4301
4302    for (i = 0; i < props.length; i += 3) {
4303      props[i + 1] ? target[props[i]] = props[i + 2] : props[i + 2] ? style[props[i]] = props[i + 2] : style.removeProperty(props[i].substr(0, 2) === "--" ? props[i] : props[i].replace(_capsExp, "-$1").toLowerCase());
4304    }
4305
4306    if (this.tfm) {
4307      for (p in this.tfm) {
4308        cache[p] = this.tfm[p];
4309      }
4310
4311      if (cache.svg) {
4312        cache.renderTransform();
4313        target.setAttribute("data-svg-origin", this.svgo || "");
4314      }
4315
4316      i = _reverting$1();
4317
4318      if ((!i || !i.isStart) && !style[_transformProp]) {
4319        _removeIndependentTransforms(style);
4320
4321        if (cache.zOrigin && style[_transformOriginProp]) {
4322          style[_transformOriginProp] += " " + cache.zOrigin + "px";
4323          cache.zOrigin = 0;
4324          cache.renderTransform();
4325        }
4326
4327        cache.uncache = 1;
4328      }
4329    }
4330  },
4331      _getStyleSaver = function _getStyleSaver(target, properties) {
4332    var saver = {
4333      target: target,
4334      props: [],
4335      revert: _revertStyle,
4336      save: _saveStyle
4337    };
4338    target._gsap || gsap.core.getCache(target);
4339    properties && properties.split(",").forEach(function (p) {
4340      return saver.save(p);
4341    });
4342    return saver;
4343  },
4344      _supports3D,
4345      _createElement = function _createElement(type, ns) {
4346    var e = _doc$1.createElementNS ? _doc$1.createElementNS((ns || "http://www.w3.org/1999/xhtml").replace(/^https/, "http"), type) : _doc$1.createElement(type);
4347    return e && e.style ? e : _doc$1.createElement(type);
4348  },
4349      _getComputedProperty = function _getComputedProperty(target, property, skipPrefixFallback) {
4350    var cs = getComputedStyle(target);
4351    return cs[property] || cs.getPropertyValue(property.replace(_capsExp, "-$1").toLowerCase()) || cs.getPropertyValue(property) || !skipPrefixFallback && _getComputedProperty(target, _checkPropPrefix(property) || property, 1) || "";
4352  },
4353      _prefixes = "O,Moz,ms,Ms,Webkit".split(","),
4354      _checkPropPrefix = function _checkPropPrefix(property, element, preferPrefix) {
4355    var e = element || _tempDiv,
4356        s = e.style,
4357        i = 5;
4358
4359    if (property in s && !preferPrefix) {
4360      return property;
4361    }
4362
4363    property = property.charAt(0).toUpperCase() + property.substr(1);
4364
4365    while (i-- && !(_prefixes[i] + property in s)) {}
4366
4367    return i < 0 ? null : (i === 3 ? "ms" : i >= 0 ? _prefixes[i] : "") + property;
4368  },
4369      _initCore = function _initCore() {
4370    if (_windowExists$1() && window.document) {
4371      _win$1 = window;
4372      _doc$1 = _win$1.document;
4373      _docElement = _doc$1.documentElement;
4374      _tempDiv = _createElement("div") || {
4375        style: {}
4376      };
4377      _tempDivStyler = _createElement("div");
4378      _transformProp = _checkPropPrefix(_transformProp);
4379      _transformOriginProp = _transformProp + "Origin";
4380      _tempDiv.style.cssText = "border-width:0;line-height:0;position:absolute;padding:0";
4381      _supports3D = !!_checkPropPrefix("perspective");
4382      _reverting$1 = gsap.core.reverting;
4383      _pluginInitted = 1;
4384    }
4385  },
4386      _getBBoxHack = function _getBBoxHack(swapIfPossible) {
4387    var svg = _createElement("svg", this.ownerSVGElement && this.ownerSVGElement.getAttribute("xmlns") || "http://www.w3.org/2000/svg"),
4388        oldParent = this.parentNode,
4389        oldSibling = this.nextSibling,
4390        oldCSS = this.style.cssText,
4391        bbox;
4392
4393    _docElement.appendChild(svg);
4394
4395    svg.appendChild(this);
4396    this.style.display = "block";
4397
4398    if (swapIfPossible) {
4399      try {
4400        bbox = this.getBBox();
4401        this._gsapBBox = this.getBBox;
4402        this.getBBox = _getBBoxHack;
4403      } catch (e) {}
4404    } else if (this._gsapBBox) {
4405      bbox = this._gsapBBox();
4406    }
4407
4408    if (oldParent) {
4409      if (oldSibling) {
4410        oldParent.insertBefore(this, oldSibling);
4411      } else {
4412        oldParent.appendChild(this);
4413      }
4414    }
4415
4416    _docElement.removeChild(svg);
4417
4418    this.style.cssText = oldCSS;
4419    return bbox;
4420  },
4421      _getAttributeFallbacks = function _getAttributeFallbacks(target, attributesArray) {
4422    var i = attributesArray.length;
4423
4424    while (i--) {
4425      if (target.hasAttribute(attributesArray[i])) {
4426        return target.getAttribute(attributesArray[i]);
4427      }
4428    }
4429  },
4430      _getBBox = function _getBBox(target) {
4431    var bounds;
4432
4433    try {
4434      bounds = target.getBBox();
4435    } catch (error) {
4436      bounds = _getBBoxHack.call(target, true);
4437    }
4438
4439    bounds && (bounds.width || bounds.height) || target.getBBox === _getBBoxHack || (bounds = _getBBoxHack.call(target, true));
4440    return bounds && !bounds.width && !bounds.x && !bounds.y ? {
4441      x: +_getAttributeFallbacks(target, ["x", "cx", "x1"]) || 0,
4442      y: +_getAttributeFallbacks(target, ["y", "cy", "y1"]) || 0,
4443      width: 0,
4444      height: 0
4445    } : bounds;
4446  },
4447      _isSVG = function _isSVG(e) {
4448    return !!(e.getCTM && (!e.parentNode || e.ownerSVGElement) && _getBBox(e));
4449  },
4450      _removeProperty = function _removeProperty(target, property) {
4451    if (property) {
4452      var style = target.style,
4453          first2Chars;
4454
4455      if (property in _transformProps && property !== _transformOriginProp) {
4456        property = _transformProp;
4457      }
4458
4459      if (style.removeProperty) {
4460        first2Chars = property.substr(0, 2);
4461
4462        if (first2Chars === "ms" || property.substr(0, 6) === "webkit") {
4463          property = "-" + property;
4464        }
4465
4466        style.removeProperty(first2Chars === "--" ? property : property.replace(_capsExp, "-$1").toLowerCase());
4467      } else {
4468        style.removeAttribute(property);
4469      }
4470    }
4471  },
4472      _addNonTweeningPT = function _addNonTweeningPT(plugin, target, property, beginning, end, onlySetAtEnd) {
4473    var pt = new PropTween(plugin._pt, target, property, 0, 1, onlySetAtEnd ? _renderNonTweeningValueOnlyAtEnd : _renderNonTweeningValue);
4474    plugin._pt = pt;
4475    pt.b = beginning;
4476    pt.e = end;
4477
4478    plugin._props.push(property);
4479
4480    return pt;
4481  },
4482      _nonConvertibleUnits = {
4483    deg: 1,
4484    rad: 1,
4485    turn: 1
4486  },
4487      _nonStandardLayouts = {
4488    grid: 1,
4489    flex: 1
4490  },
4491      _convertToUnit = function _convertToUnit(target, property, value, unit) {
4492    var curValue = parseFloat(value) || 0,
4493        curUnit = (value + "").trim().substr((curValue + "").length) || "px",
4494        style = _tempDiv.style,
4495        horizontal = _horizontalExp.test(property),
4496        isRootSVG = target.tagName.toLowerCase() === "svg",
4497        measureProperty = (isRootSVG ? "client" : "offset") + (horizontal ? "Width" : "Height"),
4498        amount = 100,
4499        toPixels = unit === "px",
4500        toPercent = unit === "%",
4501        px,
4502        parent,
4503        cache,
4504        isSVG;
4505
4506    if (unit === curUnit || !curValue || _nonConvertibleUnits[unit] || _nonConvertibleUnits[curUnit]) {
4507      return curValue;
4508    }
4509
4510    curUnit !== "px" && !toPixels && (curValue = _convertToUnit(target, property, value, "px"));
4511    isSVG = target.getCTM && _isSVG(target);
4512
4513    if ((toPercent || curUnit === "%") && (_transformProps[property] || ~property.indexOf("adius"))) {
4514      px = isSVG ? target.getBBox()[horizontal ? "width" : "height"] : target[measureProperty];
4515      return _round(toPercent ? curValue / px * amount : curValue / 100 * px);
4516    }
4517
4518    style[horizontal ? "width" : "height"] = amount + (toPixels ? curUnit : unit);
4519    parent = ~property.indexOf("adius") || unit === "em" && target.appendChild && !isRootSVG ? target : target.parentNode;
4520
4521    if (isSVG) {
4522      parent = (target.ownerSVGElement || {}).parentNode;
4523    }
4524
4525    if (!parent || parent === _doc$1 || !parent.appendChild) {
4526      parent = _doc$1.body;
4527    }
4528
4529    cache = parent._gsap;
4530
4531    if (cache && toPercent && cache.width && horizontal && cache.time === _ticker.time && !cache.uncache) {
4532      return _round(curValue / cache.width * amount);
4533    } else {
4534      if (toPercent && (property === "height" || property === "width")) {
4535        var v = target.style[property];
4536        target.style[property] = amount + unit;
4537        px = target[measureProperty];
4538        v ? target.style[property] = v : _removeProperty(target, property);
4539      } else {
4540        (toPercent || curUnit === "%") && !_nonStandardLayouts[_getComputedProperty(parent, "display")] && (style.position = _getComputedProperty(target, "position"));
4541        parent === target && (style.position = "static");
4542        parent.appendChild(_tempDiv);
4543        px = _tempDiv[measureProperty];
4544        parent.removeChild(_tempDiv);
4545        style.position = "absolute";
4546      }
4547
4548      if (horizontal && toPercent) {
4549        cache = _getCache(parent);
4550        cache.time = _ticker.time;
4551        cache.width = parent[measureProperty];
4552      }
4553    }
4554
4555    return _round(toPixels ? px * curValue / amount : px && curValue ? amount / px * curValue : 0);
4556  },
4557      _get = function _get(target, property, unit, uncache) {
4558    var value;
4559    _pluginInitted || _initCore();
4560
4561    if (property in _propertyAliases && property !== "transform") {
4562      property = _propertyAliases[property];
4563
4564      if (~property.indexOf(",")) {
4565        property = property.split(",")[0];
4566      }
4567    }
4568
4569    if (_transformProps[property] && property !== "transform") {
4570      value = _parseTransform(target, uncache);
4571      value = property !== "transformOrigin" ? value[property] : value.svg ? value.origin : _firstTwoOnly(_getComputedProperty(target, _transformOriginProp)) + " " + value.zOrigin + "px";
4572    } else {
4573      value = target.style[property];
4574
4575      if (!value || value === "auto" || uncache || ~(value + "").indexOf("calc(")) {
4576        value = _specialProps[property] && _specialProps[property](target, property, unit) || _getComputedProperty(target, property) || _getProperty(target, property) || (property === "opacity" ? 1 : 0);
4577      }
4578    }
4579
4580    return unit && !~(value + "").trim().indexOf(" ") ? _convertToUnit(target, property, value, unit) + unit : value;
4581  },
4582      _tweenComplexCSSString = function _tweenComplexCSSString(target, prop, start, end) {
4583    if (!start || start === "none") {
4584      var p = _checkPropPrefix(prop, target, 1),
4585          s = p && _getComputedProperty(target, p, 1);
4586
4587      if (s && s !== start) {
4588        prop = p;
4589        start = s;
4590      } else if (prop === "borderColor") {
4591        start = _getComputedProperty(target, "borderTopColor");
4592      }
4593    }
4594
4595    var pt = new PropTween(this._pt, target.style, prop, 0, 1, _renderComplexString),
4596        index = 0,
4597        matchIndex = 0,
4598        a,
4599        result,
4600        startValues,
4601        startNum,
4602        color,
4603        startValue,
4604        endValue,
4605        endNum,
4606        chunk,
4607        endUnit,
4608        startUnit,
4609        endValues;
4610    pt.b = start;
4611    pt.e = end;
4612    start += "";
4613    end += "";
4614
4615    if (end === "auto") {
4616      startValue = target.style[prop];
4617      target.style[prop] = end;
4618      end = _getComputedProperty(target, prop) || end;
4619      startValue ? target.style[prop] = startValue : _removeProperty(target, prop);
4620    }
4621
4622    a = [start, end];
4623
4624    _colorStringFilter(a);
4625
4626    start = a[0];
4627    end = a[1];
4628    startValues = start.match(_numWithUnitExp) || [];
4629    endValues = end.match(_numWithUnitExp) || [];
4630
4631    if (endValues.length) {
4632      while (result = _numWithUnitExp.exec(end)) {
4633        endValue = result[0];
4634        chunk = end.substring(index, result.index);
4635
4636        if (color) {
4637          color = (color + 1) % 5;
4638        } else if (chunk.substr(-5) === "rgba(" || chunk.substr(-5) === "hsla(") {
4639          color = 1;
4640        }
4641
4642        if (endValue !== (startValue = startValues[matchIndex++] || "")) {
4643          startNum = parseFloat(startValue) || 0;
4644          startUnit = startValue.substr((startNum + "").length);
4645          endValue.charAt(1) === "=" && (endValue = _parseRelative(startNum, endValue) + startUnit);
4646          endNum = parseFloat(endValue);
4647          endUnit = endValue.substr((endNum + "").length);
4648          index = _numWithUnitExp.lastIndex - endUnit.length;
4649
4650          if (!endUnit) {
4651            endUnit = endUnit || _config.units[prop] || startUnit;
4652
4653            if (index === end.length) {
4654              end += endUnit;
4655              pt.e += endUnit;
4656            }
4657          }
4658
4659          if (startUnit !== endUnit) {
4660            startNum = _convertToUnit(target, prop, startValue, endUnit) || 0;
4661          }
4662
4663          pt._pt = {
4664            _next: pt._pt,
4665            p: chunk || matchIndex === 1 ? chunk : ",",
4666            s: startNum,
4667            c: endNum - startNum,
4668            m: color && color < 4 || prop === "zIndex" ? Math.round : 0
4669          };
4670        }
4671      }
4672
4673      pt.c = index < end.length ? end.substring(index, end.length) : "";
4674    } else {
4675      pt.r = prop === "display" && end === "none" ? _renderNonTweeningValueOnlyAtEnd : _renderNonTweeningValue;
4676    }
4677
4678    _relExp.test(end) && (pt.e = 0);
4679    this._pt = pt;
4680    return pt;
4681  },
4682      _keywordToPercent = {
4683    top: "0%",
4684    bottom: "100%",
4685    left: "0%",
4686    right: "100%",
4687    center: "50%"
4688  },
4689      _convertKeywordsToPercentages = function _convertKeywordsToPercentages(value) {
4690    var split = value.split(" "),
4691        x = split[0],
4692        y = split[1] || "50%";
4693
4694    if (x === "top" || x === "bottom" || y === "left" || y === "right") {
4695      value = x;
4696      x = y;
4697      y = value;
4698    }
4699
4700    split[0] = _keywordToPercent[x] || x;
4701    split[1] = _keywordToPercent[y] || y;
4702    return split.join(" ");
4703  },
4704      _renderClearProps = function _renderClearProps(ratio, data) {
4705    if (data.tween && data.tween._time === data.tween._dur) {
4706      var target = data.t,
4707          style = target.style,
4708          props = data.u,
4709          cache = target._gsap,
4710          prop,
4711          clearTransforms,
4712          i;
4713
4714      if (props === "all" || props === true) {
4715        style.cssText = "";
4716        clearTransforms = 1;
4717      } else {
4718        props = props.split(",");
4719        i = props.length;
4720
4721        while (--i > -1) {
4722          prop = props[i];
4723
4724          if (_transformProps[prop]) {
4725            clearTransforms = 1;
4726            prop = prop === "transformOrigin" ? _transformOriginProp : _transformProp;
4727          }
4728
4729          _removeProperty(target, prop);
4730        }
4731      }
4732
4733      if (clearTransforms) {
4734        _removeProperty(target, _transformProp);
4735
4736        if (cache) {
4737          cache.svg && target.removeAttribute("transform");
4738
4739          _parseTransform(target, 1);
4740
4741          cache.uncache = 1;
4742
4743          _removeIndependentTransforms(style);
4744        }
4745      }
4746    }
4747  },
4748      _specialProps = {
4749    clearProps: function clearProps(plugin, target, property, endValue, tween) {

vendor: 1,580 bytes, lines 4750-4790

4750      if (tween.data !== "isFromStart") {
4751        var pt = plugin._pt = new PropTween(plugin._pt, target, property, 0, 0, _renderClearProps);
4752        pt.u = endValue;
4753        pt.pr = -10;
4754        pt.tween = tween;
4755
4756        plugin._props.push(property);
4757
4758        return 1;
4759      }
4760    }
4761  },
4762      _identity2DMatrix = [1, 0, 0, 1, 0, 0],
4763      _rotationalProperties = {},
4764      _isNullTransform = function _isNullTransform(value) {
4765    return value === "matrix(1, 0, 0, 1, 0, 0)" || value === "none" || !value;
4766  },
4767      _getComputedTransformMatrixAsArray = function _getComputedTransformMatrixAsArray(target) {
4768    var matrixString = _getComputedProperty(target, _transformProp);
4769
4770    return _isNullTransform(matrixString) ? _identity2DMatrix : matrixString.substr(7).match(_numExp).map(_round);
4771  },
4772      _getMatrix = function _getMatrix(target, force2D) {
4773    var cache = target._gsap || _getCache(target),
4774        style = target.style,
4775        matrix = _getComputedTransformMatrixAsArray(target),
4776        parent,
4777        nextSibling,
4778        temp,
4779        addedToDOM;
4780
4781    if (cache.svg && target.getAttribute("transform")) {
4782      temp = target.transform.baseVal.consolidate().matrix;
4783      matrix = [temp.a, temp.b, temp.c, temp.d, temp.e, temp.f];
4784      return matrix.join(",") === "1,0,0,1,0,0" ? _identity2DMatrix : matrix;
4785    } else if (matrix === _identity2DMatrix && !target.offsetParent && target !== _docElement && !cache.svg) {
4786      temp = style.display;
4787      style.display = "block";
4788      parent = target.parentNode;
4789
4790      if (!parent || !target.offsetParent

vendor: 18,926 bytes, lines 4790-5387

4790) {
4791        addedToDOM = 1;
4792        nextSibling = target.nextElementSibling;
4793
4794        _docElement.appendChild(target);
4795      }
4796
4797      matrix = _getComputedTransformMatrixAsArray(target);
4798      temp ? style.display = temp : _removeProperty(target, "display");
4799
4800      if (addedToDOM) {
4801        nextSibling ? parent.insertBefore(target, nextSibling) : parent ? parent.appendChild(target) : _docElement.removeChild(target);
4802      }
4803    }
4804
4805    return force2D && matrix.length > 6 ? [matrix[0], matrix[1], matrix[4], matrix[5], matrix[12], matrix[13]] : matrix;
4806  },
4807      _applySVGOrigin = function _applySVGOrigin(target, origin, originIsAbsolute, smooth, matrixArray, pluginToAddPropTweensTo) {
4808    var cache = target._gsap,
4809        matrix = matrixArray || _getMatrix(target, true),
4810        xOriginOld = cache.xOrigin || 0,
4811        yOriginOld = cache.yOrigin || 0,
4812        xOffsetOld = cache.xOffset || 0,
4813        yOffsetOld = cache.yOffset || 0,
4814        a = matrix[0],
4815        b = matrix[1],
4816        c = matrix[2],
4817        d = matrix[3],
4818        tx = matrix[4],
4819        ty = matrix[5],
4820        originSplit = origin.split(" "),
4821        xOrigin = parseFloat(originSplit[0]) || 0,
4822        yOrigin = parseFloat(originSplit[1]) || 0,
4823        bounds,
4824        determinant,
4825        x,
4826        y;
4827
4828    if (!originIsAbsolute) {
4829      bounds = _getBBox(target);
4830      xOrigin = bounds.x + (~originSplit[0].indexOf("%") ? xOrigin / 100 * bounds.width : xOrigin);
4831      yOrigin = bounds.y + (~(originSplit[1] || originSplit[0]).indexOf("%") ? yOrigin / 100 * bounds.height : yOrigin);
4832    } else if (matrix !== _identity2DMatrix && (determinant = a * d - b * c)) {
4833      x = xOrigin * (d / determinant) + yOrigin * (-c / determinant) + (c * ty - d * tx) / determinant;
4834      y = xOrigin * (-b / determinant) + yOrigin * (a / determinant) - (a * ty - b * tx) / determinant;
4835      xOrigin = x;
4836      yOrigin = y;
4837    }
4838
4839    if (smooth || smooth !== false && cache.smooth) {
4840      tx = xOrigin - xOriginOld;
4841      ty = yOrigin - yOriginOld;
4842      cache.xOffset = xOffsetOld + (tx * a + ty * c) - tx;
4843      cache.yOffset = yOffsetOld + (tx * b + ty * d) - ty;
4844    } else {
4845      cache.xOffset = cache.yOffset = 0;
4846    }
4847
4848    cache.xOrigin = xOrigin;
4849    cache.yOrigin = yOrigin;
4850    cache.smooth = !!smooth;
4851    cache.origin = origin;
4852    cache.originIsAbsolute = !!originIsAbsolute;
4853    target.style[_transformOriginProp] = "0px 0px";
4854
4855    if (pluginToAddPropTweensTo) {
4856      _addNonTweeningPT(pluginToAddPropTweensTo, cache, "xOrigin", xOriginOld, xOrigin);
4857
4858      _addNonTweeningPT(pluginToAddPropTweensTo, cache, "yOrigin", yOriginOld, yOrigin);
4859
4860      _addNonTweeningPT(pluginToAddPropTweensTo, cache, "xOffset", xOffsetOld, cache.xOffset);
4861
4862      _addNonTweeningPT(pluginToAddPropTweensTo, cache, "yOffset", yOffsetOld, cache.yOffset);
4863    }
4864
4865    target.setAttribute("data-svg-origin", xOrigin + " " + yOrigin);
4866  },
4867      _parseTransform = function _parseTransform(target, uncache) {
4868    var cache = target._gsap || new GSCache(target);
4869
4870    if ("x" in cache && !uncache && !cache.uncache) {
4871      return cache;
4872    }
4873
4874    var style = target.style,
4875        invertedScaleX = cache.scaleX < 0,
4876        px = "px",
4877        deg = "deg",
4878        cs = getComputedStyle(target),
4879        origin = _getComputedProperty(target, _transformOriginProp) || "0",
4880        x,
4881        y,
4882        z,
4883        scaleX,
4884        scaleY,
4885        rotation,
4886        rotationX,
4887        rotationY,
4888        skewX,
4889        skewY,
4890        perspective,
4891        xOrigin,
4892        yOrigin,
4893        matrix,
4894        angle,
4895        cos,
4896        sin,
4897        a,
4898        b,
4899        c,
4900        d,
4901        a12,
4902        a22,
4903        t1,
4904        t2,
4905        t3,
4906        a13,
4907        a23,
4908        a33,
4909        a42,
4910        a43,
4911        a32;
4912    x = y = z = rotation = rotationX = rotationY = skewX = skewY = perspective = 0;
4913    scaleX = scaleY = 1;
4914    cache.svg = !!(target.getCTM && _isSVG(target));
4915
4916    if (cs.translate) {
4917      if (cs.translate !== "none" || cs.scale !== "none" || cs.rotate !== "none") {
4918        style[_transformProp] = (cs.translate !== "none" ? "translate3d(" + (cs.translate + " 0 0").split(" ").slice(0, 3).join(", ") + ") " : "") + (cs.rotate !== "none" ? "rotate(" + cs.rotate + ") " : "") + (cs.scale !== "none" ? "scale(" + cs.scale.split(" ").join(",") + ") " : "") + (cs[_transformProp] !== "none" ? cs[_transformProp] : "");
4919      }
4920
4921      style.scale = style.rotate = style.translate = "none";
4922    }
4923
4924    matrix = _getMatrix(target, cache.svg);
4925
4926    if (cache.svg) {
4927      if (cache.uncache) {
4928        t2 = target.getBBox();
4929        origin = cache.xOrigin - t2.x + "px " + (cache.yOrigin - t2.y) + "px";
4930        t1 = "";
4931      } else {
4932        t1 = !uncache && target.getAttribute("data-svg-origin");
4933      }
4934
4935      _applySVGOrigin(target, t1 || origin, !!t1 || cache.originIsAbsolute, cache.smooth !== false, matrix);
4936    }
4937
4938    xOrigin = cache.xOrigin || 0;
4939    yOrigin = cache.yOrigin || 0;
4940
4941    if (matrix !== _identity2DMatrix) {
4942      a = matrix[0];
4943      b = matrix[1];
4944      c = matrix[2];
4945      d = matrix[3];
4946      x = a12 = matrix[4];
4947      y = a22 = matrix[5];
4948
4949      if (matrix.length === 6) {
4950        scaleX = Math.sqrt(a * a + b * b);
4951        scaleY = Math.sqrt(d * d + c * c);
4952        rotation = a || b ? _atan2(b, a) * _RAD2DEG : 0;
4953        skewX = c || d ? _atan2(c, d) * _RAD2DEG + rotation : 0;
4954        skewX && (scaleY *= Math.abs(Math.cos(skewX * _DEG2RAD)));
4955
4956        if (cache.svg) {
4957          x -= xOrigin - (xOrigin * a + yOrigin * c);
4958          y -= yOrigin - (xOrigin * b + yOrigin * d);
4959        }
4960      } else {
4961        a32 = matrix[6];
4962        a42 = matrix[7];
4963        a13 = matrix[8];
4964        a23 = matrix[9];
4965        a33 = matrix[10];
4966        a43 = matrix[11];
4967        x = matrix[12];
4968        y = matrix[13];
4969        z = matrix[14];
4970        angle = _atan2(a32, a33);
4971        rotationX = angle * _RAD2DEG;
4972
4973        if (angle) {
4974          cos = Math.cos(-angle);
4975          sin = Math.sin(-angle);
4976          t1 = a12 * cos + a13 * sin;
4977          t2 = a22 * cos + a23 * sin;
4978          t3 = a32 * cos + a33 * sin;
4979          a13 = a12 * -sin + a13 * cos;
4980          a23 = a22 * -sin + a23 * cos;
4981          a33 = a32 * -sin + a33 * cos;
4982          a43 = a42 * -sin + a43 * cos;
4983          a12 = t1;
4984          a22 = t2;
4985          a32 = t3;
4986        }
4987
4988        angle = _atan2(-c, a33);
4989        rotationY = angle * _RAD2DEG;
4990
4991        if (angle) {
4992          cos = Math.cos(-angle);
4993          sin = Math.sin(-angle);
4994          t1 = a * cos - a13 * sin;
4995          t2 = b * cos - a23 * sin;
4996          t3 = c * cos - a33 * sin;
4997          a43 = d * sin + a43 * cos;
4998          a = t1;
4999          b = t2;
5000          c = t3;
5001        }
5002
5003        angle = _atan2(b, a);
5004        rotation = angle * _RAD2DEG;
5005
5006        if (angle) {
5007          cos = Math.cos(angle);
5008          sin = Math.sin(angle);
5009          t1 = a * cos + b * sin;
5010          t2 = a12 * cos + a22 * sin;
5011          b = b * cos - a * sin;
5012          a22 = a22 * cos - a12 * sin;
5013          a = t1;
5014          a12 = t2;
5015        }
5016
5017        if (rotationX && Math.abs(rotationX) + Math.abs(rotation) > 359.9) {
5018          rotationX = rotation = 0;
5019          rotationY = 180 - rotationY;
5020        }
5021
5022        scaleX = _round(Math.sqrt(a * a + b * b + c * c));
5023        scaleY = _round(Math.sqrt(a22 * a22 + a32 * a32));
5024        angle = _atan2(a12, a22);
5025        skewX = Math.abs(angle) > 0.0002 ? angle * _RAD2DEG : 0;
5026        perspective = a43 ? 1 / (a43 < 0 ? -a43 : a43) : 0;
5027      }
5028
5029      if (cache.svg) {
5030        t1 = target.getAttribute("transform");
5031        cache.forceCSS = target.setAttribute("transform", "") || !_isNullTransform(_getComputedProperty(target, _transformProp));
5032        t1 && target.setAttribute("transform", t1);
5033      }
5034    }
5035
5036    if (Math.abs(skewX) > 90 && Math.abs(skewX) < 270) {
5037      if (invertedScaleX) {
5038        scaleX *= -1;
5039        skewX += rotation <= 0 ? 180 : -180;
5040        rotation += rotation <= 0 ? 180 : -180;
5041      } else {
5042        scaleY *= -1;
5043        skewX += skewX <= 0 ? 180 : -180;
5044      }
5045    }
5046
5047    uncache = uncache || cache.uncache;
5048    cache.x = x - ((cache.xPercent = x && (!uncache && cache.xPercent || (Math.round(target.offsetWidth / 2) === Math.round(-x) ? -50 : 0))) ? target.offsetWidth * cache.xPercent / 100 : 0) + px;
5049    cache.y = y - ((cache.yPercent = y && (!uncache && cache.yPercent || (Math.round(target.offsetHeight / 2) === Math.round(-y) ? -50 : 0))) ? target.offsetHeight * cache.yPercent / 100 : 0) + px;
5050    cache.z = z + px;
5051    cache.scaleX = _round(scaleX);
5052    cache.scaleY = _round(scaleY);
5053    cache.rotation = _round(rotation) + deg;
5054    cache.rotationX = _round(rotationX) + deg;
5055    cache.rotationY = _round(rotationY) + deg;
5056    cache.skewX = skewX + deg;
5057    cache.skewY = skewY + deg;
5058    cache.transformPerspective = perspective + px;
5059
5060    if (cache.zOrigin = parseFloat(origin.split(" ")[2]) || !uncache && cache.zOrigin || 0) {
5061      style[_transformOriginProp] = _firstTwoOnly(origin);
5062    }
5063
5064    cache.xOffset = cache.yOffset = 0;
5065    cache.force3D = _config.force3D;
5066    cache.renderTransform = cache.svg ? _renderSVGTransforms : _supports3D ? _renderCSSTransforms : _renderNon3DTransforms;
5067    cache.uncache = 0;
5068    return cache;
5069  },
5070      _firstTwoOnly = function _firstTwoOnly(value) {
5071    return (value = value.split(" "))[0] + " " + value[1];
5072  },
5073      _addPxTranslate = function _addPxTranslate(target, start, value) {
5074    var unit = getUnit(start);
5075    return _round(parseFloat(start) + parseFloat(_convertToUnit(target, "x", value + "px", unit))) + unit;
5076  },
5077      _renderNon3DTransforms = function _renderNon3DTransforms(ratio, cache) {
5078    cache.z = "0px";
5079    cache.rotationY = cache.rotationX = "0deg";
5080    cache.force3D = 0;
5081
5082    _renderCSSTransforms(ratio, cache);
5083  },
5084      _zeroDeg = "0deg",
5085      _zeroPx = "0px",
5086      _endParenthesis = ") ",
5087      _renderCSSTransforms = function _renderCSSTransforms(ratio, cache) {
5088    var _ref = cache || this,
5089        xPercent = _ref.xPercent,
5090        yPercent = _ref.yPercent,
5091        x = _ref.x,
5092        y = _ref.y,
5093        z = _ref.z,
5094        rotation = _ref.rotation,
5095        rotationY = _ref.rotationY,
5096        rotationX = _ref.rotationX,
5097        skewX = _ref.skewX,
5098        skewY = _ref.skewY,
5099        scaleX = _ref.scaleX,
5100        scaleY = _ref.scaleY,
5101        transformPerspective = _ref.transformPerspective,
5102        force3D = _ref.force3D,
5103        target = _ref.target,
5104        zOrigin = _ref.zOrigin,
5105        transforms = "",
5106        use3D = force3D === "auto" && ratio && ratio !== 1 || force3D === true;
5107
5108    if (zOrigin && (rotationX !== _zeroDeg || rotationY !== _zeroDeg)) {
5109      var angle = parseFloat(rotationY) * _DEG2RAD,
5110          a13 = Math.sin(angle),
5111          a33 = Math.cos(angle),
5112          cos;
5113
5114      angle = parseFloat(rotationX) * _DEG2RAD;
5115      cos = Math.cos(angle);
5116      x = _addPxTranslate(target, x, a13 * cos * -zOrigin);
5117      y = _addPxTranslate(target, y, -Math.sin(angle) * -zOrigin);
5118      z = _addPxTranslate(target, z, a33 * cos * -zOrigin + zOrigin);
5119    }
5120
5121    if (transformPerspective !== _zeroPx) {
5122      transforms += "perspective(" + transformPerspective + _endParenthesis;
5123    }
5124
5125    if (xPercent || yPercent) {
5126      transforms += "translate(" + xPercent + "%, " + yPercent + "%) ";
5127    }
5128
5129    if (use3D || x !== _zeroPx || y !== _zeroPx || z !== _zeroPx) {
5130      transforms += z !== _zeroPx || use3D ? "translate3d(" + x + ", " + y + ", " + z + ") " : "translate(" + x + ", " + y + _endParenthesis;
5131    }
5132
5133    if (rotation !== _zeroDeg) {
5134      transforms += "rotate(" + rotation + _endParenthesis;
5135    }
5136
5137    if (rotationY !== _zeroDeg) {
5138      transforms += "rotateY(" + rotationY + _endParenthesis;
5139    }
5140
5141    if (rotationX !== _zeroDeg) {
5142      transforms += "rotateX(" + rotationX + _endParenthesis;
5143    }
5144
5145    if (skewX !== _zeroDeg || skewY !== _zeroDeg) {
5146      transforms += "skew(" + skewX + ", " + skewY + _endParenthesis;
5147    }
5148
5149    if (scaleX !== 1 || scaleY !== 1) {
5150      transforms += "scale(" + scaleX + ", " + scaleY + _endParenthesis;
5151    }
5152
5153    target.style[_transformProp] = transforms || "translate(0, 0)";
5154  },
5155      _renderSVGTransforms = function _renderSVGTransforms(ratio, cache) {
5156    var _ref2 = cache || this,
5157        xPercent = _ref2.xPercent,
5158        yPercent = _ref2.yPercent,
5159        x = _ref2.x,
5160        y = _ref2.y,
5161        rotation = _ref2.rotation,
5162        skewX = _ref2.skewX,
5163        skewY = _ref2.skewY,
5164        scaleX = _ref2.scaleX,
5165        scaleY = _ref2.scaleY,
5166        target = _ref2.target,
5167        xOrigin = _ref2.xOrigin,
5168        yOrigin = _ref2.yOrigin,
5169        xOffset = _ref2.xOffset,
5170        yOffset = _ref2.yOffset,
5171        forceCSS = _ref2.forceCSS,
5172        tx = parseFloat(x),
5173        ty = parseFloat(y),
5174        a11,
5175        a21,
5176        a12,
5177        a22,
5178        temp;
5179
5180    rotation = parseFloat(rotation);
5181    skewX = parseFloat(skewX);
5182    skewY = parseFloat(skewY);
5183
5184    if (skewY) {
5185      skewY = parseFloat(skewY);
5186      skewX += skewY;
5187      rotation += skewY;
5188    }
5189
5190    if (rotation || skewX) {
5191      rotation *= _DEG2RAD;
5192      skewX *= _DEG2RAD;
5193      a11 = Math.cos(rotation) * scaleX;
5194      a21 = Math.sin(rotation) * scaleX;
5195      a12 = Math.sin(rotation - skewX) * -scaleY;
5196      a22 = Math.cos(rotation - skewX) * scaleY;
5197
5198      if (skewX) {
5199        skewY *= _DEG2RAD;
5200        temp = Math.tan(skewX - skewY);
5201        temp = Math.sqrt(1 + temp * temp);
5202        a12 *= temp;
5203        a22 *= temp;
5204
5205        if (skewY) {
5206          temp = Math.tan(skewY);
5207          temp = Math.sqrt(1 + temp * temp);
5208          a11 *= temp;
5209          a21 *= temp;
5210        }
5211      }
5212
5213      a11 = _round(a11);
5214      a21 = _round(a21);
5215      a12 = _round(a12);
5216      a22 = _round(a22);
5217    } else {
5218      a11 = scaleX;
5219      a22 = scaleY;
5220      a21 = a12 = 0;
5221    }
5222
5223    if (tx && !~(x + "").indexOf("px") || ty && !~(y + "").indexOf("px")) {
5224      tx = _convertToUnit(target, "x", x, "px");
5225      ty = _convertToUnit(target, "y", y, "px");
5226    }
5227
5228    if (xOrigin || yOrigin || xOffset || yOffset) {
5229      tx = _round(tx + xOrigin - (xOrigin * a11 + yOrigin * a12) + xOffset);
5230      ty = _round(ty + yOrigin - (xOrigin * a21 + yOrigin * a22) + yOffset);
5231    }
5232
5233    if (xPercent || yPercent) {
5234      temp = target.getBBox();
5235      tx = _round(tx + xPercent / 100 * temp.width);
5236      ty = _round(ty + yPercent / 100 * temp.height);
5237    }
5238
5239    temp = "matrix(" + a11 + "," + a21 + "," + a12 + "," + a22 + "," + tx + "," + ty + ")";
5240    target.setAttribute("transform", temp);
5241    forceCSS && (target.style[_transformProp] = temp);
5242  },
5243      _addRotationalPropTween = function _addRotationalPropTween(plugin, target, property, startNum, endValue) {
5244    var cap = 360,
5245        isString = _isString(endValue),
5246        endNum = parseFloat(endValue) * (isString && ~endValue.indexOf("rad") ? _RAD2DEG : 1),
5247        change = endNum - startNum,
5248        finalValue = startNum + change + "deg",
5249        direction,
5250        pt;
5251
5252    if (isString) {
5253      direction = endValue.split("_")[1];
5254
5255      if (direction === "short") {
5256        change %= cap;
5257
5258        if (change !== change % (cap / 2)) {
5259          change += change < 0 ? cap : -cap;
5260        }
5261      }
5262
5263      if (direction === "cw" && change < 0) {
5264        change = (change + cap * _bigNum$1) % cap - ~~(change / cap) * cap;
5265      } else if (direction === "ccw" && change > 0) {
5266        change = (change - cap * _bigNum$1) % cap - ~~(change / cap) * cap;
5267      }
5268    }
5269
5270    plugin._pt = pt = new PropTween(plugin._pt, target, property, startNum, change, _renderPropWithEnd);
5271    pt.e = finalValue;
5272    pt.u = "deg";
5273
5274    plugin._props.push(property);
5275
5276    return pt;
5277  },
5278      _assign = function _assign(target, source) {
5279    for (var p in source) {
5280      target[p] = source[p];
5281    }
5282
5283    return target;
5284  },
5285      _addRawTransformPTs = function _addRawTransformPTs(plugin, transforms, target) {
5286    var startCache = _assign({}, target._gsap),
5287        exclude = "perspective,force3D,transformOrigin,svgOrigin",
5288        style = target.style,
5289        endCache,
5290        p,
5291        startValue,
5292        endValue,
5293        startNum,
5294        endNum,
5295        startUnit,
5296        endUnit;
5297
5298    if (startCache.svg) {
5299      startValue = target.getAttribute("transform");
5300      target.setAttribute("transform", "");
5301      style[_transformProp] = transforms;
5302      endCache = _parseTransform(target, 1);
5303
5304      _removeProperty(target, _transformProp);
5305
5306      target.setAttribute("transform", startValue);
5307    } else {
5308      startValue = getComputedStyle(target)[_transformProp];
5309      style[_transformProp] = transforms;
5310      endCache = _parseTransform(target, 1);
5311      style[_transformProp] = startValue;
5312    }
5313
5314    for (p in _transformProps) {
5315      startValue = startCache[p];
5316      endValue = endCache[p];
5317
5318      if (startValue !== endValue && exclude.indexOf(p) < 0) {
5319        startUnit = getUnit(startValue);
5320        endUnit = getUnit(endValue);
5321        startNum = startUnit !== endUnit ? _convertToUnit(target, p, startValue, endUnit) : parseFloat(startValue);
5322        endNum = parseFloat(endValue);
5323        plugin._pt = new PropTween(plugin._pt, endCache, p, startNum, endNum - startNum, _renderCSSProp);
5324        plugin._pt.u = endUnit || 0;
5325
5326        plugin._props.push(p);
5327      }
5328    }
5329
5330    _assign(endCache, startCache);
5331  };
5332
5333  _forEachName("padding,margin,Width,Radius", function (name, index) {
5334    var t = "Top",
5335        r = "Right",
5336        b = "Bottom",
5337        l = "Left",
5338        props = (index < 3 ? [t, r, b, l] : [t + l, t + r, b + r, b + l]).map(function (side) {
5339      return index < 2 ? name + side : "border" + side + name;
5340    });
5341
5342    _specialProps[index > 1 ? "border" + name : name] = function (plugin, target, property, endValue, tween) {
5343      var a, vars;
5344
5345      if (arguments.length < 4) {
5346        a = props.map(function (prop) {
5347          return _get(plugin, prop, property);
5348        });
5349        vars = a.join(" ");
5350        return vars.split(a[0]).length === 5 ? a[0] : vars;
5351      }
5352
5353      a = (endValue + "").split(" ");
5354      vars = {};
5355      props.forEach(function (prop, i) {
5356        return vars[prop] = a[i] = a[i] || a[(i - 1) / 2 | 0];
5357      });
5358      plugin.init(target, vars, tween);
5359    };
5360  });
5361
5362  var CSSPlugin = {
5363    name: "css",
5364    register: _initCore,
5365    targetTest: function targetTest(target) {
5366      return target.style && target.nodeType;
5367    },
5368    init: function init(target, vars, tween, index, targets) {
5369      var props = this._props,
5370          style = target.style,
5371          startAt = tween.vars.startAt,
5372          startValue,
5373          endValue,
5374          endNum,
5375          startNum,
5376          type,
5377          specialProp,
5378          p,
5379          startUnit,
5380          endUnit,
5381          relative,
5382          isTransformRelated,
5383          transformPropTween,
5384          cache,
5385          smooth,
5386          hasPriority,
5387          inlineProps

vendor: 8,025 bytes, lines 5387-5574

5387;
5388      _pluginInitted || _initCore();
5389      this.styles = this.styles || _getStyleSaver(target);
5390      inlineProps = this.styles.props;
5391      this.tween = tween;
5392
5393      for (p in vars) {
5394        if (p === "autoRound") {
5395          continue;
5396        }
5397
5398        endValue = vars[p];
5399
5400        if (_plugins[p] && _checkPlugin(p, vars, tween, index, target, targets)) {
5401          continue;
5402        }
5403
5404        type = typeof endValue;
5405        specialProp = _specialProps[p];
5406
5407        if (type === "function") {
5408          endValue = endValue.call(tween, index, target, targets);
5409          type = typeof endValue;
5410        }
5411
5412        if (type === "string" && ~endValue.indexOf("random(")) {
5413          endValue = _replaceRandom(endValue);
5414        }
5415
5416        if (specialProp) {
5417          specialProp(this, target, p, endValue, tween) && (hasPriority = 1);
5418        } else if (p.substr(0, 2) === "--") {
5419          startValue = (getComputedStyle(target).getPropertyValue(p) + "").trim();
5420          endValue += "";
5421          _colorExp.lastIndex = 0;
5422
5423          if (!_colorExp.test(startValue)) {
5424            startUnit = getUnit(startValue);
5425            endUnit = getUnit(endValue);
5426          }
5427
5428          endUnit ? startUnit !== endUnit && (startValue = _convertToUnit(target, p, startValue, endUnit) + endUnit) : startUnit && (endValue += startUnit);
5429          this.add(style, "setProperty", startValue, endValue, index, targets, 0, 0, p);
5430          props.push(p);
5431          inlineProps.push(p, 0, style[p]);
5432        } else if (type !== "undefined") {
5433          if (startAt && p in startAt) {
5434            startValue = typeof startAt[p] === "function" ? startAt[p].call(tween, index, target, targets) : startAt[p];
5435            _isString(startValue) && ~startValue.indexOf("random(") && (startValue = _replaceRandom(startValue));
5436            getUnit(startValue + "") || startValue === "auto" || (startValue += _config.units[p] || getUnit(_get(target, p)) || "");
5437            (startValue + "").charAt(1) === "=" && (startValue = _get(target, p));
5438          } else {
5439            startValue = _get(target, p);
5440          }
5441
5442          startNum = parseFloat(startValue);
5443          relative = type === "string" && endValue.charAt(1) === "=" && endValue.substr(0, 2);
5444          relative && (endValue = endValue.substr(2));
5445          endNum = parseFloat(endValue);
5446
5447          if (p in _propertyAliases) {
5448            if (p === "autoAlpha") {
5449              if (startNum === 1 && _get(target, "visibility") === "hidden" && endNum) {
5450                startNum = 0;
5451              }
5452
5453              inlineProps.push("visibility", 0, style.visibility);
5454
5455              _addNonTweeningPT(this, style, "visibility", startNum ? "inherit" : "hidden", endNum ? "inherit" : "hidden", !endNum);
5456            }
5457
5458            if (p !== "scale" && p !== "transform") {
5459              p = _propertyAliases[p];
5460              ~p.indexOf(",") && (p = p.split(",")[0]);
5461            }
5462          }
5463
5464          isTransformRelated = p in _transformProps;
5465
5466          if (isTransformRelated) {
5467            this.styles.save(p);
5468
5469            if (!transformPropTween) {
5470              cache = target._gsap;
5471              cache.renderTransform && !vars.parseTransform || _parseTransform(target, vars.parseTransform);
5472              smooth = vars.smoothOrigin !== false && cache.smooth;
5473              transformPropTween = this._pt = new PropTween(this._pt, style, _transformProp, 0, 1, cache.renderTransform, cache, 0, -1);
5474              transformPropTween.dep = 1;
5475            }
5476
5477            if (p === "scale") {
5478              this._pt = new PropTween(this._pt, cache, "scaleY", cache.scaleY, (relative ? _parseRelative(cache.scaleY, relative + endNum) : endNum) - cache.scaleY || 0, _renderCSSProp);
5479              this._pt.u = 0;
5480              props.push("scaleY", p);
5481              p += "X";
5482            } else if (p === "transformOrigin") {
5483              inlineProps.push(_transformOriginProp, 0, style[_transformOriginProp]);
5484              endValue = _convertKeywordsToPercentages(endValue);
5485
5486              if (cache.svg) {
5487                _applySVGOrigin(target, endValue, 0, smooth, 0, this);
5488              } else {
5489                endUnit = parseFloat(endValue.split(" ")[2]) || 0;
5490                endUnit !== cache.zOrigin && _addNonTweeningPT(this, cache, "zOrigin", cache.zOrigin, endUnit);
5491
5492                _addNonTweeningPT(this, style, p, _firstTwoOnly(startValue), _firstTwoOnly(endValue));
5493              }
5494
5495              continue;
5496            } else if (p === "svgOrigin") {
5497              _applySVGOrigin(target, endValue, 1, smooth, 0, this);
5498
5499              continue;
5500            } else if (p in _rotationalProperties) {
5501              _addRotationalPropTween(this, cache, p, startNum, relative ? _parseRelative(startNum, relative + endValue) : endValue);
5502
5503              continue;
5504            } else if (p === "smoothOrigin") {
5505              _addNonTweeningPT(this, cache, "smooth", cache.smooth, endValue);
5506
5507              continue;
5508            } else if (p === "force3D") {
5509              cache[p] = endValue;
5510              continue;
5511            } else if (p === "transform") {
5512              _addRawTransformPTs(this, endValue, target);
5513
5514              continue;
5515            }
5516          } else if (!(p in style)) {
5517            p = _checkPropPrefix(p) || p;
5518          }
5519
5520          if (isTransformRelated || (endNum || endNum === 0) && (startNum || startNum === 0) && !_complexExp.test(endValue) && p in style) {
5521            startUnit = (startValue + "").substr((startNum + "").length);
5522            endNum || (endNum = 0);
5523            endUnit = getUnit(endValue) || (p in _config.units ? _config.units[p] : startUnit);
5524            startUnit !== endUnit && (startNum = _convertToUnit(target, p, startValue, endUnit));
5525            this._pt = new PropTween(this._pt, isTransformRelated ? cache : style, p, startNum, (relative ? _parseRelative(startNum, relative + endNum) : endNum) - startNum, !isTransformRelated && (endUnit === "px" || p === "zIndex") && vars.autoRound !== false ? _renderRoundedCSSProp : _renderCSSProp);
5526            this._pt.u = endUnit || 0;
5527
5528            if (startUnit !== endUnit && endUnit !== "%") {
5529              this._pt.b = startValue;
5530              this._pt.r = _renderCSSPropWithBeginning;
5531            }
5532          } else if (!(p in style)) {
5533            if (p in target) {
5534              this.add(target, p, startValue || target[p], relative ? relative + endValue : endValue, index, targets);
5535            } else if (p !== "parseTransform") {
5536              _missingPlugin(p, endValue);
5537
5538              continue;
5539            }
5540          } else {
5541            _tweenComplexCSSString.call(this, target, p, startValue, relative ? relative + endValue : endValue);
5542          }
5543
5544          isTransformRelated || (p in style ? inlineProps.push(p, 0, style[p]) : inlineProps.push(p, 1, startValue || target[p]));
5545          props.push(p);
5546        }
5547      }
5548
5549      hasPriority && _sortPropTweensByPriority(this);
5550    },
5551    render: function render(ratio, data) {
5552      if (data.tween._time || !_reverting$1()) {
5553        var pt = data._pt;
5554
5555        while (pt) {
5556          pt.r(ratio, pt.d);
5557          pt = pt._next;
5558        }
5559      } else {
5560        data.styles.revert();
5561      }
5562    },
5563    get: _get,
5564    aliases: _propertyAliases,
5565    getSetter: function getSetter(target, property, plugin) {
5566      var p = _propertyAliases[property];
5567      p && p.indexOf(",") < 0 && (property = p);
5568      return property in _transformProps && property !== _transformOriginProp && (target._gsap.x || _get(target, "x")) ? plugin && _recentSetterPlugin === plugin ? property === "scale" ? _setterScale : _setterTransform : (_recentSetterPlugin = plugin || {}) && (property === "scale" ? _setterScaleWithRender : _setterTransformWithRender) : target.style && !_isUndefined(target.style[property]) ? _setterCSSStyle : ~property.indexOf("-") ? _setterCSSProp : _getSetter(target, property);
5569    },
5570    core: {
5571      _removeProperty: _removeProperty,
5572      _getMatrix: _getMatrix
5573    }
5574  };

vendor: 2,267 bytes, lines 5575-5633

5575  gsap.utils.checkPrefix = _checkPropPrefix;
5576  gsap.core.getStyleSaver = _getStyleSaver;
5577
5578  (function (positionAndScale, rotation, others, aliases) {
5579    var all = _forEachName(positionAndScale + "," + rotation + "," + others, function (name) {
5580      _transformProps[name] = 1;
5581    });
5582
5583    _forEachName(rotation, function (name) {
5584      _config.units[name] = "deg";
5585      _rotationalProperties[name] = 1;
5586    });
5587
5588    _propertyAliases[all[13]] = positionAndScale + "," + rotation;
5589
5590    _forEachName(aliases, function (name) {
5591      var split = name.split(":");
5592      _propertyAliases[split[1]] = all[split[0]];
5593    });
5594  })("x,y,z,scale,scaleX,scaleY,xPercent,yPercent", "rotation,rotationX,rotationY,skewX,skewY", "transform,transformOrigin,svgOrigin,force3D,smoothOrigin,transformPerspective", "0:translateX,1:translateY,2:translateZ,8:rotate,8:rotationZ,8:rotateZ,9:rotateX,10:rotateY");
5595
5596  _forEachName("x,y,z,top,right,bottom,left,width,height,fontSize,padding,margin,perspective", function (name) {
5597    _config.units[name] = "px";
5598  });
5599
5600  gsap.registerPlugin(CSSPlugin);
5601
5602  var _svgPathExp = /[achlmqstvz]|(-?\d*\.?\d*(?:e[\-+]?\d+)?)[0-9]/ig,
5603      _numbersExp = /(?:(-)?\d*\.?\d*(?:e[\-+]?\d+)?)[0-9]/ig,
5604      _scientific = /[\+\-]?\d*\.?\d+e[\+\-]?\d+/ig,
5605      _selectorExp = /(^[#\.][a-z]|[a-y][a-z])/i,
5606      _DEG2RAD$1 = Math.PI / 180,
5607      _RAD2DEG$1 = 180 / Math.PI,
5608      _sin$1 = Math.sin,
5609      _cos$1 = Math.cos,
5610      _abs = Math.abs,
5611      _sqrt$1 = Math.sqrt,
5612      _atan2$1 = Math.atan2,
5613      _largeNum = 1e8,
5614      _isString$1 = function _isString(value) {
5615    return typeof value === "string";
5616  },
5617      _isNumber$1 = function _isNumber(value) {
5618    return typeof value === "number";
5619  },
5620      _isUndefined$1 = function _isUndefined(value) {
5621    return typeof value === "undefined";
5622  },
5623      _temp = {},
5624      _temp2 = {},
5625      _roundingNum = 1e5,
5626      _wrapProgress = function _wrapProgress(progress) {
5627    return Math.round((progress + _largeNum) % 1 * _roundingNum) / _roundingNum || (progress < 0 ? 0 : 1);
5628  },
5629      _round$1 = function _round(value) {
5630    return Math.round(value * _roundingNum) / _roundingNum || 0;
5631  },
5632      _roundPrecise$1 = function _roundPrecise(value) {
5633    return Math.round(value * 1e10) / 1e10 || 0

vendor: 12,714 bytes, lines 5633-6097

5633;
5634  },
5635      _splitSegment = function _splitSegment(rawPath, segIndex, i, t) {
5636    var segment = rawPath[segIndex],
5637        shift = t === 1 ? 6 : subdivideSegment(segment, i, t);
5638
5639    if ((shift || !t) && shift + i + 2 < segment.length) {
5640      rawPath.splice(segIndex, 0, segment.slice(0, i + shift + 2));
5641      segment.splice(0, i + shift);
5642      return 1;
5643    }
5644  },
5645      _getSampleIndex = function _getSampleIndex(samples, length, progress) {
5646    var l = samples.length,
5647        i = ~~(progress * l);
5648
5649    if (samples[i] > length) {
5650      while (--i && samples[i] > length) {}
5651
5652      i < 0 && (i = 0);
5653    } else {
5654      while (samples[++i] < length && i < l) {}
5655    }
5656
5657    return i < l ? i : l - 1;
5658  },
5659      _reverseRawPath = function _reverseRawPath(rawPath, skipOuter) {
5660    var i = rawPath.length;
5661    skipOuter || rawPath.reverse();
5662
5663    while (i--) {
5664      rawPath[i].reversed || reverseSegment(rawPath[i]);
5665    }
5666  },
5667      _copyMetaData = function _copyMetaData(source, copy) {
5668    copy.totalLength = source.totalLength;
5669
5670    if (source.samples) {
5671      copy.samples = source.samples.slice(0);
5672      copy.lookup = source.lookup.slice(0);
5673      copy.minLength = source.minLength;
5674      copy.resolution = source.resolution;
5675    } else if (source.totalPoints) {
5676      copy.totalPoints = source.totalPoints;
5677    }
5678
5679    return copy;
5680  },
5681      _appendOrMerge = function _appendOrMerge(rawPath, segment) {
5682    var index = rawPath.length,
5683        prevSeg = rawPath[index - 1] || [],
5684        l = prevSeg.length;
5685
5686    if (index && segment[0] === prevSeg[l - 2] && segment[1] === prevSeg[l - 1]) {
5687      segment = prevSeg.concat(segment.slice(2));
5688      index--;
5689    }
5690
5691    rawPath[index] = segment;
5692  },
5693      _bestDistance;
5694
5695  function getRawPath(value) {
5696    value = _isString$1(value) && _selectorExp.test(value) ? document.querySelector(value) || value : value;
5697    var e = value.getAttribute ? value : 0,
5698        rawPath;
5699
5700    if (e && (value = value.getAttribute("d"))) {
5701      if (!e._gsPath) {
5702        e._gsPath = {};
5703      }
5704
5705      rawPath = e._gsPath[value];
5706      return rawPath && !rawPath._dirty ? rawPath : e._gsPath[value] = stringToRawPath(value);
5707    }
5708
5709    return !value ? console.warn("Expecting a <path> element or an SVG path data string") : _isString$1(value) ? stringToRawPath(value) : _isNumber$1(value[0]) ? [value] : value;
5710  }
5711  function copyRawPath(rawPath) {
5712    var a = [],
5713        i = 0;
5714
5715    for (; i < rawPath.length; i++) {
5716      a[i] = _copyMetaData(rawPath[i], rawPath[i].slice(0));
5717    }
5718
5719    return _copyMetaData(rawPath, a);
5720  }
5721  function reverseSegment(segment) {
5722    var i = 0,
5723        y;
5724    segment.reverse();
5725
5726    for (; i < segment.length; i += 2) {
5727      y = segment[i];
5728      segment[i] = segment[i + 1];
5729      segment[i + 1] = y;
5730    }
5731
5732    segment.reversed = !segment.reversed;
5733  }
5734
5735  var _createPath = function _createPath(e, ignore) {
5736    var path = document.createElementNS("http://www.w3.org/2000/svg", "path"),
5737        attr = [].slice.call(e.attributes),
5738        i = attr.length,
5739        name;
5740    ignore = "," + ignore + ",";
5741
5742    while (--i > -1) {
5743      name = attr[i].nodeName.toLowerCase();
5744
5745      if (ignore.indexOf("," + name + ",") < 0) {
5746        path.setAttributeNS(null, name, attr[i].nodeValue);
5747      }
5748    }
5749
5750    return path;
5751  },
5752      _typeAttrs = {
5753    rect: "rx,ry,x,y,width,height",
5754    circle: "r,cx,cy",
5755    ellipse: "rx,ry,cx,cy",
5756    line: "x1,x2,y1,y2"
5757  },
5758      _attrToObj = function _attrToObj(e, attrs) {
5759    var props = attrs ? attrs.split(",") : [],
5760        obj = {},
5761        i = props.length;
5762
5763    while (--i > -1) {
5764      obj[props[i]] = +e.getAttribute(props[i]) || 0;
5765    }
5766
5767    return obj;
5768  };
5769
5770  function convertToPath(element, swap) {
5771    var type = element.tagName.toLowerCase(),
5772        circ = 0.552284749831,
5773        data,
5774        x,
5775        y,
5776        r,
5777        ry,
5778        path,
5779        rcirc,
5780        rycirc,
5781        points,
5782        w,
5783        h,
5784        x2,
5785        x3,
5786        x4,
5787        x5,
5788        x6,
5789        y2,
5790        y3,
5791        y4,
5792        y5,
5793        y6,
5794        attr;
5795
5796    if (type === "path" || !element.getBBox) {
5797      return element;
5798    }
5799
5800    path = _createPath(element, "x,y,width,height,cx,cy,rx,ry,r,x1,x2,y1,y2,points");
5801    attr = _attrToObj(element, _typeAttrs[type]);
5802
5803    if (type === "rect") {
5804      r = attr.rx;
5805      ry = attr.ry || r;
5806      x = attr.x;
5807      y = attr.y;
5808      w = attr.width - r * 2;
5809      h = attr.height - ry * 2;
5810
5811      if (r || ry) {
5812        x2 = x + r * (1 - circ);
5813        x3 = x + r;
5814        x4 = x3 + w;
5815        x5 = x4 + r * circ;
5816        x6 = x4 + r;
5817        y2 = y + ry * (1 - circ);
5818        y3 = y + ry;
5819        y4 = y3 + h;
5820        y5 = y4 + ry * circ;
5821        y6 = y4 + ry;
5822        data = "M" + x6 + "," + y3 + " V" + y4 + " C" + [x6, y5, x5, y6, x4, y6, x4 - (x4 - x3) / 3, y6, x3 + (x4 - x3) / 3, y6, x3, y6, x2, y6, x, y5, x, y4, x, y4 - (y4 - y3) / 3, x, y3 + (y4 - y3) / 3, x, y3, x, y2, x2, y, x3, y, x3 + (x4 - x3) / 3, y, x4 - (x4 - x3) / 3, y, x4, y, x5, y, x6, y2, x6, y3].join(",") + "z";
5823      } else {
5824        data = "M" + (x + w) + "," + y + " v" + h + " h" + -w + " v" + -h + " h" + w + "z";
5825      }
5826    } else if (type === "circle" || type === "ellipse") {
5827      if (type === "circle") {
5828        r = ry = attr.r;
5829        rycirc = r * circ;
5830      } else {
5831        r = attr.rx;
5832        ry = attr.ry;
5833        rycirc = ry * circ;
5834      }
5835
5836      x = attr.cx;
5837      y = attr.cy;
5838      rcirc = r * circ;
5839      data = "M" + (x + r) + "," + y + " C" + [x + r, y + rycirc, x + rcirc, y + ry, x, y + ry, x - rcirc, y + ry, x - r, y + rycirc, x - r, y, x - r, y - rycirc, x - rcirc, y - ry, x, y - ry, x + rcirc, y - ry, x + r, y - rycirc, x + r, y].join(",") + "z";
5840    } else if (type === "line") {
5841      data = "M" + attr.x1 + "," + attr.y1 + " L" + attr.x2 + "," + attr.y2;
5842    } else if (type === "polyline" || type === "polygon") {
5843      points = (element.getAttribute("points") + "").match(_numbersExp) || [];
5844      x = points.shift();
5845      y = points.shift();
5846      data = "M" + x + "," + y + " L" + points.join(",");
5847
5848      if (type === "polygon") {
5849        data += "," + x + "," + y + "z";
5850      }
5851    }
5852
5853    path.setAttribute("d", rawPathToString(path._gsRawPath = stringToRawPath(data)));
5854
5855    if (swap && element.parentNode) {
5856      element.parentNode.insertBefore(path, element);
5857      element.parentNode.removeChild(element);
5858    }
5859
5860    return path;
5861  }
5862
5863  function getRotationAtBezierT(segment, i, t) {
5864    var a = segment[i],
5865        b = segment[i + 2],
5866        c = segment[i + 4],
5867        x;
5868    a += (b - a) * t;
5869    b += (c - b) * t;
5870    a += (b - a) * t;
5871    x = b + (c + (segment[i + 6] - c) * t - b) * t - a;
5872    a = segment[i + 1];
5873    b = segment[i + 3];
5874    c = segment[i + 5];
5875    a += (b - a) * t;
5876    b += (c - b) * t;
5877    a += (b - a) * t;
5878    return _round$1(_atan2$1(b + (c + (segment[i + 7] - c) * t - b) * t - a, x) * _RAD2DEG$1);
5879  }
5880
5881  function sliceRawPath(rawPath, start, end) {
5882    end = _isUndefined$1(end) ? 1 : _roundPrecise$1(end) || 0;
5883    start = _roundPrecise$1(start) || 0;
5884    var loops = Math.max(0, ~~(_abs(end - start) - 1e-8)),
5885        path = copyRawPath(rawPath);
5886
5887    if (start > end) {
5888      start = 1 - start;
5889      end = 1 - end;
5890
5891      _reverseRawPath(path);
5892
5893      path.totalLength = 0;
5894    }
5895
5896    if (start < 0 || end < 0) {
5897      var offset = Math.abs(~~Math.min(start, end)) + 1;
5898      start += offset;
5899      end += offset;
5900    }
5901
5902    path.totalLength || cacheRawPathMeasurements(path);
5903    var wrap = end > 1,
5904        s = getProgressData(path, start, _temp, true),
5905        e = getProgressData(path, end, _temp2),
5906        eSeg = e.segment,
5907        sSeg = s.segment,
5908        eSegIndex = e.segIndex,
5909        sSegIndex = s.segIndex,
5910        ei = e.i,
5911        si = s.i,
5912        sameSegment = sSegIndex === eSegIndex,
5913        sameBezier = ei === si && sameSegment,
5914        wrapsBehind,
5915        sShift,
5916        eShift,
5917        i,
5918        copy,
5919        totalSegments,
5920        l,
5921        j;
5922
5923    if (wrap || loops) {
5924      wrapsBehind = eSegIndex < sSegIndex || sameSegment && ei < si || sameBezier && e.t < s.t;
5925
5926      if (_splitSegment(path, sSegIndex, si, s.t)) {
5927        sSegIndex++;
5928
5929        if (!wrapsBehind) {
5930          eSegIndex++;
5931
5932          if (sameBezier) {
5933            e.t = (e.t - s.t) / (1 - s.t);
5934            ei = 0;
5935          } else if (sameSegment) {
5936            ei -= si;
5937          }
5938        }
5939      }
5940
5941      if (Math.abs(1 - (end - start)) < 1e-5) {
5942        eSegIndex = sSegIndex - 1;
5943      } else if (!e.t && eSegIndex) {
5944        eSegIndex--;
5945      } else if (_splitSegment(path, eSegIndex, ei, e.t) && wrapsBehind) {
5946        sSegIndex++;
5947      }
5948
5949      if (s.t === 1) {
5950        sSegIndex = (sSegIndex + 1) % path.length;
5951      }
5952
5953      copy = [];
5954      totalSegments = path.length;
5955      l = 1 + totalSegments * loops;
5956      j = sSegIndex;
5957      l += (totalSegments - sSegIndex + eSegIndex) % totalSegments;
5958
5959      for (i = 0; i < l; i++) {
5960        _appendOrMerge(copy, path[j++ % totalSegments]);
5961      }
5962
5963      path = copy;
5964    } else {
5965      eShift = e.t === 1 ? 6 : subdivideSegment(eSeg, ei, e.t);
5966
5967      if (start !== end) {
5968        sShift = subdivideSegment(sSeg, si, sameBezier ? s.t / e.t : s.t);
5969        sameSegment && (eShift += sShift);
5970        eSeg.splice(ei + eShift + 2);
5971        (sShift || si) && sSeg.splice(0, si + sShift);
5972        i = path.length;
5973
5974        while (i--) {
5975          (i < sSegIndex || i > eSegIndex) && path.splice(i, 1);
5976        }
5977      } else {
5978        eSeg.angle = getRotationAtBezierT(eSeg, ei + eShift, 0);
5979        ei += eShift;
5980        s = eSeg[ei];
5981        e = eSeg[ei + 1];
5982        eSeg.length = eSeg.totalLength = 0;
5983        eSeg.totalPoints = path.totalPoints = 8;
5984        eSeg.push(s, e, s, e, s, e, s, e);
5985      }
5986    }
5987
5988    path.totalLength = 0;
5989    return path;
5990  }
5991
5992  function measureSegment(segment, startIndex, bezierQty) {
5993    startIndex = startIndex || 0;
5994
5995    if (!segment.samples) {
5996      segment.samples = [];
5997      segment.lookup = [];
5998    }
5999
6000    var resolution = ~~segment.resolution || 12,
6001        inc = 1 / resolution,
6002        endIndex = bezierQty ? startIndex + bezierQty * 6 + 1 : segment.length,
6003        x1 = segment[startIndex],
6004        y1 = segment[startIndex + 1],
6005        samplesIndex = startIndex ? startIndex / 6 * resolution : 0,
6006        samples = segment.samples,
6007        lookup = segment.lookup,
6008        min = (startIndex ? segment.minLength : _largeNum) || _largeNum,
6009        prevLength = samples[samplesIndex + bezierQty * resolution - 1],
6010        length = startIndex ? samples[samplesIndex - 1] : 0,
6011        i,
6012        j,
6013        x4,
6014        x3,
6015        x2,
6016        xd,
6017        xd1,
6018        y4,
6019        y3,
6020        y2,
6021        yd,
6022        yd1,
6023        inv,
6024        t,
6025        lengthIndex,
6026        l,
6027        segLength;
6028    samples.length = lookup.length = 0;
6029
6030    for (j = startIndex + 2; j < endIndex; j += 6) {
6031      x4 = segment[j + 4] - x1;
6032      x3 = segment[j + 2] - x1;
6033      x2 = segment[j] - x1;
6034      y4 = segment[j + 5] - y1;
6035      y3 = segment[j + 3] - y1;
6036      y2 = segment[j + 1] - y1;
6037      xd = xd1 = yd = yd1 = 0;
6038
6039      if (_abs(x4) < .01 && _abs(y4) < .01 && _abs(x2) + _abs(y2) < .01) {
6040        if (segment.length > 8) {
6041          segment.splice(j, 6);
6042          j -= 6;
6043          endIndex -= 6;
6044        }
6045      } else {
6046        for (i = 1; i <= resolution; i++) {
6047          t = inc * i;
6048          inv = 1 - t;
6049          xd = xd1 - (xd1 = (t * t * x4 + 3 * inv * (t * x3 + inv * x2)) * t);
6050          yd = yd1 - (yd1 = (t * t * y4 + 3 * inv * (t * y3 + inv * y2)) * t);
6051          l = _sqrt$1(yd * yd + xd * xd);
6052
6053          if (l < min) {
6054            min = l;
6055          }
6056
6057          length += l;
6058          samples[samplesIndex++] = length;
6059        }
6060      }
6061
6062      x1 += x4;
6063      y1 += y4;
6064    }
6065
6066    if (prevLength) {
6067      prevLength -= length;
6068
6069      for (; samplesIndex < samples.length; samplesIndex++) {
6070        samples[samplesIndex] += prevLength;
6071      }
6072    }
6073
6074    if (samples.length && min) {
6075      segment.totalLength = segLength = samples[samples.length - 1] || 0;
6076      segment.minLength = min;
6077
6078      if (segLength / min < 9999) {
6079        l = lengthIndex = 0;
6080
6081        for (i = 0; i < segLength; i += min) {
6082          lookup[l++] = samples[lengthIndex] < i ? ++lengthIndex : lengthIndex;
6083        }
6084      }
6085    } else {
6086      segment.totalLength = samples[0] = 0;
6087    }
6088
6089    return startIndex ? length - samples[startIndex / 2 - 1] : length;
6090  }
6091
6092  function cacheRawPathMeasurements(rawPath, resolution) {
6093    var pathLength, points, i;
6094
6095    for (i = pathLength = points = 0; i < rawPath.length; i++) {
6096      rawPath[i].resolution = ~~resolution || 12;
6097      p

vendor: 3,989 bytes, lines 6097-6241

6097oints += rawPath[i].length;
6098      pathLength += measureSegment(rawPath[i]);
6099    }
6100
6101    rawPath.totalPoints = points;
6102    rawPath.totalLength = pathLength;
6103    return rawPath;
6104  }
6105  function subdivideSegment(segment, i, t) {
6106    if (t <= 0 || t >= 1) {
6107      return 0;
6108    }
6109
6110    var ax = segment[i],
6111        ay = segment[i + 1],
6112        cp1x = segment[i + 2],
6113        cp1y = segment[i + 3],
6114        cp2x = segment[i + 4],
6115        cp2y = segment[i + 5],
6116        bx = segment[i + 6],
6117        by = segment[i + 7],
6118        x1a = ax + (cp1x - ax) * t,
6119        x2 = cp1x + (cp2x - cp1x) * t,
6120        y1a = ay + (cp1y - ay) * t,
6121        y2 = cp1y + (cp2y - cp1y) * t,
6122        x1 = x1a + (x2 - x1a) * t,
6123        y1 = y1a + (y2 - y1a) * t,
6124        x2a = cp2x + (bx - cp2x) * t,
6125        y2a = cp2y + (by - cp2y) * t;
6126    x2 += (x2a - x2) * t;
6127    y2 += (y2a - y2) * t;
6128    segment.splice(i + 2, 4, _round$1(x1a), _round$1(y1a), _round$1(x1), _round$1(y1), _round$1(x1 + (x2 - x1) * t), _round$1(y1 + (y2 - y1) * t), _round$1(x2), _round$1(y2), _round$1(x2a), _round$1(y2a));
6129    segment.samples && segment.samples.splice(i / 6 * segment.resolution | 0, 0, 0, 0, 0, 0, 0, 0);
6130    return 6;
6131  }
6132
6133  function getProgressData(rawPath, progress, decoratee, pushToNextIfAtEnd) {
6134    decoratee = decoratee || {};
6135    rawPath.totalLength || cacheRawPathMeasurements(rawPath);
6136
6137    if (progress < 0 || progress > 1) {
6138      progress = _wrapProgress(progress);
6139    }
6140
6141    var segIndex = 0,
6142        segment = rawPath[0],
6143        samples,
6144        resolution,
6145        length,
6146        min,
6147        max,
6148        i,
6149        t;
6150
6151    if (!progress) {
6152      t = i = segIndex = 0;
6153      segment = rawPath[0];
6154    } else if (progress === 1) {
6155      t = 1;
6156      segIndex = rawPath.length - 1;
6157      segment = rawPath[segIndex];
6158      i = segment.length - 8;
6159    } else {
6160      if (rawPath.length > 1) {
6161        length = rawPath.totalLength * progress;
6162        max = i = 0;
6163
6164        while ((max += rawPath[i++].totalLength) < length) {
6165          segIndex = i;
6166        }
6167
6168        segment = rawPath[segIndex];
6169        min = max - segment.totalLength;
6170        progress = (length - min) / (max - min) || 0;
6171      }
6172
6173      samples = segment.samples;
6174      resolution = segment.resolution;
6175      length = segment.totalLength * progress;
6176      i = segment.lookup.length ? segment.lookup[~~(length / segment.minLength)] || 0 : _getSampleIndex(samples, length, progress);
6177      min = i ? samples[i - 1] : 0;
6178      max = samples[i];
6179
6180      if (max < length) {
6181        min = max;
6182        max = samples[++i];
6183      }
6184
6185      t = 1 / resolution * ((length - min) / (max - min) + i % resolution);
6186      i = ~~(i / resolution) * 6;
6187
6188      if (pushToNextIfAtEnd && t === 1) {
6189        if (i + 6 < segment.length) {
6190          i += 6;
6191          t = 0;
6192        } else if (segIndex + 1 < rawPath.length) {
6193          i = t = 0;
6194          segment = rawPath[++segIndex];
6195        }
6196      }
6197    }
6198
6199    decoratee.t = t;
6200    decoratee.i = i;
6201    decoratee.path = rawPath;
6202    decoratee.segment = segment;
6203    decoratee.segIndex = segIndex;
6204    return decoratee;
6205  }
6206
6207  function getPositionOnPath(rawPath, progress, includeAngle, point) {
6208    var segment = rawPath[0],
6209        result = point || {},
6210        samples,
6211        resolution,
6212        length,
6213        min,
6214        max,
6215        i,
6216        t,
6217        a,
6218        inv;
6219
6220    if (progress < 0 || progress > 1) {
6221      progress = _wrapProgress(progress);
6222    }
6223
6224    segment.lookup || cacheRawPathMeasurements(rawPath);
6225
6226    if (rawPath.length > 1) {
6227      length = rawPath.totalLength * progress;
6228      max = i = 0;
6229
6230      while ((max += rawPath[i++].totalLength) < length) {
6231        segment = rawPath[i];
6232      }
6233
6234      min = max - segment.totalLength;
6235      progress = (length - min) / (max - min) || 0;
6236    }
6237
6238    samples = segment.samples;
6239    resolution = segment.resolution;
6240    length = segment.totalLength * progress;
6241    i = segment.lookup.length ? segment.lookup[progress < 1 ? ~~(length /

vendor: 16,896 bytes, lines 6241-6857

6241segment.minLength) : segment.lookup.length - 1] || 0 : _getSampleIndex(samples, length, progress);
6242    min = i ? samples[i - 1] : 0;
6243    max = samples[i];
6244
6245    if (max < length) {
6246      min = max;
6247      max = samples[++i];
6248    }
6249
6250    t = 1 / resolution * ((length - min) / (max - min) + i % resolution) || 0;
6251    inv = 1 - t;
6252    i = ~~(i / resolution) * 6;
6253    a = segment[i];
6254    result.x = _round$1((t * t * (segment[i + 6] - a) + 3 * inv * (t * (segment[i + 4] - a) + inv * (segment[i + 2] - a))) * t + a);
6255    result.y = _round$1((t * t * (segment[i + 7] - (a = segment[i + 1])) + 3 * inv * (t * (segment[i + 5] - a) + inv * (segment[i + 3] - a))) * t + a);
6256
6257    if (includeAngle) {
6258      result.angle = segment.totalLength ? getRotationAtBezierT(segment, i, t >= 1 ? 1 - 1e-9 : t ? t : 1e-9) : segment.angle || 0;
6259    }
6260
6261    return result;
6262  }
6263  function transformRawPath(rawPath, a, b, c, d, tx, ty) {
6264    var j = rawPath.length,
6265        segment,
6266        l,
6267        i,
6268        x,
6269        y;
6270
6271    while (--j > -1) {
6272      segment = rawPath[j];
6273      l = segment.length;
6274
6275      for (i = 0; i < l; i += 2) {
6276        x = segment[i];
6277        y = segment[i + 1];
6278        segment[i] = x * a + y * c + tx;
6279        segment[i + 1] = x * b + y * d + ty;
6280      }
6281    }
6282
6283    rawPath._dirty = 1;
6284    return rawPath;
6285  }
6286
6287  function arcToSegment(lastX, lastY, rx, ry, angle, largeArcFlag, sweepFlag, x, y) {
6288    if (lastX === x && lastY === y) {
6289      return;
6290    }
6291
6292    rx = _abs(rx);
6293    ry = _abs(ry);
6294
6295    var angleRad = angle % 360 * _DEG2RAD$1,
6296        cosAngle = _cos$1(angleRad),
6297        sinAngle = _sin$1(angleRad),
6298        PI = Math.PI,
6299        TWOPI = PI * 2,
6300        dx2 = (lastX - x) / 2,
6301        dy2 = (lastY - y) / 2,
6302        x1 = cosAngle * dx2 + sinAngle * dy2,
6303        y1 = -sinAngle * dx2 + cosAngle * dy2,
6304        x1_sq = x1 * x1,
6305        y1_sq = y1 * y1,
6306        radiiCheck = x1_sq / (rx * rx) + y1_sq / (ry * ry);
6307
6308    if (radiiCheck > 1) {
6309      rx = _sqrt$1(radiiCheck) * rx;
6310      ry = _sqrt$1(radiiCheck) * ry;
6311    }
6312
6313    var rx_sq = rx * rx,
6314        ry_sq = ry * ry,
6315        sq = (rx_sq * ry_sq - rx_sq * y1_sq - ry_sq * x1_sq) / (rx_sq * y1_sq + ry_sq * x1_sq);
6316
6317    if (sq < 0) {
6318      sq = 0;
6319    }
6320
6321    var coef = (largeArcFlag === sweepFlag ? -1 : 1) * _sqrt$1(sq),
6322        cx1 = coef * (rx * y1 / ry),
6323        cy1 = coef * -(ry * x1 / rx),
6324        sx2 = (lastX + x) / 2,
6325        sy2 = (lastY + y) / 2,
6326        cx = sx2 + (cosAngle * cx1 - sinAngle * cy1),
6327        cy = sy2 + (sinAngle * cx1 + cosAngle * cy1),
6328        ux = (x1 - cx1) / rx,
6329        uy = (y1 - cy1) / ry,
6330        vx = (-x1 - cx1) / rx,
6331        vy = (-y1 - cy1) / ry,
6332        temp = ux * ux + uy * uy,
6333        angleStart = (uy < 0 ? -1 : 1) * Math.acos(ux / _sqrt$1(temp)),
6334        angleExtent = (ux * vy - uy * vx < 0 ? -1 : 1) * Math.acos((ux * vx + uy * vy) / _sqrt$1(temp * (vx * vx + vy * vy)));
6335
6336    isNaN(angleExtent) && (angleExtent = PI);
6337
6338    if (!sweepFlag && angleExtent > 0) {
6339      angleExtent -= TWOPI;
6340    } else if (sweepFlag && angleExtent < 0) {
6341      angleExtent += TWOPI;
6342    }
6343
6344    angleStart %= TWOPI;
6345    angleExtent %= TWOPI;
6346
6347    var segments = Math.ceil(_abs(angleExtent) / (TWOPI / 4)),
6348        rawPath = [],
6349        angleIncrement = angleExtent / segments,
6350        controlLength = 4 / 3 * _sin$1(angleIncrement / 2) / (1 + _cos$1(angleIncrement / 2)),
6351        ma = cosAngle * rx,
6352        mb = sinAngle * rx,
6353        mc = sinAngle * -ry,
6354        md = cosAngle * ry,
6355        i;
6356
6357    for (i = 0; i < segments; i++) {
6358      angle = angleStart + i * angleIncrement;
6359      x1 = _cos$1(angle);
6360      y1 = _sin$1(angle);
6361      ux = _cos$1(angle += angleIncrement);
6362      uy = _sin$1(angle);
6363      rawPath.push(x1 - controlLength * y1, y1 + controlLength * x1, ux + controlLength * uy, uy - controlLength * ux, ux, uy);
6364    }
6365
6366    for (i = 0; i < rawPath.length; i += 2) {
6367      x1 = rawPath[i];
6368      y1 = rawPath[i + 1];
6369      rawPath[i] = x1 * ma + y1 * mc + cx;
6370      rawPath[i + 1] = x1 * mb + y1 * md + cy;
6371    }
6372
6373    rawPath[i - 2] = x;
6374    rawPath[i - 1] = y;
6375    return rawPath;
6376  }
6377
6378  function stringToRawPath(d) {
6379    var a = (d + "").replace(_scientific, function (m) {
6380      var n = +m;
6381      return n < 0.0001 && n > -0.0001 ? 0 : n;
6382    }).match(_svgPathExp) || [],
6383        path = [],
6384        relativeX = 0,
6385        relativeY = 0,
6386        twoThirds = 2 / 3,
6387        elements = a.length,
6388        points = 0,
6389        errorMessage = "ERROR: malformed path: " + d,
6390        i,
6391        j,
6392        x,
6393        y,
6394        command,
6395        isRelative,
6396        segment,
6397        startX,
6398        startY,
6399        difX,
6400        difY,
6401        beziers,
6402        prevCommand,
6403        flag1,
6404        flag2,
6405        line = function line(sx, sy, ex, ey) {
6406      difX = (ex - sx) / 3;
6407      difY = (ey - sy) / 3;
6408      segment.push(sx + difX, sy + difY, ex - difX, ey - difY, ex, ey);
6409    };
6410
6411    if (!d || !isNaN(a[0]) || isNaN(a[1])) {
6412      console.log(errorMessage);
6413      return path;
6414    }
6415
6416    for (i = 0; i < elements; i++) {
6417      prevCommand = command;
6418
6419      if (isNaN(a[i])) {
6420        command = a[i].toUpperCase();
6421        isRelative = command !== a[i];
6422      } else {
6423        i--;
6424      }
6425
6426      x = +a[i + 1];
6427      y = +a[i + 2];
6428
6429      if (isRelative) {
6430        x += relativeX;
6431        y += relativeY;
6432      }
6433
6434      if (!i) {
6435        startX = x;
6436        startY = y;
6437      }
6438
6439      if (command === "M") {
6440        if (segment) {
6441          if (segment.length < 8) {
6442            path.length -= 1;
6443          } else {
6444            points += segment.length;
6445          }
6446        }
6447
6448        relativeX = startX = x;
6449        relativeY = startY = y;
6450        segment = [x, y];
6451        path.push(segment);
6452        i += 2;
6453        command = "L";
6454      } else if (command === "C") {
6455        if (!segment) {
6456          segment = [0, 0];
6457        }
6458
6459        if (!isRelative) {
6460          relativeX = relativeY = 0;
6461        }
6462
6463        segment.push(x, y, relativeX + a[i + 3] * 1, relativeY + a[i + 4] * 1, relativeX += a[i + 5] * 1, relativeY += a[i + 6] * 1);
6464        i += 6;
6465      } else if (command === "S") {
6466        difX = relativeX;
6467        difY = relativeY;
6468
6469        if (prevCommand === "C" || prevCommand === "S") {
6470          difX += relativeX - segment[segment.length - 4];
6471          difY += relativeY - segment[segment.length - 3];
6472        }
6473
6474        if (!isRelative) {
6475          relativeX = relativeY = 0;
6476        }
6477
6478        segment.push(difX, difY, x, y, relativeX += a[i + 3] * 1, relativeY += a[i + 4] * 1);
6479        i += 4;
6480      } else if (command === "Q") {
6481        difX = relativeX + (x - relativeX) * twoThirds;
6482        difY = relativeY + (y - relativeY) * twoThirds;
6483
6484        if (!isRelative) {
6485          relativeX = relativeY = 0;
6486        }
6487
6488        relativeX += a[i + 3] * 1;
6489        relativeY += a[i + 4] * 1;
6490        segment.push(difX, difY, relativeX + (x - relativeX) * twoThirds, relativeY + (y - relativeY) * twoThirds, relativeX, relativeY);
6491        i += 4;
6492      } else if (command === "T") {
6493        difX = relativeX - segment[segment.length - 4];
6494        difY = relativeY - segment[segment.length - 3];
6495        segment.push(relativeX + difX, relativeY + difY, x + (relativeX + difX * 1.5 - x) * twoThirds, y + (relativeY + difY * 1.5 - y) * twoThirds, relativeX = x, relativeY = y);
6496        i += 2;
6497      } else if (command === "H") {
6498        line(relativeX, relativeY, relativeX = x, relativeY);
6499        i += 1;
6500      } else if (command === "V") {
6501        line(relativeX, relativeY, relativeX, relativeY = x + (isRelative ? relativeY - relativeX : 0));
6502        i += 1;
6503      } else if (command === "L" || command === "Z") {
6504        if (command === "Z") {
6505          x = startX;
6506          y = startY;
6507          segment.closed = true;
6508        }
6509
6510        if (command === "L" || _abs(relativeX - x) > 0.5 || _abs(relativeY - y) > 0.5) {
6511          line(relativeX, relativeY, x, y);
6512
6513          if (command === "L") {
6514            i += 2;
6515          }
6516        }
6517
6518        relativeX = x;
6519        relativeY = y;
6520      } else if (command === "A") {
6521        flag1 = a[i + 4];
6522        flag2 = a[i + 5];
6523        difX = a[i + 6];
6524        difY = a[i + 7];
6525        j = 7;
6526
6527        if (flag1.length > 1) {
6528          if (flag1.length < 3) {
6529            difY = difX;
6530            difX = flag2;
6531            j--;
6532          } else {
6533            difY = flag2;
6534            difX = flag1.substr(2);
6535            j -= 2;
6536          }
6537
6538          flag2 = flag1.charAt(1);
6539          flag1 = flag1.charAt(0);
6540        }
6541
6542        beziers = arcToSegment(relativeX, relativeY, +a[i + 1], +a[i + 2], +a[i + 3], +flag1, +flag2, (isRelative ? relativeX : 0) + difX * 1, (isRelative ? relativeY : 0) + difY * 1);
6543        i += j;
6544
6545        if (beziers) {
6546          for (j = 0; j < beziers.length; j++) {
6547            segment.push(beziers[j]);
6548          }
6549        }
6550
6551        relativeX = segment[segment.length - 2];
6552        relativeY = segment[segment.length - 1];
6553      } else {
6554        console.log(errorMessage);
6555      }
6556    }
6557
6558    i = segment.length;
6559
6560    if (i < 6) {
6561      path.pop();
6562      i = 0;
6563    } else if (segment[0] === segment[i - 2] && segment[1] === segment[i - 1]) {
6564      segment.closed = true;
6565    }
6566
6567    path.totalPoints = points + i;
6568    return path;
6569  }
6570  function bezierToPoints(x1, y1, x2, y2, x3, y3, x4, y4, threshold, points, index) {
6571    var x12 = (x1 + x2) / 2,
6572        y12 = (y1 + y2) / 2,
6573        x23 = (x2 + x3) / 2,
6574        y23 = (y2 + y3) / 2,
6575        x34 = (x3 + x4) / 2,
6576        y34 = (y3 + y4) / 2,
6577        x123 = (x12 + x23) / 2,
6578        y123 = (y12 + y23) / 2,
6579        x234 = (x23 + x34) / 2,
6580        y234 = (y23 + y34) / 2,
6581        x1234 = (x123 + x234) / 2,
6582        y1234 = (y123 + y234) / 2,
6583        dx = x4 - x1,
6584        dy = y4 - y1,
6585        d2 = _abs((x2 - x4) * dy - (y2 - y4) * dx),
6586        d3 = _abs((x3 - x4) * dy - (y3 - y4) * dx),
6587        length;
6588
6589    if (!points) {
6590      points = [x1, y1, x4, y4];
6591      index = 2;
6592    }
6593
6594    points.splice(index || points.length - 2, 0, x1234, y1234);
6595
6596    if ((d2 + d3) * (d2 + d3) > threshold * (dx * dx + dy * dy)) {
6597      length = points.length;
6598      bezierToPoints(x1, y1, x12, y12, x123, y123, x1234, y1234, threshold, points, index);
6599      bezierToPoints(x1234, y1234, x234, y234, x34, y34, x4, y4, threshold, points, index + 2 + (points.length - length));
6600    }
6601
6602    return points;
6603  }
6604  function flatPointsToSegment(points, curviness) {
6605    if (curviness === void 0) {
6606      curviness = 1;
6607    }
6608
6609    var x = points[0],
6610        y = 0,
6611        segment = [x, y],
6612        i = 2;
6613
6614    for (; i < points.length; i += 2) {
6615      segment.push(x, y, points[i], y = (points[i] - x) * curviness / 2, x = points[i], -y);
6616    }
6617
6618    return segment;
6619  }
6620  function pointsToSegment(points, curviness) {
6621    _abs(points[0] - points[2]) < 1e-4 && _abs(points[1] - points[3]) < 1e-4 && (points = points.slice(2));
6622    var l = points.length - 2,
6623        x = +points[0],
6624        y = +points[1],
6625        nextX = +points[2],
6626        nextY = +points[3],
6627        segment = [x, y, x, y],
6628        dx2 = nextX - x,
6629        dy2 = nextY - y,
6630        closed = Math.abs(points[l] - x) < 0.001 && Math.abs(points[l + 1] - y) < 0.001,
6631        prevX,
6632        prevY,
6633        i,
6634        dx1,
6635        dy1,
6636        r1,
6637        r2,
6638        r3,
6639        tl,
6640        mx1,
6641        mx2,
6642        mxm,
6643        my1,
6644        my2,
6645        mym;
6646
6647    if (closed) {
6648      points.push(nextX, nextY);
6649      nextX = x;
6650      nextY = y;
6651      x = points[l - 2];
6652      y = points[l - 1];
6653      points.unshift(x, y);
6654      l += 4;
6655    }
6656
6657    curviness = curviness || curviness === 0 ? +curviness : 1;
6658
6659    for (i = 2; i < l; i += 2) {
6660      prevX = x;
6661      prevY = y;
6662      x = nextX;
6663      y = nextY;
6664      nextX = +points[i + 2];
6665      nextY = +points[i + 3];
6666
6667      if (x === nextX && y === nextY) {
6668        continue;
6669      }
6670
6671      dx1 = dx2;
6672      dy1 = dy2;
6673      dx2 = nextX - x;
6674      dy2 = nextY - y;
6675      r1 = _sqrt$1(dx1 * dx1 + dy1 * dy1);
6676      r2 = _sqrt$1(dx2 * dx2 + dy2 * dy2);
6677      r3 = _sqrt$1(Math.pow(dx2 / r2 + dx1 / r1, 2) + Math.pow(dy2 / r2 + dy1 / r1, 2));
6678      tl = (r1 + r2) * curviness * 0.25 / r3;
6679      mx1 = x - (x - prevX) * (r1 ? tl / r1 : 0);
6680      mx2 = x + (nextX - x) * (r2 ? tl / r2 : 0);
6681      mxm = x - (mx1 + ((mx2 - mx1) * (r1 * 3 / (r1 + r2) + 0.5) / 4 || 0));
6682      my1 = y - (y - prevY) * (r1 ? tl / r1 : 0);
6683      my2 = y + (nextY - y) * (r2 ? tl / r2 : 0);
6684      mym = y - (my1 + ((my2 - my1) * (r1 * 3 / (r1 + r2) + 0.5) / 4 || 0));
6685
6686      if (x !== prevX || y !== prevY) {
6687        segment.push(_round$1(mx1 + mxm), _round$1(my1 + mym), _round$1(x), _round$1(y), _round$1(mx2 + mxm), _round$1(my2 + mym));
6688      }
6689    }
6690
6691    x !== nextX || y !== nextY || segment.length < 4 ? segment.push(_round$1(nextX), _round$1(nextY), _round$1(nextX), _round$1(nextY)) : segment.length -= 2;
6692
6693    if (segment.length === 2) {
6694      segment.push(x, y, x, y, x, y);
6695    } else if (closed) {
6696      segment.splice(0, 6);
6697      segment.length = segment.length - 6;
6698    }
6699
6700    return segment;
6701  }
6702
6703  function pointToSegDist(x, y, x1, y1, x2, y2) {
6704    var dx = x2 - x1,
6705        dy = y2 - y1,
6706        t;
6707
6708    if (dx || dy) {
6709      t = ((x - x1) * dx + (y - y1) * dy) / (dx * dx + dy * dy);
6710
6711      if (t > 1) {
6712        x1 = x2;
6713        y1 = y2;
6714      } else if (t > 0) {
6715        x1 += dx * t;
6716        y1 += dy * t;
6717      }
6718    }
6719
6720    return Math.pow(x - x1, 2) + Math.pow(y - y1, 2);
6721  }
6722
6723  function simplifyStep(points, first, last, tolerance, simplified) {
6724    var maxSqDist = tolerance,
6725        firstX = points[first],
6726        firstY = points[first + 1],
6727        lastX = points[last],
6728        lastY = points[last + 1],
6729        index,
6730        i,
6731        d;
6732
6733    for (i = first + 2; i < last; i += 2) {
6734      d = pointToSegDist(points[i], points[i + 1], firstX, firstY, lastX, lastY);
6735
6736      if (d > maxSqDist) {
6737        index = i;
6738        maxSqDist = d;
6739      }
6740    }
6741
6742    if (maxSqDist > tolerance) {
6743      index - first > 2 && simplifyStep(points, first, index, tolerance, simplified);
6744      simplified.push(points[index], points[index + 1]);
6745      last - index > 2 && simplifyStep(points, index, last, tolerance, simplified);
6746    }
6747  }
6748
6749  function simplifyPoints(points, tolerance) {
6750    var prevX = parseFloat(points[0]),
6751        prevY = parseFloat(points[1]),
6752        temp = [prevX, prevY],
6753        l = points.length - 2,
6754        i,
6755        x,
6756        y,
6757        dx,
6758        dy,
6759        result,
6760        last;
6761    tolerance = Math.pow(tolerance || 1, 2);
6762
6763    for (i = 2; i < l; i += 2) {
6764      x = parseFloat(points[i]);
6765      y = parseFloat(points[i + 1]);
6766      dx = prevX - x;
6767      dy = prevY - y;
6768
6769      if (dx * dx + dy * dy > tolerance) {
6770        temp.push(x, y);
6771        prevX = x;
6772        prevY = y;
6773      }
6774    }
6775
6776    temp.push(parseFloat(points[l]), parseFloat(points[l + 1]));
6777    last = temp.length - 2;
6778    result = [temp[0], temp[1]];
6779    simplifyStep(temp, 0, last, tolerance, result);
6780    result.push(temp[last], temp[last + 1]);
6781    return result;
6782  }
6783
6784  function getClosestProgressOnBezier(iterations, px, py, start, end, slices, x0, y0, x1, y1, x2, y2, x3, y3) {
6785    var inc = (end - start) / slices,
6786        best = 0,
6787        t = start,
6788        x,
6789        y,
6790        d,
6791        dx,
6792        dy,
6793        inv;
6794    _bestDistance = _largeNum;
6795
6796    while (t <= end) {
6797      inv = 1 - t;
6798      x = inv * inv * inv * x0 + 3 * inv * inv * t * x1 + 3 * inv * t * t * x2 + t * t * t * x3;
6799      y = inv * inv * inv * y0 + 3 * inv * inv * t * y1 + 3 * inv * t * t * y2 + t * t * t * y3;
6800      dx = x - px;
6801      dy = y - py;
6802      d = dx * dx + dy * dy;
6803
6804      if (d < _bestDistance) {
6805        _bestDistance = d;
6806        best = t;
6807      }
6808
6809      t += inc;
6810    }
6811
6812    return iterations > 1 ? getClosestProgressOnBezier(iterations - 1, px, py, Math.max(best - inc, 0), Math.min(best + inc, 1), slices, x0, y0, x1, y1, x2, y2, x3, y3) : best;
6813  }
6814
6815  function getClosestData(rawPath, x, y, slices) {
6816    var closest = {
6817      j: 0,
6818      i: 0,
6819      t: 0
6820    },
6821        bestDistance = _largeNum,
6822        i,
6823        j,
6824        t,
6825        segment;
6826
6827    for (j = 0; j < rawPath.length; j++) {
6828      segment = rawPath[j];
6829
6830      for (i = 0; i < segment.length; i += 6) {
6831        t = getClosestProgressOnBezier(1, x, y, 0, 1, slices || 20, segment[i], segment[i + 1], segment[i + 2], segment[i + 3], segment[i + 4], segment[i + 5], segment[i + 6], segment[i + 7]);
6832
6833        if (bestDistance > _bestDistance) {
6834          bestDistance = _bestDistance;
6835          closest.j = j;
6836          closest.i = i;
6837          closest.t = t;
6838        }
6839      }
6840    }
6841
6842    return closest;
6843  }
6844  function rawPathToString(rawPath) {
6845    if (_isNumber$1(rawPath[0])) {
6846      rawPath = [rawPath];
6847    }
6848
6849    var result = "",
6850        l = rawPath.length,
6851        sl,
6852        s,
6853        i,
6854        segment;
6855
6856    for (s = 0; s < l; s++) {
6857      segment = rawPath[s];

vendor: 8,187 bytes, lines 6858-7170

6858      result += "M" + _round$1(segment[0]) + "," + _round$1(segment[1]) + " C";
6859      sl = segment.length;
6860
6861      for (i = 2; i < sl; i++) {
6862        result += _round$1(segment[i++]) + "," + _round$1(segment[i++]) + " " + _round$1(segment[i++]) + "," + _round$1(segment[i++]) + " " + _round$1(segment[i++]) + "," + _round$1(segment[i]) + " ";
6863      }
6864
6865      if (segment.closed) {
6866        result += "z";
6867      }
6868    }
6869
6870    return result;
6871  }
6872
6873  /*!
6874   * CustomEase 3.12.5
6875   * https://gsap.com
6876   *
6877   * @license Copyright 2008-2024, GreenSock. All rights reserved.
6878   * Subject to the terms at https://gsap.com/standard-license or for
6879   * Club GSAP members, the agreement issued with that membership.
6880   * @author: Jack Doyle, [email protected]
6881  */
6882
6883  var gsap$1,
6884      _coreInitted$1,
6885      _getGSAP = function _getGSAP() {
6886    return gsap$1 || typeof window !== "undefined" && (gsap$1 = window.gsap) && gsap$1.registerPlugin && gsap$1;
6887  },
6888      _initCore$1 = function _initCore() {
6889    gsap$1 = _getGSAP();
6890
6891    if (gsap$1) {
6892      gsap$1.registerEase("_CE", CustomEase.create);
6893      _coreInitted$1 = 1;
6894    } else {
6895      console.warn("Please gsap.registerPlugin(CustomEase)");
6896    }
6897  },
6898      _bigNum$2 = 1e20,
6899      _round$2 = function _round(value) {
6900    return ~~(value * 1000 + (value < 0 ? -.5 : .5)) / 1000;
6901  },
6902      _numExp$1 = /[-+=.]*\d+[.e\-+]*\d*[e\-+]*\d*/gi,
6903      _needsParsingExp = /[cLlsSaAhHvVtTqQ]/g,
6904      _findMinimum = function _findMinimum(values) {
6905    var l = values.length,
6906        min = _bigNum$2,
6907        i;
6908
6909    for (i = 1; i < l; i += 6) {
6910      +values[i] < min && (min = +values[i]);
6911    }
6912
6913    return min;
6914  },
6915      _normalize = function _normalize(values, height, originY) {
6916    if (!originY && originY !== 0) {
6917      originY = Math.max(+values[values.length - 1], +values[1]);
6918    }
6919
6920    var tx = +values[0] * -1,
6921        ty = -originY,
6922        l = values.length,
6923        sx = 1 / (+values[l - 2] + tx),
6924        sy = -height || (Math.abs(+values[l - 1] - +values[1]) < 0.01 * (+values[l - 2] - +values[0]) ? _findMinimum(values) + ty : +values[l - 1] + ty),
6925        i;
6926
6927    if (sy) {
6928      sy = 1 / sy;
6929    } else {
6930      sy = -sx;
6931    }
6932
6933    for (i = 0; i < l; i += 2) {
6934      values[i] = (+values[i] + tx) * sx;
6935      values[i + 1] = (+values[i + 1] + ty) * sy;
6936    }
6937  },
6938      _bezierToPoints = function _bezierToPoints(x1, y1, x2, y2, x3, y3, x4, y4, threshold, points, index) {
6939    var x12 = (x1 + x2) / 2,
6940        y12 = (y1 + y2) / 2,
6941        x23 = (x2 + x3) / 2,
6942        y23 = (y2 + y3) / 2,
6943        x34 = (x3 + x4) / 2,
6944        y34 = (y3 + y4) / 2,
6945        x123 = (x12 + x23) / 2,
6946        y123 = (y12 + y23) / 2,
6947        x234 = (x23 + x34) / 2,
6948        y234 = (y23 + y34) / 2,
6949        x1234 = (x123 + x234) / 2,
6950        y1234 = (y123 + y234) / 2,
6951        dx = x4 - x1,
6952        dy = y4 - y1,
6953        d2 = Math.abs((x2 - x4) * dy - (y2 - y4) * dx),
6954        d3 = Math.abs((x3 - x4) * dy - (y3 - y4) * dx),
6955        length;
6956
6957    if (!points) {
6958      points = [{
6959        x: x1,
6960        y: y1
6961      }, {
6962        x: x4,
6963        y: y4
6964      }];
6965      index = 1;
6966    }
6967
6968    points.splice(index || points.length - 1, 0, {
6969      x: x1234,
6970      y: y1234
6971    });
6972
6973    if ((d2 + d3) * (d2 + d3) > threshold * (dx * dx + dy * dy)) {
6974      length = points.length;
6975
6976      _bezierToPoints(x1, y1, x12, y12, x123, y123, x1234, y1234, threshold, points, index);
6977
6978      _bezierToPoints(x1234, y1234, x234, y234, x34, y34, x4, y4, threshold, points, index + 1 + (points.length - length));
6979    }
6980
6981    return points;
6982  };
6983
6984  var CustomEase = function () {
6985    function CustomEase(id, data, config) {
6986      _coreInitted$1 || _initCore$1();
6987      this.id = id;
6988       this.setData(data, config);
6989    }
6990
6991    var _proto = CustomEase.prototype;
6992
6993    _proto.setData = function setData(data, config) {
6994      config = config || {};
6995      data = data || "0,0,1,1";
6996      var values = data.match(_numExp$1),
6997          closest = 1,
6998          points = [],
6999          lookup = [],
7000          precision = config.precision || 1,
7001          fast = precision <= 1,
7002          l,
7003          a1,
7004          a2,
7005          i,
7006          inc,
7007          j,
7008          point,
7009          prevPoint,
7010          p;
7011      this.data = data;
7012
7013      if (_needsParsingExp.test(data) || ~data.indexOf("M") && data.indexOf("C") < 0) {
7014        values = stringToRawPath(data)[0];
7015      }
7016
7017      l = values.length;
7018
7019      if (l === 4) {
7020        values.unshift(0, 0);
7021        values.push(1, 1);
7022        l = 8;
7023      } else if ((l - 2) % 6) {
7024        throw "Invalid CustomEase";
7025      }
7026
7027      if (+values[0] !== 0 || +values[l - 2] !== 1) {
7028        _normalize(values, config.height, config.originY);
7029      }
7030
7031      this.segment = values;
7032
7033      for (i = 2; i < l; i += 6) {
7034        a1 = {
7035          x: +values[i - 2],
7036          y: +values[i - 1]
7037        };
7038        a2 = {
7039          x: +values[i + 4],
7040          y: +values[i + 5]
7041        };
7042        points.push(a1, a2);
7043
7044        _bezierToPoints(a1.x, a1.y, +values[i], +values[i + 1], +values[i + 2], +values[i + 3], a2.x, a2.y, 1 / (precision * 200000), points, points.length - 1);
7045      }
7046
7047      l = points.length;
7048
7049      for (i = 0; i < l; i++) {
7050        point = points[i];
7051        prevPoint = points[i - 1] || point;
7052
7053        if ((point.x > prevPoint.x || prevPoint.y !== point.y && prevPoint.x === point.x || point === prevPoint) && point.x <= 1) {
7054          prevPoint.cx = point.x - prevPoint.x;
7055          prevPoint.cy = point.y - prevPoint.y;
7056          prevPoint.n = point;
7057          prevPoint.nx = point.x;
7058
7059          if (fast && i > 1 && Math.abs(prevPoint.cy / prevPoint.cx - points[i - 2].cy / points[i - 2].cx) > 2) {
7060            fast = 0;
7061          }
7062
7063          if (prevPoint.cx < closest) {
7064            if (!prevPoint.cx) {
7065              prevPoint.cx = 0.001;
7066
7067              if (i === l - 1) {
7068                prevPoint.x -= 0.001;
7069                closest = Math.min(closest, 0.001);
7070                fast = 0;
7071              }
7072            } else {
7073              closest = prevPoint.cx;
7074            }
7075          }
7076        } else {
7077          points.splice(i--, 1);
7078          l--;
7079        }
7080      }
7081
7082      l = 1 / closest + 1 | 0;
7083      inc = 1 / l;
7084      j = 0;
7085      point = points[0];
7086
7087      if (fast) {
7088        for (i = 0; i < l; i++) {
7089          p = i * inc;
7090
7091          if (point.nx < p) {
7092            point = points[++j];
7093          }
7094
7095          a1 = point.y + (p - point.x) / point.cx * point.cy;
7096          lookup[i] = {
7097            x: p,
7098            cx: inc,
7099            y: a1,
7100            cy: 0,
7101            nx: 9
7102          };
7103
7104          if (i) {
7105            lookup[i - 1].cy = a1 - lookup[i - 1].y;
7106          }
7107        }
7108
7109        lookup[l - 1].cy = points[points.length - 1].y - a1;
7110      } else {
7111        for (i = 0; i < l; i++) {
7112          if (point.nx < i * inc) {
7113            point = points[++j];
7114          }
7115
7116          lookup[i] = point;
7117        }
7118
7119        if (j < points.length - 1) {
7120          lookup[i - 1] = points[points.length - 2];
7121        }
7122      }
7123
7124      this.ease = function (p) {
7125        var point = lookup[p * l | 0] || lookup[l - 1];
7126
7127        if (point.nx < p) {
7128          point = point.n;
7129        }
7130
7131        return point.y + (p - point.x) / point.cx * point.cy;
7132      };
7133
7134      this.ease.custom = this;
7135      this.id && gsap$1 && gsap$1.registerEase(this.id, this.ease);
7136      return this;
7137    };
7138
7139    _proto.getSVGData = function getSVGData(config) {
7140      return CustomEase.getSVGData(this, config);
7141    };
7142
7143    CustomEase.create = function create(id, data, config) {
7144      return new CustomEase(id, data, config).ease;
7145    };
7146
7147    CustomEase.register = function register(core) {
7148      gsap$1 = core;
7149
7150      _initCore$1();
7151    };
7152
7153    CustomEase.get = function get(id) {
7154      return gsap$1.parseEase(id);
7155    };
7156
7157    CustomEase.getSVGData = function getSVGData(ease, config) {
7158      config = config || {};
7159      var width = config.width || 100,
7160          height = config.height || 100,
7161          x = config.x || 0,
7162          y = (config.y || 0) + height,
7163          e = gsap$1.utils.toArray(config.path)[0],
7164          a,
7165          slope,
7166          i,
7167          inc,
7168          tx,
7169          ty,
7170          precision,

vendor: 7,069 bytes, lines 7171-7410

7171          threshold,
7172          prevX,
7173          prevY;
7174
7175      if (config.invert) {
7176        height = -height;
7177        y = 0;
7178      }
7179
7180      if (typeof ease === "string") {
7181        ease = gsap$1.parseEase(ease);
7182      }
7183
7184      if (ease.custom) {
7185        ease = ease.custom;
7186      }
7187
7188      if (ease instanceof CustomEase) {
7189        a = rawPathToString(transformRawPath([ease.segment], width, 0, 0, -height, x, y));
7190      } else {
7191        a = [x, y];
7192        precision = Math.max(5, (config.precision || 1) * 200);
7193        inc = 1 / precision;
7194        precision += 2;
7195        threshold = 5 / precision;
7196        prevX = _round$2(x + inc * width);
7197        prevY = _round$2(y + ease(inc) * -height);
7198        slope = (prevY - y) / (prevX - x);
7199
7200        for (i = 2; i < precision; i++) {
7201          tx = _round$2(x + i * inc * width);
7202          ty = _round$2(y + ease(i * inc) * -height);
7203
7204          if (Math.abs((ty - prevY) / (tx - prevX) - slope) > threshold || i === precision - 1) {
7205            a.push(prevX, prevY);
7206            slope = (ty - prevY) / (tx - prevX);
7207          }
7208
7209          prevX = tx;
7210          prevY = ty;
7211        }
7212
7213        a = "M" + a.join(",");
7214      }
7215
7216      e && e.setAttribute("d", a);
7217      return a;
7218    };
7219
7220    return CustomEase;
7221  }();
7222  _getGSAP() && gsap$1.registerPlugin(CustomEase);
7223  CustomEase.version = "3.12.5";
7224
7225  var _doc$2,
7226      _win$2,
7227      _docElement$1,
7228      _body,
7229      _divContainer,
7230      _svgContainer,
7231      _identityMatrix,
7232      _gEl,
7233      _transformProp$1 = "transform",
7234      _transformOriginProp$1 = _transformProp$1 + "Origin",
7235      _hasOffsetBug,
7236      _setDoc = function _setDoc(element) {
7237    var doc = element.ownerDocument || element;
7238
7239    if (!(_transformProp$1 in element.style) && "msTransform" in element.style) {
7240      _transformProp$1 = "msTransform";
7241      _transformOriginProp$1 = _transformProp$1 + "Origin";
7242    }
7243
7244    while (doc.parentNode && (doc = doc.parentNode)) {}
7245
7246    _win$2 = window;
7247    _identityMatrix = new Matrix2D();
7248
7249    if (doc) {
7250      _doc$2 = doc;
7251      _docElement$1 = doc.documentElement;
7252      _body = doc.body;
7253      _gEl = _doc$2.createElementNS("http://www.w3.org/2000/svg", "g");
7254      _gEl.style.transform = "none";
7255      var d1 = doc.createElement("div"),
7256          d2 = doc.createElement("div"),
7257          root = doc && (doc.body || doc.firstElementChild);
7258
7259      if (root && root.appendChild) {
7260        root.appendChild(d1);
7261        d1.appendChild(d2);
7262        d1.setAttribute("style", "position:static;transform:translate3d(0,0,1px)");
7263        _hasOffsetBug = d2.offsetParent !== d1;
7264        root.removeChild(d1);
7265      }
7266    }
7267
7268    return doc;
7269  },
7270      _forceNonZeroScale = function _forceNonZeroScale(e) {
7271    var a, cache;
7272
7273    while (e && e !== _body) {
7274      cache = e._gsap;
7275      cache && cache.uncache && cache.get(e, "x");
7276
7277      if (cache && !cache.scaleX && !cache.scaleY && cache.renderTransform) {
7278        cache.scaleX = cache.scaleY = 1e-4;
7279        cache.renderTransform(1, cache);
7280        a ? a.push(cache) : a = [cache];
7281      }
7282
7283      e = e.parentNode;
7284    }
7285
7286    return a;
7287  },
7288      _svgTemps = [],
7289      _divTemps = [],
7290      _getDocScrollTop = function _getDocScrollTop() {
7291    return _win$2.pageYOffset || _doc$2.scrollTop || _docElement$1.scrollTop || _body.scrollTop || 0;
7292  },
7293      _getDocScrollLeft = function _getDocScrollLeft() {
7294    return _win$2.pageXOffset || _doc$2.scrollLeft || _docElement$1.scrollLeft || _body.scrollLeft || 0;
7295  },
7296      _svgOwner = function _svgOwner(element) {
7297    return element.ownerSVGElement || ((element.tagName + "").toLowerCase() === "svg" ? element : null);
7298  },
7299      _isFixed = function _isFixed(element) {
7300    if (_win$2.getComputedStyle(element).position === "fixed") {
7301      return true;
7302    }
7303
7304    element = element.parentNode;
7305
7306    if (element && element.nodeType === 1) {
7307      return _isFixed(element);
7308    }
7309  },
7310      _createSibling = function _createSibling(element, i) {
7311    if (element.parentNode && (_doc$2 || _setDoc(element))) {
7312      var svg = _svgOwner(element),
7313          ns = svg ? svg.getAttribute("xmlns") || "http://www.w3.org/2000/svg" : "http://www.w3.org/1999/xhtml",
7314          type = svg ? i ? "rect" : "g" : "div",
7315          x = i !== 2 ? 0 : 100,
7316          y = i === 3 ? 100 : 0,
7317          css = "position:absolute;display:block;pointer-events:none;margin:0;padding:0;",
7318          e = _doc$2.createElementNS ? _doc$2.createElementNS(ns.replace(/^https/, "http"), type) : _doc$2.createElement(type);
7319
7320      if (i) {
7321        if (!svg) {
7322          if (!_divContainer) {
7323            _divContainer = _createSibling(element);
7324            _divContainer.style.cssText = css;
7325          }
7326
7327          e.style.cssText = css + "width:0.1px;height:0.1px;top:" + y + "px;left:" + x + "px";
7328
7329          _divContainer.appendChild(e);
7330        } else {
7331          _svgContainer || (_svgContainer = _createSibling(element));
7332          e.setAttribute("width", 0.01);
7333          e.setAttribute("height", 0.01);
7334          e.setAttribute("transform", "translate(" + x + "," + y + ")");
7335
7336          _svgContainer.appendChild(e);
7337        }
7338      }
7339
7340      return e;
7341    }
7342
7343    throw "Need document and parent.";
7344  },
7345      _consolidate = function _consolidate(m) {
7346    var c = new Matrix2D(),
7347        i = 0;
7348
7349    for (; i < m.numberOfItems; i++) {
7350      c.multiply(m.getItem(i).matrix);
7351    }
7352
7353    return c;
7354  },
7355      _getCTM = function _getCTM(svg) {
7356    var m = svg.getCTM(),
7357        transform;
7358
7359    if (!m) {
7360      transform = svg.style[_transformProp$1];
7361      svg.style[_transformProp$1] = "none";
7362      svg.appendChild(_gEl);
7363      m = _gEl.getCTM();
7364      svg.removeChild(_gEl);
7365      transform ? svg.style[_transformProp$1] = transform : svg.style.removeProperty(_transformProp$1.replace(/([A-Z])/g, "-$1").toLowerCase());
7366    }
7367
7368    return m || _identityMatrix.clone();
7369  },
7370      _placeSiblings = function _placeSiblings(element, adjustGOffset) {
7371    var svg = _svgOwner(element),
7372        isRootSVG = element === svg,
7373        siblings = svg ? _svgTemps : _divTemps,
7374        parent = element.parentNode,
7375        container,
7376        m,
7377        b,
7378        x,
7379        y,
7380        cs;
7381
7382    if (element === _win$2) {
7383      return element;
7384    }
7385
7386    siblings.length || siblings.push(_createSibling(element, 1), _createSibling(element, 2), _createSibling(element, 3));
7387    container = svg ? _svgContainer : _divContainer;
7388
7389    if (svg) {
7390      if (isRootSVG) {
7391        b = _getCTM(element);
7392        x = -b.e / b.a;
7393        y = -b.f / b.d;
7394        m = _identityMatrix;
7395      } else if (element.getBBox) {
7396        b = element.getBBox();
7397        m = element.transform ? element.transform.baseVal : {};
7398        m = !m.numberOfItems ? _identityMatrix : m.numberOfItems > 1 ? _consolidate(m) : m.getItem(0).matrix;
7399        x = m.a * b.x + m.c * b.y;
7400        y = m.b * b.x + m.d * b.y;
7401      } else {
7402        m = new Matrix2D();
7403        x = y = 0;
7404      }
7405
7406      if (adjustGOffset && element.tagName.toLowerCase() === "g") {
7407        x = y = 0;
7408      }
7409
7410      (isRootSVG ? svg : parent).appendChild(container);

vendor: 1,153 bytes, lines 7411-7446

7411      container.setAttribute("transform", "matrix(" + m.a + "," + m.b + "," + m.c + "," + m.d + "," + (m.e + x) + "," + (m.f + y) + ")");
7412    } else {
7413      x = y = 0;
7414
7415      if (_hasOffsetBug) {
7416        m = element.offsetParent;
7417        b = element;
7418
7419        while (b && (b = b.parentNode) && b !== m && b.parentNode) {
7420          if ((_win$2.getComputedStyle(b)[_transformProp$1] + "").length > 4) {
7421            x = b.offsetLeft;
7422            y = b.offsetTop;
7423            b = 0;
7424          }
7425        }
7426      }
7427
7428      cs = _win$2.getComputedStyle(element);
7429
7430      if (cs.position !== "absolute" && cs.position !== "fixed") {
7431        m = element.offsetParent;
7432
7433        while (parent && parent !== m) {
7434          x += parent.scrollLeft || 0;
7435          y += parent.scrollTop || 0;
7436          parent = parent.parentNode;
7437        }
7438      }
7439
7440      b = container.style;
7441      b.top = element.offsetTop - y + "px";
7442      b.left = element.offsetLeft - x + "px";
7443      b[_transformProp$1] = cs[_transformProp$1];
7444      b[_transformOriginProp$1] = cs[_transformOriginProp$1];
7445      b.position = cs.position === "fixed" ? "fixed" : "absolute";
7446      element.parentNode

vendor: 37,620 bytes, lines 7446-8701

7446.appendChild(container);
7447    }
7448
7449    return container;
7450  },
7451      _setMatrix = function _setMatrix(m, a, b, c, d, e, f) {
7452    m.a = a;
7453    m.b = b;
7454    m.c = c;
7455    m.d = d;
7456    m.e = e;
7457    m.f = f;
7458    return m;
7459  };
7460
7461  var Matrix2D = function () {
7462    function Matrix2D(a, b, c, d, e, f) {
7463      if (a === void 0) {
7464        a = 1;
7465      }
7466
7467      if (b === void 0) {
7468        b = 0;
7469      }
7470
7471      if (c === void 0) {
7472        c = 0;
7473      }
7474
7475      if (d === void 0) {
7476        d = 1;
7477      }
7478
7479      if (e === void 0) {
7480        e = 0;
7481      }
7482
7483      if (f === void 0) {
7484        f = 0;
7485      }
7486
7487      _setMatrix(this, a, b, c, d, e, f);
7488    }
7489
7490    var _proto = Matrix2D.prototype;
7491
7492    _proto.inverse = function inverse() {
7493      var a = this.a,
7494          b = this.b,
7495          c = this.c,
7496          d = this.d,
7497          e = this.e,
7498          f = this.f,
7499          determinant = a * d - b * c || 1e-10;
7500      return _setMatrix(this, d / determinant, -b / determinant, -c / determinant, a / determinant, (c * f - d * e) / determinant, -(a * f - b * e) / determinant);
7501    };
7502
7503    _proto.multiply = function multiply(matrix) {
7504      var a = this.a,
7505          b = this.b,
7506          c = this.c,
7507          d = this.d,
7508          e = this.e,
7509          f = this.f,
7510          a2 = matrix.a,
7511          b2 = matrix.c,
7512          c2 = matrix.b,
7513          d2 = matrix.d,
7514          e2 = matrix.e,
7515          f2 = matrix.f;
7516      return _setMatrix(this, a2 * a + c2 * c, a2 * b + c2 * d, b2 * a + d2 * c, b2 * b + d2 * d, e + e2 * a + f2 * c, f + e2 * b + f2 * d);
7517    };
7518
7519    _proto.clone = function clone() {
7520      return new Matrix2D(this.a, this.b, this.c, this.d, this.e, this.f);
7521    };
7522
7523    _proto.equals = function equals(matrix) {
7524      var a = this.a,
7525          b = this.b,
7526          c = this.c,
7527          d = this.d,
7528          e = this.e,
7529          f = this.f;
7530      return a === matrix.a && b === matrix.b && c === matrix.c && d === matrix.d && e === matrix.e && f === matrix.f;
7531    };
7532
7533    _proto.apply = function apply(point, decoratee) {
7534      if (decoratee === void 0) {
7535        decoratee = {};
7536      }
7537
7538      var x = point.x,
7539          y = point.y,
7540          a = this.a,
7541          b = this.b,
7542          c = this.c,
7543          d = this.d,
7544          e = this.e,
7545          f = this.f;
7546      decoratee.x = x * a + y * c + e || 0;
7547      decoratee.y = x * b + y * d + f || 0;
7548      return decoratee;
7549    };
7550
7551    return Matrix2D;
7552  }();
7553  function getGlobalMatrix(element, inverse, adjustGOffset, includeScrollInFixed) {
7554    if (!element || !element.parentNode || (_doc$2 || _setDoc(element)).documentElement === element) {
7555      return new Matrix2D();
7556    }
7557
7558    var zeroScales = _forceNonZeroScale(element),
7559        svg = _svgOwner(element),
7560        temps = svg ? _svgTemps : _divTemps,
7561        container = _placeSiblings(element, adjustGOffset),
7562        b1 = temps[0].getBoundingClientRect(),
7563        b2 = temps[1].getBoundingClientRect(),
7564        b3 = temps[2].getBoundingClientRect(),
7565        parent = container.parentNode,
7566        isFixed = !includeScrollInFixed && _isFixed(element),
7567        m = new Matrix2D((b2.left - b1.left) / 100, (b2.top - b1.top) / 100, (b3.left - b1.left) / 100, (b3.top - b1.top) / 100, b1.left + (isFixed ? 0 : _getDocScrollLeft()), b1.top + (isFixed ? 0 : _getDocScrollTop()));
7568
7569    parent.removeChild(container);
7570
7571    if (zeroScales) {
7572      b1 = zeroScales.length;
7573
7574      while (b1--) {
7575        b2 = zeroScales[b1];
7576        b2.scaleX = b2.scaleY = 0;
7577        b2.renderTransform(1, b2);
7578      }
7579    }
7580
7581    return inverse ? m.inverse() : m;
7582  }
7583
7584  var gsap$2,
7585      _win$3,
7586      _doc$3,
7587      _docElement$2,
7588      _body$1,
7589      _tempDiv$1,
7590      _placeholderDiv,
7591      _coreInitted$2,
7592      _checkPrefix,
7593      _toArray,
7594      _supportsPassive,
7595      _isTouchDevice,
7596      _touchEventLookup,
7597      _isMultiTouching,
7598      _isAndroid,
7599      InertiaPlugin,
7600      _defaultCursor,
7601      _supportsPointer,
7602      _context$1,
7603      _getStyleSaver$1,
7604      _dragCount$1 = 0,
7605      _windowExists$2 = function _windowExists() {
7606    return typeof window !== "undefined";
7607  },
7608      _getGSAP$1 = function _getGSAP() {
7609    return gsap$2 || _windowExists$2() && (gsap$2 = window.gsap) && gsap$2.registerPlugin && gsap$2;
7610  },
7611      _isFunction$1 = function _isFunction(value) {
7612    return typeof value === "function";
7613  },
7614      _isObject$1 = function _isObject(value) {
7615    return typeof value === "object";
7616  },
7617      _isUndefined$2 = function _isUndefined(value) {
7618    return typeof value === "undefined";
7619  },
7620      _emptyFunc$1 = function _emptyFunc() {
7621    return false;
7622  },
7623      _transformProp$2 = "transform",
7624      _transformOriginProp$2 = "transformOrigin",
7625      _round$3 = function _round(value) {
7626    return Math.round(value * 10000) / 10000;
7627  },
7628      _isArray$1 = Array.isArray,
7629      _createElement$1 = function _createElement(type, ns) {
7630    var e = _doc$3.createElementNS ? _doc$3.createElementNS((ns || "http://www.w3.org/1999/xhtml").replace(/^https/, "http"), type) : _doc$3.createElement(type);
7631    return e.style ? e : _doc$3.createElement(type);
7632  },
7633      _RAD2DEG$2 = 180 / Math.PI,
7634      _bigNum$3 = 1e20,
7635      _identityMatrix$1 = new Matrix2D(),
7636      _getTime = Date.now || function () {
7637    return new Date().getTime();
7638  },
7639      _renderQueue = [],
7640      _lookup = {},
7641      _lookupCount = 0,
7642      _clickableTagExp = /^(?:a|input|textarea|button|select)$/i,
7643      _lastDragTime = 0,
7644      _temp1 = {},
7645      _windowProxy = {},
7646      _copy = function _copy(obj, factor) {
7647    var copy = {},
7648        p;
7649
7650    for (p in obj) {
7651      copy[p] = factor ? obj[p] * factor : obj[p];
7652    }
7653
7654    return copy;
7655  },
7656      _extend = function _extend(obj, defaults) {
7657    for (var p in defaults) {
7658      if (!(p in obj)) {
7659        obj[p] = defaults[p];
7660      }
7661    }
7662
7663    return obj;
7664  },
7665      _setTouchActionForAllDescendants = function _setTouchActionForAllDescendants(elements, value) {
7666    var i = elements.length,
7667        children;
7668
7669    while (i--) {
7670      value ? elements[i].style.touchAction = value : elements[i].style.removeProperty("touch-action");
7671      children = elements[i].children;
7672      children && children.length && _setTouchActionForAllDescendants(children, value);
7673    }
7674  },
7675      _renderQueueTick = function _renderQueueTick() {
7676    return _renderQueue.forEach(function (func) {
7677      return func();
7678    });
7679  },
7680      _addToRenderQueue = function _addToRenderQueue(func) {
7681    _renderQueue.push(func);
7682
7683    if (_renderQueue.length === 1) {
7684      gsap$2.ticker.add(_renderQueueTick);
7685    }
7686  },
7687      _renderQueueTimeout = function _renderQueueTimeout() {
7688    return !_renderQueue.length && gsap$2.ticker.remove(_renderQueueTick);
7689  },
7690      _removeFromRenderQueue = function _removeFromRenderQueue(func) {
7691    var i = _renderQueue.length;
7692
7693    while (i--) {
7694      if (_renderQueue[i] === func) {
7695        _renderQueue.splice(i, 1);
7696      }
7697    }
7698
7699    gsap$2.to(_renderQueueTimeout, {
7700      overwrite: true,
7701      delay: 15,
7702      duration: 0,
7703      onComplete: _renderQueueTimeout,
7704      data: "_draggable"
7705    });
7706  },
7707      _setDefaults$1 = function _setDefaults(obj, defaults) {
7708    for (var p in defaults) {
7709      if (!(p in obj)) {
7710        obj[p] = defaults[p];
7711      }
7712    }
7713
7714    return obj;
7715  },
7716      _addListener = function _addListener(element, type, func, capture) {
7717    if (element.addEventListener) {
7718      var touchType = _touchEventLookup[type];
7719      capture = capture || (_supportsPassive ? {
7720        passive: false
7721      } : null);
7722      element.addEventListener(touchType || type, func, capture);
7723      touchType && type !== touchType && element.addEventListener(type, func, capture);
7724    }
7725  },
7726      _removeListener = function _removeListener(element, type, func, capture) {
7727    if (element.removeEventListener) {
7728      var touchType = _touchEventLookup[type];
7729      element.removeEventListener(touchType || type, func, capture);
7730      touchType && type !== touchType && element.removeEventListener(type, func, capture);
7731    }
7732  },
7733      _preventDefault = function _preventDefault(event) {
7734    event.preventDefault && event.preventDefault();
7735    event.preventManipulation && event.preventManipulation();
7736  },
7737      _hasTouchID = function _hasTouchID(list, ID) {
7738    var i = list.length;
7739
7740    while (i--) {
7741      if (list[i].identifier === ID) {
7742        return true;
7743      }
7744    }
7745  },
7746      _onMultiTouchDocumentEnd = function _onMultiTouchDocumentEnd(event) {
7747    _isMultiTouching = event.touches && _dragCount$1 < event.touches.length;
7748
7749    _removeListener(event.target, "touchend", _onMultiTouchDocumentEnd);
7750  },
7751      _onMultiTouchDocument = function _onMultiTouchDocument(event) {
7752    _isMultiTouching = event.touches && _dragCount$1 < event.touches.length;
7753
7754    _addListener(event.target, "touchend", _onMultiTouchDocumentEnd);
7755  },
7756      _getDocScrollTop$1 = function _getDocScrollTop(doc) {
7757    return _win$3.pageYOffset || doc.scrollTop || doc.documentElement.scrollTop || doc.body.scrollTop || 0;
7758  },
7759      _getDocScrollLeft$1 = function _getDocScrollLeft(doc) {
7760    return _win$3.pageXOffset || doc.scrollLeft || doc.documentElement.scrollLeft || doc.body.scrollLeft || 0;
7761  },
7762      _addScrollListener = function _addScrollListener(e, callback) {
7763    _addListener(e, "scroll", callback);
7764
7765    if (!_isRoot(e.parentNode)) {
7766      _addScrollListener(e.parentNode, callback);
7767    }
7768  },
7769      _removeScrollListener = function _removeScrollListener(e, callback) {
7770    _removeListener(e, "scroll", callback);
7771
7772    if (!_isRoot(e.parentNode)) {
7773      _removeScrollListener(e.parentNode, callback);
7774    }
7775  },
7776      _isRoot = function _isRoot(e) {
7777    return !!(!e || e === _docElement$2 || e.nodeType === 9 || e === _doc$3.body || e === _win$3 || !e.nodeType || !e.parentNode);
7778  },
7779      _getMaxScroll = function _getMaxScroll(element, axis) {
7780    var dim = axis === "x" ? "Width" : "Height",
7781        scroll = "scroll" + dim,
7782        client = "client" + dim;
7783    return Math.max(0, _isRoot(element) ? Math.max(_docElement$2[scroll], _body$1[scroll]) - (_win$3["inner" + dim] || _docElement$2[client] || _body$1[client]) : element[scroll] - element[client]);
7784  },
7785      _recordMaxScrolls = function _recordMaxScrolls(e, skipCurrent) {
7786    var x = _getMaxScroll(e, "x"),
7787        y = _getMaxScroll(e, "y");
7788
7789    if (_isRoot(e)) {
7790      e = _windowProxy;
7791    } else {
7792      _recordMaxScrolls(e.parentNode, skipCurrent);
7793    }
7794
7795    e._gsMaxScrollX = x;
7796    e._gsMaxScrollY = y;
7797
7798    if (!skipCurrent) {
7799      e._gsScrollX = e.scrollLeft || 0;
7800      e._gsScrollY = e.scrollTop || 0;
7801    }
7802  },
7803      _setStyle = function _setStyle(element, property, value) {
7804    var style = element.style;
7805
7806    if (!style) {
7807      return;
7808    }
7809
7810    if (_isUndefined$2(style[property])) {
7811      property = _checkPrefix(property, element) || property;
7812    }
7813
7814    if (value == null) {
7815      style.removeProperty && style.removeProperty(property.replace(/([A-Z])/g, "-$1").toLowerCase());
7816    } else {
7817      style[property] = value;
7818    }
7819  },
7820      _getComputedStyle = function _getComputedStyle(element) {
7821    return _win$3.getComputedStyle(element instanceof Element ? element : element.host || (element.parentNode || {}).host || element);
7822  },
7823      _tempRect = {},
7824      _parseRect = function _parseRect(e) {
7825    if (e === _win$3) {
7826      _tempRect.left = _tempRect.top = 0;
7827      _tempRect.width = _tempRect.right = _docElement$2.clientWidth || e.innerWidth || _body$1.clientWidth || 0;
7828      _tempRect.height = _tempRect.bottom = (e.innerHeight || 0) - 20 < _docElement$2.clientHeight ? _docElement$2.clientHeight : e.innerHeight || _body$1.clientHeight || 0;
7829      return _tempRect;
7830    }
7831
7832    var doc = e.ownerDocument || _doc$3,
7833        r = !_isUndefined$2(e.pageX) ? {
7834      left: e.pageX - _getDocScrollLeft$1(doc),
7835      top: e.pageY - _getDocScrollTop$1(doc),
7836      right: e.pageX - _getDocScrollLeft$1(doc) + 1,
7837      bottom: e.pageY - _getDocScrollTop$1(doc) + 1
7838    } : !e.nodeType && !_isUndefined$2(e.left) && !_isUndefined$2(e.top) ? e : _toArray(e)[0].getBoundingClientRect();
7839
7840    if (_isUndefined$2(r.right) && !_isUndefined$2(r.width)) {
7841      r.right = r.left + r.width;
7842      r.bottom = r.top + r.height;
7843    } else if (_isUndefined$2(r.width)) {
7844      r = {
7845        width: r.right - r.left,
7846        height: r.bottom - r.top,
7847        right: r.right,
7848        left: r.left,
7849        bottom: r.bottom,
7850        top: r.top
7851      };
7852    }
7853
7854    return r;
7855  },
7856      _dispatchEvent = function _dispatchEvent(target, type, callbackName) {
7857    var vars = target.vars,
7858        callback = vars[callbackName],
7859        listeners = target._listeners[type],
7860        result;
7861
7862    if (_isFunction$1(callback)) {
7863      result = callback.apply(vars.callbackScope || target, vars[callbackName + "Params"] || [target.pointerEvent]);
7864    }
7865
7866    if (listeners && target.dispatchEvent(type) === false) {
7867      result = false;
7868    }
7869
7870    return result;
7871  },
7872      _getBounds = function _getBounds(target, context) {
7873    var e = _toArray(target)[0],
7874        top,
7875        left,
7876        offset;
7877
7878    if (!e.nodeType && e !== _win$3) {
7879      if (!_isUndefined$2(target.left)) {
7880        offset = {
7881          x: 0,
7882          y: 0
7883        };
7884        return {
7885          left: target.left - offset.x,
7886          top: target.top - offset.y,
7887          width: target.width,
7888          height: target.height
7889        };
7890      }
7891
7892      left = target.min || target.minX || target.minRotation || 0;
7893      top = target.min || target.minY || 0;
7894      return {
7895        left: left,
7896        top: top,
7897        width: (target.max || target.maxX || target.maxRotation || 0) - left,
7898        height: (target.max || target.maxY || 0) - top
7899      };
7900    }
7901
7902    return _getElementBounds(e, context);
7903  },
7904      _point1 = {},
7905      _getElementBounds = function _getElementBounds(element, context) {
7906    context = _toArray(context)[0];
7907    var isSVG = element.getBBox && element.ownerSVGElement,
7908        doc = element.ownerDocument || _doc$3,
7909        left,
7910        right,
7911        top,
7912        bottom,
7913        matrix,
7914        p1,
7915        p2,
7916        p3,
7917        p4,
7918        bbox,
7919        width,
7920        height,
7921        cs;
7922
7923    if (element === _win$3) {
7924      top = _getDocScrollTop$1(doc);
7925      left = _getDocScrollLeft$1(doc);
7926      right = left + (doc.documentElement.clientWidth || element.innerWidth || doc.body.clientWidth || 0);
7927      bottom = top + ((element.innerHeight || 0) - 20 < doc.documentElement.clientHeight ? doc.documentElement.clientHeight : element.innerHeight || doc.body.clientHeight || 0);
7928    } else if (context === _win$3 || _isUndefined$2(context)) {
7929      return element.getBoundingClientRect();
7930    } else {
7931      left = top = 0;
7932
7933      if (isSVG) {
7934        bbox = element.getBBox();
7935        width = bbox.width;
7936        height = bbox.height;
7937      } else {
7938        if (element.viewBox && (bbox = element.viewBox.baseVal)) {
7939          left = bbox.x || 0;
7940          top = bbox.y || 0;
7941          width = bbox.width;
7942          height = bbox.height;
7943        }
7944
7945        if (!width) {
7946          cs = _getComputedStyle(element);
7947          bbox = cs.boxSizing === "border-box";
7948          width = (parseFloat(cs.width) || element.clientWidth || 0) + (bbox ? 0 : parseFloat(cs.borderLeftWidth) + parseFloat(cs.borderRightWidth));
7949          height = (parseFloat(cs.height) || element.clientHeight || 0) + (bbox ? 0 : parseFloat(cs.borderTopWidth) + parseFloat(cs.borderBottomWidth));
7950        }
7951      }
7952
7953      right = width;
7954      bottom = height;
7955    }
7956
7957    if (element === context) {
7958      return {
7959        left: left,
7960        top: top,
7961        width: right - left,
7962        height: bottom - top
7963      };
7964    }
7965
7966    matrix = getGlobalMatrix(context, true).multiply(getGlobalMatrix(element));
7967    p1 = matrix.apply({
7968      x: left,
7969      y: top
7970    });
7971    p2 = matrix.apply({
7972      x: right,
7973      y: top
7974    });
7975    p3 = matrix.apply({
7976      x: right,
7977      y: bottom
7978    });
7979    p4 = matrix.apply({
7980      x: left,
7981      y: bottom
7982    });
7983    left = Math.min(p1.x, p2.x, p3.x, p4.x);
7984    top = Math.min(p1.y, p2.y, p3.y, p4.y);
7985    return {
7986      left: left,
7987      top: top,
7988      width: Math.max(p1.x, p2.x, p3.x, p4.x) - left,
7989      height: Math.max(p1.y, p2.y, p3.y, p4.y) - top
7990    };
7991  },
7992      _parseInertia = function _parseInertia(draggable, snap, max, min, factor, forceZeroVelocity) {
7993    var vars = {},
7994        a,
7995        i,
7996        l;
7997
7998    if (snap) {
7999      if (factor !== 1 && snap instanceof Array) {
8000        vars.end = a = [];
8001        l = snap.length;
8002
8003        if (_isObject$1(snap[0])) {
8004          for (i = 0; i < l; i++) {
8005            a[i] = _copy(snap[i], factor);
8006          }
8007        } else {
8008          for (i = 0; i < l; i++) {
8009            a[i] = snap[i] * factor;
8010          }
8011        }
8012
8013        max += 1.1;
8014        min -= 1.1;
8015      } else if (_isFunction$1(snap)) {
8016        vars.end = function (value) {
8017          var result = snap.call(draggable, value),
8018              copy,
8019              p;
8020
8021          if (factor !== 1) {
8022            if (_isObject$1(result)) {
8023              copy = {};
8024
8025              for (p in result) {
8026                copy[p] = result[p] * factor;
8027              }
8028
8029              result = copy;
8030            } else {
8031              result *= factor;
8032            }
8033          }
8034
8035          return result;
8036        };
8037      } else {
8038        vars.end = snap;
8039      }
8040    }
8041
8042    if (max || max === 0) {
8043      vars.max = max;
8044    }
8045
8046    if (min || min === 0) {
8047      vars.min = min;
8048    }
8049
8050    if (forceZeroVelocity) {
8051      vars.velocity = 0;
8052    }
8053
8054    return vars;
8055  },
8056      _isClickable = function _isClickable(element) {
8057    var data;
8058    return !element || !element.getAttribute || element === _body$1 ? false : (data = element.getAttribute("data-clickable")) === "true" || data !== "false" && (_clickableTagExp.test(element.nodeName + "") || element.getAttribute("contentEditable") === "true") ? true : _isClickable(element.parentNode);
8059  },
8060      _setSelectable = function _setSelectable(elements, selectable) {
8061    var i = elements.length,
8062        e;
8063
8064    while (i--) {
8065      e = elements[i];
8066      e.ondragstart = e.onselectstart = selectable ? null : _emptyFunc$1;
8067      gsap$2.set(e, {
8068        lazy: true,
8069        userSelect: selectable ? "text" : "none"
8070      });
8071    }
8072  },
8073      _isFixed$1 = function _isFixed(element) {
8074    if (_getComputedStyle(element).position === "fixed") {
8075      return true;
8076    }
8077
8078    element = element.parentNode;
8079
8080    if (element && element.nodeType === 1) {
8081      return _isFixed(element);
8082    }
8083  },
8084      _supports3D$1,
8085      _addPaddingBR,
8086      ScrollProxy = function ScrollProxy(element, vars) {
8087    element = gsap$2.utils.toArray(element)[0];
8088    vars = vars || {};
8089    var content = document.createElement("div"),
8090        style = content.style,
8091        node = element.firstChild,
8092        offsetTop = 0,
8093        offsetLeft = 0,
8094        prevTop = element.scrollTop,
8095        prevLeft = element.scrollLeft,
8096        scrollWidth = element.scrollWidth,
8097        scrollHeight = element.scrollHeight,
8098        extraPadRight = 0,
8099        maxLeft = 0,
8100        maxTop = 0,
8101        elementWidth,
8102        elementHeight,
8103        contentHeight,
8104        nextNode,
8105        transformStart,
8106        transformEnd;
8107
8108    if (_supports3D$1 && vars.force3D !== false) {
8109      transformStart = "translate3d(";
8110      transformEnd = "px,0px)";
8111    } else if (_transformProp$2) {
8112      transformStart = "translate(";
8113      transformEnd = "px)";
8114    }
8115
8116    this.scrollTop = function (value, force) {
8117      if (!arguments.length) {
8118        return -this.top();
8119      }
8120
8121      this.top(-value, force);
8122    };
8123
8124    this.scrollLeft = function (value, force) {
8125      if (!arguments.length) {
8126        return -this.left();
8127      }
8128
8129      this.left(-value, force);
8130    };
8131
8132    this.left = function (value, force) {
8133      if (!arguments.length) {
8134        return -(element.scrollLeft + offsetLeft);
8135      }
8136
8137      var dif = element.scrollLeft - prevLeft,
8138          oldOffset = offsetLeft;
8139
8140      if ((dif > 2 || dif < -2) && !force) {
8141        prevLeft = element.scrollLeft;
8142        gsap$2.killTweensOf(this, {
8143          left: 1,
8144          scrollLeft: 1
8145        });
8146        this.left(-prevLeft);
8147
8148        if (vars.onKill) {
8149          vars.onKill();
8150        }
8151
8152        return;
8153      }
8154
8155      value = -value;
8156
8157      if (value < 0) {
8158        offsetLeft = value - 0.5 | 0;
8159        value = 0;
8160      } else if (value > maxLeft) {
8161        offsetLeft = value - maxLeft | 0;
8162        value = maxLeft;
8163      } else {
8164        offsetLeft = 0;
8165      }
8166
8167      if (offsetLeft || oldOffset) {
8168        if (!this._skip) {
8169          style[_transformProp$2] = transformStart + -offsetLeft + "px," + -offsetTop + transformEnd;
8170        }
8171
8172        if (offsetLeft + extraPadRight >= 0) {
8173          style.paddingRight = offsetLeft + extraPadRight + "px";
8174        }
8175      }
8176
8177      element.scrollLeft = value | 0;
8178      prevLeft = element.scrollLeft;
8179    };
8180
8181    this.top = function (value, force) {
8182      if (!arguments.length) {
8183        return -(element.scrollTop + offsetTop);
8184      }
8185
8186      var dif = element.scrollTop - prevTop,
8187          oldOffset = offsetTop;
8188
8189      if ((dif > 2 || dif < -2) && !force) {
8190        prevTop = element.scrollTop;
8191        gsap$2.killTweensOf(this, {
8192          top: 1,
8193          scrollTop: 1
8194        });
8195        this.top(-prevTop);
8196
8197        if (vars.onKill) {
8198          vars.onKill();
8199        }
8200
8201        return;
8202      }
8203
8204      value = -value;
8205
8206      if (value < 0) {
8207        offsetTop = value - 0.5 | 0;
8208        value = 0;
8209      } else if (value > maxTop) {
8210        offsetTop = value - maxTop | 0;
8211        value = maxTop;
8212      } else {
8213        offsetTop = 0;
8214      }
8215
8216      if (offsetTop || oldOffset) {
8217        if (!this._skip) {
8218          style[_transformProp$2] = transformStart + -offsetLeft + "px," + -offsetTop + transformEnd;
8219        }
8220      }
8221
8222      element.scrollTop = value | 0;
8223      prevTop = element.scrollTop;
8224    };
8225
8226    this.maxScrollTop = function () {
8227      return maxTop;
8228    };
8229
8230    this.maxScrollLeft = function () {
8231      return maxLeft;
8232    };
8233
8234    this.disable = function () {
8235      node = content.firstChild;
8236
8237      while (node) {
8238        nextNode = node.nextSibling;
8239        element.appendChild(node);
8240        node = nextNode;
8241      }
8242
8243      if (element === content.parentNode) {
8244        element.removeChild(content);
8245      }
8246    };
8247
8248    this.enable = function () {
8249      node = element.firstChild;
8250
8251      if (node === content) {
8252        return;
8253      }
8254
8255      while (node) {
8256        nextNode = node.nextSibling;
8257        content.appendChild(node);
8258        node = nextNode;
8259      }
8260
8261      element.appendChild(content);
8262      this.calibrate();
8263    };
8264
8265    this.calibrate = function (force) {
8266      var widthMatches = element.clientWidth === elementWidth,
8267          cs,
8268          x,
8269          y;
8270      prevTop = element.scrollTop;
8271      prevLeft = element.scrollLeft;
8272
8273      if (widthMatches && element.clientHeight === elementHeight && content.offsetHeight === contentHeight && scrollWidth === element.scrollWidth && scrollHeight === element.scrollHeight && !force) {
8274        return;
8275      }
8276
8277      if (offsetTop || offsetLeft) {
8278        x = this.left();
8279        y = this.top();
8280        this.left(-element.scrollLeft);
8281        this.top(-element.scrollTop);
8282      }
8283
8284      cs = _getComputedStyle(element);
8285
8286      if (!widthMatches || force) {
8287        style.display = "block";
8288        style.width = "auto";
8289        style.paddingRight = "0px";
8290        extraPadRight = Math.max(0, element.scrollWidth - element.clientWidth);
8291
8292        if (extraPadRight) {
8293          extraPadRight += parseFloat(cs.paddingLeft) + (_addPaddingBR ? parseFloat(cs.paddingRight) : 0);
8294        }
8295      }
8296
8297      style.display = "inline-block";
8298      style.position = "relative";
8299      style.overflow = "visible";
8300      style.verticalAlign = "top";
8301      style.boxSizing = "content-box";
8302      style.width = "100%";
8303      style.paddingRight = extraPadRight + "px";
8304
8305      if (_addPaddingBR) {
8306        style.paddingBottom = cs.paddingBottom;
8307      }
8308
8309      elementWidth = element.clientWidth;
8310      elementHeight = element.clientHeight;
8311      scrollWidth = element.scrollWidth;
8312      scrollHeight = element.scrollHeight;
8313      maxLeft = element.scrollWidth - elementWidth;
8314      maxTop = element.scrollHeight - elementHeight;
8315      contentHeight = content.offsetHeight;
8316      style.display = "block";
8317
8318      if (x || y) {
8319        this.left(x);
8320        this.top(y);
8321      }
8322    };
8323
8324    this.content = content;
8325    this.element = element;
8326    this._skip = false;
8327    this.enable();
8328  },
8329      _initCore$2 = function _initCore(required) {
8330    if (_windowExists$2() && document.body) {
8331      var nav = window && window.navigator;
8332      _win$3 = window;
8333      _doc$3 = document;
8334      _docElement$2 = _doc$3.documentElement;
8335      _body$1 = _doc$3.body;
8336      _tempDiv$1 = _createElement$1("div");
8337      _supportsPointer = !!window.PointerEvent;
8338      _placeholderDiv = _createElement$1("div");
8339      _placeholderDiv.style.cssText = "visibility:hidden;height:1px;top:-1px;pointer-events:none;position:relative;clear:both;cursor:grab";
8340      _defaultCursor = _placeholderDiv.style.cursor === "grab" ? "grab" : "move";
8341      _isAndroid = nav && nav.userAgent.toLowerCase().indexOf("android") !== -1;
8342      _isTouchDevice = "ontouchstart" in _docElement$2 && "orientation" in _win$3 || nav && (nav.MaxTouchPoints > 0 || nav.msMaxTouchPoints > 0);
8343
8344      _addPaddingBR = function () {
8345        var div = _createElement$1("div"),
8346            child = _createElement$1("div"),
8347            childStyle = child.style,
8348            parent = _body$1,
8349            val;
8350
8351        childStyle.display = "inline-block";
8352        childStyle.position = "relative";
8353        div.style.cssText = "width:90px;height:40px;padding:10px;overflow:auto;visibility:hidden";
8354        div.appendChild(child);
8355        parent.appendChild(div);
8356        val = child.offsetHeight + 18 > div.scrollHeight;
8357        parent.removeChild(div);
8358        return val;
8359      }();
8360
8361      _touchEventLookup = function (types) {
8362        var standard = types.split(","),
8363            converted = ("onpointerdown" in _tempDiv$1 ? "pointerdown,pointermove,pointerup,pointercancel" : "onmspointerdown" in _tempDiv$1 ? "MSPointerDown,MSPointerMove,MSPointerUp,MSPointerCancel" : types).split(","),
8364            obj = {},
8365            i = 4;
8366
8367        while (--i > -1) {
8368          obj[standard[i]] = converted[i];
8369          obj[converted[i]] = standard[i];
8370        }
8371
8372        try {
8373          _docElement$2.addEventListener("test", null, Object.defineProperty({}, "passive", {
8374            get: function get() {
8375              _supportsPassive = 1;
8376            }
8377          }));
8378        } catch (e) {}
8379
8380        return obj;
8381      }("touchstart,touchmove,touchend,touchcancel");
8382
8383      _addListener(_doc$3, "touchcancel", _emptyFunc$1);
8384
8385      _addListener(_win$3, "touchmove", _emptyFunc$1);
8386
8387      _body$1 && _body$1.addEventListener("touchstart", _emptyFunc$1);
8388
8389      _addListener(_doc$3, "contextmenu", function () {
8390        for (var p in _lookup) {
8391          if (_lookup[p].isPressed) {
8392            _lookup[p].endDrag();
8393          }
8394        }
8395      });
8396
8397      gsap$2 = _coreInitted$2 = _getGSAP$1();
8398    }
8399
8400    if (gsap$2) {
8401      InertiaPlugin = gsap$2.plugins.inertia;
8402
8403      _context$1 = gsap$2.core.context || function () {};
8404
8405      _checkPrefix = gsap$2.utils.checkPrefix;
8406      _transformProp$2 = _checkPrefix(_transformProp$2);
8407      _transformOriginProp$2 = _checkPrefix(_transformOriginProp$2);
8408      _toArray = gsap$2.utils.toArray;
8409      _getStyleSaver$1 = gsap$2.core.getStyleSaver;
8410      _supports3D$1 = !!_checkPrefix("perspective");
8411    } else if (required) {
8412      console.warn("Please gsap.registerPlugin(Draggable)");
8413    }
8414  };
8415
8416  var EventDispatcher = function () {
8417    function EventDispatcher(target) {
8418      this._listeners = {};
8419      this.target = target || this;
8420    }
8421
8422    var _proto = EventDispatcher.prototype;
8423
8424    _proto.addEventListener = function addEventListener(type, callback) {
8425      var list = this._listeners[type] || (this._listeners[type] = []);
8426
8427      if (!~list.indexOf(callback)) {
8428        list.push(callback);
8429      }
8430    };
8431
8432    _proto.removeEventListener = function removeEventListener(type, callback) {
8433      var list = this._listeners[type],
8434          i = list && list.indexOf(callback);
8435      i >= 0 && list.splice(i, 1);
8436    };
8437
8438    _proto.dispatchEvent = function dispatchEvent(type) {
8439      var _this = this;
8440
8441      var result;
8442      (this._listeners[type] || []).forEach(function (callback) {
8443        return callback.call(_this, {
8444          type: type,
8445          target: _this.target
8446        }) === false && (result = false);
8447      });
8448      return result;
8449    };
8450
8451    return EventDispatcher;
8452  }();
8453
8454  var Draggable = function (_EventDispatcher) {
8455    _inheritsLoose(Draggable, _EventDispatcher);
8456
8457    function Draggable(target, vars) {
8458      var _this2;
8459
8460      _this2 = _EventDispatcher.call(this) || this;
8461      _coreInitted$2 || _initCore$2(1);
8462      target = _toArray(target)[0];
8463      _this2.styles = _getStyleSaver$1 && _getStyleSaver$1(target, "transform,left,top");
8464
8465      if (!InertiaPlugin) {
8466        InertiaPlugin = gsap$2.plugins.inertia;
8467      }
8468
8469      _this2.vars = vars = _copy(vars || {});
8470      _this2.target = target;
8471      _this2.x = _this2.y = _this2.rotation = 0;
8472      _this2.dragResistance = parseFloat(vars.dragResistance) || 0;
8473      _this2.edgeResistance = isNaN(vars.edgeResistance) ? 1 : parseFloat(vars.edgeResistance) || 0;
8474      _this2.lockAxis = vars.lockAxis;
8475      _this2.autoScroll = vars.autoScroll || 0;
8476      _this2.lockedAxis = null;
8477      _this2.allowEventDefault = !!vars.allowEventDefault;
8478      gsap$2.getProperty(target, "x");
8479
8480      var type = (vars.type || "x,y").toLowerCase(),
8481          xyMode = ~type.indexOf("x") || ~type.indexOf("y"),
8482          rotationMode = type.indexOf("rotation") !== -1,
8483          xProp = rotationMode ? "rotation" : xyMode ? "x" : "left",
8484          yProp = xyMode ? "y" : "top",
8485          allowX = !!(~type.indexOf("x") || ~type.indexOf("left") || type === "scroll"),
8486          allowY = !!(~type.indexOf("y") || ~type.indexOf("top") || type === "scroll"),
8487          minimumMovement = vars.minimumMovement || 2,
8488          self = _assertThisInitialized(_this2),
8489          triggers = _toArray(vars.trigger || vars.handle || target),
8490          killProps = {},
8491          dragEndTime = 0,
8492          checkAutoScrollBounds = false,
8493          autoScrollMarginTop = vars.autoScrollMarginTop || 40,
8494          autoScrollMarginRight = vars.autoScrollMarginRight || 40,
8495          autoScrollMarginBottom = vars.autoScrollMarginBottom || 40,
8496          autoScrollMarginLeft = vars.autoScrollMarginLeft || 40,
8497          isClickable = vars.clickableTest || _isClickable,
8498          clickTime = 0,
8499          gsCache = target._gsap || gsap$2.core.getCache(target),
8500          isFixed = _isFixed$1(target),
8501          getPropAsNum = function getPropAsNum(property, unit) {
8502        return parseFloat(gsCache.get(target, property, unit));
8503      },
8504          ownerDoc = target.ownerDocument || _doc$3,
8505          enabled,
8506          scrollProxy,
8507          startPointerX,
8508          startPointerY,
8509          startElementX,
8510          startElementY,
8511          hasBounds,
8512          hasDragCallback,
8513          hasMoveCallback,
8514          maxX,
8515          minX,
8516          maxY,
8517          minY,
8518          touch,
8519          touchID,
8520          rotationOrigin,
8521          dirty,
8522          old,
8523          snapX,
8524          snapY,
8525          snapXY,
8526          isClicking,
8527          touchEventTarget,
8528          matrix,
8529          interrupted,
8530          allowNativeTouchScrolling,
8531          touchDragAxis,
8532          isDispatching,
8533          clickDispatch,
8534          trustedClickDispatch,
8535          isPreventingDefault,
8536          innerMatrix,
8537          dragged,
8538          onContextMenu = function onContextMenu(e) {
8539        _preventDefault(e);
8540
8541        e.stopImmediatePropagation && e.stopImmediatePropagation();
8542        return false;
8543      },
8544          render = function render(suppressEvents) {
8545        if (self.autoScroll && self.isDragging && (checkAutoScrollBounds || dirty)) {
8546          var e = target,
8547              autoScrollFactor = self.autoScroll * 15,
8548              parent,
8549              isRoot,
8550              rect,
8551              pointerX,
8552              pointerY,
8553              changeX,
8554              changeY,
8555              gap;
8556          checkAutoScrollBounds = false;
8557          _windowProxy.scrollTop = _win$3.pageYOffset != null ? _win$3.pageYOffset : ownerDoc.documentElement.scrollTop != null ? ownerDoc.documentElement.scrollTop : ownerDoc.body.scrollTop;
8558          _windowProxy.scrollLeft = _win$3.pageXOffset != null ? _win$3.pageXOffset : ownerDoc.documentElement.scrollLeft != null ? ownerDoc.documentElement.scrollLeft : ownerDoc.body.scrollLeft;
8559          pointerX = self.pointerX - _windowProxy.scrollLeft;
8560          pointerY = self.pointerY - _windowProxy.scrollTop;
8561
8562          while (e && !isRoot) {
8563            isRoot = _isRoot(e.parentNode);
8564            parent = isRoot ? _windowProxy : e.parentNode;
8565            rect = isRoot ? {
8566              bottom: Math.max(_docElement$2.clientHeight, _win$3.innerHeight || 0),
8567              right: Math.max(_docElement$2.clientWidth, _win$3.innerWidth || 0),
8568              left: 0,
8569              top: 0
8570            } : parent.getBoundingClientRect();
8571            changeX = changeY = 0;
8572
8573            if (allowY) {
8574              gap = parent._gsMaxScrollY - parent.scrollTop;
8575
8576              if (gap < 0) {
8577                changeY = gap;
8578              } else if (pointerY > rect.bottom - autoScrollMarginBottom && gap) {
8579                checkAutoScrollBounds = true;
8580                changeY = Math.min(gap, autoScrollFactor * (1 - Math.max(0, rect.bottom - pointerY) / autoScrollMarginBottom) | 0);
8581              } else if (pointerY < rect.top + autoScrollMarginTop && parent.scrollTop) {
8582                checkAutoScrollBounds = true;
8583                changeY = -Math.min(parent.scrollTop, autoScrollFactor * (1 - Math.max(0, pointerY - rect.top) / autoScrollMarginTop) | 0);
8584              }
8585
8586              if (changeY) {
8587                parent.scrollTop += changeY;
8588              }
8589            }
8590
8591            if (allowX) {
8592              gap = parent._gsMaxScrollX - parent.scrollLeft;
8593
8594              if (gap < 0) {
8595                changeX = gap;
8596              } else if (pointerX > rect.right - autoScrollMarginRight && gap) {
8597                checkAutoScrollBounds = true;
8598                changeX = Math.min(gap, autoScrollFactor * (1 - Math.max(0, rect.right - pointerX) / autoScrollMarginRight) | 0);
8599              } else if (pointerX < rect.left + autoScrollMarginLeft && parent.scrollLeft) {
8600                checkAutoScrollBounds = true;
8601                changeX = -Math.min(parent.scrollLeft, autoScrollFactor * (1 - Math.max(0, pointerX - rect.left) / autoScrollMarginLeft) | 0);
8602              }
8603
8604              if (changeX) {
8605                parent.scrollLeft += changeX;
8606              }
8607            }
8608
8609            if (isRoot && (changeX || changeY)) {
8610              _win$3.scrollTo(parent.scrollLeft, parent.scrollTop);
8611
8612              setPointerPosition(self.pointerX + changeX, self.pointerY + changeY);
8613            }
8614
8615            e = parent;
8616          }
8617        }
8618
8619        if (dirty) {
8620          var x = self.x,
8621              y = self.y;
8622
8623          if (rotationMode) {
8624            self.deltaX = x - parseFloat(gsCache.rotation);
8625            self.rotation = x;
8626            gsCache.rotation = x + "deg";
8627            gsCache.renderTransform(1, gsCache);
8628          } else {
8629            if (scrollProxy) {
8630              if (allowY) {
8631                self.deltaY = y - scrollProxy.top();
8632                scrollProxy.top(y);
8633              }
8634
8635              if (allowX) {
8636                self.deltaX = x - scrollProxy.left();
8637                scrollProxy.left(x);
8638              }
8639            } else if (xyMode) {
8640              if (allowY) {
8641                self.deltaY = y - parseFloat(gsCache.y);
8642                gsCache.y = y + "px";
8643              }
8644
8645              if (allowX) {
8646                self.deltaX = x - parseFloat(gsCache.x);
8647                gsCache.x = x + "px";
8648              }
8649
8650              gsCache.renderTransform(1, gsCache);
8651            } else {
8652              if (allowY) {
8653                self.deltaY = y - parseFloat(target.style.top || 0);
8654                target.style.top = y + "px";
8655              }
8656
8657              if (allowX) {
8658                self.deltaX = x - parseFloat(target.style.left || 0);
8659                target.style.left = x + "px";
8660              }
8661            }
8662          }
8663
8664          if (hasDragCallback && !suppressEvents && !isDispatching) {
8665            isDispatching = true;
8666
8667            if (_dispatchEvent(self, "drag", "onDrag") === false) {
8668              if (allowX) {
8669                self.x -= self.deltaX;
8670              }
8671
8672              if (allowY) {
8673                self.y -= self.deltaY;
8674              }
8675
8676              render(true);
8677            }
8678
8679            isDispatching = false;
8680          }
8681        }
8682
8683        dirty = false;
8684      },
8685          syncXY = function syncXY(skipOnUpdate, skipSnap) {
8686        var x = self.x,
8687            y = self.y,
8688            snappedValue,
8689            cs;
8690
8691        if (!target._gsap) {
8692          gsCache = gsap$2.core.getCache(target);
8693        }
8694
8695        gsCache.uncache && gsap$2.getProperty(target, "x");
8696
8697        if (xyMode) {
8698          self.x = parseFloat(gsCache.x);
8699          self.y = parseFloat(gsCache.y);
8700        } else if (rotationMode) {
8701          self.x = self.rotation =

8701parseFloat(gsCache.rotation

vendor: 18,383 bytes, lines 8701-9251

8701);
8702        } else if (scrollProxy) {
8703          self.y = scrollProxy.top();
8704          self.x = scrollProxy.left();
8705        } else {
8706          self.y = parseFloat(target.style.top || (cs = _getComputedStyle(target)) && cs.top) || 0;
8707          self.x = parseFloat(target.style.left || (cs || {}).left) || 0;
8708        }
8709
8710        if ((snapX || snapY || snapXY) && !skipSnap && (self.isDragging || self.isThrowing)) {
8711          if (snapXY) {
8712            _temp1.x = self.x;
8713            _temp1.y = self.y;
8714            snappedValue = snapXY(_temp1);
8715
8716            if (snappedValue.x !== self.x) {
8717              self.x = snappedValue.x;
8718              dirty = true;
8719            }
8720
8721            if (snappedValue.y !== self.y) {
8722              self.y = snappedValue.y;
8723              dirty = true;
8724            }
8725          }
8726
8727          if (snapX) {
8728            snappedValue = snapX(self.x);
8729
8730            if (snappedValue !== self.x) {
8731              self.x = snappedValue;
8732
8733              if (rotationMode) {
8734                self.rotation = snappedValue;
8735              }
8736
8737              dirty = true;
8738            }
8739          }
8740
8741          if (snapY) {
8742            snappedValue = snapY(self.y);
8743
8744            if (snappedValue !== self.y) {
8745              self.y = snappedValue;
8746            }
8747
8748            dirty = true;
8749          }
8750        }
8751
8752        dirty && render(true);
8753
8754        if (!skipOnUpdate) {
8755          self.deltaX = self.x - x;
8756          self.deltaY = self.y - y;
8757
8758          _dispatchEvent(self, "throwupdate", "onThrowUpdate");
8759        }
8760      },
8761          buildSnapFunc = function buildSnapFunc(snap, min, max, factor) {
8762        if (min == null) {
8763          min = -_bigNum$3;
8764        }
8765
8766        if (max == null) {
8767          max = _bigNum$3;
8768        }
8769
8770        if (_isFunction$1(snap)) {
8771          return function (n) {
8772            var edgeTolerance = !self.isPressed ? 1 : 1 - self.edgeResistance;
8773            return snap.call(self, (n > max ? max + (n - max) * edgeTolerance : n < min ? min + (n - min) * edgeTolerance : n) * factor) * factor;
8774          };
8775        }
8776
8777        if (_isArray$1(snap)) {
8778          return function (n) {
8779            var i = snap.length,
8780                closest = 0,
8781                absDif = _bigNum$3,
8782                val,
8783                dif;
8784
8785            while (--i > -1) {
8786              val = snap[i];
8787              dif = val - n;
8788
8789              if (dif < 0) {
8790                dif = -dif;
8791              }
8792
8793              if (dif < absDif && val >= min && val <= max) {
8794                closest = i;
8795                absDif = dif;
8796              }
8797            }
8798
8799            return snap[closest];
8800          };
8801        }
8802
8803        return isNaN(snap) ? function (n) {
8804          return n;
8805        } : function () {
8806          return snap * factor;
8807        };
8808      },
8809          buildPointSnapFunc = function buildPointSnapFunc(snap, minX, maxX, minY, maxY, radius, factor) {
8810        radius = radius && radius < _bigNum$3 ? radius * radius : _bigNum$3;
8811
8812        if (_isFunction$1(snap)) {
8813          return function (point) {
8814            var edgeTolerance = !self.isPressed ? 1 : 1 - self.edgeResistance,
8815                x = point.x,
8816                y = point.y,
8817                result,
8818                dx,
8819                dy;
8820            point.x = x = x > maxX ? maxX + (x - maxX) * edgeTolerance : x < minX ? minX + (x - minX) * edgeTolerance : x;
8821            point.y = y = y > maxY ? maxY + (y - maxY) * edgeTolerance : y < minY ? minY + (y - minY) * edgeTolerance : y;
8822            result = snap.call(self, point);
8823
8824            if (result !== point) {
8825              point.x = result.x;
8826              point.y = result.y;
8827            }
8828
8829            if (factor !== 1) {
8830              point.x *= factor;
8831              point.y *= factor;
8832            }
8833
8834            if (radius < _bigNum$3) {
8835              dx = point.x - x;
8836              dy = point.y - y;
8837
8838              if (dx * dx + dy * dy > radius) {
8839                point.x = x;
8840                point.y = y;
8841              }
8842            }
8843
8844            return point;
8845          };
8846        }
8847
8848        if (_isArray$1(snap)) {
8849          return function (p) {
8850            var i = snap.length,
8851                closest = 0,
8852                minDist = _bigNum$3,
8853                x,
8854                y,
8855                point,
8856                dist;
8857
8858            while (--i > -1) {
8859              point = snap[i];
8860              x = point.x - p.x;
8861              y = point.y - p.y;
8862              dist = x * x + y * y;
8863
8864              if (dist < minDist) {
8865                closest = i;
8866                minDist = dist;
8867              }
8868            }
8869
8870            return minDist <= radius ? snap[closest] : p;
8871          };
8872        }
8873
8874        return function (n) {
8875          return n;
8876        };
8877      },
8878          calculateBounds = function calculateBounds() {
8879        var bounds, targetBounds, snap, snapIsRaw;
8880        hasBounds = false;
8881
8882        if (scrollProxy) {
8883          scrollProxy.calibrate();
8884          self.minX = minX = -scrollProxy.maxScrollLeft();
8885          self.minY = minY = -scrollProxy.maxScrollTop();
8886          self.maxX = maxX = self.maxY = maxY = 0;
8887          hasBounds = true;
8888        } else if (!!vars.bounds) {
8889          bounds = _getBounds(vars.bounds, target.parentNode);
8890
8891          if (rotationMode) {
8892            self.minX = minX = bounds.left;
8893            self.maxX = maxX = bounds.left + bounds.width;
8894            self.minY = minY = self.maxY = maxY = 0;
8895          } else if (!_isUndefined$2(vars.bounds.maxX) || !_isUndefined$2(vars.bounds.maxY)) {
8896            bounds = vars.bounds;
8897            self.minX = minX = bounds.minX;
8898            self.minY = minY = bounds.minY;
8899            self.maxX = maxX = bounds.maxX;
8900            self.maxY = maxY = bounds.maxY;
8901          } else {
8902            targetBounds = _getBounds(target, target.parentNode);
8903            self.minX = minX = Math.round(getPropAsNum(xProp, "px") + bounds.left - targetBounds.left);
8904            self.minY = minY = Math.round(getPropAsNum(yProp, "px") + bounds.top - targetBounds.top);
8905            self.maxX = maxX = Math.round(minX + (bounds.width - targetBounds.width));
8906            self.maxY = maxY = Math.round(minY + (bounds.height - targetBounds.height));
8907          }
8908
8909          if (minX > maxX) {
8910            self.minX = maxX;
8911            self.maxX = maxX = minX;
8912            minX = self.minX;
8913          }
8914
8915          if (minY > maxY) {
8916            self.minY = maxY;
8917            self.maxY = maxY = minY;
8918            minY = self.minY;
8919          }
8920
8921          if (rotationMode) {
8922            self.minRotation = minX;
8923            self.maxRotation = maxX;
8924          }
8925
8926          hasBounds = true;
8927        }
8928
8929        if (vars.liveSnap) {
8930          snap = vars.liveSnap === true ? vars.snap || {} : vars.liveSnap;
8931          snapIsRaw = _isArray$1(snap) || _isFunction$1(snap);
8932
8933          if (rotationMode) {
8934            snapX = buildSnapFunc(snapIsRaw ? snap : snap.rotation, minX, maxX, 1);
8935            snapY = null;
8936          } else {
8937            if (snap.points) {
8938              snapXY = buildPointSnapFunc(snapIsRaw ? snap : snap.points, minX, maxX, minY, maxY, snap.radius, scrollProxy ? -1 : 1);
8939            } else {
8940              if (allowX) {
8941                snapX = buildSnapFunc(snapIsRaw ? snap : snap.x || snap.left || snap.scrollLeft, minX, maxX, scrollProxy ? -1 : 1);
8942              }
8943
8944              if (allowY) {
8945                snapY = buildSnapFunc(snapIsRaw ? snap : snap.y || snap.top || snap.scrollTop, minY, maxY, scrollProxy ? -1 : 1);
8946              }
8947            }
8948          }
8949        }
8950      },
8951          onThrowComplete = function onThrowComplete() {
8952        self.isThrowing = false;
8953
8954        _dispatchEvent(self, "throwcomplete", "onThrowComplete");
8955      },
8956          onThrowInterrupt = function onThrowInterrupt() {
8957        self.isThrowing = false;
8958      },
8959          animate = function animate(inertia, forceZeroVelocity) {
8960        var snap, snapIsRaw, tween, overshootTolerance;
8961
8962        if (inertia && InertiaPlugin) {
8963          if (inertia === true) {
8964            snap = vars.snap || vars.liveSnap || {};
8965            snapIsRaw = _isArray$1(snap) || _isFunction$1(snap);
8966            inertia = {
8967              resistance: (vars.throwResistance || vars.resistance || 1000) / (rotationMode ? 10 : 1)
8968            };
8969
8970            if (rotationMode) {
8971              inertia.rotation = _parseInertia(self, snapIsRaw ? snap : snap.rotation, maxX, minX, 1, forceZeroVelocity);
8972            } else {
8973              if (allowX) {
8974                inertia[xProp] = _parseInertia(self, snapIsRaw ? snap : snap.points || snap.x || snap.left, maxX, minX, scrollProxy ? -1 : 1, forceZeroVelocity || self.lockedAxis === "x");
8975              }
8976
8977              if (allowY) {
8978                inertia[yProp] = _parseInertia(self, snapIsRaw ? snap : snap.points || snap.y || snap.top, maxY, minY, scrollProxy ? -1 : 1, forceZeroVelocity || self.lockedAxis === "y");
8979              }
8980
8981              if (snap.points || _isArray$1(snap) && _isObject$1(snap[0])) {
8982                inertia.linkedProps = xProp + "," + yProp;
8983                inertia.radius = snap.radius;
8984              }
8985            }
8986          }
8987
8988          self.isThrowing = true;
8989          overshootTolerance = !isNaN(vars.overshootTolerance) ? vars.overshootTolerance : vars.edgeResistance === 1 ? 0 : 1 - self.edgeResistance + 0.2;
8990
8991          if (!inertia.duration) {
8992            inertia.duration = {
8993              max: Math.max(vars.minDuration || 0, "maxDuration" in vars ? vars.maxDuration : 2),
8994              min: !isNaN(vars.minDuration) ? vars.minDuration : overshootTolerance === 0 || _isObject$1(inertia) && inertia.resistance > 1000 ? 0 : 0.5,
8995              overshoot: overshootTolerance
8996            };
8997          }
8998
8999          self.tween = tween = gsap$2.to(scrollProxy || target, {
9000            inertia: inertia,
9001            data: "_draggable",
9002            inherit: false,
9003            onComplete: onThrowComplete,
9004            onInterrupt: onThrowInterrupt,
9005            onUpdate: vars.fastMode ? _dispatchEvent : syncXY,
9006            onUpdateParams: vars.fastMode ? [self, "onthrowupdate", "onThrowUpdate"] : snap && snap.radius ? [false, true] : []
9007          });
9008
9009          if (!vars.fastMode) {
9010            if (scrollProxy) {
9011              scrollProxy._skip = true;
9012            }
9013
9014            tween.render(1e9, true, true);
9015            syncXY(true, true);
9016            self.endX = self.x;
9017            self.endY = self.y;
9018
9019            if (rotationMode) {
9020              self.endRotation = self.x;
9021            }
9022
9023            tween.play(0);
9024            syncXY(true, true);
9025
9026            if (scrollProxy) {
9027              scrollProxy._skip = false;
9028            }
9029          }
9030        } else if (hasBounds) {
9031          self.applyBounds();
9032        }
9033      },
9034          updateMatrix = function updateMatrix(shiftStart) {
9035        var start = matrix,
9036            p;
9037        matrix = getGlobalMatrix(target.parentNode, true);
9038
9039        if (shiftStart && self.isPressed && !matrix.equals(start || new Matrix2D())) {
9040          p = start.inverse().apply({
9041            x: startPointerX,
9042            y: startPointerY
9043          });
9044          matrix.apply(p, p);
9045          startPointerX = p.x;
9046          startPointerY = p.y;
9047        }
9048
9049        if (matrix.equals(_identityMatrix$1)) {
9050          matrix = null;
9051        }
9052      },
9053          recordStartPositions = function recordStartPositions() {
9054        var edgeTolerance = 1 - self.edgeResistance,
9055            offsetX = isFixed ? _getDocScrollLeft$1(ownerDoc) : 0,
9056            offsetY = isFixed ? _getDocScrollTop$1(ownerDoc) : 0,
9057            parsedOrigin,
9058            x,
9059            y;
9060
9061        if (xyMode) {
9062          gsCache.x = getPropAsNum(xProp, "px") + "px";
9063          gsCache.y = getPropAsNum(yProp, "px") + "px";
9064          gsCache.renderTransform();
9065        }
9066
9067        updateMatrix(false);
9068        _point1.x = self.pointerX - offsetX;
9069        _point1.y = self.pointerY - offsetY;
9070        matrix && matrix.apply(_point1, _point1);
9071        startPointerX = _point1.x;
9072        startPointerY = _point1.y;
9073
9074        if (dirty) {
9075          setPointerPosition(self.pointerX, self.pointerY);
9076          render(true);
9077        }
9078
9079        innerMatrix = getGlobalMatrix(target);
9080
9081        if (scrollProxy) {
9082          calculateBounds();
9083          startElementY = scrollProxy.top();
9084          startElementX = scrollProxy.left();
9085        } else {
9086          if (isTweening()) {
9087            syncXY(true, true);
9088            calculateBounds();
9089          } else {
9090            self.applyBounds();
9091          }
9092
9093          if (rotationMode) {
9094            parsedOrigin = target.ownerSVGElement ? [gsCache.xOrigin - target.getBBox().x, gsCache.yOrigin - target.getBBox().y] : (_getComputedStyle(target)[_transformOriginProp$2] || "0 0").split(" ");
9095            rotationOrigin = self.rotationOrigin = getGlobalMatrix(target).apply({
9096              x: parseFloat(parsedOrigin[0]) || 0,
9097              y: parseFloat(parsedOrigin[1]) || 0
9098            });
9099            syncXY(true, true);
9100            x = self.pointerX - rotationOrigin.x - offsetX;
9101            y = rotationOrigin.y - self.pointerY + offsetY;
9102            startElementX = self.x;
9103            startElementY = self.y = Math.atan2(y, x) * _RAD2DEG$2;
9104          } else {
9105            startElementY = getPropAsNum(yProp, "px");
9106            startElementX = getPropAsNum(xProp, "px");
9107          }
9108        }
9109
9110        if (hasBounds && edgeTolerance) {
9111          if (startElementX > maxX) {
9112            startElementX = maxX + (startElementX - maxX) / edgeTolerance;
9113          } else if (startElementX < minX) {
9114            startElementX = minX - (minX - startElementX) / edgeTolerance;
9115          }
9116
9117          if (!rotationMode) {
9118            if (startElementY > maxY) {
9119              startElementY = maxY + (startElementY - maxY) / edgeTolerance;
9120            } else if (startElementY < minY) {
9121              startElementY = minY - (minY - startElementY) / edgeTolerance;
9122            }
9123          }
9124        }
9125
9126        self.startX = startElementX = _round$3(startElementX);
9127        self.startY = startElementY = _round$3(startElementY);
9128      },
9129          isTweening = function isTweening() {
9130        return self.tween && self.tween.isActive();
9131      },
9132          removePlaceholder = function removePlaceholder() {
9133        if (_placeholderDiv.parentNode && !isTweening() && !self.isDragging) {
9134          _placeholderDiv.parentNode.removeChild(_placeholderDiv);
9135        }
9136      },
9137          onPress = function onPress(e, force) {
9138        var i;
9139
9140        if (!enabled || self.isPressed || !e || (e.type === "mousedown" || e.type === "pointerdown") && !force && _getTime() - clickTime < 30 && _touchEventLookup[self.pointerEvent.type]) {
9141          isPreventingDefault && e && enabled && _preventDefault(e);
9142          return;
9143        }
9144
9145        interrupted = isTweening();
9146        dragged = false;
9147        self.pointerEvent = e;
9148
9149        if (_touchEventLookup[e.type]) {
9150          touchEventTarget = ~e.type.indexOf("touch") ? e.currentTarget || e.target : ownerDoc;
9151
9152          _addListener(touchEventTarget, "touchend", onRelease);
9153
9154          _addListener(touchEventTarget, "touchmove", onMove);
9155
9156          _addListener(touchEventTarget, "touchcancel", onRelease);
9157
9158          _addListener(ownerDoc, "touchstart", _onMultiTouchDocument);
9159        } else {
9160          touchEventTarget = null;
9161
9162          _addListener(ownerDoc, "mousemove", onMove);
9163        }
9164
9165        touchDragAxis = null;
9166
9167        if (!_supportsPointer || !touchEventTarget) {
9168          _addListener(ownerDoc, "mouseup", onRelease);
9169
9170          e && e.target && _addListener(e.target, "mouseup", onRelease);
9171        }
9172
9173        isClicking = isClickable.call(self, e.target) && vars.dragClickables === false && !force;
9174
9175        if (isClicking) {
9176          _addListener(e.target, "change", onRelease);
9177
9178          _dispatchEvent(self, "pressInit", "onPressInit");
9179
9180          _dispatchEvent(self, "press", "onPress");
9181
9182          _setSelectable(triggers, true);
9183
9184          isPreventingDefault = false;
9185          return;
9186        }
9187
9188        allowNativeTouchScrolling = !touchEventTarget || allowX === allowY || self.vars.allowNativeTouchScrolling === false || self.vars.allowContextMenu && e && (e.ctrlKey || e.which > 2) ? false : allowX ? "y" : "x";
9189        isPreventingDefault = !allowNativeTouchScrolling && !self.allowEventDefault;
9190
9191        if (isPreventingDefault) {
9192          _preventDefault(e);
9193
9194          _addListener(_win$3, "touchforcechange", _preventDefault);
9195        }
9196
9197        if (e.changedTouches) {
9198          e = touch = e.changedTouches[0];
9199          touchID = e.identifier;
9200        } else if (e.pointerId) {
9201          touchID = e.pointerId;
9202        } else {
9203          touch = touchID = null;
9204        }
9205
9206        _dragCount$1++;
9207
9208        _addToRenderQueue(render);
9209
9210        startPointerY = self.pointerY = e.pageY;
9211        startPointerX = self.pointerX = e.pageX;
9212
9213        _dispatchEvent(self, "pressInit", "onPressInit");
9214
9215        if (allowNativeTouchScrolling || self.autoScroll) {
9216          _recordMaxScrolls(target.parentNode);
9217        }
9218
9219        if (target.parentNode && self.autoScroll && !scrollProxy && !rotationMode && target.parentNode._gsMaxScrollX && !_placeholderDiv.parentNode && !target.getBBox) {
9220          _placeholderDiv.style.width = target.parentNode.scrollWidth + "px";
9221          target.parentNode.appendChild(_placeholderDiv);
9222        }
9223
9224        recordStartPositions();
9225        self.tween && self.tween.kill();
9226        self.isThrowing = false;
9227        gsap$2.killTweensOf(scrollProxy || target, killProps, true);
9228        scrollProxy && gsap$2.killTweensOf(target, {
9229          scrollTo: 1
9230        }, true);
9231        self.tween = self.lockedAxis = null;
9232
9233        if (vars.zIndexBoost || !rotationMode && !scrollProxy && vars.zIndexBoost !== false) {
9234          target.style.zIndex = Draggable.zIndex++;
9235        }
9236
9237        self.isPressed = true;
9238        hasDragCallback = !!(vars.onDrag || self._listeners.drag);
9239        hasMoveCallback = !!(vars.onMove || self._listeners.move);
9240
9241        if (vars.cursor !== false || vars.activeCursor) {
9242          i = triggers.length;
9243
9244          while (--i > -1) {
9245            gsap$2.set(triggers[i], {
9246              cursor: vars.activeCursor || vars.cursor || (_defaultCursor === "grab" ? "grabbing" : _defaultCursor)
9247            });
9248          }
9249        }
9250
9251        _dispatchEvent(self, "press", "onPress");

vendor: 2,449 bytes, lines 9252-9319

9252      },
9253          onMove = function onMove(e) {
9254        var originalEvent = e,
9255            touches,
9256            pointerX,
9257            pointerY,
9258            i,
9259            dx,
9260            dy;
9261
9262        if (!enabled || _isMultiTouching || !self.isPressed || !e) {
9263          isPreventingDefault && e && enabled && _preventDefault(e);
9264          return;
9265        }
9266
9267        self.pointerEvent = e;
9268        touches = e.changedTouches;
9269
9270        if (touches) {
9271          e = touches[0];
9272
9273          if (e !== touch && e.identifier !== touchID) {
9274            i = touches.length;
9275
9276            while (--i > -1 && (e = touches[i]).identifier !== touchID && e.target !== target) {}
9277
9278            if (i < 0) {
9279              return;
9280            }
9281          }
9282        } else if (e.pointerId && touchID && e.pointerId !== touchID) {
9283          return;
9284        }
9285
9286        if (touchEventTarget && allowNativeTouchScrolling && !touchDragAxis) {
9287          _point1.x = e.pageX - (isFixed ? _getDocScrollLeft$1(ownerDoc) : 0);
9288          _point1.y = e.pageY - (isFixed ? _getDocScrollTop$1(ownerDoc) : 0);
9289          matrix && matrix.apply(_point1, _point1);
9290          pointerX = _point1.x;
9291          pointerY = _point1.y;
9292          dx = Math.abs(pointerX - startPointerX);
9293          dy = Math.abs(pointerY - startPointerY);
9294
9295          if (dx !== dy && (dx > minimumMovement || dy > minimumMovement) || _isAndroid && allowNativeTouchScrolling === touchDragAxis) {
9296            touchDragAxis = dx > dy && allowX ? "x" : "y";
9297
9298            if (allowNativeTouchScrolling && touchDragAxis !== allowNativeTouchScrolling) {
9299              _addListener(_win$3, "touchforcechange", _preventDefault);
9300            }
9301
9302            if (self.vars.lockAxisOnTouchScroll !== false && allowX && allowY) {
9303              self.lockedAxis = touchDragAxis === "x" ? "y" : "x";
9304              _isFunction$1(self.vars.onLockAxis) && self.vars.onLockAxis.call(self, originalEvent);
9305            }
9306
9307            if (_isAndroid && allowNativeTouchScrolling === touchDragAxis) {
9308              onRelease(originalEvent);
9309              return;
9310            }
9311          }
9312        }
9313
9314        if (!self.allowEventDefault && (!allowNativeTouchScrolling || touchDragAxis && allowNativeTouchScrolling !== touchDragAxis) && originalEvent.cancelable !== false) {
9315          _preventDefault(originalEvent);
9316
9317          isPreventingDefault = true;
9318        } else if (isPreventingDefault) {
9319          isPreventingDefault = false;

vendor: 3,933 bytes, lines 9320-9448

9320        }
9321
9322        if (self.autoScroll) {
9323          checkAutoScrollBounds = true;
9324        }
9325
9326        setPointerPosition(e.pageX, e.pageY, hasMoveCallback);
9327      },
9328          setPointerPosition = function setPointerPosition(pointerX, pointerY, invokeOnMove) {
9329        var dragTolerance = 1 - self.dragResistance,
9330            edgeTolerance = 1 - self.edgeResistance,
9331            prevPointerX = self.pointerX,
9332            prevPointerY = self.pointerY,
9333            prevStartElementY = startElementY,
9334            prevX = self.x,
9335            prevY = self.y,
9336            prevEndX = self.endX,
9337            prevEndY = self.endY,
9338            prevEndRotation = self.endRotation,
9339            prevDirty = dirty,
9340            xChange,
9341            yChange,
9342            x,
9343            y,
9344            dif,
9345            temp;
9346        self.pointerX = pointerX;
9347        self.pointerY = pointerY;
9348
9349        if (isFixed) {
9350          pointerX -= _getDocScrollLeft$1(ownerDoc);
9351          pointerY -= _getDocScrollTop$1(ownerDoc);
9352        }
9353
9354        if (rotationMode) {
9355          y = Math.atan2(rotationOrigin.y - pointerY, pointerX - rotationOrigin.x) * _RAD2DEG$2;
9356          dif = self.y - y;
9357
9358          if (dif > 180) {
9359            startElementY -= 360;
9360            self.y = y;
9361          } else if (dif < -180) {
9362            startElementY += 360;
9363            self.y = y;
9364          }
9365
9366          if (self.x !== startElementX || Math.abs(startElementY - y) > minimumMovement) {
9367            self.y = y;
9368            x = startElementX + (startElementY - y) * dragTolerance;
9369          } else {
9370            x = startElementX;
9371          }
9372        } else {
9373          if (matrix) {
9374            temp = pointerX * matrix.a + pointerY * matrix.c + matrix.e;
9375            pointerY = pointerX * matrix.b + pointerY * matrix.d + matrix.f;
9376            pointerX = temp;
9377          }
9378
9379          yChange = pointerY - startPointerY;
9380          xChange = pointerX - startPointerX;
9381
9382          if (yChange < minimumMovement && yChange > -minimumMovement) {
9383            yChange = 0;
9384          }
9385
9386          if (xChange < minimumMovement && xChange > -minimumMovement) {
9387            xChange = 0;
9388          }
9389
9390          if ((self.lockAxis || self.lockedAxis) && (xChange || yChange)) {
9391            temp = self.lockedAxis;
9392
9393            if (!temp) {
9394              self.lockedAxis = temp = allowX && Math.abs(xChange) > Math.abs(yChange) ? "y" : allowY ? "x" : null;
9395
9396              if (temp && _isFunction$1(self.vars.onLockAxis)) {
9397                self.vars.onLockAxis.call(self, self.pointerEvent);
9398              }
9399            }
9400
9401            if (temp === "y") {
9402              yChange = 0;
9403            } else if (temp === "x") {
9404              xChange = 0;
9405            }
9406          }
9407
9408          x = _round$3(startElementX + xChange * dragTolerance);
9409          y = _round$3(startElementY + yChange * dragTolerance);
9410        }
9411
9412        if ((snapX || snapY || snapXY) && (self.x !== x || self.y !== y && !rotationMode)) {
9413          if (snapXY) {
9414            _temp1.x = x;
9415            _temp1.y = y;
9416            temp = snapXY(_temp1);
9417            x = _round$3(temp.x);
9418            y = _round$3(temp.y);
9419          }
9420
9421          if (snapX) {
9422            x = _round$3(snapX(x));
9423          }
9424
9425          if (snapY) {
9426            y = _round$3(snapY(y));
9427          }
9428        }
9429
9430        if (hasBounds) {
9431          if (x > maxX) {
9432            x = maxX + Math.round((x - maxX) * edgeTolerance);
9433          } else if (x < minX) {
9434            x = minX + Math.round((x - minX) * edgeTolerance);
9435          }
9436
9437          if (!rotationMode) {
9438            if (y > maxY) {
9439              y = Math.round(maxY + (y - maxY) * edgeTolerance);
9440            } else if (y < minY) {
9441              y = Math.round(minY + (y - minY) * edgeTolerance);
9442            }
9443          }
9444        }
9445
9446        if (self.x !== x || self.y !== y && !rotationMode) {
9447          if (rotationMode) {
9448            self.endRotation = self.x = self.endX = x

vendor: 13,674 bytes, lines 9448-9855

9448;
9449            dirty = true;
9450          } else {
9451            if (allowY) {
9452              self.y = self.endY = y;
9453              dirty = true;
9454            }
9455
9456            if (allowX) {
9457              self.x = self.endX = x;
9458              dirty = true;
9459            }
9460          }
9461
9462          if (!invokeOnMove || _dispatchEvent(self, "move", "onMove") !== false) {
9463            if (!self.isDragging && self.isPressed) {
9464              self.isDragging = dragged = true;
9465
9466              _dispatchEvent(self, "dragstart", "onDragStart");
9467            }
9468          } else {
9469            self.pointerX = prevPointerX;
9470            self.pointerY = prevPointerY;
9471            startElementY = prevStartElementY;
9472            self.x = prevX;
9473            self.y = prevY;
9474            self.endX = prevEndX;
9475            self.endY = prevEndY;
9476            self.endRotation = prevEndRotation;
9477            dirty = prevDirty;
9478          }
9479        }
9480      },
9481          onRelease = function onRelease(e, force) {
9482        if (!enabled || !self.isPressed || e && touchID != null && !force && (e.pointerId && e.pointerId !== touchID && e.target !== target || e.changedTouches && !_hasTouchID(e.changedTouches, touchID))) {
9483          isPreventingDefault && e && enabled && _preventDefault(e);
9484          return;
9485        }
9486
9487        self.isPressed = false;
9488        var originalEvent = e,
9489            wasDragging = self.isDragging,
9490            isContextMenuRelease = self.vars.allowContextMenu && e && (e.ctrlKey || e.which > 2),
9491            placeholderDelayedCall = gsap$2.delayedCall(0.001, removePlaceholder),
9492            touches,
9493            i,
9494            syntheticEvent,
9495            eventTarget,
9496            syntheticClick;
9497
9498        if (touchEventTarget) {
9499          _removeListener(touchEventTarget, "touchend", onRelease);
9500
9501          _removeListener(touchEventTarget, "touchmove", onMove);
9502
9503          _removeListener(touchEventTarget, "touchcancel", onRelease);
9504
9505          _removeListener(ownerDoc, "touchstart", _onMultiTouchDocument);
9506        } else {
9507          _removeListener(ownerDoc, "mousemove", onMove);
9508        }
9509
9510        _removeListener(_win$3, "touchforcechange", _preventDefault);
9511
9512        if (!_supportsPointer || !touchEventTarget) {
9513          _removeListener(ownerDoc, "mouseup", onRelease);
9514
9515          e && e.target && _removeListener(e.target, "mouseup", onRelease);
9516        }
9517
9518        dirty = false;
9519
9520        if (wasDragging) {
9521          dragEndTime = _lastDragTime = _getTime();
9522          self.isDragging = false;
9523        }
9524
9525        _removeFromRenderQueue(render);
9526
9527        if (isClicking && !isContextMenuRelease) {
9528          if (e) {
9529            _removeListener(e.target, "change", onRelease);
9530
9531            self.pointerEvent = originalEvent;
9532          }
9533
9534          _setSelectable(triggers, false);
9535
9536          _dispatchEvent(self, "release", "onRelease");
9537
9538          _dispatchEvent(self, "click", "onClick");
9539
9540          isClicking = false;
9541          return;
9542        }
9543
9544        i = triggers.length;
9545
9546        while (--i > -1) {
9547          _setStyle(triggers[i], "cursor", vars.cursor || (vars.cursor !== false ? _defaultCursor : null));
9548        }
9549
9550        _dragCount$1--;
9551
9552        if (e) {
9553          touches = e.changedTouches;
9554
9555          if (touches) {
9556            e = touches[0];
9557
9558            if (e !== touch && e.identifier !== touchID) {
9559              i = touches.length;
9560
9561              while (--i > -1 && (e = touches[i]).identifier !== touchID && e.target !== target) {}
9562
9563              if (i < 0 && !force) {
9564                return;
9565              }
9566            }
9567          }
9568
9569          self.pointerEvent = originalEvent;
9570          self.pointerX = e.pageX;
9571          self.pointerY = e.pageY;
9572        }
9573
9574        if (isContextMenuRelease && originalEvent) {
9575          _preventDefault(originalEvent);
9576
9577          isPreventingDefault = true;
9578
9579          _dispatchEvent(self, "release", "onRelease");
9580        } else if (originalEvent && !wasDragging) {
9581          isPreventingDefault = false;
9582
9583          if (interrupted && (vars.snap || vars.bounds)) {
9584            animate(vars.inertia || vars.throwProps);
9585          }
9586
9587          _dispatchEvent(self, "release", "onRelease");
9588
9589          if ((!_isAndroid || originalEvent.type !== "touchmove") && originalEvent.type.indexOf("cancel") === -1) {
9590            _dispatchEvent(self, "click", "onClick");
9591
9592            if (_getTime() - clickTime < 300) {
9593              _dispatchEvent(self, "doubleclick", "onDoubleClick");
9594            }
9595
9596            eventTarget = originalEvent.target || target;
9597            clickTime = _getTime();
9598
9599            syntheticClick = function syntheticClick() {
9600              if (clickTime !== clickDispatch && self.enabled() && !self.isPressed && !originalEvent.defaultPrevented) {
9601                if (eventTarget.click) {
9602                  eventTarget.click();
9603                } else if (ownerDoc.createEvent) {
9604                  syntheticEvent = ownerDoc.createEvent("MouseEvents");
9605                  syntheticEvent.initMouseEvent("click", true, true, _win$3, 1, self.pointerEvent.screenX, self.pointerEvent.screenY, self.pointerX, self.pointerY, false, false, false, false, 0, null);
9606                  eventTarget.dispatchEvent(syntheticEvent);
9607                }
9608              }
9609            };
9610
9611            if (!_isAndroid && !originalEvent.defaultPrevented) {
9612              gsap$2.delayedCall(0.05, syntheticClick);
9613            }
9614          }
9615        } else {
9616          animate(vars.inertia || vars.throwProps);
9617
9618          if (!self.allowEventDefault && originalEvent && (vars.dragClickables !== false || !isClickable.call(self, originalEvent.target)) && wasDragging && (!allowNativeTouchScrolling || touchDragAxis && allowNativeTouchScrolling === touchDragAxis) && originalEvent.cancelable !== false) {
9619            isPreventingDefault = true;
9620
9621            _preventDefault(originalEvent);
9622          } else {
9623            isPreventingDefault = false;
9624          }
9625
9626          _dispatchEvent(self, "release", "onRelease");
9627        }
9628
9629        isTweening() && placeholderDelayedCall.duration(self.tween.duration());
9630        wasDragging && _dispatchEvent(self, "dragend", "onDragEnd");
9631        return true;
9632      },
9633          updateScroll = function updateScroll(e) {
9634        if (e && self.isDragging && !scrollProxy) {
9635          var parent = e.target || target.parentNode,
9636              deltaX = parent.scrollLeft - parent._gsScrollX,
9637              deltaY = parent.scrollTop - parent._gsScrollY;
9638
9639          if (deltaX || deltaY) {
9640            if (matrix) {
9641              startPointerX -= deltaX * matrix.a + deltaY * matrix.c;
9642              startPointerY -= deltaY * matrix.d + deltaX * matrix.b;
9643            } else {
9644              startPointerX -= deltaX;
9645              startPointerY -= deltaY;
9646            }
9647
9648            parent._gsScrollX += deltaX;
9649            parent._gsScrollY += deltaY;
9650            setPointerPosition(self.pointerX, self.pointerY);
9651          }
9652        }
9653      },
9654          onClick = function onClick(e) {
9655        var time = _getTime(),
9656            recentlyClicked = time - clickTime < 100,
9657            recentlyDragged = time - dragEndTime < 50,
9658            alreadyDispatched = recentlyClicked && clickDispatch === clickTime,
9659            defaultPrevented = self.pointerEvent && self.pointerEvent.defaultPrevented,
9660            alreadyDispatchedTrusted = recentlyClicked && trustedClickDispatch === clickTime,
9661            trusted = e.isTrusted || e.isTrusted == null && recentlyClicked && alreadyDispatched;
9662
9663        if ((alreadyDispatched || recentlyDragged && self.vars.suppressClickOnDrag !== false) && e.stopImmediatePropagation) {
9664          e.stopImmediatePropagation();
9665        }
9666
9667        if (recentlyClicked && !(self.pointerEvent && self.pointerEvent.defaultPrevented) && (!alreadyDispatched || trusted && !alreadyDispatchedTrusted)) {
9668          if (trusted && alreadyDispatched) {
9669            trustedClickDispatch = clickTime;
9670          }
9671
9672          clickDispatch = clickTime;
9673          return;
9674        }
9675
9676        if (self.isPressed || recentlyDragged || recentlyClicked) {
9677          if (!trusted || !e.detail || !recentlyClicked || defaultPrevented) {
9678            _preventDefault(e);
9679          }
9680        }
9681
9682        if (!recentlyClicked && !recentlyDragged && !dragged) {
9683          e && e.target && (self.pointerEvent = e);
9684
9685          _dispatchEvent(self, "click", "onClick");
9686        }
9687      },
9688          localizePoint = function localizePoint(p) {
9689        return matrix ? {
9690          x: p.x * matrix.a + p.y * matrix.c + matrix.e,
9691          y: p.x * matrix.b + p.y * matrix.d + matrix.f
9692        } : {
9693          x: p.x,
9694          y: p.y
9695        };
9696      };
9697
9698      old = Draggable.get(target);
9699      old && old.kill();
9700
9701      _this2.startDrag = function (event, align) {
9702        var r1, r2, p1, p2;
9703        onPress(event || self.pointerEvent, true);
9704
9705        if (align && !self.hitTest(event || self.pointerEvent)) {
9706          r1 = _parseRect(event || self.pointerEvent);
9707          r2 = _parseRect(target);
9708          p1 = localizePoint({
9709            x: r1.left + r1.width / 2,
9710            y: r1.top + r1.height / 2
9711          });
9712          p2 = localizePoint({
9713            x: r2.left + r2.width / 2,
9714            y: r2.top + r2.height / 2
9715          });
9716          startPointerX -= p1.x - p2.x;
9717          startPointerY -= p1.y - p2.y;
9718        }
9719
9720        if (!self.isDragging) {
9721          self.isDragging = dragged = true;
9722
9723          _dispatchEvent(self, "dragstart", "onDragStart");
9724        }
9725      };
9726
9727      _this2.drag = onMove;
9728
9729      _this2.endDrag = function (e) {
9730        return onRelease(e || self.pointerEvent, true);
9731      };
9732
9733      _this2.timeSinceDrag = function () {
9734        return self.isDragging ? 0 : (_getTime() - dragEndTime) / 1000;
9735      };
9736
9737      _this2.timeSinceClick = function () {
9738        return (_getTime() - clickTime) / 1000;
9739      };
9740
9741      _this2.hitTest = function (target, threshold) {
9742        return Draggable.hitTest(self.target, target, threshold);
9743      };
9744
9745      _this2.getDirection = function (from, diagonalThreshold) {
9746        var mode = from === "velocity" && InertiaPlugin ? from : _isObject$1(from) && !rotationMode ? "element" : "start",
9747            xChange,
9748            yChange,
9749            ratio,
9750            direction,
9751            r1,
9752            r2;
9753
9754        if (mode === "element") {
9755          r1 = _parseRect(self.target);
9756          r2 = _parseRect(from);
9757        }
9758
9759        xChange = mode === "start" ? self.x - startElementX : mode === "velocity" ? InertiaPlugin.getVelocity(target, xProp) : r1.left + r1.width / 2 - (r2.left + r2.width / 2);
9760
9761        if (rotationMode) {
9762          return xChange < 0 ? "counter-clockwise" : "clockwise";
9763        } else {
9764          diagonalThreshold = diagonalThreshold || 2;
9765          yChange = mode === "start" ? self.y - startElementY : mode === "velocity" ? InertiaPlugin.getVelocity(target, yProp) : r1.top + r1.height / 2 - (r2.top + r2.height / 2);
9766          ratio = Math.abs(xChange / yChange);
9767          direction = ratio < 1 / diagonalThreshold ? "" : xChange < 0 ? "left" : "right";
9768
9769          if (ratio < diagonalThreshold) {
9770            if (direction !== "") {
9771              direction += "-";
9772            }
9773
9774            direction += yChange < 0 ? "up" : "down";
9775          }
9776        }
9777
9778        return direction;
9779      };
9780
9781      _this2.applyBounds = function (newBounds, sticky) {
9782        var x, y, forceZeroVelocity, e, parent, isRoot;
9783
9784        if (newBounds && vars.bounds !== newBounds) {
9785          vars.bounds = newBounds;
9786          return self.update(true, sticky);
9787        }
9788
9789        syncXY(true);
9790        calculateBounds();
9791
9792        if (hasBounds && !isTweening()) {
9793          x = self.x;
9794          y = self.y;
9795
9796          if (x > maxX) {
9797            x = maxX;
9798          } else if (x < minX) {
9799            x = minX;
9800          }
9801
9802          if (y > maxY) {
9803            y = maxY;
9804          } else if (y < minY) {
9805            y = minY;
9806          }
9807
9808          if (self.x !== x || self.y !== y) {
9809            forceZeroVelocity = true;
9810            self.x = self.endX = x;
9811
9812            if (rotationMode) {
9813              self.endRotation = x;
9814            } else {
9815              self.y = self.endY = y;
9816            }
9817
9818            dirty = true;
9819            render(true);
9820
9821            if (self.autoScroll && !self.isDragging) {
9822              _recordMaxScrolls(target.parentNode);
9823
9824              e = target;
9825              _windowProxy.scrollTop = _win$3.pageYOffset != null ? _win$3.pageYOffset : ownerDoc.documentElement.scrollTop != null ? ownerDoc.documentElement.scrollTop : ownerDoc.body.scrollTop;
9826              _windowProxy.scrollLeft = _win$3.pageXOffset != null ? _win$3.pageXOffset : ownerDoc.documentElement.scrollLeft != null ? ownerDoc.documentElement.scrollLeft : ownerDoc.body.scrollLeft;
9827
9828              while (e && !isRoot) {
9829                isRoot = _isRoot(e.parentNode);
9830                parent = isRoot ? _windowProxy : e.parentNode;
9831
9832                if (allowY && parent.scrollTop > parent._gsMaxScrollY) {
9833                  parent.scrollTop = parent._gsMaxScrollY;
9834                }
9835
9836                if (allowX && parent.scrollLeft > parent._gsMaxScrollX) {
9837                  parent.scrollLeft = parent._gsMaxScrollX;
9838                }
9839
9840                e = parent;
9841              }
9842            }
9843          }
9844
9845          if (self.isThrowing && (forceZeroVelocity || self.endX > maxX || self.endX < minX || self.endY > maxY || self.endY < minY)) {
9846            animate(vars.inertia || vars.throwProps, forceZeroVelocity);
9847          }
9848        }
9849
9850        return self;
9851      };
9852
9853      _this2.update = function (applyBounds, sticky, ignoreExternalChanges) {
9854        if (sticky && self.isPressed) {
9855

vendor: 3,076 bytes, lines 9855-9956

9855var m = getGlobalMatrix(target),
9856              p = innerMatrix.apply({
9857            x: self.x - startElementX,
9858            y: self.y - startElementY
9859          }),
9860              m2 = getGlobalMatrix(target.parentNode, true);
9861          m2.apply({
9862            x: m.e - p.x,
9863            y: m.f - p.y
9864          }, p);
9865          self.x -= p.x - m2.e;
9866          self.y -= p.y - m2.f;
9867          render(true);
9868          recordStartPositions();
9869        }
9870
9871        var x = self.x,
9872            y = self.y;
9873        updateMatrix(!sticky);
9874
9875        if (applyBounds) {
9876          self.applyBounds();
9877        } else {
9878          dirty && ignoreExternalChanges && render(true);
9879          syncXY(true);
9880        }
9881
9882        if (sticky) {
9883          setPointerPosition(self.pointerX, self.pointerY);
9884          dirty && render(true);
9885        }
9886
9887        if (self.isPressed && !sticky && (allowX && Math.abs(x - self.x) > 0.01 || allowY && Math.abs(y - self.y) > 0.01 && !rotationMode)) {
9888          recordStartPositions();
9889        }
9890
9891        if (self.autoScroll) {
9892          _recordMaxScrolls(target.parentNode, self.isDragging);
9893
9894          checkAutoScrollBounds = self.isDragging;
9895          render(true);
9896
9897          _removeScrollListener(target, updateScroll);
9898
9899          _addScrollListener(target, updateScroll);
9900        }
9901
9902        return self;
9903      };
9904
9905      _this2.enable = function (type) {
9906        var setVars = {
9907          lazy: true
9908        },
9909            id,
9910            i,
9911            trigger;
9912
9913        if (vars.cursor !== false) {
9914          setVars.cursor = vars.cursor || _defaultCursor;
9915        }
9916
9917        if (gsap$2.utils.checkPrefix("touchCallout")) {
9918          setVars.touchCallout = "none";
9919        }
9920
9921        if (type !== "soft") {
9922          _setTouchActionForAllDescendants(triggers, allowX === allowY ? "none" : vars.allowNativeTouchScrolling && target.scrollHeight === target.clientHeight === (target.scrollWidth === target.clientHeight) || vars.allowEventDefault ? "manipulation" : allowX ? "pan-y" : "pan-x");
9923
9924          i = triggers.length;
9925
9926          while (--i > -1) {
9927            trigger = triggers[i];
9928            _supportsPointer || _addListener(trigger, "mousedown", onPress);
9929
9930            _addListener(trigger, "touchstart", onPress);
9931
9932            _addListener(trigger, "click", onClick, true);
9933
9934            gsap$2.set(trigger, setVars);
9935
9936            if (trigger.getBBox && trigger.ownerSVGElement && allowX !== allowY) {
9937              gsap$2.set(trigger.ownerSVGElement, {
9938                touchAction: vars.allowNativeTouchScrolling || vars.allowEventDefault ? "manipulation" : allowX ? "pan-y" : "pan-x"
9939              });
9940            }
9941
9942            vars.allowContextMenu || _addListener(trigger, "contextmenu", onContextMenu);
9943          }
9944
9945          _setSelectable(triggers, false);
9946        }
9947
9948        _addScrollListener(target, updateScroll);
9949
9950        enabled = true;
9951
9952        if (InertiaPlugin && type !== "soft") {
9953          InertiaPlugin.track(scrollProxy || target, xyMode ? "x,y" : rotationMode ? "rotation" : "top,left");
9954        }
9955
9956        target._gsDragID = id =

vendor: 5,480 bytes, lines 9956-10162

9956 "d" + _lookupCount++;
9957        _lookup[id] = self;
9958
9959        if (scrollProxy) {
9960          scrollProxy.enable();
9961          scrollProxy.element._gsDragID = id;
9962        }
9963
9964        (vars.bounds || rotationMode) && recordStartPositions();
9965        vars.bounds && self.applyBounds();
9966        return self;
9967      };
9968
9969      _this2.disable = function (type) {
9970        var dragging = self.isDragging,
9971            i = triggers.length,
9972            trigger;
9973
9974        while (--i > -1) {
9975          _setStyle(triggers[i], "cursor", null);
9976        }
9977
9978        if (type !== "soft") {
9979          _setTouchActionForAllDescendants(triggers, null);
9980
9981          i = triggers.length;
9982
9983          while (--i > -1) {
9984            trigger = triggers[i];
9985
9986            _setStyle(trigger, "touchCallout", null);
9987
9988            _removeListener(trigger, "mousedown", onPress);
9989
9990            _removeListener(trigger, "touchstart", onPress);
9991
9992            _removeListener(trigger, "click", onClick, true);
9993
9994            _removeListener(trigger, "contextmenu", onContextMenu);
9995          }
9996
9997          _setSelectable(triggers, true);
9998
9999          if (touchEventTarget) {
10000            _removeListener(touchEventTarget, "touchcancel", onRelease);
10001
10002            _removeListener(touchEventTarget, "touchend", onRelease);
10003
10004            _removeListener(touchEventTarget, "touchmove", onMove);
10005          }
10006
10007          _removeListener(ownerDoc, "mouseup", onRelease);
10008
10009          _removeListener(ownerDoc, "mousemove", onMove);
10010        }
10011
10012        _removeScrollListener(target, updateScroll);
10013
10014        enabled = false;
10015
10016        if (InertiaPlugin && type !== "soft") {
10017          InertiaPlugin.untrack(scrollProxy || target, xyMode ? "x,y" : rotationMode ? "rotation" : "top,left");
10018          self.tween && self.tween.kill();
10019        }
10020
10021        scrollProxy && scrollProxy.disable();
10022
10023        _removeFromRenderQueue(render);
10024
10025        self.isDragging = self.isPressed = isClicking = false;
10026        dragging && _dispatchEvent(self, "dragend", "onDragEnd");
10027        return self;
10028      };
10029
10030      _this2.enabled = function (value, type) {
10031        return arguments.length ? value ? self.enable(type) : self.disable(type) : enabled;
10032      };
10033
10034      _this2.kill = function () {
10035        self.isThrowing = false;
10036        self.tween && self.tween.kill();
10037        self.disable();
10038        gsap$2.set(triggers, {
10039          clearProps: "userSelect"
10040        });
10041        delete _lookup[target._gsDragID];
10042        return self;
10043      };
10044
10045      _this2.revert = function () {
10046        this.kill();
10047        this.styles && this.styles.revert();
10048      };
10049
10050      if (~type.indexOf("scroll")) {
10051        scrollProxy = _this2.scrollProxy = new ScrollProxy(target, _extend({
10052          onKill: function onKill() {
10053            self.isPressed && onRelease(null);
10054          }
10055        }, vars));
10056        target.style.overflowY = allowY && !_isTouchDevice ? "auto" : "hidden";
10057        target.style.overflowX = allowX && !_isTouchDevice ? "auto" : "hidden";
10058        target = scrollProxy.content;
10059      }
10060
10061      if (rotationMode) {
10062        killProps.rotation = 1;
10063      } else {
10064        if (allowX) {
10065          killProps[xProp] = 1;
10066        }
10067
10068        if (allowY) {
10069          killProps[yProp] = 1;
10070        }
10071      }
10072
10073      gsCache.force3D = "force3D" in vars ? vars.force3D : true;
10074
10075      _context$1(_assertThisInitialized(_this2));
10076
10077      _this2.enable();
10078
10079      return _this2;
10080    }
10081
10082    Draggable.register = function register(core) {
10083      gsap$2 = core;
10084
10085      _initCore$2();
10086    };
10087
10088    Draggable.create = function create(targets, vars) {
10089      _coreInitted$2 || _initCore$2(true);
10090      return _toArray(targets).map(function (target) {
10091        return new Draggable(target, vars);
10092      });
10093    };
10094
10095    Draggable.get = function get(target) {
10096      return _lookup[(_toArray(target)[0] || {})._gsDragID];
10097    };
10098
10099    Draggable.timeSinceDrag = function timeSinceDrag() {
10100      return (_getTime() - _lastDragTime) / 1000;
10101    };
10102
10103    Draggable.hitTest = function hitTest(obj1, obj2, threshold) {
10104      if (obj1 === obj2) {
10105        return false;
10106      }
10107
10108      var r1 = _parseRect(obj1),
10109          r2 = _parseRect(obj2),
10110          top = r1.top,
10111          left = r1.left,
10112          right = r1.right,
10113          bottom = r1.bottom,
10114          width = r1.width,
10115          height = r1.height,
10116          isOutside = r2.left > right || r2.right < left || r2.top > bottom || r2.bottom < top,
10117          overlap,
10118          area,
10119          isRatio;
10120
10121      if (isOutside || !threshold) {
10122        return !isOutside;
10123      }
10124
10125      isRatio = (threshold + "").indexOf("%") !== -1;
10126      threshold = parseFloat(threshold) || 0;
10127      overlap = {
10128        left: Math.max(left, r2.left),
10129        top: Math.max(top, r2.top)
10130      };
10131      overlap.width = Math.min(right, r2.right) - overlap.left;
10132      overlap.height = Math.min(bottom, r2.bottom) - overlap.top;
10133
10134      if (overlap.width < 0 || overlap.height < 0) {
10135        return false;
10136      }
10137
10138      if (isRatio) {
10139        threshold *= 0.01;
10140        area = overlap.width * overlap.height;
10141        return area >= width * height * threshold || area >= r2.width * r2.height * threshold;
10142      }
10143
10144      return overlap.width > threshold && overlap.height > threshold;
10145    };
10146
10147    return Draggable;
10148  }(EventDispatcher);
10149
10150  _setDefaults$1(Draggable.prototype, {
10151    pointerX: 0,
10152    pointerY: 0,
10153    startX: 0,
10154    startY: 0,
10155    deltaX: 0,
10156    deltaY: 0,
10157    isDragging: false,
10158    isPressed: false
10159  });
10160
10161  Draggable.zIndex = 1000;
10162  Draggable.version = "3.1

101622.5";
10163  _getGSAP$1() && gsap$2.registerPlugin(Draggable);
10164
10165  /*!
10166   * CSSRulePlugin 3.12.5
10167   * https://gsap.com
10168   *
10169   * @license Copyright 2008-2024, GreenSock. All rights reserved.
10170   * Subject to the terms at https://gsap.com/standard-license or for
10171   * Club GSAP members, the agreement issued with that membership.
10172   * @author: Jack Doyle, [email protected]
10173  */
10174  var gsap$3,
10175      _coreInitted$3,
10176      _doc$4,
10177      CSSPlugin$1,
10178      _windowExists$3 = function _windowExists() {
10179    return typeof window !== "undefined";
10180  },
10181      _getGSAP$2 = function _getGSAP() {
10182    return gsap$3 || _windowExists$3() && (gsap$3 = window.gsap) && gsap$3.registerPlugin && gsap$3;
10183  },

vendor: 1,389 bytes, lines 10184-10243

10184      _checkRegister = function _checkRegister() {
10185    if (!_coreInitted$3) {
10186      _initCore$3();
10187
10188      if (!CSSPlugin$1) {
10189        console.warn("Please gsap.registerPlugin(CSSPlugin, CSSRulePlugin)");
10190      }
10191    }
10192
10193    return _coreInitted$3;
10194  },
10195      _initCore$3 = function _initCore(core) {
10196    gsap$3 = core || _getGSAP$2();
10197
10198    if (_windowExists$3()) {
10199      _doc$4 = document;
10200    }
10201
10202    if (gsap$3) {
10203      CSSPlugin$1 = gsap$3.plugins.css;
10204
10205      if (CSSPlugin$1) {
10206        _coreInitted$3 = 1;
10207      }
10208    }
10209  };
10210
10211  var CSSRulePlugin = {
10212    version: "3.12.5",
10213    name: "cssRule",
10214    init: function init(target, value, tween, index, targets) {
10215      if (!_checkRegister() || typeof target.cssText === "undefined") {
10216        return false;
10217      }
10218
10219      var div = target._gsProxy = target._gsProxy || _doc$4.createElement("div");
10220
10221      this.ss = target;
10222      this.style = div.style;
10223      div.style.cssText = target.cssText;
10224      CSSPlugin$1.prototype.init.call(this, div, value, tween, index, targets);
10225    },
10226    render: function render(ratio, data) {
10227      var pt = data._pt,
10228          style = data.style,
10229          ss = data.ss,
10230          i;
10231
10232      while (pt) {
10233        pt.r(ratio, pt.d);
10234        pt = pt._next;
10235      }
10236
10237      i = style.length;
10238
10239      while (--i > -1) {
10240        ss[style[i]] = style[style[i]];
10241      }
10242    },
10243    getRule: function getRule(selector) {

vendor: 4,352 bytes, lines 10244-10403

10244      _checkRegister();
10245
10246      var ruleProp = _doc$4.all ? "rules" : "cssRules",
10247          styleSheets = _doc$4.styleSheets,
10248          i = styleSheets.length,
10249          pseudo = selector.charAt(0) === ":",
10250          j,
10251          curSS,
10252          cs,
10253          a;
10254      selector = (pseudo ? "" : ",") + selector.split("::").join(":").toLowerCase() + ",";
10255
10256      if (pseudo) {
10257        a = [];
10258      }
10259
10260      while (i--) {
10261        try {
10262          curSS = styleSheets[i][ruleProp];
10263
10264          if (!curSS) {
10265            continue;
10266          }
10267
10268          j = curSS.length;
10269        } catch (e) {
10270          console.warn(e);
10271          continue;
10272        }
10273
10274        while (--j > -1) {
10275          cs = curSS[j];
10276
10277          if (cs.selectorText && ("," + cs.selectorText.split("::").join(":").toLowerCase() + ",").indexOf(selector) !== -1) {
10278            if (pseudo) {
10279              a.push(cs.style);
10280            } else {
10281              return cs.style;
10282            }
10283          }
10284        }
10285      }
10286
10287      return a;
10288    },
10289    register: _initCore$3
10290  };
10291  _getGSAP$2() && gsap$3.registerPlugin(CSSRulePlugin);
10292
10293  /*!
10294   * EaselPlugin 3.12.5
10295   * https://gsap.com
10296   *
10297   * @license Copyright 2008-2024, GreenSock. All rights reserved.
10298   * Subject to the terms at https://gsap.com/standard-license or for
10299   * Club GSAP members, the agreement issued with that membership.
10300   * @author: Jack Doyle, [email protected]
10301  */
10302  var gsap$4,
10303      _coreInitted$4,
10304      _win$4,
10305      _createJS,
10306      _ColorFilter,
10307      _ColorMatrixFilter,
10308      _colorProps = "redMultiplier,greenMultiplier,blueMultiplier,alphaMultiplier,redOffset,greenOffset,blueOffset,alphaOffset".split(","),
10309      _windowExists$4 = function _windowExists() {
10310    return typeof window !== "undefined";
10311  },
10312      _getGSAP$3 = function _getGSAP() {
10313    return gsap$4 || _windowExists$4() && (gsap$4 = window.gsap) && gsap$4.registerPlugin && gsap$4;
10314  },
10315      _getCreateJS = function _getCreateJS() {
10316    return _createJS || _win$4 && _win$4.createjs || _win$4 || {};
10317  },
10318      _warn$1 = function _warn(message) {
10319    return console.warn(message);
10320  },
10321      _cache = function _cache(target) {
10322    var b = target.getBounds && target.getBounds();
10323
10324    if (!b) {
10325      b = target.nominalBounds || {
10326        x: 0,
10327        y: 0,
10328        width: 100,
10329        height: 100
10330      };
10331      target.setBounds && target.setBounds(b.x, b.y, b.width, b.height);
10332    }
10333
10334    target.cache && target.cache(b.x, b.y, b.width, b.height);
10335
10336    _warn$1("EaselPlugin: for filters to display in EaselJS, you must call the object's cache() method first. GSAP attempted to use the target's getBounds() for the cache but that may not be completely accurate. " + target);
10337  },
10338      _parseColorFilter = function _parseColorFilter(target, v, plugin) {
10339    if (!_ColorFilter) {
10340      _ColorFilter = _getCreateJS().ColorFilter;
10341
10342      if (!_ColorFilter) {
10343        _warn$1("EaselPlugin error: The EaselJS ColorFilter JavaScript file wasn't loaded.");
10344      }
10345    }
10346
10347    var filters = target.filters || [],
10348        i = filters.length,
10349        c,
10350        s,
10351        e,
10352        a,
10353        p,
10354        pt;
10355
10356    while (i--) {
10357      if (filters[i] instanceof _ColorFilter) {
10358        s = filters[i];
10359        break;
10360      }
10361    }
10362
10363    if (!s) {
10364      s = new _ColorFilter();
10365      filters.push(s);
10366      target.filters = filters;
10367    }
10368
10369    e = s.clone();
10370
10371    if (v.tint != null) {
10372      c = gsap$4.utils.splitColor(v.tint);
10373      a = v.tintAmount != null ? +v.tintAmount : 1;
10374      e.redOffset = +c[0] * a;
10375      e.greenOffset = +c[1] * a;
10376      e.blueOffset = +c[2] * a;
10377      e.redMultiplier = e.greenMultiplier = e.blueMultiplier = 1 - a;
10378    } else {
10379      for (p in v) {
10380        if (p !== "exposure") if (p !== "brightness") {
10381          e[p] = +v[p];
10382        }
10383      }
10384    }
10385
10386    if (v.exposure != null) {
10387      e.redOffset = e.greenOffset = e.blueOffset = 255 * (+v.exposure - 1);
10388      e.redMultiplier = e.greenMultiplier = e.blueMultiplier = 1;
10389    } else if (v.brightness != null) {
10390      a = +v.brightness - 1;
10391      e.redOffset = e.greenOffset = e.blueOffset = a > 0 ? a * 255 : 0;
10392      e.redMultiplier = e.greenMultiplier = e.blueMultiplier = 1 - Math.abs(a);
10393    }
10394
10395    i = 8;
10396
10397    while (i--) {
10398      p = _colorProps[i];
10399
10400      if (s[p] !== e[p]) {
10401        pt = plugin.add(s, p, s[p], e[p], 0, 0, 0, 0, 0, 1);
10402
10403        if (pt) {

vendor: 5,418 bytes, lines 10404-10600

10404          pt.op = "easel_colorFilter";
10405        }
10406      }
10407    }
10408
10409    plugin._props.push("easel_colorFilter");
10410
10411    if (!target.cacheID) {
10412      _cache(target);
10413    }
10414  },
10415      _idMatrix = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0],
10416      _lumR = 0.212671,
10417      _lumG = 0.715160,
10418      _lumB = 0.072169,
10419      _applyMatrix = function _applyMatrix(m, m2) {
10420    if (!(m instanceof Array) || !(m2 instanceof Array)) {
10421      return m2;
10422    }
10423
10424    var temp = [],
10425        i = 0,
10426        z = 0,
10427        y,
10428        x;
10429
10430    for (y = 0; y < 4; y++) {
10431      for (x = 0; x < 5; x++) {
10432        z = x === 4 ? m[i + 4] : 0;
10433        temp[i + x] = m[i] * m2[x] + m[i + 1] * m2[x + 5] + m[i + 2] * m2[x + 10] + m[i + 3] * m2[x + 15] + z;
10434      }
10435
10436      i += 5;
10437    }
10438
10439    return temp;
10440  },
10441      _setSaturation = function _setSaturation(m, n) {
10442    if (isNaN(n)) {
10443      return m;
10444    }
10445
10446    var inv = 1 - n,
10447        r = inv * _lumR,
10448        g = inv * _lumG,
10449        b = inv * _lumB;
10450    return _applyMatrix([r + n, g, b, 0, 0, r, g + n, b, 0, 0, r, g, b + n, 0, 0, 0, 0, 0, 1, 0], m);
10451  },
10452      _colorize = function _colorize(m, color, amount) {
10453    if (isNaN(amount)) {
10454      amount = 1;
10455    }
10456
10457    var c = gsap$4.utils.splitColor(color),
10458        r = c[0] / 255,
10459        g = c[1] / 255,
10460        b = c[2] / 255,
10461        inv = 1 - amount;
10462    return _applyMatrix([inv + amount * r * _lumR, amount * r * _lumG, amount * r * _lumB, 0, 0, amount * g * _lumR, inv + amount * g * _lumG, amount * g * _lumB, 0, 0, amount * b * _lumR, amount * b * _lumG, inv + amount * b * _lumB, 0, 0, 0, 0, 0, 1, 0], m);
10463  },
10464      _setHue = function _setHue(m, n) {
10465    if (isNaN(n)) {
10466      return m;
10467    }
10468
10469    n *= Math.PI / 180;
10470    var c = Math.cos(n),
10471        s = Math.sin(n);
10472    return _applyMatrix([_lumR + c * (1 - _lumR) + s * -_lumR, _lumG + c * -_lumG + s * -_lumG, _lumB + c * -_lumB + s * (1 - _lumB), 0, 0, _lumR + c * -_lumR + s * 0.143, _lumG + c * (1 - _lumG) + s * 0.14, _lumB + c * -_lumB + s * -0.283, 0, 0, _lumR + c * -_lumR + s * -(1 - _lumR), _lumG + c * -_lumG + s * _lumG, _lumB + c * (1 - _lumB) + s * _lumB, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1], m);
10473  },
10474      _setContrast = function _setContrast(m, n) {
10475    if (isNaN(n)) {
10476      return m;
10477    }
10478
10479    n += 0.01;
10480    return _applyMatrix([n, 0, 0, 0, 128 * (1 - n), 0, n, 0, 0, 128 * (1 - n), 0, 0, n, 0, 128 * (1 - n), 0, 0, 0, 1, 0], m);
10481  },
10482      _parseColorMatrixFilter = function _parseColorMatrixFilter(target, v, plugin) {
10483    if (!_ColorMatrixFilter) {
10484      _ColorMatrixFilter = _getCreateJS().ColorMatrixFilter;
10485
10486      if (!_ColorMatrixFilter) {
10487        _warn$1("EaselPlugin: The EaselJS ColorMatrixFilter JavaScript file wasn't loaded.");
10488      }
10489    }
10490
10491    var filters = target.filters || [],
10492        i = filters.length,
10493        matrix,
10494        startMatrix,
10495        s,
10496        pg;
10497
10498    while (--i > -1) {
10499      if (filters[i] instanceof _ColorMatrixFilter) {
10500        s = filters[i];
10501        break;
10502      }
10503    }
10504
10505    if (!s) {
10506      s = new _ColorMatrixFilter(_idMatrix.slice());
10507      filters.push(s);
10508      target.filters = filters;
10509    }
10510
10511    startMatrix = s.matrix;
10512    matrix = _idMatrix.slice();
10513
10514    if (v.colorize != null) {
10515      matrix = _colorize(matrix, v.colorize, Number(v.colorizeAmount));
10516    }
10517
10518    if (v.contrast != null) {
10519      matrix = _setContrast(matrix, Number(v.contrast));
10520    }
10521
10522    if (v.hue != null) {
10523      matrix = _setHue(matrix, Number(v.hue));
10524    }
10525
10526    if (v.saturation != null) {
10527      matrix = _setSaturation(matrix, Number(v.saturation));
10528    }
10529
10530    i = matrix.length;
10531
10532    while (--i > -1) {
10533      if (matrix[i] !== startMatrix[i]) {
10534        pg = plugin.add(startMatrix, i, startMatrix[i], matrix[i], 0, 0, 0, 0, 0, 1);
10535
10536        if (pg) {
10537          pg.op = "easel_colorMatrixFilter";
10538        }
10539      }
10540    }
10541
10542    plugin._props.push("easel_colorMatrixFilter");
10543
10544    if (!target.cacheID) {
10545      _cache();
10546    }
10547
10548    plugin._matrix = startMatrix;
10549  },
10550      _initCore$4 = function _initCore(core) {
10551    gsap$4 = core || _getGSAP$3();
10552
10553    if (_windowExists$4()) {
10554      _win$4 = window;
10555    }
10556
10557    if (gsap$4) {
10558      _coreInitted$4 = 1;
10559    }
10560  };
10561
10562  var EaselPlugin = {
10563    version: "3.12.5",
10564    name: "easel",
10565    init: function init(target, value, tween, index, targets) {
10566      if (!_coreInitted$4) {
10567        _initCore$4();
10568
10569        if (!gsap$4) {
10570          _warn$1("Please gsap.registerPlugin(EaselPlugin)");
10571        }
10572      }
10573
10574      this.target = target;
10575      var p, pt, tint, colorMatrix, end, labels, i;
10576
10577      for (p in value) {
10578        end = value[p];
10579
10580        if (p === "colorFilter" || p === "tint" || p === "tintAmount" || p === "exposure" || p === "brightness") {
10581          if (!tint) {
10582            _parseColorFilter(target, value.colorFilter || value, this);
10583
10584            tint = true;
10585          }
10586        } else if (p === "saturation" || p === "contrast" || p === "hue" || p === "colorize" || p === "colorizeAmount") {
10587          if (!colorMatrix) {
10588            _parseColorMatrixFilter(target, value.colorMatrixFilter || value, this);
10589
10590            colorMatrix = true;
10591          }
10592        } else if (p === "frame") {
10593          if (typeof end === "string" && end.charAt(1) !== "=" && (labels = target.labels)) {
10594            for (i = 0; i < labels.length; i++) {
10595              if (labels[i].label === end) {
10596                end = labels[i].position;
10597              }
10598            }
10599          }
10600

vendor: 5,367 bytes, lines 10601-10812

10601          pt = this.add(target, "gotoAndStop", target.currentFrame, end, index, targets, Math.round, 0, 0, 1);
10602
10603          if (pt) {
10604            pt.op = p;
10605          }
10606        } else if (target[p] != null) {
10607          this.add(target, p, "get", end);
10608        }
10609      }
10610    },
10611    render: function render(ratio, data) {
10612      var pt = data._pt;
10613
10614      while (pt) {
10615        pt.r(ratio, pt.d);
10616        pt = pt._next;
10617      }
10618
10619      if (data.target.cacheID) {
10620        data.target.updateCache();
10621      }
10622    },
10623    register: _initCore$4
10624  };
10625
10626  EaselPlugin.registerCreateJS = function (createjs) {
10627    _createJS = createjs;
10628  };
10629
10630  _getGSAP$3() && gsap$4.registerPlugin(EaselPlugin);
10631
10632  /*!
10633   * EasePack 3.12.5
10634   * https://gsap.com
10635   *
10636   * @license Copyright 2008-2024, GreenSock. All rights reserved.
10637   * Subject to the terms at https://gsap.com/standard-license or for
10638   * Club GSAP members, the agreement issued with that membership.
10639   * @author: Jack Doyle, [email protected]
10640  */
10641  var gsap$5,
10642      _registerEase,
10643      _getGSAP$4 = function _getGSAP() {
10644    return gsap$5 || typeof window !== "undefined" && (gsap$5 = window.gsap) && gsap$5.registerPlugin && gsap$5;
10645  },
10646      _boolean = function _boolean(value, defaultValue) {
10647    return !!(typeof value === "undefined" ? defaultValue : value && !~(value + "").indexOf("false"));
10648  },
10649      _initCore$5 = function _initCore(core) {
10650    gsap$5 = core || _getGSAP$4();
10651
10652    if (gsap$5) {
10653      _registerEase = gsap$5.registerEase;
10654
10655      var eases = gsap$5.parseEase(),
10656          createConfig = function createConfig(ease) {
10657        return function (ratio) {
10658          var y = 0.5 + ratio / 2;
10659
10660          ease.config = function (p) {
10661            return ease(2 * (1 - p) * p * y + p * p);
10662          };
10663        };
10664      },
10665          p;
10666
10667      for (p in eases) {
10668        if (!eases[p].config) {
10669          createConfig(eases[p]);
10670        }
10671      }
10672
10673      _registerEase("slow", SlowMo);
10674
10675      _registerEase("expoScale", ExpoScaleEase);
10676
10677      _registerEase("rough", RoughEase);
10678
10679      for (p in EasePack) {
10680        p !== "version" && gsap$5.core.globals(p, EasePack[p]);
10681      }
10682    }
10683  },
10684      _createSlowMo = function _createSlowMo(linearRatio, power, yoyoMode) {
10685    linearRatio = Math.min(1, linearRatio || 0.7);
10686
10687    var pow = linearRatio < 1 ? power || power === 0 ? power : 0.7 : 0,
10688        p1 = (1 - linearRatio) / 2,
10689        p3 = p1 + linearRatio,
10690        calcEnd = _boolean(yoyoMode);
10691
10692    return function (p) {
10693      var r = p + (0.5 - p) * pow;
10694      return p < p1 ? calcEnd ? 1 - (p = 1 - p / p1) * p : r - (p = 1 - p / p1) * p * p * p * r : p > p3 ? calcEnd ? p === 1 ? 0 : 1 - (p = (p - p3) / p1) * p : r + (p - r) * (p = (p - p3) / p1) * p * p * p : calcEnd ? 1 : r;
10695    };
10696  },
10697      _createExpoScale = function _createExpoScale(start, end, ease) {
10698    var p1 = Math.log(end / start),
10699        p2 = end - start;
10700    ease && (ease = gsap$5.parseEase(ease));
10701    return function (p) {
10702      return (start * Math.exp(p1 * (ease ? ease(p) : p)) - start) / p2;
10703    };
10704  },
10705      EasePoint = function EasePoint(time, value, next) {
10706    this.t = time;
10707    this.v = value;
10708
10709    if (next) {
10710      this.next = next;
10711      next.prev = this;
10712      this.c = next.v - value;
10713      this.gap = next.t - time;
10714    }
10715  },
10716      _createRoughEase = function _createRoughEase(vars) {
10717    if (typeof vars !== "object") {
10718      vars = {
10719        points: +vars || 20
10720      };
10721    }
10722
10723    var taper = vars.taper || "none",
10724        a = [],
10725        cnt = 0,
10726        points = (+vars.points || 20) | 0,
10727        i = points,
10728        randomize = _boolean(vars.randomize, true),
10729        clamp = _boolean(vars.clamp),
10730        template = gsap$5 ? gsap$5.parseEase(vars.template) : 0,
10731        strength = (+vars.strength || 1) * 0.4,
10732        x,
10733        y,
10734        bump,
10735        invX,
10736        obj,
10737        pnt,
10738        recent;
10739
10740    while (--i > -1) {
10741      x = randomize ? Math.random() : 1 / points * i;
10742      y = template ? template(x) : x;
10743
10744      if (taper === "none") {
10745        bump = strength;
10746      } else if (taper === "out") {
10747        invX = 1 - x;
10748        bump = invX * invX * strength;
10749      } else if (taper === "in") {
10750        bump = x * x * strength;
10751      } else if (x < 0.5) {
10752        invX = x * 2;
10753        bump = invX * invX * 0.5 * strength;
10754      } else {
10755        invX = (1 - x) * 2;
10756        bump = invX * invX * 0.5 * strength;
10757      }
10758
10759      if (randomize) {
10760        y += Math.random() * bump - bump * 0.5;
10761      } else if (i % 2) {
10762        y += bump * 0.5;
10763      } else {
10764        y -= bump * 0.5;
10765      }
10766
10767      if (clamp) {
10768        if (y > 1) {
10769          y = 1;
10770        } else if (y < 0) {
10771          y = 0;
10772        }
10773      }
10774
10775      a[cnt++] = {
10776        x: x,
10777        y: y
10778      };
10779    }
10780
10781    a.sort(function (a, b) {
10782      return a.x - b.x;
10783    });
10784    pnt = new EasePoint(1, 1, null);
10785    i = points;
10786
10787    while (i--) {
10788      obj = a[i];
10789      pnt = new EasePoint(obj.x, obj.y, pnt);
10790    }
10791
10792    recent = new EasePoint(0, 0, pnt.t ? pnt : pnt.next);
10793    return function (p) {
10794      var pnt = recent;
10795
10796      if (p > pnt.t) {
10797        while (pnt.next && p >= pnt.t) {
10798          pnt = pnt.next;
10799        }
10800
10801        pnt = pnt.prev;
10802      } else {
10803        while (pnt.prev && p <= pnt.t) {
10804          pnt = pnt.prev;
10805        }
10806      }
10807
10808      recent = pnt;
10809      return pnt.v + (p - pnt.t) / pnt.gap * pnt.c;
10810    };
10811  };
10812

10813  var SlowMo = _createSlowMo(0.7);
10814  SlowMo.ease = SlowMo;
10815  SlowMo.config = _createSlowMo;
10816  var ExpoScaleEase = _createExpoScale(1, 2);
10817  ExpoScaleEase.config = _createExpoScale;
10818  var RoughEase = _createRoughEase();
10819  RoughEase.ease = RoughEase;
10820  RoughEase.config = _createRoughEase;
10821  var EasePack = {
10822    SlowMo: SlowMo,
10823    RoughEase: RoughEase,
10824    ExpoScaleEase: ExpoScaleEase
10825  };
10826
10827  for (var p in EasePack) {
10828    EasePack[p].register = _initCore$5;
10829    EasePack[p].version = "3.12.5";
10830  }
10831
10832  _getGSAP$4() && gsap$5.registerPlugin(SlowMo);
10833
10834  /*!
10835   * Flip 3.12.5
10836   * https://gsap.com
10837   *
10838   * @license Copyright 2008-2024, GreenSock. All rights reserved.
10839   * Subject to the terms at https://gsap.com/standard-license or for
10840   * Club GSAP members, the agreement issued with that membership.

vendor: 9,690 bytes, lines 10840-11157

10840
10841   * @author: Jack Doyle, [email protected]
10842  */
10843
10844  var _id = 1,
10845      _toArray$1,
10846      gsap$6,
10847      _batch,
10848      _batchAction,
10849      _body$2,
10850      _closestTenth,
10851      _getStyleSaver$2,
10852      _forEachBatch = function _forEachBatch(batch, name) {
10853    return batch.actions.forEach(function (a) {
10854      return a.vars[name] && a.vars[name](a);
10855    });
10856  },
10857      _batchLookup = {},
10858      _RAD2DEG$3 = 180 / Math.PI,
10859      _DEG2RAD$2 = Math.PI / 180,
10860      _emptyObj = {},
10861      _dashedNameLookup = {},
10862      _memoizedRemoveProps = {},
10863      _listToArray = function _listToArray(list) {
10864    return typeof list === "string" ? list.split(" ").join("").split(",") : list;
10865  },
10866      _callbacks = _listToArray("onStart,onUpdate,onComplete,onReverseComplete,onInterrupt"),
10867      _removeProps = _listToArray("transform,transformOrigin,width,height,position,top,left,opacity,zIndex,maxWidth,maxHeight,minWidth,minHeight"),
10868      _getEl = function _getEl(target) {
10869    return _toArray$1(target)[0] || console.warn("Element not found:", target);
10870  },
10871      _round$4 = function _round(value) {
10872    return Math.round(value * 10000) / 10000 || 0;
10873  },
10874      _toggleClass = function _toggleClass(targets, className, action) {
10875    return targets.forEach(function (el) {
10876      return el.classList[action](className);
10877    });
10878  },
10879      _reserved = {
10880    zIndex: 1,
10881    kill: 1,
10882    simple: 1,
10883    spin: 1,
10884    clearProps: 1,
10885    targets: 1,
10886    toggleClass: 1,
10887    onComplete: 1,
10888    onUpdate: 1,
10889    onInterrupt: 1,
10890    onStart: 1,
10891    delay: 1,
10892    repeat: 1,
10893    repeatDelay: 1,
10894    yoyo: 1,
10895    scale: 1,
10896    fade: 1,
10897    absolute: 1,
10898    props: 1,
10899    onEnter: 1,
10900    onLeave: 1,
10901    custom: 1,
10902    paused: 1,
10903    nested: 1,
10904    prune: 1,
10905    absoluteOnLeave: 1
10906  },
10907      _fitReserved = {
10908    zIndex: 1,
10909    simple: 1,
10910    clearProps: 1,
10911    scale: 1,
10912    absolute: 1,
10913    fitChild: 1,
10914    getVars: 1,
10915    props: 1
10916  },
10917      _camelToDashed = function _camelToDashed(p) {
10918    return p.replace(/([A-Z])/g, "-$1").toLowerCase();
10919  },
10920      _copy$1 = function _copy(obj, exclude) {
10921    var result = {},
10922        p;
10923
10924    for (p in obj) {
10925      exclude[p] || (result[p] = obj[p]);
10926    }
10927
10928    return result;
10929  },
10930      _memoizedProps = {},
10931      _memoizeProps = function _memoizeProps(props) {
10932    var p = _memoizedProps[props] = _listToArray(props);
10933
10934    _memoizedRemoveProps[props] = p.concat(_removeProps);
10935    return p;
10936  },
10937      _getInverseGlobalMatrix = function _getInverseGlobalMatrix(el) {
10938    var cache = el._gsap || gsap$6.core.getCache(el);
10939
10940    if (cache.gmCache === gsap$6.ticker.frame) {
10941      return cache.gMatrix;
10942    }
10943
10944    cache.gmCache = gsap$6.ticker.frame;
10945    return cache.gMatrix = getGlobalMatrix(el, true, false, true);
10946  },
10947      _getDOMDepth = function _getDOMDepth(el, invert, level) {
10948    if (level === void 0) {
10949      level = 0;
10950    }
10951
10952    var parent = el.parentNode,
10953        inc = 1000 * Math.pow(10, level) * (invert ? -1 : 1),
10954        l = invert ? -inc * 900 : 0;
10955
10956    while (el) {
10957      l += inc;
10958      el = el.previousSibling;
10959    }
10960
10961    return parent ? l + _getDOMDepth(parent, invert, level + 1) : l;
10962  },
10963      _orderByDOMDepth = function _orderByDOMDepth(comps, invert, isElStates) {
10964    comps.forEach(function (comp) {
10965      return comp.d = _getDOMDepth(isElStates ? comp.element : comp.t, invert);
10966    });
10967    comps.sort(function (c1, c2) {
10968      return c1.d - c2.d;
10969    });
10970    return comps;
10971  },
10972      _recordInlineStyles = function _recordInlineStyles(elState, props) {
10973    var style = elState.element.style,
10974        a = elState.css = elState.css || [],
10975        i = props.length,
10976        p,
10977        v;
10978
10979    while (i--) {
10980      p = props[i];
10981      v = style[p] || style.getPropertyValue(p);
10982      a.push(v ? p : _dashedNameLookup[p] || (_dashedNameLookup[p] = _camelToDashed(p)), v);
10983    }
10984
10985    return style;
10986  },
10987      _applyInlineStyles = function _applyInlineStyles(state) {
10988    var css = state.css,
10989        style = state.element.style,
10990        i = 0;
10991    state.cache.uncache = 1;
10992
10993    for (; i < css.length; i += 2) {
10994      css[i + 1] ? style[css[i]] = css[i + 1] : style.removeProperty(css[i]);
10995    }
10996
10997    if (!css[css.indexOf("transform") + 1] && style.translate) {
10998      style.removeProperty("translate");
10999      style.removeProperty("scale");
11000      style.removeProperty("rotate");
11001    }
11002  },
11003      _setFinalStates = function _setFinalStates(comps, onlyTransforms) {
11004    comps.forEach(function (c) {
11005      return c.a.cache.uncache = 1;
11006    });
11007    onlyTransforms || comps.finalStates.forEach(_applyInlineStyles);
11008  },
11009      _absoluteProps = "paddingTop,paddingRight,paddingBottom,paddingLeft,gridArea,transition".split(","),
11010      _makeAbsolute = function _makeAbsolute(elState, fallbackNode, ignoreBatch) {
11011    var element = elState.element,
11012        width = elState.width,
11013        height = elState.height,
11014        uncache = elState.uncache,
11015        getProp = elState.getProp,
11016        style = element.style,
11017        i = 4,
11018        result,
11019        displayIsNone,
11020        cs;
11021    typeof fallbackNode !== "object" && (fallbackNode = elState);
11022
11023    if (_batch && ignoreBatch !== 1) {
11024      _batch._abs.push({
11025        t: element,
11026        b: elState,
11027        a: elState,
11028        sd: 0
11029      });
11030
11031      _batch._final.push(function () {
11032        return (elState.cache.uncache = 1) && _applyInlineStyles(elState);
11033      });
11034
11035      return element;
11036    }
11037
11038    displayIsNone = getProp("display") === "none";
11039
11040    if (!elState.isVisible || displayIsNone) {
11041      displayIsNone && (_recordInlineStyles(elState, ["display"]).display = fallbackNode.display);
11042      elState.matrix = fallbackNode.matrix;
11043      elState.width = width = elState.width || fallbackNode.width;
11044      elState.height = height = elState.height || fallbackNode.height;
11045    }
11046
11047    _recordInlineStyles(elState, _absoluteProps);
11048
11049    cs = window.getComputedStyle(element);
11050
11051    while (i--) {
11052      style[_absoluteProps[i]] = cs[_absoluteProps[i]];
11053    }
11054
11055    style.gridArea = "1 / 1 / 1 / 1";
11056    style.transition = "none";
11057    style.position = "absolute";
11058    style.width = width + "px";
11059    style.height = height + "px";
11060    style.top || (style.top = "0px");
11061    style.left || (style.left = "0px");
11062
11063    if (uncache) {
11064      result = new ElementState(element);
11065    } else {
11066      result = _copy$1(elState, _emptyObj);
11067      result.position = "absolute";
11068
11069      if (elState.simple) {
11070        var bounds = element.getBoundingClientRect();
11071        result.matrix = new Matrix2D(1, 0, 0, 1, bounds.left + _getDocScrollLeft(), bounds.top + _getDocScrollTop());
11072      } else {
11073        result.matrix = getGlobalMatrix(element, false, false, true);
11074      }
11075    }
11076
11077    result = _fit(result, elState, true);
11078    elState.x = _closestTenth(result.x, 0.01);
11079    elState.y = _closestTenth(result.y, 0.01);
11080    return element;
11081  },
11082      _filterComps = function _filterComps(comps, targets) {
11083    if (targets !== true) {
11084      targets = _toArray$1(targets);
11085      comps = comps.filter(function (c) {
11086        if (targets.indexOf((c.sd < 0 ? c.b : c.a).element) !== -1) {
11087          return true;
11088        } else {
11089          c.t._gsap.renderTransform(1);
11090
11091          if (c.b.isVisible) {
11092            c.t.style.width = c.b.width + "px";
11093            c.t.style.height = c.b.height + "px";
11094          }
11095        }
11096      });
11097    }
11098
11099    return comps;
11100  },
11101      _makeCompsAbsolute = function _makeCompsAbsolute(comps) {
11102    return _orderByDOMDepth(comps, true).forEach(function (c) {
11103      return (c.a.isVisible || c.b.isVisible) && _makeAbsolute(c.sd < 0 ? c.b : c.a, c.b, 1);
11104    });
11105  },
11106      _findElStateInState = function _findElStateInState(state, other) {
11107    return other && state.idLookup[_parseElementState(other).id] || state.elementStates[0];
11108  },
11109      _parseElementState = function _parseElementState(elOrNode, props, simple, other) {
11110    return elOrNode instanceof ElementState ? elOrNode : elOrNode instanceof FlipState ? _findElStateInState(elOrNode, other) : new ElementState(typeof elOrNode === "string" ? _getEl(elOrNode) || console.warn(elOrNode + " not found") : elOrNode, props, simple);
11111  },
11112      _recordProps = function _recordProps(elState, props) {
11113    var getProp = gsap$6.getProperty(elState.element, null, "native"),
11114        obj = elState.props = {},
11115        i = props.length;
11116
11117    while (i--) {
11118      obj[props[i]] = (getProp(props[i]) + "").trim();
11119    }
11120
11121    obj.zIndex && (obj.zIndex = parseFloat(obj.zIndex) || 0);
11122    return elState;
11123  },
11124      _applyProps = function _applyProps(element, props) {
11125    var style = element.style || element,
11126        p;
11127
11128    for (p in props) {
11129      style[p] = props[p];
11130    }
11131  },
11132      _getID = function _getID(el) {
11133    var id = el.getAttribute("data-flip-id");
11134    id || el.setAttribute("data-flip-id", id = "auto-" + _id++);
11135    return id;
11136  },
11137      _elementsFromElementStates = function _elementsFromElementStates(elStates) {
11138    return elStates.map(function (elState) {
11139      return elState.element;
11140    });
11141  },
11142      _handleCallback = function _handleCallback(callback, elStates, tl) {
11143    return callback && elStates.length && tl.add(callback(_elementsFromElementStates(elStates), tl, new FlipState(elStates, 0, true)), 0);
11144  },
11145      _fit = function _fit(fromState, toState, scale, applyProps, fitChild, vars) {
11146    var element = fromState.element,
11147        cache = fromState.cache,
11148        parent = fromState.parent,
11149        x = fromState.x,
11150        y = fromState.y,
11151        width = toState.width,
11152        height = toState.height,
11153        scaleX = toState.scaleX,
11154        scaleY = toState.scaleY,
11155        rotation = toState.rotation,
11156        bounds = toState.bounds,
11157        styles = vars && _getStyleSaver$2 && _getStyleSaver$2(element, "transform

vendor: 1,214 bytes, lines 11157-11184

11157"),
11158        dimensionState = fromState,
11159        _toState$matrix = toState.matrix,
11160        e = _toState$matrix.e,
11161        f = _toState$matrix.f,
11162        deep = fromState.bounds.width !== bounds.width || fromState.bounds.height !== bounds.height || fromState.scaleX !== scaleX || fromState.scaleY !== scaleY || fromState.rotation !== rotation,
11163        simple = !deep && fromState.simple && toState.simple && !fitChild,
11164        skewX,
11165        fromPoint,
11166        toPoint,
11167        getProp,
11168        parentMatrix,
11169        matrix,
11170        bbox;
11171
11172    if (simple || !parent) {
11173      scaleX = scaleY = 1;
11174      rotation = skewX = 0;
11175    } else {
11176      parentMatrix = _getInverseGlobalMatrix(parent);
11177      matrix = parentMatrix.clone().multiply(toState.ctm ? toState.matrix.clone().multiply(toState.ctm) : toState.matrix);
11178      rotation = _round$4(Math.atan2(matrix.b, matrix.a) * _RAD2DEG$3);
11179      skewX = _round$4(Math.atan2(matrix.c, matrix.d) * _RAD2DEG$3 + rotation) % 360;
11180      scaleX = Math.sqrt(Math.pow(matrix.a, 2) + Math.pow(matrix.b, 2));
11181      scaleY = Math.sqrt(Math.pow(matrix.c, 2) + Math.pow(matrix.d, 2)) * Math.cos(skewX * _DEG2RAD$2);
11182
11183      if (fitChild) {
11184        fitChild = _toArray$1(fitChild)[0];

vendor: 4,248 bytes, lines 11185-11320

11185        getProp = gsap$6.getProperty(fitChild);
11186        bbox = fitChild.getBBox && typeof fitChild.getBBox === "function" && fitChild.getBBox();
11187        dimensionState = {
11188          scaleX: getProp("scaleX"),
11189          scaleY: getProp("scaleY"),
11190          width: bbox ? bbox.width : Math.ceil(parseFloat(getProp("width", "px"))),
11191          height: bbox ? bbox.height : parseFloat(getProp("height", "px"))
11192        };
11193      }
11194
11195      cache.rotation = rotation + "deg";
11196      cache.skewX = skewX + "deg";
11197    }
11198
11199    if (scale) {
11200      scaleX *= width === dimensionState.width || !dimensionState.width ? 1 : width / dimensionState.width;
11201      scaleY *= height === dimensionState.height || !dimensionState.height ? 1 : height / dimensionState.height;
11202      cache.scaleX = scaleX;
11203      cache.scaleY = scaleY;
11204    } else {
11205      width = _closestTenth(width * scaleX / dimensionState.scaleX, 0);
11206      height = _closestTenth(height * scaleY / dimensionState.scaleY, 0);
11207      element.style.width = width + "px";
11208      element.style.height = height + "px";
11209    }
11210
11211    applyProps && _applyProps(element, toState.props);
11212
11213    if (simple || !parent) {
11214      x += e - fromState.matrix.e;
11215      y += f - fromState.matrix.f;
11216    } else if (deep || parent !== toState.parent) {
11217      cache.renderTransform(1, cache);
11218      matrix = getGlobalMatrix(fitChild || element, false, false, true);
11219      fromPoint = parentMatrix.apply({
11220        x: matrix.e,
11221        y: matrix.f
11222      });
11223      toPoint = parentMatrix.apply({
11224        x: e,
11225        y: f
11226      });
11227      x += toPoint.x - fromPoint.x;
11228      y += toPoint.y - fromPoint.y;
11229    } else {
11230      parentMatrix.e = parentMatrix.f = 0;
11231      toPoint = parentMatrix.apply({
11232        x: e - fromState.matrix.e,
11233        y: f - fromState.matrix.f
11234      });
11235      x += toPoint.x;
11236      y += toPoint.y;
11237    }
11238
11239    x = _closestTenth(x, 0.02);
11240    y = _closestTenth(y, 0.02);
11241
11242    if (vars && !(vars instanceof ElementState)) {
11243      styles && styles.revert();
11244    } else {
11245      cache.x = x + "px";
11246      cache.y = y + "px";
11247      cache.renderTransform(1, cache);
11248    }
11249
11250    if (vars) {
11251      vars.x = x;
11252      vars.y = y;
11253      vars.rotation = rotation;
11254      vars.skewX = skewX;
11255
11256      if (scale) {
11257        vars.scaleX = scaleX;
11258        vars.scaleY = scaleY;
11259      } else {
11260        vars.width = width;
11261        vars.height = height;
11262      }
11263    }
11264
11265    return vars || cache;
11266  },
11267      _parseState = function _parseState(targetsOrState, vars) {
11268    return targetsOrState instanceof FlipState ? targetsOrState : new FlipState(targetsOrState, vars);
11269  },
11270      _getChangingElState = function _getChangingElState(toState, fromState, id) {
11271    var to1 = toState.idLookup[id],
11272        to2 = toState.alt[id];
11273    return to2.isVisible && (!(fromState.getElementState(to2.element) || to2).isVisible || !to1.isVisible) ? to2 : to1;
11274  },
11275      _bodyMetrics = [],
11276      _bodyProps = "width,height,overflowX,overflowY".split(","),
11277      _bodyLocked,
11278      _lockBodyScroll = function _lockBodyScroll(lock) {
11279    if (lock !== _bodyLocked) {
11280      var s = _body$2.style,
11281          w = _body$2.clientWidth === window.outerWidth,
11282          h = _body$2.clientHeight === window.outerHeight,
11283          i = 4;
11284
11285      if (lock && (w || h)) {
11286        while (i--) {
11287          _bodyMetrics[i] = s[_bodyProps[i]];
11288        }
11289
11290        if (w) {
11291          s.width = _body$2.clientWidth + "px";
11292          s.overflowY = "hidden";
11293        }
11294
11295        if (h) {
11296          s.height = _body$2.clientHeight + "px";
11297          s.overflowX = "hidden";
11298        }
11299
11300        _bodyLocked = lock;
11301      } else if (_bodyLocked) {
11302        while (i--) {
11303          _bodyMetrics[i] ? s[_bodyProps[i]] = _bodyMetrics[i] : s.removeProperty(_camelToDashed(_bodyProps[i]));
11304        }
11305
11306        _bodyLocked = lock;
11307      }
11308    }
11309  },
11310      _fromTo = function _fromTo(fromState, toState, vars, relative) {
11311    fromState instanceof FlipState && toState instanceof FlipState || console.warn("Not a valid state object.");
11312    vars = vars || {};
11313
11314    var _vars = vars,
11315        clearProps = _vars.clearProps,
11316        onEnter = _vars.onEnter,
11317        onLeave = _vars.onLeave,
11318        absolute = _vars.absolute,
11319        absoluteOnLeave = _vars.absoluteOnLeave,
11320        custom = _vars.custom,

vendor: 3,935 bytes, lines 11321-11454

11321        delay = _vars.delay,
11322        paused = _vars.paused,
11323        repeat = _vars.repeat,
11324        repeatDelay = _vars.repeatDelay,
11325        yoyo = _vars.yoyo,
11326        toggleClass = _vars.toggleClass,
11327        nested = _vars.nested,
11328        _zIndex = _vars.zIndex,
11329        scale = _vars.scale,
11330        fade = _vars.fade,
11331        stagger = _vars.stagger,
11332        spin = _vars.spin,
11333        prune = _vars.prune,
11334        props = ("props" in vars ? vars : fromState).props,
11335        tweenVars = _copy$1(vars, _reserved),
11336        animation = gsap$6.timeline({
11337      delay: delay,
11338      paused: paused,
11339      repeat: repeat,
11340      repeatDelay: repeatDelay,
11341      yoyo: yoyo,
11342      data: "isFlip"
11343    }),
11344        remainingProps = tweenVars,
11345        entering = [],
11346        leaving = [],
11347        comps = [],
11348        swapOutTargets = [],
11349        spinNum = spin === true ? 1 : spin || 0,
11350        spinFunc = typeof spin === "function" ? spin : function () {
11351      return spinNum;
11352    },
11353        interrupted = fromState.interrupted || toState.interrupted,
11354        addFunc = animation[relative !== 1 ? "to" : "from"],
11355        v,
11356        p,
11357        endTime,
11358        i,
11359        el,
11360        comp,
11361        state,
11362        targets,
11363        finalStates,
11364        fromNode,
11365        toNode,
11366        run,
11367        a,
11368        b;
11369
11370    for (p in toState.idLookup) {
11371      toNode = !toState.alt[p] ? toState.idLookup[p] : _getChangingElState(toState, fromState, p);
11372      el = toNode.element;
11373      fromNode = fromState.idLookup[p];
11374      fromState.alt[p] && el === fromNode.element && (fromState.alt[p].isVisible || !toNode.isVisible) && (fromNode = fromState.alt[p]);
11375
11376      if (fromNode) {
11377        comp = {
11378          t: el,
11379          b: fromNode,
11380          a: toNode,
11381          sd: fromNode.element === el ? 0 : toNode.isVisible ? 1 : -1
11382        };
11383        comps.push(comp);
11384
11385        if (comp.sd) {
11386          if (comp.sd < 0) {
11387            comp.b = toNode;
11388            comp.a = fromNode;
11389          }
11390
11391          interrupted && _recordInlineStyles(comp.b, props ? _memoizedRemoveProps[props] : _removeProps);
11392          fade && comps.push(comp.swap = {
11393            t: fromNode.element,
11394            b: comp.b,
11395            a: comp.a,
11396            sd: -comp.sd,
11397            swap: comp
11398          });
11399        }
11400
11401        el._flip = fromNode.element._flip = _batch ? _batch.timeline : animation;
11402      } else if (toNode.isVisible) {
11403        comps.push({
11404          t: el,
11405          b: _copy$1(toNode, {
11406            isVisible: 1
11407          }),
11408          a: toNode,
11409          sd: 0,
11410          entering: 1
11411        });
11412        el._flip = _batch ? _batch.timeline : animation;
11413      }
11414    }
11415
11416    props && (_memoizedProps[props] || _memoizeProps(props)).forEach(function (p) {
11417      return tweenVars[p] = function (i) {
11418        return comps[i].a.props[p];
11419      };
11420    });
11421    comps.finalStates = finalStates = [];
11422
11423    run = function run() {
11424      _orderByDOMDepth(comps);
11425
11426      _lockBodyScroll(true);
11427
11428      for (i = 0; i < comps.length; i++) {
11429        comp = comps[i];
11430        a = comp.a;
11431        b = comp.b;
11432
11433        if (prune && !a.isDifferent(b) && !comp.entering) {
11434          comps.splice(i--, 1);
11435        } else {
11436          el = comp.t;
11437          nested && !(comp.sd < 0) && i && (a.matrix = getGlobalMatrix(el, false, false, true));
11438
11439          if (b.isVisible && a.isVisible) {
11440            if (comp.sd < 0) {
11441              state = new ElementState(el, props, fromState.simple);
11442
11443              _fit(state, a, scale, 0, 0, state);
11444
11445              state.matrix = getGlobalMatrix(el, false, false, true);
11446              state.css = comp.b.css;
11447              comp.a = a = state;
11448              fade && (el.style.opacity = interrupted ? b.opacity : a.opacity);
11449              stagger && swapOutTargets.push(el);
11450            } else if (comp.sd > 0 && fade) {
11451              el.style.opacity = interrupted ? a.opacity - b.opacity : "0";
11452            }
11453
11454            _fit(a, b, scale, props

vendor: 12,565 bytes, lines 11454-11872

11454);
11455          } else if (b.isVisible !== a.isVisible) {
11456            if (!b.isVisible) {
11457              a.isVisible && entering.push(a);
11458              comps.splice(i--, 1);
11459            } else if (!a.isVisible) {
11460              b.css = a.css;
11461              leaving.push(b);
11462              comps.splice(i--, 1);
11463              absolute && nested && _fit(a, b, scale, props);
11464            }
11465          }
11466
11467          if (!scale) {
11468            el.style.maxWidth = Math.max(a.width, b.width) + "px";
11469            el.style.maxHeight = Math.max(a.height, b.height) + "px";
11470            el.style.minWidth = Math.min(a.width, b.width) + "px";
11471            el.style.minHeight = Math.min(a.height, b.height) + "px";
11472          }
11473
11474          nested && toggleClass && el.classList.add(toggleClass);
11475        }
11476
11477        finalStates.push(a);
11478      }
11479
11480      var classTargets;
11481
11482      if (toggleClass) {
11483        classTargets = finalStates.map(function (s) {
11484          return s.element;
11485        });
11486        nested && classTargets.forEach(function (e) {
11487          return e.classList.remove(toggleClass);
11488        });
11489      }
11490
11491      _lockBodyScroll(false);
11492
11493      if (scale) {
11494        tweenVars.scaleX = function (i) {
11495          return comps[i].a.scaleX;
11496        };
11497
11498        tweenVars.scaleY = function (i) {
11499          return comps[i].a.scaleY;
11500        };
11501      } else {
11502        tweenVars.width = function (i) {
11503          return comps[i].a.width + "px";
11504        };
11505
11506        tweenVars.height = function (i) {
11507          return comps[i].a.height + "px";
11508        };
11509
11510        tweenVars.autoRound = vars.autoRound || false;
11511      }
11512
11513      tweenVars.x = function (i) {
11514        return comps[i].a.x + "px";
11515      };
11516
11517      tweenVars.y = function (i) {
11518        return comps[i].a.y + "px";
11519      };
11520
11521      tweenVars.rotation = function (i) {
11522        return comps[i].a.rotation + (spin ? spinFunc(i, targets[i], targets) * 360 : 0);
11523      };
11524
11525      tweenVars.skewX = function (i) {
11526        return comps[i].a.skewX;
11527      };
11528
11529      targets = comps.map(function (c) {
11530        return c.t;
11531      });
11532
11533      if (_zIndex || _zIndex === 0) {
11534        tweenVars.modifiers = {
11535          zIndex: function zIndex() {
11536            return _zIndex;
11537          }
11538        };
11539        tweenVars.zIndex = _zIndex;
11540        tweenVars.immediateRender = vars.immediateRender !== false;
11541      }
11542
11543      fade && (tweenVars.opacity = function (i) {
11544        return comps[i].sd < 0 ? 0 : comps[i].sd > 0 ? comps[i].a.opacity : "+=0";
11545      });
11546
11547      if (swapOutTargets.length) {
11548        stagger = gsap$6.utils.distribute(stagger);
11549        var dummyArray = targets.slice(swapOutTargets.length);
11550
11551        tweenVars.stagger = function (i, el) {
11552          return stagger(~swapOutTargets.indexOf(el) ? targets.indexOf(comps[i].swap.t) : i, el, dummyArray);
11553        };
11554      }
11555
11556      _callbacks.forEach(function (name) {
11557        return vars[name] && animation.eventCallback(name, vars[name], vars[name + "Params"]);
11558      });
11559
11560      if (custom && targets.length) {
11561        remainingProps = _copy$1(tweenVars, _reserved);
11562
11563        if ("scale" in custom) {
11564          custom.scaleX = custom.scaleY = custom.scale;
11565          delete custom.scale;
11566        }
11567
11568        for (p in custom) {
11569          v = _copy$1(custom[p], _fitReserved);
11570          v[p] = tweenVars[p];
11571          !("duration" in v) && "duration" in tweenVars && (v.duration = tweenVars.duration);
11572          v.stagger = tweenVars.stagger;
11573          addFunc.call(animation, targets, v, 0);
11574          delete remainingProps[p];
11575        }
11576      }
11577
11578      if (targets.length || leaving.length || entering.length) {
11579        toggleClass && animation.add(function () {
11580          return _toggleClass(classTargets, toggleClass, animation._zTime < 0 ? "remove" : "add");
11581        }, 0) && !paused && _toggleClass(classTargets, toggleClass, "add");
11582        targets.length && addFunc.call(animation, targets, remainingProps, 0);
11583      }
11584
11585      _handleCallback(onEnter, entering, animation);
11586
11587      _handleCallback(onLeave, leaving, animation);
11588
11589      var batchTl = _batch && _batch.timeline;
11590
11591      if (batchTl) {
11592        batchTl.add(animation, 0);
11593
11594        _batch._final.push(function () {
11595          return _setFinalStates(comps, !clearProps);
11596        });
11597      }
11598
11599      endTime = animation.duration();
11600      animation.call(function () {
11601        var forward = animation.time() >= endTime;
11602        forward && !batchTl && _setFinalStates(comps, !clearProps);
11603        toggleClass && _toggleClass(classTargets, toggleClass, forward ? "remove" : "add");
11604      });
11605    };
11606
11607    absoluteOnLeave && (absolute = comps.filter(function (comp) {
11608      return !comp.sd && !comp.a.isVisible && comp.b.isVisible;
11609    }).map(function (comp) {
11610      return comp.a.element;
11611    }));
11612
11613    if (_batch) {
11614      var _batch$_abs;
11615
11616      absolute && (_batch$_abs = _batch._abs).push.apply(_batch$_abs, _filterComps(comps, absolute));
11617
11618      _batch._run.push(run);
11619    } else {
11620      absolute && _makeCompsAbsolute(_filterComps(comps, absolute));
11621      run();
11622    }
11623
11624    var anim = _batch ? _batch.timeline : animation;
11625
11626    anim.revert = function () {
11627      return _killFlip(anim, 1, 1);
11628    };
11629
11630    return anim;
11631  },
11632      _interrupt$1 = function _interrupt(tl) {
11633    tl.vars.onInterrupt && tl.vars.onInterrupt.apply(tl, tl.vars.onInterruptParams || []);
11634    tl.getChildren(true, false, true).forEach(_interrupt);
11635  },
11636      _killFlip = function _killFlip(tl, action, force) {
11637    if (tl && tl.progress() < 1 && (!tl.paused() || force)) {
11638      if (action) {
11639        _interrupt$1(tl);
11640
11641        action < 2 && tl.progress(1);
11642        tl.kill();
11643      }
11644
11645      return true;
11646    }
11647  },
11648      _createLookup = function _createLookup(state) {
11649    var lookup = state.idLookup = {},
11650        alt = state.alt = {},
11651        elStates = state.elementStates,
11652        i = elStates.length,
11653        elState;
11654
11655    while (i--) {
11656      elState = elStates[i];
11657      lookup[elState.id] ? alt[elState.id] = elState : lookup[elState.id] = elState;
11658    }
11659  };
11660
11661  var FlipState = function () {
11662    function FlipState(targets, vars, targetsAreElementStates) {
11663      this.props = vars && vars.props;
11664      this.simple = !!(vars && vars.simple);
11665
11666      if (targetsAreElementStates) {
11667        this.targets = _elementsFromElementStates(targets);
11668        this.elementStates = targets;
11669
11670        _createLookup(this);
11671      } else {
11672        this.targets = _toArray$1(targets);
11673        var soft = vars && (vars.kill === false || vars.batch && !vars.kill);
11674        _batch && !soft && _batch._kill.push(this);
11675        this.update(soft || !!_batch);
11676      }
11677    }
11678
11679    var _proto = FlipState.prototype;
11680
11681    _proto.update = function update(soft) {
11682      var _this = this;
11683
11684      this.elementStates = this.targets.map(function (el) {
11685        return new ElementState(el, _this.props, _this.simple);
11686      });
11687
11688      _createLookup(this);
11689
11690      this.interrupt(soft);
11691      this.recordInlineStyles();
11692      return this;
11693    };
11694
11695    _proto.clear = function clear() {
11696      this.targets.length = this.elementStates.length = 0;
11697
11698      _createLookup(this);
11699
11700      return this;
11701    };
11702
11703    _proto.fit = function fit(state, scale, nested) {
11704      var elStatesInOrder = _orderByDOMDepth(this.elementStates.slice(0), false, true),
11705          toElStates = (state || this).idLookup,
11706          i = 0,
11707          fromNode,
11708          toNode;
11709
11710      for (; i < elStatesInOrder.length; i++) {
11711        fromNode = elStatesInOrder[i];
11712        nested && (fromNode.matrix = getGlobalMatrix(fromNode.element, false, false, true));
11713        toNode = toElStates[fromNode.id];
11714        toNode && _fit(fromNode, toNode, scale, true, 0, fromNode);
11715        fromNode.matrix = getGlobalMatrix(fromNode.element, false, false, true);
11716      }
11717
11718      return this;
11719    };
11720
11721    _proto.getProperty = function getProperty(element, property) {
11722      var es = this.getElementState(element) || _emptyObj;
11723
11724      return (property in es ? es : es.props || _emptyObj)[property];
11725    };
11726
11727    _proto.add = function add(state) {
11728      var i = state.targets.length,
11729          lookup = this.idLookup,
11730          alt = this.alt,
11731          index,
11732          es,
11733          es2;
11734
11735      while (i--) {
11736        es = state.elementStates[i];
11737        es2 = lookup[es.id];
11738
11739        if (es2 && (es.element === es2.element || alt[es.id] && alt[es.id].element === es.element)) {
11740          index = this.elementStates.indexOf(es.element === es2.element ? es2 : alt[es.id]);
11741          this.targets.splice(index, 1, state.targets[i]);
11742          this.elementStates.splice(index, 1, es);
11743        } else {
11744          this.targets.push(state.targets[i]);
11745          this.elementStates.push(es);
11746        }
11747      }
11748
11749      state.interrupted && (this.interrupted = true);
11750      state.simple || (this.simple = false);
11751
11752      _createLookup(this);
11753
11754      return this;
11755    };
11756
11757    _proto.compare = function compare(state) {
11758      var l1 = state.idLookup,
11759          l2 = this.idLookup,
11760          unchanged = [],
11761          changed = [],
11762          enter = [],
11763          leave = [],
11764          targets = [],
11765          a1 = state.alt,
11766          a2 = this.alt,
11767          place = function place(s1, s2, el) {
11768        return (s1.isVisible !== s2.isVisible ? s1.isVisible ? enter : leave : s1.isVisible ? changed : unchanged).push(el) && targets.push(el);
11769      },
11770          placeIfDoesNotExist = function placeIfDoesNotExist(s1, s2, el) {
11771        return targets.indexOf(el) < 0 && place(s1, s2, el);
11772      },
11773          s1,
11774          s2,
11775          p,
11776          el,
11777          s1Alt,
11778          s2Alt,
11779          c1,
11780          c2;
11781
11782      for (p in l1) {
11783        s1Alt = a1[p];
11784        s2Alt = a2[p];
11785        s1 = !s1Alt ? l1[p] : _getChangingElState(state, this, p);
11786        el = s1.element;
11787        s2 = l2[p];
11788
11789        if (s2Alt) {
11790          c2 = s2.isVisible || !s2Alt.isVisible && el === s2.element ? s2 : s2Alt;
11791          c1 = s1Alt && !s1.isVisible && !s1Alt.isVisible && c2.element === s1Alt.element ? s1Alt : s1;
11792
11793          if (c1.isVisible && c2.isVisible && c1.element !== c2.element) {
11794            (c1.isDifferent(c2) ? changed : unchanged).push(c1.element, c2.element);
11795            targets.push(c1.element, c2.element);
11796          } else {
11797            place(c1, c2, c1.element);
11798          }
11799
11800          s1Alt && c1.element === s1Alt.element && (s1Alt = l1[p]);
11801          placeIfDoesNotExist(c1.element !== s2.element && s1Alt ? s1Alt : c1, s2, s2.element);
11802          placeIfDoesNotExist(s1Alt && s1Alt.element === s2Alt.element ? s1Alt : c1, s2Alt, s2Alt.element);
11803          s1Alt && placeIfDoesNotExist(s1Alt, s2Alt.element === s1Alt.element ? s2Alt : s2, s1Alt.element);
11804        } else {
11805          !s2 ? enter.push(el) : !s2.isDifferent(s1) ? unchanged.push(el) : place(s1, s2, el);
11806          s1Alt && placeIfDoesNotExist(s1Alt, s2, s1Alt.element);
11807        }
11808      }
11809
11810      for (p in l2) {
11811        if (!l1[p]) {
11812          leave.push(l2[p].element);
11813          a2[p] && leave.push(a2[p].element);
11814        }
11815      }
11816
11817      return {
11818        changed: changed,
11819        unchanged: unchanged,
11820        enter: enter,
11821        leave: leave
11822      };
11823    };
11824
11825    _proto.recordInlineStyles = function recordInlineStyles() {
11826      var props = _memoizedRemoveProps[this.props] || _removeProps,
11827          i = this.elementStates.length;
11828
11829      while (i--) {
11830        _recordInlineStyles(this.elementStates[i], props);
11831      }
11832    };
11833
11834    _proto.interrupt = function interrupt(soft) {
11835      var _this2 = this;
11836
11837      var timelines = [];
11838      this.targets.forEach(function (t) {
11839        var tl = t._flip,
11840            foundInProgress = _killFlip(tl, soft ? 0 : 1);
11841
11842        soft && foundInProgress && timelines.indexOf(tl) < 0 && tl.add(function () {
11843          return _this2.updateVisibility();
11844        });
11845        foundInProgress && timelines.push(tl);
11846      });
11847      !soft && timelines.length && this.updateVisibility();
11848      this.interrupted || (this.interrupted = !!timelines.length);
11849    };
11850
11851    _proto.updateVisibility = function updateVisibility() {
11852      this.elementStates.forEach(function (es) {
11853        var b = es.element.getBoundingClientRect();
11854        es.isVisible = !!(b.width || b.height || b.top || b.left);
11855        es.uncache = 1;
11856      });
11857    };
11858
11859    _proto.getElementState = function getElementState(element) {
11860      return this.elementStates[this.targets.indexOf(_getEl(element))];
11861    };
11862
11863    _proto.makeAbsolute = function makeAbsolute() {
11864      return _orderByDOMDepth(this.elementStates.slice(0), true, true).map(_makeAbsolute);
11865    };
11866
11867    return FlipState;
11868  }();
11869
11870  var ElementState = function () {
11871    function ElementState(element, props, simple) {
11872

vendor: 1,320 bytes, lines 11872-11898

11872this.element = element;
11873      this.update(props, simple);
11874    }
11875
11876    var _proto2 = ElementState.prototype;
11877
11878    _proto2.isDifferent = function isDifferent(state) {
11879      var b1 = this.bounds,
11880          b2 = state.bounds;
11881      return b1.top !== b2.top || b1.left !== b2.left || b1.width !== b2.width || b1.height !== b2.height || !this.matrix.equals(state.matrix) || this.opacity !== state.opacity || this.props && state.props && JSON.stringify(this.props) !== JSON.stringify(state.props);
11882    };
11883
11884    _proto2.update = function update(props, simple) {
11885      var self = this,
11886          element = self.element,
11887          getProp = gsap$6.getProperty(element),
11888          cache = gsap$6.core.getCache(element),
11889          bounds = element.getBoundingClientRect(),
11890          bbox = element.getBBox && typeof element.getBBox === "function" && element.nodeName.toLowerCase() !== "svg" && element.getBBox(),
11891          m = simple ? new Matrix2D(1, 0, 0, 1, bounds.left + _getDocScrollLeft(), bounds.top + _getDocScrollTop()) : getGlobalMatrix(element, false, false, true);
11892      self.getProp = getProp;
11893      self.element = element;
11894      self.id = _getID(element);
11895      self.matrix = m;
11896      self.cache = cache;
11897      self.bounds = bounds;
11898      self.isVisible = !!(bounds.width || bounds.height || bounds.left || bounds.top);

vendor: 4,199 bytes, lines 11899-12048

11899      self.display = getProp("display");
11900      self.position = getProp("position");
11901      self.parent = element.parentNode;
11902      self.x = getProp("x");
11903      self.y = getProp("y");
11904      self.scaleX = cache.scaleX;
11905      self.scaleY = cache.scaleY;
11906      self.rotation = getProp("rotation");
11907      self.skewX = getProp("skewX");
11908      self.opacity = getProp("opacity");
11909      self.width = bbox ? bbox.width : _closestTenth(getProp("width", "px"), 0.04);
11910      self.height = bbox ? bbox.height : _closestTenth(getProp("height", "px"), 0.04);
11911      props && _recordProps(self, _memoizedProps[props] || _memoizeProps(props));
11912      self.ctm = element.getCTM && element.nodeName.toLowerCase() === "svg" && _getCTM(element).inverse();
11913      self.simple = simple || _round$4(m.a) === 1 && !_round$4(m.b) && !_round$4(m.c) && _round$4(m.d) === 1;
11914      self.uncache = 0;
11915    };
11916
11917    return ElementState;
11918  }();
11919
11920  var FlipAction = function () {
11921    function FlipAction(vars, batch) {
11922      this.vars = vars;
11923      this.batch = batch;
11924      this.states = [];
11925      this.timeline = batch.timeline;
11926    }
11927
11928    var _proto3 = FlipAction.prototype;
11929
11930    _proto3.getStateById = function getStateById(id) {
11931      var i = this.states.length;
11932
11933      while (i--) {
11934        if (this.states[i].idLookup[id]) {
11935          return this.states[i];
11936        }
11937      }
11938    };
11939
11940    _proto3.kill = function kill() {
11941      this.batch.remove(this);
11942    };
11943
11944    return FlipAction;
11945  }();
11946
11947  var FlipBatch = function () {
11948    function FlipBatch(id) {
11949      this.id = id;
11950      this.actions = [];
11951      this._kill = [];
11952      this._final = [];
11953      this._abs = [];
11954      this._run = [];
11955      this.data = {};
11956      this.state = new FlipState();
11957      this.timeline = gsap$6.timeline();
11958    }
11959
11960    var _proto4 = FlipBatch.prototype;
11961
11962    _proto4.add = function add(config) {
11963      var result = this.actions.filter(function (action) {
11964        return action.vars === config;
11965      });
11966
11967      if (result.length) {
11968        return result[0];
11969      }
11970
11971      result = new FlipAction(typeof config === "function" ? {
11972        animate: config
11973      } : config, this);
11974      this.actions.push(result);
11975      return result;
11976    };
11977
11978    _proto4.remove = function remove(action) {
11979      var i = this.actions.indexOf(action);
11980      i >= 0 && this.actions.splice(i, 1);
11981      return this;
11982    };
11983
11984    _proto4.getState = function getState(merge) {
11985      var _this3 = this;
11986
11987      var prevBatch = _batch,
11988          prevAction = _batchAction;
11989      _batch = this;
11990      this.state.clear();
11991      this._kill.length = 0;
11992      this.actions.forEach(function (action) {
11993        if (action.vars.getState) {
11994          action.states.length = 0;
11995          _batchAction = action;
11996          action.state = action.vars.getState(action);
11997        }
11998
11999        merge && action.states.forEach(function (s) {
12000          return _this3.state.add(s);
12001        });
12002      });
12003      _batchAction = prevAction;
12004      _batch = prevBatch;
12005      this.killConflicts();
12006      return this;
12007    };
12008
12009    _proto4.animate = function animate() {
12010      var _this4 = this;
12011
12012      var prevBatch = _batch,
12013          tl = this.timeline,
12014          i = this.actions.length,
12015          finalStates,
12016          endTime;
12017      _batch = this;
12018      tl.clear();
12019      this._abs.length = this._final.length = this._run.length = 0;
12020      this.actions.forEach(function (a) {
12021        a.vars.animate && a.vars.animate(a);
12022        var onEnter = a.vars.onEnter,
12023            onLeave = a.vars.onLeave,
12024            targets = a.targets,
12025            s,
12026            result;
12027
12028        if (targets && targets.length && (onEnter || onLeave)) {
12029          s = new FlipState();
12030          a.states.forEach(function (state) {
12031            return s.add(state);
12032          });
12033          result = s.compare(Flip.getState(targets));
12034          result.enter.length && onEnter && onEnter(result.enter);
12035          result.leave.length && onLeave && onLeave(result.leave);
12036        }
12037      });
12038
12039      _makeCompsAbsolute(this._abs);
12040
12041      this._run.forEach(function (f) {
12042        return f();
12043      });
12044
12045      endTime = tl.duration();
12046      finalStates = this._final.slice(0);
12047      tl.add(function () {
12048        if (endTime <= tl.time()) {

vendor: 5,171 bytes, lines 12049-12240

12049          finalStates.forEach(function (f) {
12050            return f();
12051          });
12052
12053          _forEachBatch(_this4, "onComplete");
12054        }
12055      });
12056      _batch = prevBatch;
12057
12058      while (i--) {
12059        this.actions[i].vars.once && this.actions[i].kill();
12060      }
12061
12062      _forEachBatch(this, "onStart");
12063
12064      tl.restart();
12065      return this;
12066    };
12067
12068    _proto4.loadState = function loadState(done) {
12069      done || (done = function done() {
12070        return 0;
12071      });
12072      var queue = [];
12073      this.actions.forEach(function (c) {
12074        if (c.vars.loadState) {
12075          var i,
12076              f = function f(targets) {
12077            targets && (c.targets = targets);
12078            i = queue.indexOf(f);
12079
12080            if (~i) {
12081              queue.splice(i, 1);
12082              queue.length || done();
12083            }
12084          };
12085
12086          queue.push(f);
12087          c.vars.loadState(f);
12088        }
12089      });
12090      queue.length || done();
12091      return this;
12092    };
12093
12094    _proto4.setState = function setState() {
12095      this.actions.forEach(function (c) {
12096        return c.targets = c.vars.setState && c.vars.setState(c);
12097      });
12098      return this;
12099    };
12100
12101    _proto4.killConflicts = function killConflicts(soft) {
12102      this.state.interrupt(soft);
12103
12104      this._kill.forEach(function (state) {
12105        return state.interrupt(soft);
12106      });
12107
12108      return this;
12109    };
12110
12111    _proto4.run = function run(skipGetState, merge) {
12112      var _this5 = this;
12113
12114      if (this !== _batch) {
12115        skipGetState || this.getState(merge);
12116        this.loadState(function () {
12117          if (!_this5._killed) {
12118            _this5.setState();
12119
12120            _this5.animate();
12121          }
12122        });
12123      }
12124
12125      return this;
12126    };
12127
12128    _proto4.clear = function clear(stateOnly) {
12129      this.state.clear();
12130      stateOnly || (this.actions.length = 0);
12131    };
12132
12133    _proto4.getStateById = function getStateById(id) {
12134      var i = this.actions.length,
12135          s;
12136
12137      while (i--) {
12138        s = this.actions[i].getStateById(id);
12139
12140        if (s) {
12141          return s;
12142        }
12143      }
12144
12145      return this.state.idLookup[id] && this.state;
12146    };
12147
12148    _proto4.kill = function kill() {
12149      this._killed = 1;
12150      this.clear();
12151      delete _batchLookup[this.id];
12152    };
12153
12154    return FlipBatch;
12155  }();
12156
12157  var Flip = function () {
12158    function Flip() {}
12159
12160    Flip.getState = function getState(targets, vars) {
12161      var state = _parseState(targets, vars);
12162
12163      _batchAction && _batchAction.states.push(state);
12164      vars && vars.batch && Flip.batch(vars.batch).state.add(state);
12165      return state;
12166    };
12167
12168    Flip.from = function from(state, vars) {
12169      vars = vars || {};
12170      "clearProps" in vars || (vars.clearProps = true);
12171      return _fromTo(state, _parseState(vars.targets || state.targets, {
12172        props: vars.props || state.props,
12173        simple: vars.simple,
12174        kill: !!vars.kill
12175      }), vars, -1);
12176    };
12177
12178    Flip.to = function to(state, vars) {
12179      return _fromTo(state, _parseState(vars.targets || state.targets, {
12180        props: vars.props || state.props,
12181        simple: vars.simple,
12182        kill: !!vars.kill
12183      }), vars, 1);
12184    };
12185
12186    Flip.fromTo = function fromTo(fromState, toState, vars) {
12187      return _fromTo(fromState, toState, vars);
12188    };
12189
12190    Flip.fit = function fit(fromEl, toEl, vars) {
12191      var v = vars ? _copy$1(vars, _fitReserved) : {},
12192          _ref = vars || v,
12193          absolute = _ref.absolute,
12194          scale = _ref.scale,
12195          getVars = _ref.getVars,
12196          props = _ref.props,
12197          runBackwards = _ref.runBackwards,
12198          onComplete = _ref.onComplete,
12199          simple = _ref.simple,
12200          fitChild = vars && vars.fitChild && _getEl(vars.fitChild),
12201          before = _parseElementState(toEl, props, simple, fromEl),
12202          after = _parseElementState(fromEl, 0, simple, before),
12203          inlineProps = props ? _memoizedRemoveProps[props] : _removeProps,
12204          ctx = gsap$6.context();
12205
12206      props && _applyProps(v, before.props);
12207
12208      _recordInlineStyles(after, inlineProps);
12209
12210      if (runBackwards) {
12211        "immediateRender" in v || (v.immediateRender = true);
12212
12213        v.onComplete = function () {
12214          _applyInlineStyles(after);
12215
12216          onComplete && onComplete.apply(this, arguments);
12217        };
12218      }
12219
12220      absolute && _makeAbsolute(after, before);
12221      v = _fit(after, before, scale || fitChild, props, fitChild, v.duration || getVars ? v : 0);
12222      ctx && !getVars && ctx.add(function () {
12223        return function () {
12224          return _applyInlineStyles(after);
12225        };
12226      });
12227      return getVars ? v : v.duration ? gsap$6.to(after.element, v) : null;
12228    };
12229
12230    Flip.makeAbsolute = function makeAbsolute(targetsOrStates, vars) {
12231      return (targetsOrStates instanceof FlipState ? targetsOrStates : new FlipState(targetsOrStates, vars)).makeAbsolute();
12232    };
12233
12234    Flip.batch = function batch(id) {
12235      id || (id = "default");
12236      return _batchLookup[id] || (_batchLookup[id] = new FlipBatch(id));
12237    };
12238
12239    Flip.killFlipsOf = function killFlipsOf(targets, complete) {
12240      (targets instanceof FlipState ? targets.targets : _toArray$1(targets)).forEac

vendor: 13,942 bytes, lines 12240-12667

12240h(function (t) {
12241        return t && _killFlip(t._flip, complete !== false ? 1 : 2);
12242      });
12243    };
12244
12245    Flip.isFlipping = function isFlipping(target) {
12246      var f = Flip.getByTarget(target);
12247      return !!f && f.isActive();
12248    };
12249
12250    Flip.getByTarget = function getByTarget(target) {
12251      return (_getEl(target) || _emptyObj)._flip;
12252    };
12253
12254    Flip.getElementState = function getElementState(target, props) {
12255      return new ElementState(_getEl(target), props);
12256    };
12257
12258    Flip.convertCoordinates = function convertCoordinates(fromElement, toElement, point) {
12259      var m = getGlobalMatrix(toElement, true, true).multiply(getGlobalMatrix(fromElement));
12260      return point ? m.apply(point) : m;
12261    };
12262
12263    Flip.register = function register(core) {
12264      _body$2 = typeof document !== "undefined" && document.body;
12265
12266      if (_body$2) {
12267        gsap$6 = core;
12268
12269        _setDoc(_body$2);
12270
12271        _toArray$1 = gsap$6.utils.toArray;
12272        _getStyleSaver$2 = gsap$6.core.getStyleSaver;
12273        var snap = gsap$6.utils.snap(0.1);
12274
12275        _closestTenth = function _closestTenth(value, add) {
12276          return snap(parseFloat(value) + add);
12277        };
12278      }
12279    };
12280
12281    return Flip;
12282  }();
12283  Flip.version = "3.12.5";
12284  typeof window !== "undefined" && window.gsap && window.gsap.registerPlugin(Flip);
12285
12286  /*!
12287   * MotionPathPlugin 3.12.5
12288   * https://gsap.com
12289   *
12290   * @license Copyright 2008-2024, GreenSock. All rights reserved.
12291   * Subject to the terms at https://gsap.com/standard-license or for
12292   * Club GSAP members, the agreement issued with that membership.
12293   * @author: Jack Doyle, [email protected]
12294  */
12295
12296  var _xProps = "x,translateX,left,marginLeft,xPercent".split(","),
12297      _yProps = "y,translateY,top,marginTop,yPercent".split(","),
12298      _DEG2RAD$3 = Math.PI / 180,
12299      gsap$7,
12300      PropTween$1,
12301      _getUnit,
12302      _toArray$2,
12303      _getStyleSaver$3,
12304      _reverting$2,
12305      _getGSAP$5 = function _getGSAP() {
12306    return gsap$7 || typeof window !== "undefined" && (gsap$7 = window.gsap) && gsap$7.registerPlugin && gsap$7;
12307  },
12308      _populateSegmentFromArray = function _populateSegmentFromArray(segment, values, property, mode) {
12309    var l = values.length,
12310        si = mode === 2 ? 0 : mode,
12311        i = 0,
12312        v;
12313
12314    for (; i < l; i++) {
12315      segment[si] = v = parseFloat(values[i][property]);
12316      mode === 2 && (segment[si + 1] = 0);
12317      si += 2;
12318    }
12319
12320    return segment;
12321  },
12322      _getPropNum = function _getPropNum(target, prop, unit) {
12323    return parseFloat(target._gsap.get(target, prop, unit || "px")) || 0;
12324  },
12325      _relativize = function _relativize(segment) {
12326    var x = segment[0],
12327        y = segment[1],
12328        i;
12329
12330    for (i = 2; i < segment.length; i += 2) {
12331      x = segment[i] += x;
12332      y = segment[i + 1] += y;
12333    }
12334  },
12335      _segmentToRawPath = function _segmentToRawPath(plugin, segment, target, x, y, slicer, vars, unitX, unitY) {
12336    if (vars.type === "cubic") {
12337      segment = [segment];
12338    } else {
12339      vars.fromCurrent !== false && segment.unshift(_getPropNum(target, x, unitX), y ? _getPropNum(target, y, unitY) : 0);
12340      vars.relative && _relativize(segment);
12341      var pointFunc = y ? pointsToSegment : flatPointsToSegment;
12342      segment = [pointFunc(segment, vars.curviness)];
12343    }
12344
12345    segment = slicer(_align(segment, target, vars));
12346
12347    _addDimensionalPropTween(plugin, target, x, segment, "x", unitX);
12348
12349    y && _addDimensionalPropTween(plugin, target, y, segment, "y", unitY);
12350    return cacheRawPathMeasurements(segment, vars.resolution || (vars.curviness === 0 ? 20 : 12));
12351  },
12352      _emptyFunc$2 = function _emptyFunc(v) {
12353    return v;
12354  },
12355      _numExp$2 = /[-+\.]*\d+\.?(?:e-|e\+)?\d*/g,
12356      _originToPoint = function _originToPoint(element, origin, parentMatrix) {
12357    var m = getGlobalMatrix(element),
12358        x = 0,
12359        y = 0,
12360        svg;
12361
12362    if ((element.tagName + "").toLowerCase() === "svg") {
12363      svg = element.viewBox.baseVal;
12364      svg.width || (svg = {
12365        width: +element.getAttribute("width"),
12366        height: +element.getAttribute("height")
12367      });
12368    } else {
12369      svg = origin && element.getBBox && element.getBBox();
12370    }
12371
12372    if (origin && origin !== "auto") {
12373      x = origin.push ? origin[0] * (svg ? svg.width : element.offsetWidth || 0) : origin.x;
12374      y = origin.push ? origin[1] * (svg ? svg.height : element.offsetHeight || 0) : origin.y;
12375    }
12376
12377    return parentMatrix.apply(x || y ? m.apply({
12378      x: x,
12379      y: y
12380    }) : {
12381      x: m.e,
12382      y: m.f
12383    });
12384  },
12385      _getAlignMatrix = function _getAlignMatrix(fromElement, toElement, fromOrigin, toOrigin) {
12386    var parentMatrix = getGlobalMatrix(fromElement.parentNode, true, true),
12387        m = parentMatrix.clone().multiply(getGlobalMatrix(toElement)),
12388        fromPoint = _originToPoint(fromElement, fromOrigin, parentMatrix),
12389        _originToPoint2 = _originToPoint(toElement, toOrigin, parentMatrix),
12390        x = _originToPoint2.x,
12391        y = _originToPoint2.y,
12392        p;
12393
12394    m.e = m.f = 0;
12395
12396    if (toOrigin === "auto" && toElement.getTotalLength && toElement.tagName.toLowerCase() === "path") {
12397      p = toElement.getAttribute("d").match(_numExp$2) || [];
12398      p = m.apply({
12399        x: +p[0],
12400        y: +p[1]
12401      });
12402      x += p.x;
12403      y += p.y;
12404    }
12405
12406    if (p) {
12407      p = m.apply(toElement.getBBox());
12408      x -= p.x;
12409      y -= p.y;
12410    }
12411
12412    m.e = x - fromPoint.x;
12413    m.f = y - fromPoint.y;
12414    return m;
12415  },
12416      _align = function _align(rawPath, target, _ref) {
12417    var align = _ref.align,
12418        matrix = _ref.matrix,
12419        offsetX = _ref.offsetX,
12420        offsetY = _ref.offsetY,
12421        alignOrigin = _ref.alignOrigin;
12422
12423    var x = rawPath[0][0],
12424        y = rawPath[0][1],
12425        curX = _getPropNum(target, "x"),
12426        curY = _getPropNum(target, "y"),
12427        alignTarget,
12428        m,
12429        p;
12430
12431    if (!rawPath || !rawPath.length) {
12432      return getRawPath("M0,0L0,0");
12433    }
12434
12435    if (align) {
12436      if (align === "self" || (alignTarget = _toArray$2(align)[0] || target) === target) {
12437        transformRawPath(rawPath, 1, 0, 0, 1, curX - x, curY - y);
12438      } else {
12439        if (alignOrigin && alignOrigin[2] !== false) {
12440          gsap$7.set(target, {
12441            transformOrigin: alignOrigin[0] * 100 + "% " + alignOrigin[1] * 100 + "%"
12442          });
12443        } else {
12444          alignOrigin = [_getPropNum(target, "xPercent") / -100, _getPropNum(target, "yPercent") / -100];
12445        }
12446
12447        m = _getAlignMatrix(target, alignTarget, alignOrigin, "auto");
12448        p = m.apply({
12449          x: x,
12450          y: y
12451        });
12452        transformRawPath(rawPath, m.a, m.b, m.c, m.d, curX + m.e - (p.x - m.e), curY + m.f - (p.y - m.f));
12453      }
12454    }
12455
12456    if (matrix) {
12457      transformRawPath(rawPath, matrix.a, matrix.b, matrix.c, matrix.d, matrix.e, matrix.f);
12458    } else if (offsetX || offsetY) {
12459      transformRawPath(rawPath, 1, 0, 0, 1, offsetX || 0, offsetY || 0);
12460    }
12461
12462    return rawPath;
12463  },
12464      _addDimensionalPropTween = function _addDimensionalPropTween(plugin, target, property, rawPath, pathProperty, forceUnit) {
12465    var cache = target._gsap,
12466        harness = cache.harness,
12467        alias = harness && harness.aliases && harness.aliases[property],
12468        prop = alias && alias.indexOf(",") < 0 ? alias : property,
12469        pt = plugin._pt = new PropTween$1(plugin._pt, target, prop, 0, 0, _emptyFunc$2, 0, cache.set(target, prop, plugin));
12470    pt.u = _getUnit(cache.get(target, prop, forceUnit)) || 0;
12471    pt.path = rawPath;
12472    pt.pp = pathProperty;
12473
12474    plugin._props.push(prop);
12475  },
12476      _sliceModifier = function _sliceModifier(start, end) {
12477    return function (rawPath) {
12478      return start || end !== 1 ? sliceRawPath(rawPath, start, end) : rawPath;
12479    };
12480  };
12481
12482  var MotionPathPlugin = {
12483    version: "3.12.5",
12484    name: "motionPath",
12485    register: function register(core, Plugin, propTween) {
12486      gsap$7 = core;
12487      _getUnit = gsap$7.utils.getUnit;
12488      _toArray$2 = gsap$7.utils.toArray;
12489      _getStyleSaver$3 = gsap$7.core.getStyleSaver;
12490
12491      _reverting$2 = gsap$7.core.reverting || function () {};
12492
12493      PropTween$1 = propTween;
12494    },
12495    init: function init(target, vars, tween) {
12496      if (!gsap$7) {
12497        console.warn("Please gsap.registerPlugin(MotionPathPlugin)");
12498        return false;
12499      }
12500
12501      if (!(typeof vars === "object" && !vars.style) || !vars.path) {
12502        vars = {
12503          path: vars
12504        };
12505      }
12506
12507      var rawPaths = [],
12508          _vars = vars,
12509          path = _vars.path,
12510          autoRotate = _vars.autoRotate,
12511          unitX = _vars.unitX,
12512          unitY = _vars.unitY,
12513          x = _vars.x,
12514          y = _vars.y,
12515          firstObj = path[0],
12516          slicer = _sliceModifier(vars.start, "end" in vars ? vars.end : 1),
12517          rawPath,
12518          p;
12519
12520      this.rawPaths = rawPaths;
12521      this.target = target;
12522      this.tween = tween;
12523      this.styles = _getStyleSaver$3 && _getStyleSaver$3(target, "transform");
12524
12525      if (this.rotate = autoRotate || autoRotate === 0) {
12526        this.rOffset = parseFloat(autoRotate) || 0;
12527        this.radians = !!vars.useRadians;
12528        this.rProp = vars.rotation || "rotation";
12529        this.rSet = target._gsap.set(target, this.rProp, this);
12530        this.ru = _getUnit(target._gsap.get(target, this.rProp)) || 0;
12531      }
12532
12533      if (Array.isArray(path) && !("closed" in path) && typeof firstObj !== "number") {
12534        for (p in firstObj) {
12535          if (!x && ~_xProps.indexOf(p)) {
12536            x = p;
12537          } else if (!y && ~_yProps.indexOf(p)) {
12538            y = p;
12539          }
12540        }
12541
12542        if (x && y) {
12543          rawPaths.push(_segmentToRawPath(this, _populateSegmentFromArray(_populateSegmentFromArray([], path, x, 0), path, y, 1), target, x, y, slicer, vars, unitX || _getUnit(path[0][x]), unitY || _getUnit(path[0][y])));
12544        } else {
12545          x = y = 0;
12546        }
12547
12548        for (p in firstObj) {
12549          p !== x && p !== y && rawPaths.push(_segmentToRawPath(this, _populateSegmentFromArray([], path, p, 2), target, p, 0, slicer, vars, _getUnit(path[0][p])));
12550        }
12551      } else {
12552        rawPath = slicer(_align(getRawPath(vars.path), target, vars));
12553        cacheRawPathMeasurements(rawPath, vars.resolution);
12554        rawPaths.push(rawPath);
12555
12556        _addDimensionalPropTween(this, target, vars.x || "x", rawPath, "x", vars.unitX || "px");
12557
12558        _addDimensionalPropTween(this, target, vars.y || "y", rawPath, "y", vars.unitY || "px");
12559      }
12560    },
12561    render: function render(ratio, data) {
12562      var rawPaths = data.rawPaths,
12563          i = rawPaths.length,
12564          pt = data._pt;
12565
12566      if (data.tween._time || !_reverting$2()) {
12567        if (ratio > 1) {
12568          ratio = 1;
12569        } else if (ratio < 0) {
12570          ratio = 0;
12571        }
12572
12573        while (i--) {
12574          getPositionOnPath(rawPaths[i], ratio, !i && data.rotate, rawPaths[i]);
12575        }
12576
12577        while (pt) {
12578          pt.set(pt.t, pt.p, pt.path[pt.pp] + pt.u, pt.d, ratio);
12579          pt = pt._next;
12580        }
12581
12582        data.rotate && data.rSet(data.target, data.rProp, rawPaths[0].angle * (data.radians ? _DEG2RAD$3 : 1) + data.rOffset + data.ru, data, ratio);
12583      } else {
12584        data.styles.revert();
12585      }
12586    },
12587    getLength: function getLength(path) {
12588      return cacheRawPathMeasurements(getRawPath(path)).totalLength;
12589    },
12590    sliceRawPath: sliceRawPath,
12591    getRawPath: getRawPath,
12592    pointsToSegment: pointsToSegment,
12593    stringToRawPath: stringToRawPath,
12594    rawPathToString: rawPathToString,
12595    transformRawPath: transformRawPath,
12596    getGlobalMatrix: getGlobalMatrix,
12597    getPositionOnPath: getPositionOnPath,
12598    cacheRawPathMeasurements: cacheRawPathMeasurements,
12599    convertToPath: function convertToPath$1(targets, swap) {
12600      return _toArray$2(targets).map(function (target) {
12601        return convertToPath(target, swap !== false);
12602      });
12603    },
12604    convertCoordinates: function convertCoordinates(fromElement, toElement, point) {
12605      var m = getGlobalMatrix(toElement, true, true).multiply(getGlobalMatrix(fromElement));
12606      return point ? m.apply(point) : m;
12607    },
12608    getAlignMatrix: _getAlignMatrix,
12609    getRelativePosition: function getRelativePosition(fromElement, toElement, fromOrigin, toOrigin) {
12610      var m = _getAlignMatrix(fromElement, toElement, fromOrigin, toOrigin);
12611
12612      return {
12613        x: m.e,
12614        y: m.f
12615      };
12616    },
12617    arrayToRawPath: function arrayToRawPath(value, vars) {
12618      vars = vars || {};
12619
12620      var segment = _populateSegmentFromArray(_populateSegmentFromArray([], value, vars.x || "x", 0), value, vars.y || "y", 1);
12621
12622      vars.relative && _relativize(segment);
12623      return [vars.type === "cubic" ? segment : pointsToSegment(segment, vars.curviness)];
12624    }
12625  };
12626  _getGSAP$5() && gsap$7.registerPlugin(MotionPathPlugin);
12627
12628  /*!
12629   * Observer 3.12.5
12630   * https://gsap.com
12631   *
12632   * @license Copyright 2008-2024, GreenSock. All rights reserved.
12633   * Subject to the terms at https://gsap.com/standard-license or for
12634   * Club GSAP members, the agreement issued with that membership.
12635   * @author: Jack Doyle, [email protected]
12636  */
12637  var gsap$8,
12638      _coreInitted$5,
12639      _clamp$1,
12640      _win$5,
12641      _doc$5,
12642      _docEl,
12643      _body$3,
12644      _isTouch,
12645      _pointerType,
12646      ScrollTrigger,
12647      _root,
12648      _normalizer,
12649      _eventTypes,
12650      _context$2,
12651      _getGSAP$6 = function _getGSAP() {
12652    return gsap$8 || typeof window !== "undefined" && (gsap$8 = window.gsap) && gsap$8.registerPlugin && gsap$8;
12653  },
12654      _startup = 1,
12655      _observers = [];
12656      exports._scrollers = [];
12657      exports._proxies = [];
12658      var _getTime$1 = Date.now,
12659      _bridge = function _bridge(name, value) {
12660    return value;
12661  },
12662      _integrate = function _integrate() {
12663    var core = ScrollTrigger.core,
12664        data = core.bridge || {},
12665        scrollers = core._scrollers,
12666        proxies = core._proxies;
12667    scrollers.push.apply(scrollers, exports._scrollers);

vendor: 10,243 bytes, lines 12668-12944

12668    proxies.push.apply(proxies, exports._proxies);
12669    exports._scrollers = scrollers;
12670    exports._proxies = proxies;
12671
12672    _bridge = function _bridge(name, value) {
12673      return data[name](value);
12674    };
12675  },
12676      _getProxyProp = function _getProxyProp(element, property) {
12677    return ~exports._proxies.indexOf(element) && exports._proxies[exports._proxies.indexOf(element) + 1][property];
12678  },
12679      _isViewport = function _isViewport(el) {
12680    return !!~_root.indexOf(el);
12681  },
12682      _addListener$1 = function _addListener(element, type, func, passive, capture) {
12683    return element.addEventListener(type, func, {
12684      passive: passive !== false,
12685      capture: !!capture
12686    });
12687  },
12688      _removeListener$1 = function _removeListener(element, type, func, capture) {
12689    return element.removeEventListener(type, func, !!capture);
12690  },
12691      _scrollLeft = "scrollLeft",
12692      _scrollTop = "scrollTop",
12693      _onScroll = function _onScroll() {
12694    return _normalizer && _normalizer.isPressed || exports._scrollers.cache++;
12695  },
12696      _scrollCacheFunc = function _scrollCacheFunc(f, doNotCache) {
12697    var cachingFunc = function cachingFunc(value) {
12698      if (value || value === 0) {
12699        _startup && (_win$5.history.scrollRestoration = "manual");
12700        var isNormalizing = _normalizer && _normalizer.isPressed;
12701        value = cachingFunc.v = Math.round(value) || (_normalizer && _normalizer.iOS ? 1 : 0);
12702        f(value);
12703        cachingFunc.cacheID = exports._scrollers.cache;
12704        isNormalizing && _bridge("ss", value);
12705      } else if (doNotCache || exports._scrollers.cache !== cachingFunc.cacheID || _bridge("ref")) {
12706        cachingFunc.cacheID = exports._scrollers.cache;
12707        cachingFunc.v = f();
12708      }
12709
12710      return cachingFunc.v + cachingFunc.offset;
12711    };
12712
12713    cachingFunc.offset = 0;
12714    return f && cachingFunc;
12715  },
12716      _horizontal = {
12717    s: _scrollLeft,
12718    p: "left",
12719    p2: "Left",
12720    os: "right",
12721    os2: "Right",
12722    d: "width",
12723    d2: "Width",
12724    a: "x",
12725    sc: _scrollCacheFunc(function (value) {
12726      return arguments.length ? _win$5.scrollTo(value, _vertical.sc()) : _win$5.pageXOffset || _doc$5[_scrollLeft] || _docEl[_scrollLeft] || _body$3[_scrollLeft] || 0;
12727    })
12728  },
12729      _vertical = {
12730    s: _scrollTop,
12731    p: "top",
12732    p2: "Top",
12733    os: "bottom",
12734    os2: "Bottom",
12735    d: "height",
12736    d2: "Height",
12737    a: "y",
12738    op: _horizontal,
12739    sc: _scrollCacheFunc(function (value) {
12740      return arguments.length ? _win$5.scrollTo(_horizontal.sc(), value) : _win$5.pageYOffset || _doc$5[_scrollTop] || _docEl[_scrollTop] || _body$3[_scrollTop] || 0;
12741    })
12742  },
12743      _getTarget = function _getTarget(t, self) {
12744    return (self && self._ctx && self._ctx.selector || gsap$8.utils.toArray)(t)[0] || (typeof t === "string" && gsap$8.config().nullTargetWarn !== false ? console.warn("Element not found:", t) : null);
12745  },
12746      _getScrollFunc = function _getScrollFunc(element, _ref) {
12747    var s = _ref.s,
12748        sc = _ref.sc;
12749    _isViewport(element) && (element = _doc$5.scrollingElement || _docEl);
12750
12751    var i = exports._scrollers.indexOf(element),
12752        offset = sc === _vertical.sc ? 1 : 2;
12753
12754    !~i && (i = exports._scrollers.push(element) - 1);
12755    exports._scrollers[i + offset] || _addListener$1(element, "scroll", _onScroll);
12756    var prev = exports._scrollers[i + offset],
12757        func = prev || (exports._scrollers[i + offset] = _scrollCacheFunc(_getProxyProp(element, s), true) || (_isViewport(element) ? sc : _scrollCacheFunc(function (value) {
12758      return arguments.length ? element[s] = value : element[s];
12759    })));
12760    func.target = element;
12761    prev || (func.smooth = gsap$8.getProperty(element, "scrollBehavior") === "smooth");
12762    return func;
12763  },
12764      _getVelocityProp = function _getVelocityProp(value, minTimeRefresh, useDelta) {
12765    var v1 = value,
12766        v2 = value,
12767        t1 = _getTime$1(),
12768        t2 = t1,
12769        min = minTimeRefresh || 50,
12770        dropToZeroTime = Math.max(500, min * 3),
12771        update = function update(value, force) {
12772      var t = _getTime$1();
12773
12774      if (force || t - t1 > min) {
12775        v2 = v1;
12776        v1 = value;
12777        t2 = t1;
12778        t1 = t;
12779      } else if (useDelta) {
12780        v1 += value;
12781      } else {
12782        v1 = v2 + (value - v2) / (t - t2) * (t1 - t2);
12783      }
12784    },
12785        reset = function reset() {
12786      v2 = v1 = useDelta ? 0 : v1;
12787      t2 = t1 = 0;
12788    },
12789        getVelocity = function getVelocity(latestValue) {
12790      var tOld = t2,
12791          vOld = v2,
12792          t = _getTime$1();
12793
12794      (latestValue || latestValue === 0) && latestValue !== v1 && update(latestValue);
12795      return t1 === t2 || t - t2 > dropToZeroTime ? 0 : (v1 + (useDelta ? vOld : -vOld)) / ((useDelta ? t : t1) - tOld) * 1000;
12796    };
12797
12798    return {
12799      update: update,
12800      reset: reset,
12801      getVelocity: getVelocity
12802    };
12803  },
12804      _getEvent = function _getEvent(e, preventDefault) {
12805    preventDefault && !e._gsapAllow && e.preventDefault();
12806    return e.changedTouches ? e.changedTouches[0] : e;
12807  },
12808      _getAbsoluteMax = function _getAbsoluteMax(a) {
12809    var max = Math.max.apply(Math, a),
12810        min = Math.min.apply(Math, a);
12811    return Math.abs(max) >= Math.abs(min) ? max : min;
12812  },
12813      _setScrollTrigger = function _setScrollTrigger() {
12814    ScrollTrigger = gsap$8.core.globals().ScrollTrigger;
12815    ScrollTrigger && ScrollTrigger.core && _integrate();
12816  },
12817      _initCore$6 = function _initCore(core) {
12818    gsap$8 = core || _getGSAP$6();
12819
12820    if (!_coreInitted$5 && gsap$8 && typeof document !== "undefined" && document.body) {
12821      _win$5 = window;
12822      _doc$5 = document;
12823      _docEl = _doc$5.documentElement;
12824      _body$3 = _doc$5.body;
12825      _root = [_win$5, _doc$5, _docEl, _body$3];
12826      _clamp$1 = gsap$8.utils.clamp;
12827
12828      _context$2 = gsap$8.core.context || function () {};
12829
12830      _pointerType = "onpointerenter" in _body$3 ? "pointer" : "mouse";
12831      _isTouch = Observer.isTouch = _win$5.matchMedia && _win$5.matchMedia("(hover: none), (pointer: coarse)").matches ? 1 : "ontouchstart" in _win$5 || navigator.maxTouchPoints > 0 || navigator.msMaxTouchPoints > 0 ? 2 : 0;
12832      _eventTypes = Observer.eventTypes = ("ontouchstart" in _docEl ? "touchstart,touchmove,touchcancel,touchend" : !("onpointerdown" in _docEl) ? "mousedown,mousemove,mouseup,mouseup" : "pointerdown,pointermove,pointercancel,pointerup").split(",");
12833      setTimeout(function () {
12834        return _startup = 0;
12835      }, 500);
12836
12837      _setScrollTrigger();
12838
12839      _coreInitted$5 = 1;
12840    }
12841
12842    return _coreInitted$5;
12843  };
12844
12845  _horizontal.op = _vertical;
12846  exports._scrollers.cache = 0;
12847  var Observer = function () {
12848    function Observer(vars) {
12849      this.init(vars);
12850    }
12851
12852    var _proto = Observer.prototype;
12853
12854    _proto.init = function init(vars) {
12855      _coreInitted$5 || _initCore$6(gsap$8) || console.warn("Please gsap.registerPlugin(Observer)");
12856      ScrollTrigger || _setScrollTrigger();
12857      var tolerance = vars.tolerance,
12858          dragMinimum = vars.dragMinimum,
12859          type = vars.type,
12860          target = vars.target,
12861          lineHeight = vars.lineHeight,
12862          debounce = vars.debounce,
12863          preventDefault = vars.preventDefault,
12864          onStop = vars.onStop,
12865          onStopDelay = vars.onStopDelay,
12866          ignore = vars.ignore,
12867          wheelSpeed = vars.wheelSpeed,
12868          event = vars.event,
12869          onDragStart = vars.onDragStart,
12870          onDragEnd = vars.onDragEnd,
12871          onDrag = vars.onDrag,
12872          onPress = vars.onPress,
12873          onRelease = vars.onRelease,
12874          onRight = vars.onRight,
12875          onLeft = vars.onLeft,
12876          onUp = vars.onUp,
12877          onDown = vars.onDown,
12878          onChangeX = vars.onChangeX,
12879          onChangeY = vars.onChangeY,
12880          onChange = vars.onChange,
12881          onToggleX = vars.onToggleX,
12882          onToggleY = vars.onToggleY,
12883          onHover = vars.onHover,
12884          onHoverEnd = vars.onHoverEnd,
12885          onMove = vars.onMove,
12886          ignoreCheck = vars.ignoreCheck,
12887          isNormalizer = vars.isNormalizer,
12888          onGestureStart = vars.onGestureStart,
12889          onGestureEnd = vars.onGestureEnd,
12890          onWheel = vars.onWheel,
12891          onEnable = vars.onEnable,
12892          onDisable = vars.onDisable,
12893          onClick = vars.onClick,
12894          scrollSpeed = vars.scrollSpeed,
12895          capture = vars.capture,
12896          allowClicks = vars.allowClicks,
12897          lockAxis = vars.lockAxis,
12898          onLockAxis = vars.onLockAxis;
12899      this.target = target = _getTarget(target) || _docEl;
12900      this.vars = vars;
12901      ignore && (ignore = gsap$8.utils.toArray(ignore));
12902      tolerance = tolerance || 1e-9;
12903      dragMinimum = dragMinimum || 0;
12904      wheelSpeed = wheelSpeed || 1;
12905      scrollSpeed = scrollSpeed || 1;
12906      type = type || "wheel,touch,pointer";
12907      debounce = debounce !== false;
12908      lineHeight || (lineHeight = parseFloat(_win$5.getComputedStyle(_body$3).lineHeight) || 22);
12909
12910      var id,
12911          onStopDelayedCall,
12912          dragged,
12913          moved,
12914          wheeled,
12915          locked,
12916          axis,
12917          self = this,
12918          prevDeltaX = 0,
12919          prevDeltaY = 0,
12920          passive = vars.passive || !preventDefault,
12921          scrollFuncX = _getScrollFunc(target, _horizontal),
12922          scrollFuncY = _getScrollFunc(target, _vertical),
12923          scrollX = scrollFuncX(),
12924          scrollY = scrollFuncY(),
12925          limitToTouch = ~type.indexOf("touch") && !~type.indexOf("pointer") && _eventTypes[0] === "pointerdown",
12926          isViewport = _isViewport(target),
12927          ownerDoc = target.ownerDocument || _doc$5,
12928          deltaX = [0, 0, 0],
12929          deltaY = [0, 0, 0],
12930          onClickTime = 0,
12931          clickCapture = function clickCapture() {
12932        return onClickTime = _getTime$1();
12933      },
12934          _ignoreCheck = function _ignoreCheck(e, isPointerOrTouch) {
12935        return (self.event = e) && ignore && ~ignore.indexOf(e.target) || isPointerOrTouch && limitToTouch && e.pointerType !== "touch" || ignoreCheck && ignoreCheck(e, isPointerOrTouch);
12936      },
12937          onStopFunc = function onStopFunc() {
12938        self._vx.reset();
12939
12940        self._vy.reset();
12941
12942        onStopDelayedCall.pause();
12943        onStop && onStop(self);
12944      },

vendor: 9,992 bytes, lines 12945-13236

12945          update = function update() {
12946        var dx = self.deltaX = _getAbsoluteMax(deltaX),
12947            dy = self.deltaY = _getAbsoluteMax(deltaY),
12948            changedX = Math.abs(dx) >= tolerance,
12949            changedY = Math.abs(dy) >= tolerance;
12950
12951        onChange && (changedX || changedY) && onChange(self, dx, dy, deltaX, deltaY);
12952
12953        if (changedX) {
12954          onRight && self.deltaX > 0 && onRight(self);
12955          onLeft && self.deltaX < 0 && onLeft(self);
12956          onChangeX && onChangeX(self);
12957          onToggleX && self.deltaX < 0 !== prevDeltaX < 0 && onToggleX(self);
12958          prevDeltaX = self.deltaX;
12959          deltaX[0] = deltaX[1] = deltaX[2] = 0;
12960        }
12961
12962        if (changedY) {
12963          onDown && self.deltaY > 0 && onDown(self);
12964          onUp && self.deltaY < 0 && onUp(self);
12965          onChangeY && onChangeY(self);
12966          onToggleY && self.deltaY < 0 !== prevDeltaY < 0 && onToggleY(self);
12967          prevDeltaY = self.deltaY;
12968          deltaY[0] = deltaY[1] = deltaY[2] = 0;
12969        }
12970
12971        if (moved || dragged) {
12972          onMove && onMove(self);
12973
12974          if (dragged) {
12975            onDrag(self);
12976            dragged = false;
12977          }
12978
12979          moved = false;
12980        }
12981
12982        locked && !(locked = false) && onLockAxis && onLockAxis(self);
12983
12984        if (wheeled) {
12985          onWheel(self);
12986          wheeled = false;
12987        }
12988
12989        id = 0;
12990      },
12991          onDelta = function onDelta(x, y, index) {
12992        deltaX[index] += x;
12993        deltaY[index] += y;
12994
12995        self._vx.update(x);
12996
12997        self._vy.update(y);
12998
12999        debounce ? id || (id = requestAnimationFrame(update)) : update();
13000      },
13001          onTouchOrPointerDelta = function onTouchOrPointerDelta(x, y) {
13002        if (lockAxis && !axis) {
13003          self.axis = axis = Math.abs(x) > Math.abs(y) ? "x" : "y";
13004          locked = true;
13005        }
13006
13007        if (axis !== "y") {
13008          deltaX[2] += x;
13009
13010          self._vx.update(x, true);
13011        }
13012
13013        if (axis !== "x") {
13014          deltaY[2] += y;
13015
13016          self._vy.update(y, true);
13017        }
13018
13019        debounce ? id || (id = requestAnimationFrame(update)) : update();
13020      },
13021          _onDrag = function _onDrag(e) {
13022        if (_ignoreCheck(e, 1)) {
13023          return;
13024        }
13025
13026        e = _getEvent(e, preventDefault);
13027        var x = e.clientX,
13028            y = e.clientY,
13029            dx = x - self.x,
13030            dy = y - self.y,
13031            isDragging = self.isDragging;
13032        self.x = x;
13033        self.y = y;
13034
13035        if (isDragging || Math.abs(self.startX - x) >= dragMinimum || Math.abs(self.startY - y) >= dragMinimum) {
13036          onDrag && (dragged = true);
13037          isDragging || (self.isDragging = true);
13038          onTouchOrPointerDelta(dx, dy);
13039          isDragging || onDragStart && onDragStart(self);
13040        }
13041      },
13042          _onPress = self.onPress = function (e) {
13043        if (_ignoreCheck(e, 1) || e && e.button) {
13044          return;
13045        }
13046
13047        self.axis = axis = null;
13048        onStopDelayedCall.pause();
13049        self.isPressed = true;
13050        e = _getEvent(e);
13051        prevDeltaX = prevDeltaY = 0;
13052        self.startX = self.x = e.clientX;
13053        self.startY = self.y = e.clientY;
13054
13055        self._vx.reset();
13056
13057        self._vy.reset();
13058
13059        _addListener$1(isNormalizer ? target : ownerDoc, _eventTypes[1], _onDrag, passive, true);
13060
13061        self.deltaX = self.deltaY = 0;
13062        onPress && onPress(self);
13063      },
13064          _onRelease = self.onRelease = function (e) {
13065        if (_ignoreCheck(e, 1)) {
13066          return;
13067        }
13068
13069        _removeListener$1(isNormalizer ? target : ownerDoc, _eventTypes[1], _onDrag, true);
13070
13071        var isTrackingDrag = !isNaN(self.y - self.startY),
13072            wasDragging = self.isDragging,
13073            isDragNotClick = wasDragging && (Math.abs(self.x - self.startX) > 3 || Math.abs(self.y - self.startY) > 3),
13074            eventData = _getEvent(e);
13075
13076        if (!isDragNotClick && isTrackingDrag) {
13077          self._vx.reset();
13078
13079          self._vy.reset();
13080
13081          if (preventDefault && allowClicks) {
13082            gsap$8.delayedCall(0.08, function () {
13083              if (_getTime$1() - onClickTime > 300 && !e.defaultPrevented) {
13084                if (e.target.click) {
13085                  e.target.click();
13086                } else if (ownerDoc.createEvent) {
13087                  var syntheticEvent = ownerDoc.createEvent("MouseEvents");
13088                  syntheticEvent.initMouseEvent("click", true, true, _win$5, 1, eventData.screenX, eventData.screenY, eventData.clientX, eventData.clientY, false, false, false, false, 0, null);
13089                  e.target.dispatchEvent(syntheticEvent);
13090                }
13091              }
13092            });
13093          }
13094        }
13095
13096        self.isDragging = self.isGesturing = self.isPressed = false;
13097        onStop && wasDragging && !isNormalizer && onStopDelayedCall.restart(true);
13098        onDragEnd && wasDragging && onDragEnd(self);
13099        onRelease && onRelease(self, isDragNotClick);
13100      },
13101          _onGestureStart = function _onGestureStart(e) {
13102        return e.touches && e.touches.length > 1 && (self.isGesturing = true) && onGestureStart(e, self.isDragging);
13103      },
13104          _onGestureEnd = function _onGestureEnd() {
13105        return (self.isGesturing = false) || onGestureEnd(self);
13106      },
13107          onScroll = function onScroll(e) {
13108        if (_ignoreCheck(e)) {
13109          return;
13110        }
13111
13112        var x = scrollFuncX(),
13113            y = scrollFuncY();
13114        onDelta((x - scrollX) * scrollSpeed, (y - scrollY) * scrollSpeed, 1);
13115        scrollX = x;
13116        scrollY = y;
13117        onStop && onStopDelayedCall.restart(true);
13118      },
13119          _onWheel = function _onWheel(e) {
13120        if (_ignoreCheck(e)) {
13121          return;
13122        }
13123
13124        e = _getEvent(e, preventDefault);
13125        onWheel && (wheeled = true);
13126        var multiplier = (e.deltaMode === 1 ? lineHeight : e.deltaMode === 2 ? _win$5.innerHeight : 1) * wheelSpeed;
13127        onDelta(e.deltaX * multiplier, e.deltaY * multiplier, 0);
13128        onStop && !isNormalizer && onStopDelayedCall.restart(true);
13129      },
13130          _onMove = function _onMove(e) {
13131        if (_ignoreCheck(e)) {
13132          return;
13133        }
13134
13135        var x = e.clientX,
13136            y = e.clientY,
13137            dx = x - self.x,
13138            dy = y - self.y;
13139        self.x = x;
13140        self.y = y;
13141        moved = true;
13142        onStop && onStopDelayedCall.restart(true);
13143        (dx || dy) && onTouchOrPointerDelta(dx, dy);
13144      },
13145          _onHover = function _onHover(e) {
13146        self.event = e;
13147        onHover(self);
13148      },
13149          _onHoverEnd = function _onHoverEnd(e) {
13150        self.event = e;
13151        onHoverEnd(self);
13152      },
13153          _onClick = function _onClick(e) {
13154        return _ignoreCheck(e) || _getEvent(e, preventDefault) && onClick(self);
13155      };
13156
13157      onStopDelayedCall = self._dc = gsap$8.delayedCall(onStopDelay || 0.25, onStopFunc).pause();
13158      self.deltaX = self.deltaY = 0;
13159      self._vx = _getVelocityProp(0, 50, true);
13160      self._vy = _getVelocityProp(0, 50, true);
13161      self.scrollX = scrollFuncX;
13162      self.scrollY = scrollFuncY;
13163      self.isDragging = self.isGesturing = self.isPressed = false;
13164
13165      _context$2(this);
13166
13167      self.enable = function (e) {
13168        if (!self.isEnabled) {
13169          _addListener$1(isViewport ? ownerDoc : target, "scroll", _onScroll);
13170
13171          type.indexOf("scroll") >= 0 && _addListener$1(isViewport ? ownerDoc : target, "scroll", onScroll, passive, capture);
13172          type.indexOf("wheel") >= 0 && _addListener$1(target, "wheel", _onWheel, passive, capture);
13173
13174          if (type.indexOf("touch") >= 0 && _isTouch || type.indexOf("pointer") >= 0) {
13175            _addListener$1(target, _eventTypes[0], _onPress, passive, capture);
13176
13177            _addListener$1(ownerDoc, _eventTypes[2], _onRelease);
13178
13179            _addListener$1(ownerDoc, _eventTypes[3], _onRelease);
13180
13181            allowClicks && _addListener$1(target, "click", clickCapture, true, true);
13182            onClick && _addListener$1(target, "click", _onClick);
13183            onGestureStart && _addListener$1(ownerDoc, "gesturestart", _onGestureStart);
13184            onGestureEnd && _addListener$1(ownerDoc, "gestureend", _onGestureEnd);
13185            onHover && _addListener$1(target, _pointerType + "enter", _onHover);
13186            onHoverEnd && _addListener$1(target, _pointerType + "leave", _onHoverEnd);
13187            onMove && _addListener$1(target, _pointerType + "move", _onMove);
13188          }
13189
13190          self.isEnabled = true;
13191          e && e.type && _onPress(e);
13192          onEnable && onEnable(self);
13193        }
13194
13195        return self;
13196      };
13197
13198      self.disable = function () {
13199        if (self.isEnabled) {
13200          _observers.filter(function (o) {
13201            return o !== self && _isViewport(o.target);
13202          }).length || _removeListener$1(isViewport ? ownerDoc : target, "scroll", _onScroll);
13203
13204          if (self.isPressed) {
13205            self._vx.reset();
13206
13207            self._vy.reset();
13208
13209            _removeListener$1(isNormalizer ? target : ownerDoc, _eventTypes[1], _onDrag, true);
13210          }
13211
13212          _removeListener$1(isViewport ? ownerDoc : target, "scroll", onScroll, capture);
13213
13214          _removeListener$1(target, "wheel", _onWheel, capture);
13215
13216          _removeListener$1(target, _eventTypes[0], _onPress, capture);
13217
13218          _removeListener$1(ownerDoc, _eventTypes[2], _onRelease);
13219
13220          _removeListener$1(ownerDoc, _eventTypes[3], _onRelease);
13221
13222          _removeListener$1(target, "click", clickCapture, true);
13223
13224          _removeListener$1(target, "click", _onClick);
13225
13226          _removeListener$1(ownerDoc, "gesturestart", _onGestureStart);
13227
13228          _removeListener$1(ownerDoc, "gestureend", _onGestureEnd);
13229
13230          _removeListener$1(target, _pointerType + "enter", _onHover);
13231
13232          _removeListener$1(target, _pointerType + "leave", _onHoverEnd);
13233
13234          _removeListener$1(target, _pointerType + "move", _onMove);
13235
13236          self.isEnabled = self.isPressed = self.isDragging = false;

vendor: 13,673 bytes, lines 13237-13677

13237          onDisable && onDisable(self);
13238        }
13239      };
13240
13241      self.kill = self.revert = function () {
13242        self.disable();
13243
13244        var i = _observers.indexOf(self);
13245
13246        i >= 0 && _observers.splice(i, 1);
13247        _normalizer === self && (_normalizer = 0);
13248      };
13249
13250      _observers.push(self);
13251
13252      isNormalizer && _isViewport(target) && (_normalizer = self);
13253      self.enable(event);
13254    };
13255
13256    _createClass(Observer, [{
13257      key: "velocityX",
13258      get: function get() {
13259        return this._vx.getVelocity();
13260      }
13261    }, {
13262      key: "velocityY",
13263      get: function get() {
13264        return this._vy.getVelocity();
13265      }
13266    }]);
13267
13268    return Observer;
13269  }();
13270  Observer.version = "3.12.5";
13271
13272  Observer.create = function (vars) {
13273    return new Observer(vars);
13274  };
13275
13276  Observer.register = _initCore$6;
13277
13278  Observer.getAll = function () {
13279    return _observers.slice();
13280  };
13281
13282  Observer.getById = function (id) {
13283    return _observers.filter(function (o) {
13284      return o.vars.id === id;
13285    })[0];
13286  };
13287
13288  _getGSAP$6() && gsap$8.registerPlugin(Observer);
13289
13290  /*!
13291   * PixiPlugin 3.12.5
13292   * https://gsap.com
13293   *
13294   * @license Copyright 2008-2024, GreenSock. All rights reserved.
13295   * Subject to the terms at https://gsap.com/standard-license or for
13296   * Club GSAP members, the agreement issued with that membership.
13297   * @author: Jack Doyle, [email protected]
13298  */
13299  var gsap$9,
13300      _splitColor,
13301      _coreInitted$6,
13302      _PIXI,
13303      PropTween$2,
13304      _getSetter$1,
13305      _isV4,
13306      _windowExists$5 = function _windowExists() {
13307    return typeof window !== "undefined";
13308  },
13309      _getGSAP$7 = function _getGSAP() {
13310    return gsap$9 || _windowExists$5() && (gsap$9 = window.gsap) && gsap$9.registerPlugin && gsap$9;
13311  },
13312      _isFunction$2 = function _isFunction(value) {
13313    return typeof value === "function";
13314  },
13315      _warn$2 = function _warn(message) {
13316    return console.warn(message);
13317  },
13318      _idMatrix$1 = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0],
13319      _lumR$1 = 0.212671,
13320      _lumG$1 = 0.715160,
13321      _lumB$1 = 0.072169,
13322      _filterClass = function _filterClass(name) {
13323    return _isFunction$2(_PIXI[name]) ? _PIXI[name] : _PIXI.filters[name];
13324  },
13325      _applyMatrix$1 = function _applyMatrix(m, m2) {
13326    var temp = [],
13327        i = 0,
13328        z = 0,
13329        y,
13330        x;
13331
13332    for (y = 0; y < 4; y++) {
13333      for (x = 0; x < 5; x++) {
13334        z = x === 4 ? m[i + 4] : 0;
13335        temp[i + x] = m[i] * m2[x] + m[i + 1] * m2[x + 5] + m[i + 2] * m2[x + 10] + m[i + 3] * m2[x + 15] + z;
13336      }
13337
13338      i += 5;
13339    }
13340
13341    return temp;
13342  },
13343      _setSaturation$1 = function _setSaturation(m, n) {
13344    var inv = 1 - n,
13345        r = inv * _lumR$1,
13346        g = inv * _lumG$1,
13347        b = inv * _lumB$1;
13348    return _applyMatrix$1([r + n, g, b, 0, 0, r, g + n, b, 0, 0, r, g, b + n, 0, 0, 0, 0, 0, 1, 0], m);
13349  },
13350      _colorize$1 = function _colorize(m, color, amount) {
13351    var c = _splitColor(color),
13352        r = c[0] / 255,
13353        g = c[1] / 255,
13354        b = c[2] / 255,
13355        inv = 1 - amount;
13356
13357    return _applyMatrix$1([inv + amount * r * _lumR$1, amount * r * _lumG$1, amount * r * _lumB$1, 0, 0, amount * g * _lumR$1, inv + amount * g * _lumG$1, amount * g * _lumB$1, 0, 0, amount * b * _lumR$1, amount * b * _lumG$1, inv + amount * b * _lumB$1, 0, 0, 0, 0, 0, 1, 0], m);
13358  },
13359      _setHue$1 = function _setHue(m, n) {
13360    n *= Math.PI / 180;
13361    var c = Math.cos(n),
13362        s = Math.sin(n);
13363    return _applyMatrix$1([_lumR$1 + c * (1 - _lumR$1) + s * -_lumR$1, _lumG$1 + c * -_lumG$1 + s * -_lumG$1, _lumB$1 + c * -_lumB$1 + s * (1 - _lumB$1), 0, 0, _lumR$1 + c * -_lumR$1 + s * 0.143, _lumG$1 + c * (1 - _lumG$1) + s * 0.14, _lumB$1 + c * -_lumB$1 + s * -0.283, 0, 0, _lumR$1 + c * -_lumR$1 + s * -(1 - _lumR$1), _lumG$1 + c * -_lumG$1 + s * _lumG$1, _lumB$1 + c * (1 - _lumB$1) + s * _lumB$1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1], m);
13364  },
13365      _setContrast$1 = function _setContrast(m, n) {
13366    return _applyMatrix$1([n, 0, 0, 0, 0.5 * (1 - n), 0, n, 0, 0, 0.5 * (1 - n), 0, 0, n, 0, 0.5 * (1 - n), 0, 0, 0, 1, 0], m);
13367  },
13368      _getFilter = function _getFilter(target, type) {
13369    var filterClass = _filterClass(type),
13370        filters = target.filters || [],
13371        i = filters.length,
13372        filter;
13373
13374    filterClass || _warn$2(type + " not found. PixiPlugin.registerPIXI(PIXI)");
13375
13376    while (--i > -1) {
13377      if (filters[i] instanceof filterClass) {
13378        return filters[i];
13379      }
13380    }
13381
13382    filter = new filterClass();
13383
13384    if (type === "BlurFilter") {
13385      filter.blur = 0;
13386    }
13387
13388    filters.push(filter);
13389    target.filters = filters;
13390    return filter;
13391  },
13392      _addColorMatrixFilterCacheTween = function _addColorMatrixFilterCacheTween(p, plugin, cache, vars) {
13393    plugin.add(cache, p, cache[p], vars[p]);
13394
13395    plugin._props.push(p);
13396  },
13397      _applyBrightnessToMatrix = function _applyBrightnessToMatrix(brightness, matrix) {
13398    var filterClass = _filterClass("ColorMatrixFilter"),
13399        temp = new filterClass();
13400
13401    temp.matrix = matrix;
13402    temp.brightness(brightness, true);
13403    return temp.matrix;
13404  },
13405      _copy$2 = function _copy(obj) {
13406    var copy = {},
13407        p;
13408
13409    for (p in obj) {
13410      copy[p] = obj[p];
13411    }
13412
13413    return copy;
13414  },
13415      _CMFdefaults = {
13416    contrast: 1,
13417    saturation: 1,
13418    colorizeAmount: 0,
13419    colorize: "rgb(255,255,255)",
13420    hue: 0,
13421    brightness: 1
13422  },
13423      _parseColorMatrixFilter$1 = function _parseColorMatrixFilter(target, v, pg) {
13424    var filter = _getFilter(target, "ColorMatrixFilter"),
13425        cache = target._gsColorMatrixFilter = target._gsColorMatrixFilter || _copy$2(_CMFdefaults),
13426        combine = v.combineCMF && !("colorMatrixFilter" in v && !v.colorMatrixFilter),
13427        i,
13428        matrix,
13429        startMatrix;
13430
13431    startMatrix = filter.matrix;
13432
13433    if (v.resolution) {
13434      filter.resolution = v.resolution;
13435    }
13436
13437    if (v.matrix && v.matrix.length === startMatrix.length) {
13438      matrix = v.matrix;
13439
13440      if (cache.contrast !== 1) {
13441        _addColorMatrixFilterCacheTween("contrast", pg, cache, _CMFdefaults);
13442      }
13443
13444      if (cache.hue) {
13445        _addColorMatrixFilterCacheTween("hue", pg, cache, _CMFdefaults);
13446      }
13447
13448      if (cache.brightness !== 1) {
13449        _addColorMatrixFilterCacheTween("brightness", pg, cache, _CMFdefaults);
13450      }
13451
13452      if (cache.colorizeAmount) {
13453        _addColorMatrixFilterCacheTween("colorize", pg, cache, _CMFdefaults);
13454
13455        _addColorMatrixFilterCacheTween("colorizeAmount", pg, cache, _CMFdefaults);
13456      }
13457
13458      if (cache.saturation !== 1) {
13459        _addColorMatrixFilterCacheTween("saturation", pg, cache, _CMFdefaults);
13460      }
13461    } else {
13462      matrix = _idMatrix$1.slice();
13463
13464      if (v.contrast != null) {
13465        matrix = _setContrast$1(matrix, +v.contrast);
13466
13467        _addColorMatrixFilterCacheTween("contrast", pg, cache, v);
13468      } else if (cache.contrast !== 1) {
13469        if (combine) {
13470          matrix = _setContrast$1(matrix, cache.contrast);
13471        } else {
13472          _addColorMatrixFilterCacheTween("contrast", pg, cache, _CMFdefaults);
13473        }
13474      }
13475
13476      if (v.hue != null) {
13477        matrix = _setHue$1(matrix, +v.hue);
13478
13479        _addColorMatrixFilterCacheTween("hue", pg, cache, v);
13480      } else if (cache.hue) {
13481        if (combine) {
13482          matrix = _setHue$1(matrix, cache.hue);
13483        } else {
13484          _addColorMatrixFilterCacheTween("hue", pg, cache, _CMFdefaults);
13485        }
13486      }
13487
13488      if (v.brightness != null) {
13489        matrix = _applyBrightnessToMatrix(+v.brightness, matrix);
13490
13491        _addColorMatrixFilterCacheTween("brightness", pg, cache, v);
13492      } else if (cache.brightness !== 1) {
13493        if (combine) {
13494          matrix = _applyBrightnessToMatrix(cache.brightness, matrix);
13495        } else {
13496          _addColorMatrixFilterCacheTween("brightness", pg, cache, _CMFdefaults);
13497        }
13498      }
13499
13500      if (v.colorize != null) {
13501        v.colorizeAmount = "colorizeAmount" in v ? +v.colorizeAmount : 1;
13502        matrix = _colorize$1(matrix, v.colorize, v.colorizeAmount);
13503
13504        _addColorMatrixFilterCacheTween("colorize", pg, cache, v);
13505
13506        _addColorMatrixFilterCacheTween("colorizeAmount", pg, cache, v);
13507      } else if (cache.colorizeAmount) {
13508        if (combine) {
13509          matrix = _colorize$1(matrix, cache.colorize, cache.colorizeAmount);
13510        } else {
13511          _addColorMatrixFilterCacheTween("colorize", pg, cache, _CMFdefaults);
13512
13513          _addColorMatrixFilterCacheTween("colorizeAmount", pg, cache, _CMFdefaults);
13514        }
13515      }
13516
13517      if (v.saturation != null) {
13518        matrix = _setSaturation$1(matrix, +v.saturation);
13519
13520        _addColorMatrixFilterCacheTween("saturation", pg, cache, v);
13521      } else if (cache.saturation !== 1) {
13522        if (combine) {
13523          matrix = _setSaturation$1(matrix, cache.saturation);
13524        } else {
13525          _addColorMatrixFilterCacheTween("saturation", pg, cache, _CMFdefaults);
13526        }
13527      }
13528    }
13529
13530    i = matrix.length;
13531
13532    while (--i > -1) {
13533      if (matrix[i] !== startMatrix[i]) {
13534        pg.add(startMatrix, i, startMatrix[i], matrix[i], "colorMatrixFilter");
13535      }
13536    }
13537
13538    pg._props.push("colorMatrixFilter");
13539  },
13540      _renderColor = function _renderColor(ratio, _ref) {
13541    var t = _ref.t,
13542        p = _ref.p,
13543        color = _ref.color,
13544        set = _ref.set;
13545    set(t, p, color[0] << 16 | color[1] << 8 | color[2]);
13546  },
13547      _renderDirtyCache = function _renderDirtyCache(ratio, _ref2) {
13548    var g = _ref2.g;
13549
13550    if (g) {
13551      g.dirty++;
13552      g.clearDirty++;
13553    }
13554  },
13555      _renderAutoAlpha = function _renderAutoAlpha(ratio, data) {
13556    data.t.visible = !!data.t.alpha;
13557  },
13558      _addColorTween = function _addColorTween(target, p, value, plugin) {
13559    var currentValue = target[p],
13560        startColor = _splitColor(_isFunction$2(currentValue) ? target[p.indexOf("set") || !_isFunction$2(target["get" + p.substr(3)]) ? p : "get" + p.substr(3)]() : currentValue),
13561        endColor = _splitColor(value);
13562
13563    plugin._pt = new PropTween$2(plugin._pt, target, p, 0, 0, _renderColor, {
13564      t: target,
13565      p: p,
13566      color: startColor,
13567      set: _getSetter$1(target, p)
13568    });
13569    plugin.add(startColor, 0, startColor[0], endColor[0]);
13570    plugin.add(startColor, 1, startColor[1], endColor[1]);
13571    plugin.add(startColor, 2, startColor[2], endColor[2]);
13572  },
13573      _colorProps$1 = {
13574    tint: 1,
13575    lineColor: 1,
13576    fillColor: 1
13577  },
13578      _xyContexts = "position,scale,skew,pivot,anchor,tilePosition,tileScale".split(","),
13579      _contexts = {
13580    x: "position",
13581    y: "position",
13582    tileX: "tilePosition",
13583    tileY: "tilePosition"
13584  },
13585      _colorMatrixFilterProps = {
13586    colorMatrixFilter: 1,
13587    saturation: 1,
13588    contrast: 1,
13589    hue: 1,
13590    colorize: 1,
13591    colorizeAmount: 1,
13592    brightness: 1,
13593    combineCMF: 1
13594  },
13595      _DEG2RAD$4 = Math.PI / 180,
13596      _isString$2 = function _isString(value) {
13597    return typeof value === "string";
13598  },
13599      _degreesToRadians = function _degreesToRadians(value) {
13600    return _isString$2(value) && value.charAt(1) === "=" ? value.substr(0, 2) + parseFloat(value.substr(2)) * _DEG2RAD$4 : value * _DEG2RAD$4;
13601  },
13602      _renderPropWithEnd$1 = function _renderPropWithEnd(ratio, data) {
13603    return data.set(data.t, data.p, ratio === 1 ? data.e : Math.round((data.s + data.c * ratio) * 100000) / 100000, data);
13604  },
13605      _addRotationalPropTween$1 = function _addRotationalPropTween(plugin, target, property, startNum, endValue, radians) {
13606    var cap = 360 * (radians ? _DEG2RAD$4 : 1),
13607        isString = _isString$2(endValue),
13608        relative = isString && endValue.charAt(1) === "=" ? +(endValue.charAt(0) + "1") : 0,
13609        endNum = parseFloat(relative ? endValue.substr(2) : endValue) * (radians ? _DEG2RAD$4 : 1),
13610        change = relative ? endNum * relative : endNum - startNum,
13611        finalValue = startNum + change,
13612        direction,
13613        pt;
13614
13615    if (isString) {
13616      direction = endValue.split("_")[1];
13617
13618      if (direction === "short") {
13619        change %= cap;
13620
13621        if (change !== change % (cap / 2)) {
13622          change += change < 0 ? cap : -cap;
13623        }
13624      }
13625
13626      if (direction === "cw" && change < 0) {
13627        change = (change + cap * 1e10) % cap - ~~(change / cap) * cap;
13628      } else if (direction === "ccw" && change > 0) {
13629        change = (change - cap * 1e10) % cap - ~~(change / cap) * cap;
13630      }
13631    }
13632
13633    plugin._pt = pt = new PropTween$2(plugin._pt, target, property, startNum, change, _renderPropWithEnd$1);
13634    pt.e = finalValue;
13635    return pt;
13636  },
13637      _initCore$7 = function _initCore() {
13638    if (!_coreInitted$6) {
13639      gsap$9 = _getGSAP$7();
13640      _PIXI = _coreInitted$6 = _PIXI || _windowExists$5() && window.PIXI;
13641      _isV4 = _PIXI && _PIXI.VERSION && _PIXI.VERSION.charAt(0) === "4";
13642
13643      _splitColor = function _splitColor(color) {
13644        return gsap$9.utils.splitColor((color + "").substr(0, 2) === "0x" ? "#" + color.substr(2) : color);
13645      };
13646    }
13647  },
13648      i,
13649      p$1;
13650
13651  for (i = 0; i < _xyContexts.length; i++) {
13652    p$1 = _xyContexts[i];
13653    _contexts[p$1 + "X"] = p$1;
13654    _contexts[p$1 + "Y"] = p$1;
13655  }
13656
13657  var PixiPlugin = {
13658    version: "3.12.5",
13659    name: "pixi",
13660    register: function register(core, Plugin, propTween) {
13661      gsap$9 = core;
13662      PropTween$2 = propTween;
13663      _getSetter$1 = Plugin.getSetter;
13664
13665      _initCore$7();
13666    },
13667    headless: true,
13668    registerPIXI: function registerPIXI(pixi) {
13669      _PIXI = pixi;
13670    },
13671    init: function init(target, values, tween, index, targets) {
13672      _PIXI || _initCore$7();
13673
13674      if (!_PIXI) {
13675        _warn$2("PIXI was not found. PixiPlugin.registerPIXI(PIXI);");
13676
13677        return false;

vendor: 2,279 bytes, lines 13678-13729

13678      }
13679
13680      var context, axis, value, colorMatrix, filter, p, padding, i, data;
13681
13682      for (p in values) {
13683        context = _contexts[p];
13684        value = values[p];
13685
13686        if (context) {
13687          axis = ~p.charAt(p.length - 1).toLowerCase().indexOf("x") ? "x" : "y";
13688          this.add(target[context], axis, target[context][axis], context === "skew" ? _degreesToRadians(value) : value, 0, 0, 0, 0, 0, 1);
13689        } else if (p === "scale" || p === "anchor" || p === "pivot" || p === "tileScale") {
13690          this.add(target[p], "x", target[p].x, value);
13691          this.add(target[p], "y", target[p].y, value);
13692        } else if (p === "rotation" || p === "angle") {
13693          _addRotationalPropTween$1(this, target, p, target[p], value, p === "rotation");
13694        } else if (_colorMatrixFilterProps[p]) {
13695          if (!colorMatrix) {
13696            _parseColorMatrixFilter$1(target, values.colorMatrixFilter || values, this);
13697
13698            colorMatrix = true;
13699          }
13700        } else if (p === "blur" || p === "blurX" || p === "blurY" || p === "blurPadding") {
13701          filter = _getFilter(target, "BlurFilter");
13702          this.add(filter, p, filter[p], value);
13703
13704          if (values.blurPadding !== 0) {
13705            padding = values.blurPadding || Math.max(filter[p], value) * 2;
13706            i = target.filters.length;
13707
13708            while (--i > -1) {
13709              target.filters[i].padding = Math.max(target.filters[i].padding, padding);
13710            }
13711          }
13712        } else if (_colorProps$1[p]) {
13713          if ((p === "lineColor" || p === "fillColor") && target instanceof _PIXI.Graphics) {
13714            data = (target.geometry || target).graphicsData;
13715            this._pt = new PropTween$2(this._pt, target, p, 0, 0, _renderDirtyCache, {
13716              g: target.geometry || target
13717            });
13718            i = data.length;
13719
13720            while (--i > -1) {
13721              _addColorTween(_isV4 ? data[i] : data[i][p.substr(0, 4) + "Style"], _isV4 ? p : "color", value, this);
13722            }
13723          } else {
13724            _addColorTween(target, p, value, this);
13725          }
13726        } else if (p === "autoAlpha") {
13727          this._pt = new PropTween$2(this._pt, target, "visible", 0, 0, _renderAutoAlpha);
13728          this.add(target, "alpha", target.alpha, value);
13729

vendor: 12,467 bytes, lines 13730-14122

13730          this._props.push("alpha", "visible");
13731        } else if (p !== "resolution") {
13732          this.add(target, p, "get", value);
13733        }
13734
13735        this._props.push(p);
13736      }
13737    }
13738  };
13739  _getGSAP$7() && gsap$9.registerPlugin(PixiPlugin);
13740
13741  /*!
13742   * ScrollToPlugin 3.12.5
13743   * https://gsap.com
13744   *
13745   * @license Copyright 2008-2024, GreenSock. All rights reserved.
13746   * Subject to the terms at https://gsap.com/standard-license or for
13747   * Club GSAP members, the agreement issued with that membership.
13748   * @author: Jack Doyle, [email protected]
13749  */
13750  var gsap$a,
13751      _coreInitted$7,
13752      _window,
13753      _docEl$1,
13754      _body$4,
13755      _toArray$3,
13756      _config$1,
13757      ScrollTrigger$1,
13758      _windowExists$6 = function _windowExists() {
13759    return typeof window !== "undefined";
13760  },
13761      _getGSAP$8 = function _getGSAP() {
13762    return gsap$a || _windowExists$6() && (gsap$a = window.gsap) && gsap$a.registerPlugin && gsap$a;
13763  },
13764      _isString$3 = function _isString(value) {
13765    return typeof value === "string";
13766  },
13767      _isFunction$3 = function _isFunction(value) {
13768    return typeof value === "function";
13769  },
13770      _max = function _max(element, axis) {
13771    var dim = axis === "x" ? "Width" : "Height",
13772        scroll = "scroll" + dim,
13773        client = "client" + dim;
13774    return element === _window || element === _docEl$1 || element === _body$4 ? Math.max(_docEl$1[scroll], _body$4[scroll]) - (_window["inner" + dim] || _docEl$1[client] || _body$4[client]) : element[scroll] - element["offset" + dim];
13775  },
13776      _buildGetter = function _buildGetter(e, axis) {
13777    var p = "scroll" + (axis === "x" ? "Left" : "Top");
13778
13779    if (e === _window) {
13780      if (e.pageXOffset != null) {
13781        p = "page" + axis.toUpperCase() + "Offset";
13782      } else {
13783        e = _docEl$1[p] != null ? _docEl$1 : _body$4;
13784      }
13785    }
13786
13787    return function () {
13788      return e[p];
13789    };
13790  },
13791      _clean = function _clean(value, index, target, targets) {
13792    _isFunction$3(value) && (value = value(index, target, targets));
13793
13794    if (typeof value !== "object") {
13795      return _isString$3(value) && value !== "max" && value.charAt(1) !== "=" ? {
13796        x: value,
13797        y: value
13798      } : {
13799        y: value
13800      };
13801    } else if (value.nodeType) {
13802      return {
13803        y: value,
13804        x: value
13805      };
13806    } else {
13807      var result = {},
13808          p;
13809
13810      for (p in value) {
13811        result[p] = p !== "onAutoKill" && _isFunction$3(value[p]) ? value[p](index, target, targets) : value[p];
13812      }
13813
13814      return result;
13815    }
13816  },
13817      _getOffset = function _getOffset(element, container) {
13818    element = _toArray$3(element)[0];
13819
13820    if (!element || !element.getBoundingClientRect) {
13821      return console.warn("scrollTo target doesn't exist. Using 0") || {
13822        x: 0,
13823        y: 0
13824      };
13825    }
13826
13827    var rect = element.getBoundingClientRect(),
13828        isRoot = !container || container === _window || container === _body$4,
13829        cRect = isRoot ? {
13830      top: _docEl$1.clientTop - (_window.pageYOffset || _docEl$1.scrollTop || _body$4.scrollTop || 0),
13831      left: _docEl$1.clientLeft - (_window.pageXOffset || _docEl$1.scrollLeft || _body$4.scrollLeft || 0)
13832    } : container.getBoundingClientRect(),
13833        offsets = {
13834      x: rect.left - cRect.left,
13835      y: rect.top - cRect.top
13836    };
13837
13838    if (!isRoot && container) {
13839      offsets.x += _buildGetter(container, "x")();
13840      offsets.y += _buildGetter(container, "y")();
13841    }
13842
13843    return offsets;
13844  },
13845      _parseVal = function _parseVal(value, target, axis, currentVal, offset) {
13846    return !isNaN(value) && typeof value !== "object" ? parseFloat(value) - offset : _isString$3(value) && value.charAt(1) === "=" ? parseFloat(value.substr(2)) * (value.charAt(0) === "-" ? -1 : 1) + currentVal - offset : value === "max" ? _max(target, axis) - offset : Math.min(_max(target, axis), _getOffset(value, target)[axis] - offset);
13847  },
13848      _initCore$8 = function _initCore() {
13849    gsap$a = _getGSAP$8();
13850
13851    if (_windowExists$6() && gsap$a && typeof document !== "undefined" && document.body) {
13852      _window = window;
13853      _body$4 = document.body;
13854      _docEl$1 = document.documentElement;
13855      _toArray$3 = gsap$a.utils.toArray;
13856      gsap$a.config({
13857        autoKillThreshold: 7
13858      });
13859      _config$1 = gsap$a.config();
13860      _coreInitted$7 = 1;
13861    }
13862  };
13863
13864  var ScrollToPlugin = {
13865    version: "3.12.5",
13866    name: "scrollTo",
13867    rawVars: 1,
13868    register: function register(core) {
13869      gsap$a = core;
13870
13871      _initCore$8();
13872    },
13873    init: function init(target, value, tween, index, targets) {
13874      _coreInitted$7 || _initCore$8();
13875      var data = this,
13876          snapType = gsap$a.getProperty(target, "scrollSnapType");
13877      data.isWin = target === _window;
13878      data.target = target;
13879      data.tween = tween;
13880      value = _clean(value, index, target, targets);
13881      data.vars = value;
13882      data.autoKill = !!value.autoKill;
13883      data.getX = _buildGetter(target, "x");
13884      data.getY = _buildGetter(target, "y");
13885      data.x = data.xPrev = data.getX();
13886      data.y = data.yPrev = data.getY();
13887      ScrollTrigger$1 || (ScrollTrigger$1 = gsap$a.core.globals().ScrollTrigger);
13888      gsap$a.getProperty(target, "scrollBehavior") === "smooth" && gsap$a.set(target, {
13889        scrollBehavior: "auto"
13890      });
13891
13892      if (snapType && snapType !== "none") {
13893        data.snap = 1;
13894        data.snapInline = target.style.scrollSnapType;
13895        target.style.scrollSnapType = "none";
13896      }
13897
13898      if (value.x != null) {
13899        data.add(data, "x", data.x, _parseVal(value.x, target, "x", data.x, value.offsetX || 0), index, targets);
13900
13901        data._props.push("scrollTo_x");
13902      } else {
13903        data.skipX = 1;
13904      }
13905
13906      if (value.y != null) {
13907        data.add(data, "y", data.y, _parseVal(value.y, target, "y", data.y, value.offsetY || 0), index, targets);
13908
13909        data._props.push("scrollTo_y");
13910      } else {
13911        data.skipY = 1;
13912      }
13913    },
13914    render: function render(ratio, data) {
13915      var pt = data._pt,
13916          target = data.target,
13917          tween = data.tween,
13918          autoKill = data.autoKill,
13919          xPrev = data.xPrev,
13920          yPrev = data.yPrev,
13921          isWin = data.isWin,
13922          snap = data.snap,
13923          snapInline = data.snapInline,
13924          x,
13925          y,
13926          yDif,
13927          xDif,
13928          threshold;
13929
13930      while (pt) {
13931        pt.r(ratio, pt.d);
13932        pt = pt._next;
13933      }
13934
13935      x = isWin || !data.skipX ? data.getX() : xPrev;
13936      y = isWin || !data.skipY ? data.getY() : yPrev;
13937      yDif = y - yPrev;
13938      xDif = x - xPrev;
13939      threshold = _config$1.autoKillThreshold;
13940
13941      if (data.x < 0) {
13942        data.x = 0;
13943      }
13944
13945      if (data.y < 0) {
13946        data.y = 0;
13947      }
13948
13949      if (autoKill) {
13950        if (!data.skipX && (xDif > threshold || xDif < -threshold) && x < _max(target, "x")) {
13951          data.skipX = 1;
13952        }
13953
13954        if (!data.skipY && (yDif > threshold || yDif < -threshold) && y < _max(target, "y")) {
13955          data.skipY = 1;
13956        }
13957
13958        if (data.skipX && data.skipY) {
13959          tween.kill();
13960          data.vars.onAutoKill && data.vars.onAutoKill.apply(tween, data.vars.onAutoKillParams || []);
13961        }
13962      }
13963
13964      if (isWin) {
13965        _window.scrollTo(!data.skipX ? data.x : x, !data.skipY ? data.y : y);
13966      } else {
13967        data.skipY || (target.scrollTop = data.y);
13968        data.skipX || (target.scrollLeft = data.x);
13969      }
13970
13971      if (snap && (ratio === 1 || ratio === 0)) {
13972        y = target.scrollTop;
13973        x = target.scrollLeft;
13974        snapInline ? target.style.scrollSnapType = snapInline : target.style.removeProperty("scroll-snap-type");
13975        target.scrollTop = y + 1;
13976        target.scrollLeft = x + 1;
13977        target.scrollTop = y;
13978        target.scrollLeft = x;
13979      }
13980
13981      data.xPrev = data.x;
13982      data.yPrev = data.y;
13983      ScrollTrigger$1 && ScrollTrigger$1.update();
13984    },
13985    kill: function kill(property) {
13986      var both = property === "scrollTo",
13987          i = this._props.indexOf(property);
13988
13989      if (both || property === "scrollTo_x") {
13990        this.skipX = 1;
13991      }
13992
13993      if (both || property === "scrollTo_y") {
13994        this.skipY = 1;
13995      }
13996
13997      i > -1 && this._props.splice(i, 1);
13998      return !this._props.length;
13999    }
14000  };
14001  ScrollToPlugin.max = _max;
14002  ScrollToPlugin.getOffset = _getOffset;
14003  ScrollToPlugin.buildGetter = _buildGetter;
14004  _getGSAP$8() && gsap$a.registerPlugin(ScrollToPlugin);
14005
14006  /*!
14007   * ScrollTrigger 3.12.5
14008   * https://gsap.com
14009   *
14010   * @license Copyright 2008-2024, GreenSock. All rights reserved.
14011   * Subject to the terms at https://gsap.com/standard-license or for
14012   * Club GSAP members, the agreement issued with that membership.
14013   * @author: Jack Doyle, [email protected]
14014  */
14015
14016  var gsap$b,
14017      _coreInitted$8,
14018      _win$6,
14019      _doc$6,
14020      _docEl$2,
14021      _body$5,
14022      _root$1,
14023      _resizeDelay,
14024      _toArray$4,
14025      _clamp$2,
14026      _time2,
14027      _syncInterval,
14028      _refreshing,
14029      _pointerIsDown,
14030      _transformProp$3,
14031      _i,
14032      _prevWidth,
14033      _prevHeight,
14034      _autoRefresh,
14035      _sort,
14036      _suppressOverwrites$1,
14037      _ignoreResize,
14038      _normalizer$1,
14039      _ignoreMobileResize,
14040      _baseScreenHeight,
14041      _baseScreenWidth,
14042      _fixIOSBug,
14043      _context$3,
14044      _scrollRestoration,
14045      _div100vh,
14046      _100vh,
14047      _isReverted,
14048      _clampingMax,
14049      _limitCallbacks,
14050      _startup$1 = 1,
14051      _getTime$2 = Date.now,
14052      _time1 = _getTime$2(),
14053      _lastScrollTime = 0,
14054      _enabled = 0,
14055      _parseClamp = function _parseClamp(value, type, self) {
14056    var clamp = _isString$4(value) && (value.substr(0, 6) === "clamp(" || value.indexOf("max") > -1);
14057    self["_" + type + "Clamp"] = clamp;
14058    return clamp ? value.substr(6, value.length - 7) : value;
14059  },
14060      _keepClamp = function _keepClamp(value, clamp) {
14061    return clamp && (!_isString$4(value) || value.substr(0, 6) !== "clamp(") ? "clamp(" + value + ")" : value;
14062  },
14063      _rafBugFix = function _rafBugFix() {
14064    return _enabled && requestAnimationFrame(_rafBugFix);
14065  },
14066      _pointerDownHandler = function _pointerDownHandler() {
14067    return _pointerIsDown = 1;
14068  },
14069      _pointerUpHandler = function _pointerUpHandler() {
14070    return _pointerIsDown = 0;
14071  },
14072      _passThrough$1 = function _passThrough(v) {
14073    return v;
14074  },
14075      _round$5 = function _round(value) {
14076    return Math.round(value * 100000) / 100000 || 0;
14077  },
14078      _windowExists$7 = function _windowExists() {
14079    return typeof window !== "undefined";
14080  },
14081      _getGSAP$9 = function _getGSAP() {
14082    return gsap$b || _windowExists$7() && (gsap$b = window.gsap) && gsap$b.registerPlugin && gsap$b;
14083  },
14084      _isViewport$1 = function _isViewport(e) {
14085    return !!~_root$1.indexOf(e);
14086  },
14087      _getViewportDimension = function _getViewportDimension(dimensionProperty) {
14088    return (dimensionProperty === "Height" ? _100vh : _win$6["inner" + dimensionProperty]) || _docEl$2["client" + dimensionProperty] || _body$5["client" + dimensionProperty];
14089  },
14090      _getBoundsFunc = function _getBoundsFunc(element) {
14091    return _getProxyProp(element, "getBoundingClientRect") || (_isViewport$1(element) ? function () {
14092      _winOffsets.width = _win$6.innerWidth;
14093      _winOffsets.height = _100vh;
14094      return _winOffsets;
14095    } : function () {
14096      return _getBounds$1(element);
14097    });
14098  },
14099      _getSizeFunc = function _getSizeFunc(scroller, isViewport, _ref) {
14100    var d = _ref.d,
14101        d2 = _ref.d2,
14102        a = _ref.a;
14103    return (a = _getProxyProp(scroller, "getBoundingClientRect")) ? function () {
14104      return a()[d];
14105    } : function () {
14106      return (isViewport ? _getViewportDimension(d2) : scroller["client" + d2]) || 0;
14107    };
14108  },
14109      _getOffsetsFunc = function _getOffsetsFunc(element, isViewport) {
14110    return !isViewport || ~exports._proxies.indexOf(element) ? _getBoundsFunc(element) : function () {
14111      return _winOffsets;
14112    };
14113  },
14114      _maxScroll = function _maxScroll(element, _ref2) {
14115    var s = _ref2.s,
14116        d2 = _ref2.d2,
14117        d = _ref2.d,
14118        a = _ref2.a;
14119    return Math.max(0, (s = "scroll" + d2) && (a = _getProxyProp(element, s)) ? a() - _getBoundsFunc(element)()[d] : _isViewport$1(element) ? (_docEl$2[s] || _body$5[s]) - _getViewportDimension(d2) : element[s] - element["offset" + d2]);
14120  },
14121      _iterateAutoRefresh = function _iterateAutoRefresh(func, events) {
14122    for (var i = 0; i < _autoRefresh.length; i += 3) {

vendor: 7,264 bytes, lines 14123-14342

14123      (!events || ~events.indexOf(_autoRefresh[i + 1])) && func(_autoRefresh[i], _autoRefresh[i + 1], _autoRefresh[i + 2]);
14124    }
14125  },
14126      _isString$4 = function _isString(value) {
14127    return typeof value === "string";
14128  },
14129      _isFunction$4 = function _isFunction(value) {
14130    return typeof value === "function";
14131  },
14132      _isNumber$2 = function _isNumber(value) {
14133    return typeof value === "number";
14134  },
14135      _isObject$2 = function _isObject(value) {
14136    return typeof value === "object";
14137  },
14138      _endAnimation = function _endAnimation(animation, reversed, pause) {
14139    return animation && animation.progress(reversed ? 0 : 1) && pause && animation.pause();
14140  },
14141      _callback$1 = function _callback(self, func) {
14142    if (self.enabled) {
14143      var result = self._ctx ? self._ctx.add(function () {
14144        return func(self);
14145      }) : func(self);
14146      result && result.totalTime && (self.callbackAnimation = result);
14147    }
14148  },
14149      _abs$1 = Math.abs,
14150      _left = "left",
14151      _top = "top",
14152      _right = "right",
14153      _bottom = "bottom",
14154      _width = "width",
14155      _height = "height",
14156      _Right = "Right",
14157      _Left = "Left",
14158      _Top = "Top",
14159      _Bottom = "Bottom",
14160      _padding = "padding",
14161      _margin = "margin",
14162      _Width = "Width",
14163      _Height = "Height",
14164      _px = "px",
14165      _getComputedStyle$1 = function _getComputedStyle(element) {
14166    return _win$6.getComputedStyle(element);
14167  },
14168      _makePositionable = function _makePositionable(element) {
14169    var position = _getComputedStyle$1(element).position;
14170
14171    element.style.position = position === "absolute" || position === "fixed" ? position : "relative";
14172  },
14173      _setDefaults$2 = function _setDefaults(obj, defaults) {
14174    for (var p in defaults) {
14175      p in obj || (obj[p] = defaults[p]);
14176    }
14177
14178    return obj;
14179  },
14180      _getBounds$1 = function _getBounds(element, withoutTransforms) {
14181    var tween = withoutTransforms && _getComputedStyle$1(element)[_transformProp$3] !== "matrix(1, 0, 0, 1, 0, 0)" && gsap$b.to(element, {
14182      x: 0,
14183      y: 0,
14184      xPercent: 0,
14185      yPercent: 0,
14186      rotation: 0,
14187      rotationX: 0,
14188      rotationY: 0,
14189      scale: 1,
14190      skewX: 0,
14191      skewY: 0
14192    }).progress(1),
14193        bounds = element.getBoundingClientRect();
14194    tween && tween.progress(0).kill();
14195    return bounds;
14196  },
14197      _getSize = function _getSize(element, _ref3) {
14198    var d2 = _ref3.d2;
14199    return element["offset" + d2] || element["client" + d2] || 0;
14200  },
14201      _getLabelRatioArray = function _getLabelRatioArray(timeline) {
14202    var a = [],
14203        labels = timeline.labels,
14204        duration = timeline.duration(),
14205        p;
14206
14207    for (p in labels) {
14208      a.push(labels[p] / duration);
14209    }
14210
14211    return a;
14212  },
14213      _getClosestLabel = function _getClosestLabel(animation) {
14214    return function (value) {
14215      return gsap$b.utils.snap(_getLabelRatioArray(animation), value);
14216    };
14217  },
14218      _snapDirectional = function _snapDirectional(snapIncrementOrArray) {
14219    var snap = gsap$b.utils.snap(snapIncrementOrArray),
14220        a = Array.isArray(snapIncrementOrArray) && snapIncrementOrArray.slice(0).sort(function (a, b) {
14221      return a - b;
14222    });
14223    return a ? function (value, direction, threshold) {
14224      if (threshold === void 0) {
14225        threshold = 1e-3;
14226      }
14227
14228      var i;
14229
14230      if (!direction) {
14231        return snap(value);
14232      }
14233
14234      if (direction > 0) {
14235        value -= threshold;
14236
14237        for (i = 0; i < a.length; i++) {
14238          if (a[i] >= value) {
14239            return a[i];
14240          }
14241        }
14242
14243        return a[i - 1];
14244      } else {
14245        i = a.length;
14246        value += threshold;
14247
14248        while (i--) {
14249          if (a[i] <= value) {
14250            return a[i];
14251          }
14252        }
14253      }
14254
14255      return a[0];
14256    } : function (value, direction, threshold) {
14257      if (threshold === void 0) {
14258        threshold = 1e-3;
14259      }
14260
14261      var snapped = snap(value);
14262      return !direction || Math.abs(snapped - value) < threshold || snapped - value < 0 === direction < 0 ? snapped : snap(direction < 0 ? value - snapIncrementOrArray : value + snapIncrementOrArray);
14263    };
14264  },
14265      _getLabelAtDirection = function _getLabelAtDirection(timeline) {
14266    return function (value, st) {
14267      return _snapDirectional(_getLabelRatioArray(timeline))(value, st.direction);
14268    };
14269  },
14270      _multiListener = function _multiListener(func, element, types, callback) {
14271    return types.split(",").forEach(function (type) {
14272      return func(element, type, callback);
14273    });
14274  },
14275      _addListener$2 = function _addListener(element, type, func, nonPassive, capture) {
14276    return element.addEventListener(type, func, {
14277      passive: !nonPassive,
14278      capture: !!capture
14279    });
14280  },
14281      _removeListener$2 = function _removeListener(element, type, func, capture) {
14282    return element.removeEventListener(type, func, !!capture);
14283  },
14284      _wheelListener = function _wheelListener(func, el, scrollFunc) {
14285    scrollFunc = scrollFunc && scrollFunc.wheelHandler;
14286
14287    if (scrollFunc) {
14288      func(el, "wheel", scrollFunc);
14289      func(el, "touchmove", scrollFunc);
14290    }
14291  },
14292      _markerDefaults = {
14293    startColor: "green",
14294    endColor: "red",
14295    indent: 0,
14296    fontSize: "16px",
14297    fontWeight: "normal"
14298  },
14299      _defaults$1 = {
14300    toggleActions: "play",
14301    anticipatePin: 0
14302  },
14303      _keywords = {
14304    top: 0,
14305    left: 0,
14306    center: 0.5,
14307    bottom: 1,
14308    right: 1
14309  },
14310      _offsetToPx = function _offsetToPx(value, size) {
14311    if (_isString$4(value)) {
14312      var eqIndex = value.indexOf("="),
14313          relative = ~eqIndex ? +(value.charAt(eqIndex - 1) + 1) * parseFloat(value.substr(eqIndex + 1)) : 0;
14314
14315      if (~eqIndex) {
14316        value.indexOf("%") > eqIndex && (relative *= size / 100);
14317        value = value.substr(0, eqIndex - 1);
14318      }
14319
14320      value = relative + (value in _keywords ? _keywords[value] * size : ~value.indexOf("%") ? parseFloat(value) * size / 100 : parseFloat(value) || 0);
14321    }
14322
14323    return value;
14324  },
14325      _createMarker = function _createMarker(type, name, container, direction, _ref4, offset, matchWidthEl, containerAnimation) {
14326    var startColor = _ref4.startColor,
14327        endColor = _ref4.endColor,
14328        fontSize = _ref4.fontSize,
14329        indent = _ref4.indent,
14330        fontWeight = _ref4.fontWeight;
14331
14332    var e = _doc$6.createElement("div"),
14333        useFixedPosition = _isViewport$1(container) || _getProxyProp(container, "pinType") === "fixed",
14334        isScroller = type.indexOf("scroller") !== -1,
14335        parent = useFixedPosition ? _body$5 : container,
14336        isStart = type.indexOf("start") !== -1,
14337        color = isStart ? startColor : endColor,
14338        css = "border-color:" + color + ";font-size:" + fontSize + ";color:" + color + ";font-weight:" + fontWeight + ";pointer-events:none;white-space:nowrap;font-family:sans-serif,Arial;z-index:1000;padding:4px 8px;border-width:0;border-style:solid;";
14339
14340    css += "position:" + ((isScroller || containerAnimation) && useFixedPosition ? "fixed;" : "absolute;");
14341    (isScroller || containerAnimation || !useFixedPosition) && (css += (direction === _vertical ? _right : _bottom) + ":" + (offset + parseFloat(indent)) + "px;");
14342    matchWidthEl && (css += "box-sizing:border-box;text-align:left;

vendor: 11,014 bytes, lines 14342-14689

14342width:" + matchWidthEl.offsetWidth + "px;");
14343    e._isStart = isStart;
14344    e.setAttribute("class", "gsap-marker-" + type + (name ? " marker-" + name : ""));
14345    e.style.cssText = css;
14346    e.innerText = name || name === 0 ? type + "-" + name : type;
14347    parent.children[0] ? parent.insertBefore(e, parent.children[0]) : parent.appendChild(e);
14348    e._offset = e["offset" + direction.op.d2];
14349
14350    _positionMarker(e, 0, direction, isStart);
14351
14352    return e;
14353  },
14354      _positionMarker = function _positionMarker(marker, start, direction, flipped) {
14355    var vars = {
14356      display: "block"
14357    },
14358        side = direction[flipped ? "os2" : "p2"],
14359        oppositeSide = direction[flipped ? "p2" : "os2"];
14360    marker._isFlipped = flipped;
14361    vars[direction.a + "Percent"] = flipped ? -100 : 0;
14362    vars[direction.a] = flipped ? "1px" : 0;
14363    vars["border" + side + _Width] = 1;
14364    vars["border" + oppositeSide + _Width] = 0;
14365    vars[direction.p] = start + "px";
14366    gsap$b.set(marker, vars);
14367  },
14368      _triggers = [],
14369      _ids = {},
14370      _rafID,
14371      _sync = function _sync() {
14372    return _getTime$2() - _lastScrollTime > 34 && (_rafID || (_rafID = requestAnimationFrame(_updateAll)));
14373  },
14374      _onScroll$1 = function _onScroll() {
14375    if (!_normalizer$1 || !_normalizer$1.isPressed || _normalizer$1.startX > _body$5.clientWidth) {
14376      exports._scrollers.cache++;
14377
14378      if (_normalizer$1) {
14379        _rafID || (_rafID = requestAnimationFrame(_updateAll));
14380      } else {
14381        _updateAll();
14382      }
14383
14384      _lastScrollTime || _dispatch$1("scrollStart");
14385      _lastScrollTime = _getTime$2();
14386    }
14387  },
14388      _setBaseDimensions = function _setBaseDimensions() {
14389    _baseScreenWidth = _win$6.innerWidth;
14390    _baseScreenHeight = _win$6.innerHeight;
14391  },
14392      _onResize = function _onResize() {
14393    exports._scrollers.cache++;
14394    !_refreshing && !_ignoreResize && !_doc$6.fullscreenElement && !_doc$6.webkitFullscreenElement && (!_ignoreMobileResize || _baseScreenWidth !== _win$6.innerWidth || Math.abs(_win$6.innerHeight - _baseScreenHeight) > _win$6.innerHeight * 0.25) && _resizeDelay.restart(true);
14395  },
14396      _listeners$1 = {},
14397      _emptyArray$1 = [],
14398      _softRefresh = function _softRefresh() {
14399    return _removeListener$2(ScrollTrigger$2, "scrollEnd", _softRefresh) || _refreshAll(true);
14400  },
14401      _dispatch$1 = function _dispatch(type) {
14402    return _listeners$1[type] && _listeners$1[type].map(function (f) {
14403      return f();
14404    }) || _emptyArray$1;
14405  },
14406      _savedStyles = [],
14407      _revertRecorded = function _revertRecorded(media) {
14408    for (var i = 0; i < _savedStyles.length; i += 5) {
14409      if (!media || _savedStyles[i + 4] && _savedStyles[i + 4].query === media) {
14410        _savedStyles[i].style.cssText = _savedStyles[i + 1];
14411        _savedStyles[i].getBBox && _savedStyles[i].setAttribute("transform", _savedStyles[i + 2] || "");
14412        _savedStyles[i + 3].uncache = 1;
14413      }
14414    }
14415  },
14416      _revertAll = function _revertAll(kill, media) {
14417    var trigger;
14418
14419    for (_i = 0; _i < _triggers.length; _i++) {
14420      trigger = _triggers[_i];
14421
14422      if (trigger && (!media || trigger._ctx === media)) {
14423        if (kill) {
14424          trigger.kill(1);
14425        } else {
14426          trigger.revert(true, true);
14427        }
14428      }
14429    }
14430
14431    _isReverted = true;
14432    media && _revertRecorded(media);
14433    media || _dispatch$1("revert");
14434  },
14435      _clearScrollMemory = function _clearScrollMemory(scrollRestoration, force) {
14436    exports._scrollers.cache++;
14437    (force || !_refreshingAll) && exports._scrollers.forEach(function (obj) {
14438      return _isFunction$4(obj) && obj.cacheID++ && (obj.rec = 0);
14439    });
14440    _isString$4(scrollRestoration) && (_win$6.history.scrollRestoration = _scrollRestoration = scrollRestoration);
14441  },
14442      _refreshingAll,
14443      _refreshID = 0,
14444      _queueRefreshID,
14445      _queueRefreshAll = function _queueRefreshAll() {
14446    if (_queueRefreshID !== _refreshID) {
14447      var id = _queueRefreshID = _refreshID;
14448      requestAnimationFrame(function () {
14449        return id === _refreshID && _refreshAll(true);
14450      });
14451    }
14452  },
14453      _refresh100vh = function _refresh100vh() {
14454    _body$5.appendChild(_div100vh);
14455
14456    _100vh = !_normalizer$1 && _div100vh.offsetHeight || _win$6.innerHeight;
14457
14458    _body$5.removeChild(_div100vh);
14459  },
14460      _hideAllMarkers = function _hideAllMarkers(hide) {
14461    return _toArray$4(".gsap-marker-start, .gsap-marker-end, .gsap-marker-scroller-start, .gsap-marker-scroller-end").forEach(function (el) {
14462      return el.style.display = hide ? "none" : "block";
14463    });
14464  },
14465      _refreshAll = function _refreshAll(force, skipRevert) {
14466    if (_lastScrollTime && !force && !_isReverted) {
14467      _addListener$2(ScrollTrigger$2, "scrollEnd", _softRefresh);
14468
14469      return;
14470    }
14471
14472    _refresh100vh();
14473
14474    _refreshingAll = ScrollTrigger$2.isRefreshing = true;
14475
14476    exports._scrollers.forEach(function (obj) {
14477      return _isFunction$4(obj) && ++obj.cacheID && (obj.rec = obj());
14478    });
14479
14480    var refreshInits = _dispatch$1("refreshInit");
14481
14482    _sort && ScrollTrigger$2.sort();
14483    skipRevert || _revertAll();
14484
14485    exports._scrollers.forEach(function (obj) {
14486      if (_isFunction$4(obj)) {
14487        obj.smooth && (obj.target.style.scrollBehavior = "auto");
14488        obj(0);
14489      }
14490    });
14491
14492    _triggers.slice(0).forEach(function (t) {
14493      return t.refresh();
14494    });
14495
14496    _isReverted = false;
14497
14498    _triggers.forEach(function (t) {
14499      if (t._subPinOffset && t.pin) {
14500        var prop = t.vars.horizontal ? "offsetWidth" : "offsetHeight",
14501            original = t.pin[prop];
14502        t.revert(true, 1);
14503        t.adjustPinSpacing(t.pin[prop] - original);
14504        t.refresh();
14505      }
14506    });
14507
14508    _clampingMax = 1;
14509
14510    _hideAllMarkers(true);
14511
14512    _triggers.forEach(function (t) {
14513      var max = _maxScroll(t.scroller, t._dir),
14514          endClamp = t.vars.end === "max" || t._endClamp && t.end > max,
14515          startClamp = t._startClamp && t.start >= max;
14516
14517      (endClamp || startClamp) && t.setPositions(startClamp ? max - 1 : t.start, endClamp ? Math.max(startClamp ? max : t.start + 1, max) : t.end, true);
14518    });
14519
14520    _hideAllMarkers(false);
14521
14522    _clampingMax = 0;
14523    refreshInits.forEach(function (result) {
14524      return result && result.render && result.render(-1);
14525    });
14526
14527    exports._scrollers.forEach(function (obj) {
14528      if (_isFunction$4(obj)) {
14529        obj.smooth && requestAnimationFrame(function () {
14530          return obj.target.style.scrollBehavior = "smooth";
14531        });
14532        obj.rec && obj(obj.rec);
14533      }
14534    });
14535
14536    _clearScrollMemory(_scrollRestoration, 1);
14537
14538    _resizeDelay.pause();
14539
14540    _refreshID++;
14541    _refreshingAll = 2;
14542
14543    _updateAll(2);
14544
14545    _triggers.forEach(function (t) {
14546      return _isFunction$4(t.vars.onRefresh) && t.vars.onRefresh(t);
14547    });
14548
14549    _refreshingAll = ScrollTrigger$2.isRefreshing = false;
14550
14551    _dispatch$1("refresh");
14552  },
14553      _lastScroll = 0,
14554      _direction = 1,
14555      _primary,
14556      _updateAll = function _updateAll(force) {
14557    if (force === 2 || !_refreshingAll && !_isReverted) {
14558      ScrollTrigger$2.isUpdating = true;
14559      _primary && _primary.update(0);
14560
14561      var l = _triggers.length,
14562          time = _getTime$2(),
14563          recordVelocity = time - _time1 >= 50,
14564          scroll = l && _triggers[0].scroll();
14565
14566      _direction = _lastScroll > scroll ? -1 : 1;
14567      _refreshingAll || (_lastScroll = scroll);
14568
14569      if (recordVelocity) {
14570        if (_lastScrollTime && !_pointerIsDown && time - _lastScrollTime > 200) {
14571          _lastScrollTime = 0;
14572
14573          _dispatch$1("scrollEnd");
14574        }
14575
14576        _time2 = _time1;
14577        _time1 = time;
14578      }
14579
14580      if (_direction < 0) {
14581        _i = l;
14582
14583        while (_i-- > 0) {
14584          _triggers[_i] && _triggers[_i].update(0, recordVelocity);
14585        }
14586
14587        _direction = 1;
14588      } else {
14589        for (_i = 0; _i < l; _i++) {
14590          _triggers[_i] && _triggers[_i].update(0, recordVelocity);
14591        }
14592      }
14593
14594      ScrollTrigger$2.isUpdating = false;
14595    }
14596
14597    _rafID = 0;
14598  },
14599      _propNamesToCopy = [_left, _top, _bottom, _right, _margin + _Bottom, _margin + _Right, _margin + _Top, _margin + _Left, "display", "flexShrink", "float", "zIndex", "gridColumnStart", "gridColumnEnd", "gridRowStart", "gridRowEnd", "gridArea", "justifySelf", "alignSelf", "placeSelf", "order"],
14600      _stateProps = _propNamesToCopy.concat([_width, _height, "boxSizing", "max" + _Width, "max" + _Height, "position", _margin, _padding, _padding + _Top, _padding + _Right, _padding + _Bottom, _padding + _Left]),
14601      _swapPinOut = function _swapPinOut(pin, spacer, state) {
14602    _setState(state);
14603
14604    var cache = pin._gsap;
14605
14606    if (cache.spacerIsNative) {
14607      _setState(cache.spacerState);
14608    } else if (pin._gsap.swappedIn) {
14609      var parent = spacer.parentNode;
14610
14611      if (parent) {
14612        parent.insertBefore(pin, spacer);
14613        parent.removeChild(spacer);
14614      }
14615    }
14616
14617    pin._gsap.swappedIn = false;
14618  },
14619      _swapPinIn = function _swapPinIn(pin, spacer, cs, spacerState) {
14620    if (!pin._gsap.swappedIn) {
14621      var i = _propNamesToCopy.length,
14622          spacerStyle = spacer.style,
14623          pinStyle = pin.style,
14624          p;
14625
14626      while (i--) {
14627        p = _propNamesToCopy[i];
14628        spacerStyle[p] = cs[p];
14629      }
14630
14631      spacerStyle.position = cs.position === "absolute" ? "absolute" : "relative";
14632      cs.display === "inline" && (spacerStyle.display = "inline-block");
14633      pinStyle[_bottom] = pinStyle[_right] = "auto";
14634      spacerStyle.flexBasis = cs.flexBasis || "auto";
14635      spacerStyle.overflow = "visible";
14636      spacerStyle.boxSizing = "border-box";
14637      spacerStyle[_width] = _getSize(pin, _horizontal) + _px;
14638      spacerStyle[_height] = _getSize(pin, _vertical) + _px;
14639      spacerStyle[_padding] = pinStyle[_margin] = pinStyle[_top] = pinStyle[_left] = "0";
14640
14641      _setState(spacerState);
14642
14643      pinStyle[_width] = pinStyle["max" + _Width] = cs[_width];
14644      pinStyle[_height] = pinStyle["max" + _Height] = cs[_height];
14645      pinStyle[_padding] = cs[_padding];
14646
14647      if (pin.parentNode !== spacer) {
14648        pin.parentNode.insertBefore(spacer, pin);
14649        spacer.appendChild(pin);
14650      }
14651
14652      pin._gsap.swappedIn = true;
14653    }
14654  },
14655      _capsExp$1 = /([A-Z])/g,
14656      _setState = function _setState(state) {
14657    if (state) {
14658      var style = state.t.style,
14659          l = state.length,
14660          i = 0,
14661          p,
14662          value;
14663      (state.t._gsap || gsap$b.core.getCache(state.t)).uncache = 1;
14664
14665      for (; i < l; i += 2) {
14666        value = state[i + 1];
14667        p = state[i];
14668
14669        if (value) {
14670          style[p] = value;
14671        } else if (style[p]) {
14672          style.removeProperty(p.replace(_capsExp$1, "-$1").toLowerCase());
14673        }
14674      }
14675    }
14676  },
14677      _getState = function _getState(element) {
14678    var l = _stateProps.length,
14679        style = element.style,
14680        state = [],
14681        i = 0;
14682
14683    for (; i < l; i++) {
14684      state.push(_stateProps[i], style[_stateProps[i]]);
14685    }
14686
14687    state.t = element;
14688    return state;
14689  },

vendor: 4,984 bytes, lines 14690-14826

14690      _copyState = function _copyState(state, override, omitOffsets) {
14691    var result = [],
14692        l = state.length,
14693        i = omitOffsets ? 8 : 0,
14694        p;
14695
14696    for (; i < l; i += 2) {
14697      p = state[i];
14698      result.push(p, p in override ? override[p] : state[i + 1]);
14699    }
14700
14701    result.t = state.t;
14702    return result;
14703  },
14704      _winOffsets = {
14705    left: 0,
14706    top: 0
14707  },
14708      _parsePosition$1 = function _parsePosition(value, trigger, scrollerSize, direction, scroll, marker, markerScroller, self, scrollerBounds, borderWidth, useFixedPosition, scrollerMax, containerAnimation, clampZeroProp) {
14709    _isFunction$4(value) && (value = value(self));
14710
14711    if (_isString$4(value) && value.substr(0, 3) === "max") {
14712      value = scrollerMax + (value.charAt(4) === "=" ? _offsetToPx("0" + value.substr(3), scrollerSize) : 0);
14713    }
14714
14715    var time = containerAnimation ? containerAnimation.time() : 0,
14716        p1,
14717        p2,
14718        element;
14719    containerAnimation && containerAnimation.seek(0);
14720    isNaN(value) || (value = +value);
14721
14722    if (!_isNumber$2(value)) {
14723      _isFunction$4(trigger) && (trigger = trigger(self));
14724      var offsets = (value || "0").split(" "),
14725          bounds,
14726          localOffset,
14727          globalOffset,
14728          display;
14729      element = _getTarget(trigger, self) || _body$5;
14730      bounds = _getBounds$1(element) || {};
14731
14732      if ((!bounds || !bounds.left && !bounds.top) && _getComputedStyle$1(element).display === "none") {
14733        display = element.style.display;
14734        element.style.display = "block";
14735        bounds = _getBounds$1(element);
14736        display ? element.style.display = display : element.style.removeProperty("display");
14737      }
14738
14739      localOffset = _offsetToPx(offsets[0], bounds[direction.d]);
14740      globalOffset = _offsetToPx(offsets[1] || "0", scrollerSize);
14741      value = bounds[direction.p] - scrollerBounds[direction.p] - borderWidth + localOffset + scroll - globalOffset;
14742      markerScroller && _positionMarker(markerScroller, globalOffset, direction, scrollerSize - globalOffset < 20 || markerScroller._isStart && globalOffset > 20);
14743      scrollerSize -= scrollerSize - globalOffset;
14744    } else {
14745      containerAnimation && (value = gsap$b.utils.mapRange(containerAnimation.scrollTrigger.start, containerAnimation.scrollTrigger.end, 0, scrollerMax, value));
14746      markerScroller && _positionMarker(markerScroller, scrollerSize, direction, true);
14747    }
14748
14749    if (clampZeroProp) {
14750      self[clampZeroProp] = value || -0.001;
14751      value < 0 && (value = 0);
14752    }
14753
14754    if (marker) {
14755      var position = value + scrollerSize,
14756          isStart = marker._isStart;
14757      p1 = "scroll" + direction.d2;
14758
14759      _positionMarker(marker, position, direction, isStart && position > 20 || !isStart && (useFixedPosition ? Math.max(_body$5[p1], _docEl$2[p1]) : marker.parentNode[p1]) <= position + 1);
14760
14761      if (useFixedPosition) {
14762        scrollerBounds = _getBounds$1(markerScroller);
14763        useFixedPosition && (marker.style[direction.op.p] = scrollerBounds[direction.op.p] - direction.op.m - marker._offset + _px);
14764      }
14765    }
14766
14767    if (containerAnimation && element) {
14768      p1 = _getBounds$1(element);
14769      containerAnimation.seek(scrollerMax);
14770      p2 = _getBounds$1(element);
14771      containerAnimation._caScrollDist = p1[direction.p] - p2[direction.p];
14772      value = value / containerAnimation._caScrollDist * scrollerMax;
14773    }
14774
14775    containerAnimation && containerAnimation.seek(time);
14776    return containerAnimation ? value : Math.round(value);
14777  },
14778      _prefixExp = /(webkit|moz|length|cssText|inset)/i,
14779      _reparent = function _reparent(element, parent, top, left) {
14780    if (element.parentNode !== parent) {
14781      var style = element.style,
14782          p,
14783          cs;
14784
14785      if (parent === _body$5) {
14786        element._stOrig = style.cssText;
14787        cs = _getComputedStyle$1(element);
14788
14789        for (p in cs) {
14790          if (!+p && !_prefixExp.test(p) && cs[p] && typeof style[p] === "string" && p !== "0") {
14791            style[p] = cs[p];
14792          }
14793        }
14794
14795        style.top = top;
14796        style.left = left;
14797      } else {
14798        style.cssText = element._stOrig;
14799      }
14800
14801      gsap$b.core.getCache(element).uncache = 1;
14802      parent.appendChild(element);
14803    }
14804  },
14805      _interruptionTracker = function _interruptionTracker(getValueFunc, initialValue, onInterrupt) {
14806    var last1 = initialValue,
14807        last2 = last1;
14808    return function (value) {
14809      var current = Math.round(getValueFunc());
14810
14811      if (current !== last1 && current !== last2 && Math.abs(current - last1) > 3 && Math.abs(current - last2) > 3) {
14812        value = current;
14813        onInterrupt && onInterrupt();
14814      }
14815
14816      last2 = last1;
14817      last1 = value;
14818      return value;
14819    };
14820  },
14821      _shiftMarker = function _shiftMarker(marker, direction, value) {
14822    var vars = {};
14823    vars[direction.p] = "+=" + value;
14824    gsap$b.set(marker, vars);
14825  },
14826      _getTweenCreator = function _getTweenCreator(scroller, direction) {

vendor: 4,623 bytes, lines 14827-14955

14827    var getScroll = _getScrollFunc(scroller, direction),
14828        prop = "_scroll" + direction.p2,
14829        getTween = function getTween(scrollTo, vars, initialValue, change1, change2) {
14830      var tween = getTween.tween,
14831          onComplete = vars.onComplete,
14832          modifiers = {};
14833      initialValue = initialValue || getScroll();
14834
14835      var checkForInterruption = _interruptionTracker(getScroll, initialValue, function () {
14836        tween.kill();
14837        getTween.tween = 0;
14838      });
14839
14840      change2 = change1 && change2 || 0;
14841      change1 = change1 || scrollTo - initialValue;
14842      tween && tween.kill();
14843      vars[prop] = scrollTo;
14844      vars.inherit = false;
14845      vars.modifiers = modifiers;
14846
14847      modifiers[prop] = function () {
14848        return checkForInterruption(initialValue + change1 * tween.ratio + change2 * tween.ratio * tween.ratio);
14849      };
14850
14851      vars.onUpdate = function () {
14852        exports._scrollers.cache++;
14853        getTween.tween && _updateAll();
14854      };
14855
14856      vars.onComplete = function () {
14857        getTween.tween = 0;
14858        onComplete && onComplete.call(tween);
14859      };
14860
14861      tween = getTween.tween = gsap$b.to(scroller, vars);
14862      return tween;
14863    };
14864
14865    scroller[prop] = getScroll;
14866
14867    getScroll.wheelHandler = function () {
14868      return getTween.tween && getTween.tween.kill() && (getTween.tween = 0);
14869    };
14870
14871    _addListener$2(scroller, "wheel", getScroll.wheelHandler);
14872
14873    ScrollTrigger$2.isTouch && _addListener$2(scroller, "touchmove", getScroll.wheelHandler);
14874    return getTween;
14875  };
14876
14877  var ScrollTrigger$2 = function () {
14878    function ScrollTrigger(vars, animation) {
14879      _coreInitted$8 || ScrollTrigger.register(gsap$b) || console.warn("Please gsap.registerPlugin(ScrollTrigger)");
14880
14881      _context$3(this);
14882
14883      this.init(vars, animation);
14884    }
14885
14886    var _proto = ScrollTrigger.prototype;
14887
14888    _proto.init = function init(vars, animation) {
14889      this.progress = this.start = 0;
14890      this.vars && this.kill(true, true);
14891
14892      if (!_enabled) {
14893        this.update = this.refresh = this.kill = _passThrough$1;
14894        return;
14895      }
14896
14897      vars = _setDefaults$2(_isString$4(vars) || _isNumber$2(vars) || vars.nodeType ? {
14898        trigger: vars
14899      } : vars, _defaults$1);
14900
14901      var _vars = vars,
14902          onUpdate = _vars.onUpdate,
14903          toggleClass = _vars.toggleClass,
14904          id = _vars.id,
14905          onToggle = _vars.onToggle,
14906          onRefresh = _vars.onRefresh,
14907          scrub = _vars.scrub,
14908          trigger = _vars.trigger,
14909          pin = _vars.pin,
14910          pinSpacing = _vars.pinSpacing,
14911          invalidateOnRefresh = _vars.invalidateOnRefresh,
14912          anticipatePin = _vars.anticipatePin,
14913          onScrubComplete = _vars.onScrubComplete,
14914          onSnapComplete = _vars.onSnapComplete,
14915          once = _vars.once,
14916          snap = _vars.snap,
14917          pinReparent = _vars.pinReparent,
14918          pinSpacer = _vars.pinSpacer,
14919          containerAnimation = _vars.containerAnimation,
14920          fastScrollEnd = _vars.fastScrollEnd,
14921          preventOverlaps = _vars.preventOverlaps,
14922          direction = vars.horizontal || vars.containerAnimation && vars.horizontal !== false ? _horizontal : _vertical,
14923          isToggle = !scrub && scrub !== 0,
14924          scroller = _getTarget(vars.scroller || _win$6),
14925          scrollerCache = gsap$b.core.getCache(scroller),
14926          isViewport = _isViewport$1(scroller),
14927          useFixedPosition = ("pinType" in vars ? vars.pinType : _getProxyProp(scroller, "pinType") || isViewport && "fixed") === "fixed",
14928          callbacks = [vars.onEnter, vars.onLeave, vars.onEnterBack, vars.onLeaveBack],
14929          toggleActions = isToggle && vars.toggleActions.split(" "),
14930          markers = "markers" in vars ? vars.markers : _defaults$1.markers,
14931          borderWidth = isViewport ? 0 : parseFloat(_getComputedStyle$1(scroller)["border" + direction.p2 + _Width]) || 0,
14932          self = this,
14933          onRefreshInit = vars.onRefreshInit && function () {
14934        return vars.onRefreshInit(self);
14935      },
14936          getScrollerSize = _getSizeFunc(scroller, isViewport, direction),
14937          getScrollerOffsets = _getOffsetsFunc(scroller, isViewport),
14938          lastSnap = 0,
14939          lastRefresh = 0,
14940          prevProgress = 0,
14941          scrollFunc = _getScrollFunc(scroller, direction),
14942          tweenTo,
14943          pinCache,
14944          snapFunc,
14945          scroll1,
14946          scroll2,
14947          start,
14948          end,
14949          markerStart,
14950          markerEnd,
14951          markerStartTrigger,
14952          markerEndTrigger,
14953          markerVars,
14954          executingOnRefresh,
14955          change,

vendor: 7,747 bytes, lines 14956-15144

14956          pinOriginalState,
14957          pinActiveState,
14958          pinState,
14959          spacer,
14960          offset,
14961          pinGetter,
14962          pinSetter,
14963          pinStart,
14964          pinChange,
14965          spacingStart,
14966          spacerState,
14967          markerStartSetter,
14968          pinMoves,
14969          markerEndSetter,
14970          cs,
14971          snap1,
14972          snap2,
14973          scrubTween,
14974          scrubSmooth,
14975          snapDurClamp,
14976          snapDelayedCall,
14977          prevScroll,
14978          prevAnimProgress,
14979          caMarkerSetter,
14980          customRevertReturn;
14981
14982      self._startClamp = self._endClamp = false;
14983      self._dir = direction;
14984      anticipatePin *= 45;
14985      self.scroller = scroller;
14986      self.scroll = containerAnimation ? containerAnimation.time.bind(containerAnimation) : scrollFunc;
14987      scroll1 = scrollFunc();
14988      self.vars = vars;
14989      animation = animation || vars.animation;
14990
14991      if ("refreshPriority" in vars) {
14992        _sort = 1;
14993        vars.refreshPriority === -9999 && (_primary = self);
14994      }
14995
14996      scrollerCache.tweenScroll = scrollerCache.tweenScroll || {
14997        top: _getTweenCreator(scroller, _vertical),
14998        left: _getTweenCreator(scroller, _horizontal)
14999      };
15000      self.tweenTo = tweenTo = scrollerCache.tweenScroll[direction.p];
15001
15002      self.scrubDuration = function (value) {
15003        scrubSmooth = _isNumber$2(value) && value;
15004
15005        if (!scrubSmooth) {
15006          scrubTween && scrubTween.progress(1).kill();
15007          scrubTween = 0;
15008        } else {
15009          scrubTween ? scrubTween.duration(value) : scrubTween = gsap$b.to(animation, {
15010            ease: "expo",
15011            totalProgress: "+=0",
15012            inherit: false,
15013            duration: scrubSmooth,
15014            paused: true,
15015            onComplete: function onComplete() {
15016              return onScrubComplete && onScrubComplete(self);
15017            }
15018          });
15019        }
15020      };
15021
15022      if (animation) {
15023        animation.vars.lazy = false;
15024        animation._initted && !self.isReverted || animation.vars.immediateRender !== false && vars.immediateRender !== false && animation.duration() && animation.render(0, true, true);
15025        self.animation = animation.pause();
15026        animation.scrollTrigger = self;
15027        self.scrubDuration(scrub);
15028        snap1 = 0;
15029        id || (id = animation.vars.id);
15030      }
15031
15032      if (snap) {
15033        if (!_isObject$2(snap) || snap.push) {
15034          snap = {
15035            snapTo: snap
15036          };
15037        }
15038
15039        "scrollBehavior" in _body$5.style && gsap$b.set(isViewport ? [_body$5, _docEl$2] : scroller, {
15040          scrollBehavior: "auto"
15041        });
15042
15043        exports._scrollers.forEach(function (o) {
15044          return _isFunction$4(o) && o.target === (isViewport ? _doc$6.scrollingElement || _docEl$2 : scroller) && (o.smooth = false);
15045        });
15046
15047        snapFunc = _isFunction$4(snap.snapTo) ? snap.snapTo : snap.snapTo === "labels" ? _getClosestLabel(animation) : snap.snapTo === "labelsDirectional" ? _getLabelAtDirection(animation) : snap.directional !== false ? function (value, st) {
15048          return _snapDirectional(snap.snapTo)(value, _getTime$2() - lastRefresh < 500 ? 0 : st.direction);
15049        } : gsap$b.utils.snap(snap.snapTo);
15050        snapDurClamp = snap.duration || {
15051          min: 0.1,
15052          max: 2
15053        };
15054        snapDurClamp = _isObject$2(snapDurClamp) ? _clamp$2(snapDurClamp.min, snapDurClamp.max) : _clamp$2(snapDurClamp, snapDurClamp);
15055        snapDelayedCall = gsap$b.delayedCall(snap.delay || scrubSmooth / 2 || 0.1, function () {
15056          var scroll = scrollFunc(),
15057              refreshedRecently = _getTime$2() - lastRefresh < 500,
15058              tween = tweenTo.tween;
15059
15060          if ((refreshedRecently || Math.abs(self.getVelocity()) < 10) && !tween && !_pointerIsDown && lastSnap !== scroll) {
15061            var progress = (scroll - start) / change,
15062                totalProgress = animation && !isToggle ? animation.totalProgress() : progress,
15063                velocity = refreshedRecently ? 0 : (totalProgress - snap2) / (_getTime$2() - _time2) * 1000 || 0,
15064                change1 = gsap$b.utils.clamp(-progress, 1 - progress, _abs$1(velocity / 2) * velocity / 0.185),
15065                naturalEnd = progress + (snap.inertia === false ? 0 : change1),
15066                endValue,
15067                endScroll,
15068                _snap = snap,
15069                onStart = _snap.onStart,
15070                _onInterrupt = _snap.onInterrupt,
15071                _onComplete = _snap.onComplete;
15072            endValue = snapFunc(naturalEnd, self);
15073            _isNumber$2(endValue) || (endValue = naturalEnd);
15074            endScroll = Math.round(start + endValue * change);
15075
15076            if (scroll <= end && scroll >= start && endScroll !== scroll) {
15077              if (tween && !tween._initted && tween.data <= _abs$1(endScroll - scroll)) {
15078                return;
15079              }
15080
15081              if (snap.inertia === false) {
15082                change1 = endValue - progress;
15083              }
15084
15085              tweenTo(endScroll, {
15086                duration: snapDurClamp(_abs$1(Math.max(_abs$1(naturalEnd - totalProgress), _abs$1(endValue - totalProgress)) * 0.185 / velocity / 0.05 || 0)),
15087                ease: snap.ease || "power3",
15088                data: _abs$1(endScroll - scroll),
15089                onInterrupt: function onInterrupt() {
15090                  return snapDelayedCall.restart(true) && _onInterrupt && _onInterrupt(self);
15091                },
15092                onComplete: function onComplete() {
15093                  self.update();
15094                  lastSnap = scrollFunc();
15095
15096                  if (animation) {
15097                    scrubTween ? scrubTween.resetTo("totalProgress", endValue, animation._tTime / animation._tDur) : animation.progress(endValue);
15098                  }
15099
15100                  snap1 = snap2 = animation && !isToggle ? animation.totalProgress() : self.progress;
15101                  onSnapComplete && onSnapComplete(self);
15102                  _onComplete && _onComplete(self);
15103                }
15104              }, scroll, change1 * change, endScroll - scroll - change1 * change);
15105              onStart && onStart(self, tweenTo.tween);
15106            }
15107          } else if (self.isActive && lastSnap !== scroll) {
15108            snapDelayedCall.restart(true);
15109          }
15110        }).pause();
15111      }
15112
15113      id && (_ids[id] = self);
15114      trigger = self.trigger = _getTarget(trigger || pin !== true && pin);
15115      customRevertReturn = trigger && trigger._gsap && trigger._gsap.stRevert;
15116      customRevertReturn && (customRevertReturn = customRevertReturn(self));
15117      pin = pin === true ? trigger : _getTarget(pin);
15118      _isString$4(toggleClass) && (toggleClass = {
15119        targets: trigger,
15120        className: toggleClass
15121      });
15122
15123      if (pin) {
15124        pinSpacing === false || pinSpacing === _margin || (pinSpacing = !pinSpacing && pin.parentNode && pin.parentNode.style && _getComputedStyle$1(pin.parentNode).display === "flex" ? false : _padding);
15125        self.pin = pin;
15126        pinCache = gsap$b.core.getCache(pin);
15127
15128        if (!pinCache.spacer) {
15129          if (pinSpacer) {
15130            pinSpacer = _getTarget(pinSpacer);
15131            pinSpacer && !pinSpacer.nodeType && (pinSpacer = pinSpacer.current || pinSpacer.nativeElement);
15132            pinCache.spacerIsNative = !!pinSpacer;
15133            pinSpacer && (pinCache.spacerState = _getState(pinSpacer));
15134          }
15135
15136          pinCache.spacer = spacer = pinSpacer || _doc$6.createElement("div");
15137          spacer.classList.add("pin-spacer");
15138          id && spacer.classList.add("pin-spacer-" + id);
15139          pinCache.pinState = pinOriginalState = _getState(pin);
15140        } else {
15141          pinOriginalState = pinCache.pinState;
15142        }
15143
15144        vars.force3D !== false && gsap$b.set(pin, {

vendor: 4,121 bytes, lines 15145-15260

15145          force3D: true
15146        });
15147        self.spacer = spacer = pinCache.spacer;
15148        cs = _getComputedStyle$1(pin);
15149        spacingStart = cs[pinSpacing + direction.os2];
15150        pinGetter = gsap$b.getProperty(pin);
15151        pinSetter = gsap$b.quickSetter(pin, direction.a, _px);
15152
15153        _swapPinIn(pin, spacer, cs);
15154
15155        pinState = _getState(pin);
15156      }
15157
15158      if (markers) {
15159        markerVars = _isObject$2(markers) ? _setDefaults$2(markers, _markerDefaults) : _markerDefaults;
15160        markerStartTrigger = _createMarker("scroller-start", id, scroller, direction, markerVars, 0);
15161        markerEndTrigger = _createMarker("scroller-end", id, scroller, direction, markerVars, 0, markerStartTrigger);
15162        offset = markerStartTrigger["offset" + direction.op.d2];
15163
15164        var content = _getTarget(_getProxyProp(scroller, "content") || scroller);
15165
15166        markerStart = this.markerStart = _createMarker("start", id, content, direction, markerVars, offset, 0, containerAnimation);
15167        markerEnd = this.markerEnd = _createMarker("end", id, content, direction, markerVars, offset, 0, containerAnimation);
15168        containerAnimation && (caMarkerSetter = gsap$b.quickSetter([markerStart, markerEnd], direction.a, _px));
15169
15170        if (!useFixedPosition && !(exports._proxies.length && _getProxyProp(scroller, "fixedMarkers") === true)) {
15171          _makePositionable(isViewport ? _body$5 : scroller);
15172
15173          gsap$b.set([markerStartTrigger, markerEndTrigger], {
15174            force3D: true
15175          });
15176          markerStartSetter = gsap$b.quickSetter(markerStartTrigger, direction.a, _px);
15177          markerEndSetter = gsap$b.quickSetter(markerEndTrigger, direction.a, _px);
15178        }
15179      }
15180
15181      if (containerAnimation) {
15182        var oldOnUpdate = containerAnimation.vars.onUpdate,
15183            oldParams = containerAnimation.vars.onUpdateParams;
15184        containerAnimation.eventCallback("onUpdate", function () {
15185          self.update(0, 0, 1);
15186          oldOnUpdate && oldOnUpdate.apply(containerAnimation, oldParams || []);
15187        });
15188      }
15189
15190      self.previous = function () {
15191        return _triggers[_triggers.indexOf(self) - 1];
15192      };
15193
15194      self.next = function () {
15195        return _triggers[_triggers.indexOf(self) + 1];
15196      };
15197
15198      self.revert = function (revert, temp) {
15199        if (!temp) {
15200          return self.kill(true);
15201        }
15202
15203        var r = revert !== false || !self.enabled,
15204            prevRefreshing = _refreshing;
15205
15206        if (r !== self.isReverted) {
15207          if (r) {
15208            prevScroll = Math.max(scrollFunc(), self.scroll.rec || 0);
15209            prevProgress = self.progress;
15210            prevAnimProgress = animation && animation.progress();
15211          }
15212
15213          markerStart && [markerStart, markerEnd, markerStartTrigger, markerEndTrigger].forEach(function (m) {
15214            return m.style.display = r ? "none" : "block";
15215          });
15216
15217          if (r) {
15218            _refreshing = self;
15219            self.update(r);
15220          }
15221
15222          if (pin && (!pinReparent || !self.isActive)) {
15223            if (r) {
15224              _swapPinOut(pin, spacer, pinOriginalState);
15225            } else {
15226              _swapPinIn(pin, spacer, _getComputedStyle$1(pin), spacerState);
15227            }
15228          }
15229
15230          r || self.update(r);
15231          _refreshing = prevRefreshing;
15232          self.isReverted = r;
15233        }
15234      };
15235
15236      self.refresh = function (soft, force, position, pinOffset) {
15237        if ((_refreshing || !self.enabled) && !force) {
15238          return;
15239        }
15240
15241        if (pin && soft && _lastScrollTime) {
15242          _addListener$2(ScrollTrigger, "scrollEnd", _softRefresh);
15243
15244          return;
15245        }
15246
15247        !_refreshingAll && onRefreshInit && onRefreshInit(self);
15248        _refreshing = self;
15249
15250        if (tweenTo.tween && !position) {
15251          tweenTo.tween.kill();
15252          tweenTo.tween = 0;
15253        }
15254
15255        scrubTween && scrubTween.pause();
15256        invalidateOnRefresh && animation && animation.revert({
15257          kill: false
15258        }).invalidate();
15259        self.isReverted || self.revert(true, true);
15260        self._subPinOffset = false;

vendor: 5,560 bytes, lines 15261-15388

15261
15262        var size = getScrollerSize(),
15263            scrollerBounds = getScrollerOffsets(),
15264            max = containerAnimation ? containerAnimation.duration() : _maxScroll(scroller, direction),
15265            isFirstRefresh = change <= 0.01,
15266            offset = 0,
15267            otherPinOffset = pinOffset || 0,
15268            parsedEnd = _isObject$2(position) ? position.end : vars.end,
15269            parsedEndTrigger = vars.endTrigger || trigger,
15270            parsedStart = _isObject$2(position) ? position.start : vars.start || (vars.start === 0 || !trigger ? 0 : pin ? "0 0" : "0 100%"),
15271            pinnedContainer = self.pinnedContainer = vars.pinnedContainer && _getTarget(vars.pinnedContainer, self),
15272            triggerIndex = trigger && Math.max(0, _triggers.indexOf(self)) || 0,
15273            i = triggerIndex,
15274            cs,
15275            bounds,
15276            scroll,
15277            isVertical,
15278            override,
15279            curTrigger,
15280            curPin,
15281            oppositeScroll,
15282            initted,
15283            revertedPins,
15284            forcedOverflow,
15285            markerStartOffset,
15286            markerEndOffset;
15287
15288        if (markers && _isObject$2(position)) {
15289          markerStartOffset = gsap$b.getProperty(markerStartTrigger, direction.p);
15290          markerEndOffset = gsap$b.getProperty(markerEndTrigger, direction.p);
15291        }
15292
15293        while (i--) {
15294          curTrigger = _triggers[i];
15295          curTrigger.end || curTrigger.refresh(0, 1) || (_refreshing = self);
15296          curPin = curTrigger.pin;
15297
15298          if (curPin && (curPin === trigger || curPin === pin || curPin === pinnedContainer) && !curTrigger.isReverted) {
15299            revertedPins || (revertedPins = []);
15300            revertedPins.unshift(curTrigger);
15301            curTrigger.revert(true, true);
15302          }
15303
15304          if (curTrigger !== _triggers[i]) {
15305            triggerIndex--;
15306            i--;
15307          }
15308        }
15309
15310        _isFunction$4(parsedStart) && (parsedStart = parsedStart(self));
15311        parsedStart = _parseClamp(parsedStart, "start", self);
15312        start = _parsePosition$1(parsedStart, trigger, size, direction, scrollFunc(), markerStart, markerStartTrigger, self, scrollerBounds, borderWidth, useFixedPosition, max, containerAnimation, self._startClamp && "_startClamp") || (pin ? -0.001 : 0);
15313        _isFunction$4(parsedEnd) && (parsedEnd = parsedEnd(self));
15314
15315        if (_isString$4(parsedEnd) && !parsedEnd.indexOf("+=")) {
15316          if (~parsedEnd.indexOf(" ")) {
15317            parsedEnd = (_isString$4(parsedStart) ? parsedStart.split(" ")[0] : "") + parsedEnd;
15318          } else {
15319            offset = _offsetToPx(parsedEnd.substr(2), size);
15320            parsedEnd = _isString$4(parsedStart) ? parsedStart : (containerAnimation ? gsap$b.utils.mapRange(0, containerAnimation.duration(), containerAnimation.scrollTrigger.start, containerAnimation.scrollTrigger.end, start) : start) + offset;
15321            parsedEndTrigger = trigger;
15322          }
15323        }
15324
15325        parsedEnd = _parseClamp(parsedEnd, "end", self);
15326        end = Math.max(start, _parsePosition$1(parsedEnd || (parsedEndTrigger ? "100% 0" : max), parsedEndTrigger, size, direction, scrollFunc() + offset, markerEnd, markerEndTrigger, self, scrollerBounds, borderWidth, useFixedPosition, max, containerAnimation, self._endClamp && "_endClamp")) || -0.001;
15327        offset = 0;
15328        i = triggerIndex;
15329
15330        while (i--) {
15331          curTrigger = _triggers[i];
15332          curPin = curTrigger.pin;
15333
15334          if (curPin && curTrigger.start - curTrigger._pinPush <= start && !containerAnimation && curTrigger.end > 0) {
15335            cs = curTrigger.end - (self._startClamp ? Math.max(0, curTrigger.start) : curTrigger.start);
15336
15337            if ((curPin === trigger && curTrigger.start - curTrigger._pinPush < start || curPin === pinnedContainer) && isNaN(parsedStart)) {
15338              offset += cs * (1 - curTrigger.progress);
15339            }
15340
15341            curPin === pin && (otherPinOffset += cs);
15342          }
15343        }
15344
15345        start += offset;
15346        end += offset;
15347        self._startClamp && (self._startClamp += offset);
15348
15349        if (self._endClamp && !_refreshingAll) {
15350          self._endClamp = end || -0.001;
15351          end = Math.min(end, _maxScroll(scroller, direction));
15352        }
15353
15354        change = end - start || (start -= 0.01) && 0.001;
15355
15356        if (isFirstRefresh) {
15357          prevProgress = gsap$b.utils.clamp(0, 1, gsap$b.utils.normalize(start, end, prevScroll));
15358        }
15359
15360        self._pinPush = otherPinOffset;
15361
15362        if (markerStart && offset) {
15363          cs = {};
15364          cs[direction.a] = "+=" + offset;
15365          pinnedContainer && (cs[direction.p] = "-=" + scrollFunc());
15366          gsap$b.set([markerStart, markerEnd], cs);
15367        }
15368
15369        if (pin && !(_clampingMax && self.end >= _maxScroll(scroller, direction))) {
15370          cs = _getComputedStyle$1(pin);
15371          isVertical = direction === _vertical;
15372          scroll = scrollFunc();
15373          pinStart = parseFloat(pinGetter(direction.a)) + otherPinOffset;
15374
15375          if (!max && end > 1) {
15376            forcedOverflow = (isViewport ? _doc$6.scrollingElement || _docEl$2 : scroller).style;
15377            forcedOverflow = {
15378              style: forcedOverflow,
15379              value: forcedOverflow["overflow" + direction.a.toUpperCase()]
15380            };
15381
15382            if (isViewport && _getComputedStyle$1(_body$5)["overflow" + direction.a.toUpperCase()] !== "scroll") {
15383              forcedOverflow.style["overflow" + direction.a.toUpperCase()] = "scroll";
15384            }
15385          }
15386
15387          _swapPinIn(pin, spacer, cs);
15388

vendor: 4,418 bytes, lines 15389-15494

15389          pinState = _getState(pin);
15390          bounds = _getBounds$1(pin, true);
15391          oppositeScroll = useFixedPosition && _getScrollFunc(scroller, isVertical ? _horizontal : _vertical)();
15392
15393          if (pinSpacing) {
15394            spacerState = [pinSpacing + direction.os2, change + otherPinOffset + _px];
15395            spacerState.t = spacer;
15396            i = pinSpacing === _padding ? _getSize(pin, direction) + change + otherPinOffset : 0;
15397
15398            if (i) {
15399              spacerState.push(direction.d, i + _px);
15400              spacer.style.flexBasis !== "auto" && (spacer.style.flexBasis = i + _px);
15401            }
15402
15403            _setState(spacerState);
15404
15405            if (pinnedContainer) {
15406              _triggers.forEach(function (t) {
15407                if (t.pin === pinnedContainer && t.vars.pinSpacing !== false) {
15408                  t._subPinOffset = true;
15409                }
15410              });
15411            }
15412
15413            useFixedPosition && scrollFunc(prevScroll);
15414          } else {
15415            i = _getSize(pin, direction);
15416            i && spacer.style.flexBasis !== "auto" && (spacer.style.flexBasis = i + _px);
15417          }
15418
15419          if (useFixedPosition) {
15420            override = {
15421              top: bounds.top + (isVertical ? scroll - start : oppositeScroll) + _px,
15422              left: bounds.left + (isVertical ? oppositeScroll : scroll - start) + _px,
15423              boxSizing: "border-box",
15424              position: "fixed"
15425            };
15426            override[_width] = override["max" + _Width] = Math.ceil(bounds.width) + _px;
15427            override[_height] = override["max" + _Height] = Math.ceil(bounds.height) + _px;
15428            override[_margin] = override[_margin + _Top] = override[_margin + _Right] = override[_margin + _Bottom] = override[_margin + _Left] = "0";
15429            override[_padding] = cs[_padding];
15430            override[_padding + _Top] = cs[_padding + _Top];
15431            override[_padding + _Right] = cs[_padding + _Right];
15432            override[_padding + _Bottom] = cs[_padding + _Bottom];
15433            override[_padding + _Left] = cs[_padding + _Left];
15434            pinActiveState = _copyState(pinOriginalState, override, pinReparent);
15435            _refreshingAll && scrollFunc(0);
15436          }
15437
15438          if (animation) {
15439            initted = animation._initted;
15440
15441            _suppressOverwrites$1(1);
15442
15443            animation.render(animation.duration(), true, true);
15444            pinChange = pinGetter(direction.a) - pinStart + change + otherPinOffset;
15445            pinMoves = Math.abs(change - pinChange) > 1;
15446            useFixedPosition && pinMoves && pinActiveState.splice(pinActiveState.length - 2, 2);
15447            animation.render(0, true, true);
15448            initted || animation.invalidate(true);
15449            animation.parent || animation.totalTime(animation.totalTime());
15450
15451            _suppressOverwrites$1(0);
15452          } else {
15453            pinChange = change;
15454          }
15455
15456          forcedOverflow && (forcedOverflow.value ? forcedOverflow.style["overflow" + direction.a.toUpperCase()] = forcedOverflow.value : forcedOverflow.style.removeProperty("overflow-" + direction.a));
15457        } else if (trigger && scrollFunc() && !containerAnimation) {
15458          bounds = trigger.parentNode;
15459
15460          while (bounds && bounds !== _body$5) {
15461            if (bounds._pinOffset) {
15462              start -= bounds._pinOffset;
15463              end -= bounds._pinOffset;
15464            }
15465
15466            bounds = bounds.parentNode;
15467          }
15468        }
15469
15470        revertedPins && revertedPins.forEach(function (t) {
15471          return t.revert(false, true);
15472        });
15473        self.start = start;
15474        self.end = end;
15475        scroll1 = scroll2 = _refreshingAll ? prevScroll : scrollFunc();
15476
15477        if (!containerAnimation && !_refreshingAll) {
15478          scroll1 < prevScroll && scrollFunc(prevScroll);
15479          self.scroll.rec = 0;
15480        }
15481
15482        self.revert(false, true);
15483        lastRefresh = _getTime$2();
15484
15485        if (snapDelayedCall) {
15486          lastSnap = -1;
15487          snapDelayedCall.restart(true);
15488        }
15489
15490        _refreshing = 0;
15491        animation && isToggle && (animation._initted || prevAnimProgress) && animation.progress() !== prevAnimProgress && animation.progress(prevAnimProgress || 0, true).render(animation.time(), true, true);
15492
15493        if (isFirstRefresh || prevProgress !== self.progress || containerAnimation || invalidateOnRefresh) {
15494          animation && !isToggle

vendor: 10,328 bytes, lines 15494-15750

15494 && animation.totalProgress(containerAnimation && start < -0.001 && !prevProgress ? gsap$b.utils.normalize(start, end, 0) : prevProgress, true);
15495          self.progress = isFirstRefresh || (scroll1 - start) / change === prevProgress ? 0 : prevProgress;
15496        }
15497
15498        pin && pinSpacing && (spacer._pinOffset = Math.round(self.progress * pinChange));
15499        scrubTween && scrubTween.invalidate();
15500
15501        if (!isNaN(markerStartOffset)) {
15502          markerStartOffset -= gsap$b.getProperty(markerStartTrigger, direction.p);
15503          markerEndOffset -= gsap$b.getProperty(markerEndTrigger, direction.p);
15504
15505          _shiftMarker(markerStartTrigger, direction, markerStartOffset);
15506
15507          _shiftMarker(markerStart, direction, markerStartOffset - (pinOffset || 0));
15508
15509          _shiftMarker(markerEndTrigger, direction, markerEndOffset);
15510
15511          _shiftMarker(markerEnd, direction, markerEndOffset - (pinOffset || 0));
15512        }
15513
15514        isFirstRefresh && !_refreshingAll && self.update();
15515
15516        if (onRefresh && !_refreshingAll && !executingOnRefresh) {
15517          executingOnRefresh = true;
15518          onRefresh(self);
15519          executingOnRefresh = false;
15520        }
15521      };
15522
15523      self.getVelocity = function () {
15524        return (scrollFunc() - scroll2) / (_getTime$2() - _time2) * 1000 || 0;
15525      };
15526
15527      self.endAnimation = function () {
15528        _endAnimation(self.callbackAnimation);
15529
15530        if (animation) {
15531          scrubTween ? scrubTween.progress(1) : !animation.paused() ? _endAnimation(animation, animation.reversed()) : isToggle || _endAnimation(animation, self.direction < 0, 1);
15532        }
15533      };
15534
15535      self.labelToScroll = function (label) {
15536        return animation && animation.labels && (start || self.refresh() || start) + animation.labels[label] / animation.duration() * change || 0;
15537      };
15538
15539      self.getTrailing = function (name) {
15540        var i = _triggers.indexOf(self),
15541            a = self.direction > 0 ? _triggers.slice(0, i).reverse() : _triggers.slice(i + 1);
15542
15543        return (_isString$4(name) ? a.filter(function (t) {
15544          return t.vars.preventOverlaps === name;
15545        }) : a).filter(function (t) {
15546          return self.direction > 0 ? t.end <= start : t.start >= end;
15547        });
15548      };
15549
15550      self.update = function (reset, recordVelocity, forceFake) {
15551        if (containerAnimation && !forceFake && !reset) {
15552          return;
15553        }
15554
15555        var scroll = _refreshingAll === true ? prevScroll : self.scroll(),
15556            p = reset ? 0 : (scroll - start) / change,
15557            clipped = p < 0 ? 0 : p > 1 ? 1 : p || 0,
15558            prevProgress = self.progress,
15559            isActive,
15560            wasActive,
15561            toggleState,
15562            action,
15563            stateChanged,
15564            toggled,
15565            isAtMax,
15566            isTakingAction;
15567
15568        if (recordVelocity) {
15569          scroll2 = scroll1;
15570          scroll1 = containerAnimation ? scrollFunc() : scroll;
15571
15572          if (snap) {
15573            snap2 = snap1;
15574            snap1 = animation && !isToggle ? animation.totalProgress() : clipped;
15575          }
15576        }
15577
15578        if (anticipatePin && pin && !_refreshing && !_startup$1 && _lastScrollTime) {
15579          if (!clipped && start < scroll + (scroll - scroll2) / (_getTime$2() - _time2) * anticipatePin) {
15580            clipped = 0.0001;
15581          } else if (clipped === 1 && end > scroll + (scroll - scroll2) / (_getTime$2() - _time2) * anticipatePin) {
15582            clipped = 0.9999;
15583          }
15584        }
15585
15586        if (clipped !== prevProgress && self.enabled) {
15587          isActive = self.isActive = !!clipped && clipped < 1;
15588          wasActive = !!prevProgress && prevProgress < 1;
15589          toggled = isActive !== wasActive;
15590          stateChanged = toggled || !!clipped !== !!prevProgress;
15591          self.direction = clipped > prevProgress ? 1 : -1;
15592          self.progress = clipped;
15593
15594          if (stateChanged && !_refreshing) {
15595            toggleState = clipped && !prevProgress ? 0 : clipped === 1 ? 1 : prevProgress === 1 ? 2 : 3;
15596
15597            if (isToggle) {
15598              action = !toggled && toggleActions[toggleState + 1] !== "none" && toggleActions[toggleState + 1] || toggleActions[toggleState];
15599              isTakingAction = animation && (action === "complete" || action === "reset" || action in animation);
15600            }
15601          }
15602
15603          preventOverlaps && (toggled || isTakingAction) && (isTakingAction || scrub || !animation) && (_isFunction$4(preventOverlaps) ? preventOverlaps(self) : self.getTrailing(preventOverlaps).forEach(function (t) {
15604            return t.endAnimation();
15605          }));
15606
15607          if (!isToggle) {
15608            if (scrubTween && !_refreshing && !_startup$1) {
15609              scrubTween._dp._time - scrubTween._start !== scrubTween._time && scrubTween.render(scrubTween._dp._time - scrubTween._start);
15610
15611              if (scrubTween.resetTo) {
15612                scrubTween.resetTo("totalProgress", clipped, animation._tTime / animation._tDur);
15613              } else {
15614                scrubTween.vars.totalProgress = clipped;
15615                scrubTween.invalidate().restart();
15616              }
15617            } else if (animation) {
15618              animation.totalProgress(clipped, !!(_refreshing && (lastRefresh || reset)));
15619            }
15620          }
15621
15622          if (pin) {
15623            reset && pinSpacing && (spacer.style[pinSpacing + direction.os2] = spacingStart);
15624
15625            if (!useFixedPosition) {
15626              pinSetter(_round$5(pinStart + pinChange * clipped));
15627            } else if (stateChanged) {
15628              isAtMax = !reset && clipped > prevProgress && end + 1 > scroll && scroll + 1 >= _maxScroll(scroller, direction);
15629
15630              if (pinReparent) {
15631                if (!reset && (isActive || isAtMax)) {
15632                  var bounds = _getBounds$1(pin, true),
15633                      _offset = scroll - start;
15634
15635                  _reparent(pin, _body$5, bounds.top + (direction === _vertical ? _offset : 0) + _px, bounds.left + (direction === _vertical ? 0 : _offset) + _px);
15636                } else {
15637                  _reparent(pin, spacer);
15638                }
15639              }
15640
15641              _setState(isActive || isAtMax ? pinActiveState : pinState);
15642
15643              pinMoves && clipped < 1 && isActive || pinSetter(pinStart + (clipped === 1 && !isAtMax ? pinChange : 0));
15644            }
15645          }
15646
15647          snap && !tweenTo.tween && !_refreshing && !_startup$1 && snapDelayedCall.restart(true);
15648          toggleClass && (toggled || once && clipped && (clipped < 1 || !_limitCallbacks)) && _toArray$4(toggleClass.targets).forEach(function (el) {
15649            return el.classList[isActive || once ? "add" : "remove"](toggleClass.className);
15650          });
15651          onUpdate && !isToggle && !reset && onUpdate(self);
15652
15653          if (stateChanged && !_refreshing) {
15654            if (isToggle) {
15655              if (isTakingAction) {
15656                if (action === "complete") {
15657                  animation.pause().totalProgress(1);
15658                } else if (action === "reset") {
15659                  animation.restart(true).pause();
15660                } else if (action === "restart") {
15661                  animation.restart(true);
15662                } else {
15663                  animation[action]();
15664                }
15665              }
15666
15667              onUpdate && onUpdate(self);
15668            }
15669
15670            if (toggled || !_limitCallbacks) {
15671              onToggle && toggled && _callback$1(self, onToggle);
15672              callbacks[toggleState] && _callback$1(self, callbacks[toggleState]);
15673              once && (clipped === 1 ? self.kill(false, 1) : callbacks[toggleState] = 0);
15674
15675              if (!toggled) {
15676                toggleState = clipped === 1 ? 1 : 3;
15677                callbacks[toggleState] && _callback$1(self, callbacks[toggleState]);
15678              }
15679            }
15680
15681            if (fastScrollEnd && !isActive && Math.abs(self.getVelocity()) > (_isNumber$2(fastScrollEnd) ? fastScrollEnd : 2500)) {
15682              _endAnimation(self.callbackAnimation);
15683
15684              scrubTween ? scrubTween.progress(1) : _endAnimation(animation, action === "reverse" ? 1 : !clipped, 1);
15685            }
15686          } else if (isToggle && onUpdate && !_refreshing) {
15687            onUpdate(self);
15688          }
15689        }
15690
15691        if (markerEndSetter) {
15692          var n = containerAnimation ? scroll / containerAnimation.duration() * (containerAnimation._caScrollDist || 0) : scroll;
15693          markerStartSetter(n + (markerStartTrigger._isFlipped ? 1 : 0));
15694          markerEndSetter(n);
15695        }
15696
15697        caMarkerSetter && caMarkerSetter(-scroll / containerAnimation.duration() * (containerAnimation._caScrollDist || 0));
15698      };
15699
15700      self.enable = function (reset, refresh) {
15701        if (!self.enabled) {
15702          self.enabled = true;
15703
15704          _addListener$2(scroller, "resize", _onResize);
15705
15706          isViewport || _addListener$2(scroller, "scroll", _onScroll$1);
15707          onRefreshInit && _addListener$2(ScrollTrigger, "refreshInit", onRefreshInit);
15708
15709          if (reset !== false) {
15710            self.progress = prevProgress = 0;
15711            scroll1 = scroll2 = lastSnap = scrollFunc();
15712          }
15713
15714          refresh !== false && self.refresh();
15715        }
15716      };
15717
15718      self.getTween = function (snap) {
15719        return snap && tweenTo ? tweenTo.tween : scrubTween;
15720      };
15721
15722      self.setPositions = function (newStart, newEnd, keepClamp, pinOffset) {
15723        if (containerAnimation) {
15724          var st = containerAnimation.scrollTrigger,
15725              duration = containerAnimation.duration(),
15726              _change = st.end - st.start;
15727
15728          newStart = st.start + _change * newStart / duration;
15729          newEnd = st.start + _change * newEnd / duration;
15730        }
15731
15732        self.refresh(false, false, {
15733          start: _keepClamp(newStart, keepClamp && !!self._startClamp),
15734          end: _keepClamp(newEnd, keepClamp && !!self._endClamp)
15735        }, pinOffset);
15736        self.update();
15737      };
15738
15739      self.adjustPinSpacing = function (amount) {
15740        if (spacerState && amount) {
15741          var i = spacerState.indexOf(direction.d) + 1;
15742          spacerState[i] = parseFloat(spacerState[i]) + amount + _px;
15743          spacerState[1] = parseFloat(spacerState[1]) + amount + _px;
15744
15745          _setState(spacerState);
15746        }
15747      };
15748
15749      self.disable = function (reset, allowAnimation) {
15750

vendor: 12,223 bytes, lines 15750-16114

15750if (self.enabled) {
15751          reset !== false && self.revert(true, true);
15752          self.enabled = self.isActive = false;
15753          allowAnimation || scrubTween && scrubTween.pause();
15754          prevScroll = 0;
15755          pinCache && (pinCache.uncache = 1);
15756          onRefreshInit && _removeListener$2(ScrollTrigger, "refreshInit", onRefreshInit);
15757
15758          if (snapDelayedCall) {
15759            snapDelayedCall.pause();
15760            tweenTo.tween && tweenTo.tween.kill() && (tweenTo.tween = 0);
15761          }
15762
15763          if (!isViewport) {
15764            var i = _triggers.length;
15765
15766            while (i--) {
15767              if (_triggers[i].scroller === scroller && _triggers[i] !== self) {
15768                return;
15769              }
15770            }
15771
15772            _removeListener$2(scroller, "resize", _onResize);
15773
15774            isViewport || _removeListener$2(scroller, "scroll", _onScroll$1);
15775          }
15776        }
15777      };
15778
15779      self.kill = function (revert, allowAnimation) {
15780        self.disable(revert, allowAnimation);
15781        scrubTween && !allowAnimation && scrubTween.kill();
15782        id && delete _ids[id];
15783
15784        var i = _triggers.indexOf(self);
15785
15786        i >= 0 && _triggers.splice(i, 1);
15787        i === _i && _direction > 0 && _i--;
15788        i = 0;
15789
15790        _triggers.forEach(function (t) {
15791          return t.scroller === self.scroller && (i = 1);
15792        });
15793
15794        i || _refreshingAll || (self.scroll.rec = 0);
15795
15796        if (animation) {
15797          animation.scrollTrigger = null;
15798          revert && animation.revert({
15799            kill: false
15800          });
15801          allowAnimation || animation.kill();
15802        }
15803
15804        markerStart && [markerStart, markerEnd, markerStartTrigger, markerEndTrigger].forEach(function (m) {
15805          return m.parentNode && m.parentNode.removeChild(m);
15806        });
15807        _primary === self && (_primary = 0);
15808
15809        if (pin) {
15810          pinCache && (pinCache.uncache = 1);
15811          i = 0;
15812
15813          _triggers.forEach(function (t) {
15814            return t.pin === pin && i++;
15815          });
15816
15817          i || (pinCache.spacer = 0);
15818        }
15819
15820        vars.onKill && vars.onKill(self);
15821      };
15822
15823      _triggers.push(self);
15824
15825      self.enable(false, false);
15826      customRevertReturn && customRevertReturn(self);
15827
15828      if (animation && animation.add && !change) {
15829        var updateFunc = self.update;
15830
15831        self.update = function () {
15832          self.update = updateFunc;
15833          start || end || self.refresh();
15834        };
15835
15836        gsap$b.delayedCall(0.01, self.update);
15837        change = 0.01;
15838        start = end = 0;
15839      } else {
15840        self.refresh();
15841      }
15842
15843      pin && _queueRefreshAll();
15844    };
15845
15846    ScrollTrigger.register = function register(core) {
15847      if (!_coreInitted$8) {
15848        gsap$b = core || _getGSAP$9();
15849        _windowExists$7() && window.document && ScrollTrigger.enable();
15850        _coreInitted$8 = _enabled;
15851      }
15852
15853      return _coreInitted$8;
15854    };
15855
15856    ScrollTrigger.defaults = function defaults(config) {
15857      if (config) {
15858        for (var p in config) {
15859          _defaults$1[p] = config[p];
15860        }
15861      }
15862
15863      return _defaults$1;
15864    };
15865
15866    ScrollTrigger.disable = function disable(reset, kill) {
15867      _enabled = 0;
15868
15869      _triggers.forEach(function (trigger) {
15870        return trigger[kill ? "kill" : "disable"](reset);
15871      });
15872
15873      _removeListener$2(_win$6, "wheel", _onScroll$1);
15874
15875      _removeListener$2(_doc$6, "scroll", _onScroll$1);
15876
15877      clearInterval(_syncInterval);
15878
15879      _removeListener$2(_doc$6, "touchcancel", _passThrough$1);
15880
15881      _removeListener$2(_body$5, "touchstart", _passThrough$1);
15882
15883      _multiListener(_removeListener$2, _doc$6, "pointerdown,touchstart,mousedown", _pointerDownHandler);
15884
15885      _multiListener(_removeListener$2, _doc$6, "pointerup,touchend,mouseup", _pointerUpHandler);
15886
15887      _resizeDelay.kill();
15888
15889      _iterateAutoRefresh(_removeListener$2);
15890
15891      for (var i = 0; i < exports._scrollers.length; i += 3) {
15892        _wheelListener(_removeListener$2, exports._scrollers[i], exports._scrollers[i + 1]);
15893
15894        _wheelListener(_removeListener$2, exports._scrollers[i], exports._scrollers[i + 2]);
15895      }
15896    };
15897
15898    ScrollTrigger.enable = function enable() {
15899      _win$6 = window;
15900      _doc$6 = document;
15901      _docEl$2 = _doc$6.documentElement;
15902      _body$5 = _doc$6.body;
15903
15904      if (gsap$b) {
15905        _toArray$4 = gsap$b.utils.toArray;
15906        _clamp$2 = gsap$b.utils.clamp;
15907        _context$3 = gsap$b.core.context || _passThrough$1;
15908        _suppressOverwrites$1 = gsap$b.core.suppressOverwrites || _passThrough$1;
15909        _scrollRestoration = _win$6.history.scrollRestoration || "auto";
15910        _lastScroll = _win$6.pageYOffset;
15911        gsap$b.core.globals("ScrollTrigger", ScrollTrigger);
15912
15913        if (_body$5) {
15914          _enabled = 1;
15915          _div100vh = document.createElement("div");
15916          _div100vh.style.height = "100vh";
15917          _div100vh.style.position = "absolute";
15918
15919          _refresh100vh();
15920
15921          _rafBugFix();
15922
15923          Observer.register(gsap$b);
15924          ScrollTrigger.isTouch = Observer.isTouch;
15925          _fixIOSBug = Observer.isTouch && /(iPad|iPhone|iPod|Mac)/g.test(navigator.userAgent);
15926          _ignoreMobileResize = Observer.isTouch === 1;
15927
15928          _addListener$2(_win$6, "wheel", _onScroll$1);
15929
15930          _root$1 = [_win$6, _doc$6, _docEl$2, _body$5];
15931
15932          if (gsap$b.matchMedia) {
15933            ScrollTrigger.matchMedia = function (vars) {
15934              var mm = gsap$b.matchMedia(),
15935                  p;
15936
15937              for (p in vars) {
15938                mm.add(p, vars[p]);
15939              }
15940
15941              return mm;
15942            };
15943
15944            gsap$b.addEventListener("matchMediaInit", function () {
15945              return _revertAll();
15946            });
15947            gsap$b.addEventListener("matchMediaRevert", function () {
15948              return _revertRecorded();
15949            });
15950            gsap$b.addEventListener("matchMedia", function () {
15951              _refreshAll(0, 1);
15952
15953              _dispatch$1("matchMedia");
15954            });
15955            gsap$b.matchMedia("(orientation: portrait)", function () {
15956              _setBaseDimensions();
15957
15958              return _setBaseDimensions;
15959            });
15960          } else {
15961            console.warn("Requires GSAP 3.11.0 or later");
15962          }
15963
15964          _setBaseDimensions();
15965
15966          _addListener$2(_doc$6, "scroll", _onScroll$1);
15967
15968          var bodyStyle = _body$5.style,
15969              border = bodyStyle.borderTopStyle,
15970              AnimationProto = gsap$b.core.Animation.prototype,
15971              bounds,
15972              i;
15973          AnimationProto.revert || Object.defineProperty(AnimationProto, "revert", {
15974            value: function value() {
15975              return this.time(-0.01, true);
15976            }
15977          });
15978          bodyStyle.borderTopStyle = "solid";
15979          bounds = _getBounds$1(_body$5);
15980          _vertical.m = Math.round(bounds.top + _vertical.sc()) || 0;
15981          _horizontal.m = Math.round(bounds.left + _horizontal.sc()) || 0;
15982          border ? bodyStyle.borderTopStyle = border : bodyStyle.removeProperty("border-top-style");
15983          _syncInterval = setInterval(_sync, 250);
15984          gsap$b.delayedCall(0.5, function () {
15985            return _startup$1 = 0;
15986          });
15987
15988          _addListener$2(_doc$6, "touchcancel", _passThrough$1);
15989
15990          _addListener$2(_body$5, "touchstart", _passThrough$1);
15991
15992          _multiListener(_addListener$2, _doc$6, "pointerdown,touchstart,mousedown", _pointerDownHandler);
15993
15994          _multiListener(_addListener$2, _doc$6, "pointerup,touchend,mouseup", _pointerUpHandler);
15995
15996          _transformProp$3 = gsap$b.utils.checkPrefix("transform");
15997
15998          _stateProps.push(_transformProp$3);
15999
16000          _coreInitted$8 = _getTime$2();
16001          _resizeDelay = gsap$b.delayedCall(0.2, _refreshAll).pause();
16002          _autoRefresh = [_doc$6, "visibilitychange", function () {
16003            var w = _win$6.innerWidth,
16004                h = _win$6.innerHeight;
16005
16006            if (_doc$6.hidden) {
16007              _prevWidth = w;
16008              _prevHeight = h;
16009            } else if (_prevWidth !== w || _prevHeight !== h) {
16010              _onResize();
16011            }
16012          }, _doc$6, "DOMContentLoaded", _refreshAll, _win$6, "load", _refreshAll, _win$6, "resize", _onResize];
16013
16014          _iterateAutoRefresh(_addListener$2);
16015
16016          _triggers.forEach(function (trigger) {
16017            return trigger.enable(0, 1);
16018          });
16019
16020          for (i = 0; i < exports._scrollers.length; i += 3) {
16021            _wheelListener(_removeListener$2, exports._scrollers[i], exports._scrollers[i + 1]);
16022
16023            _wheelListener(_removeListener$2, exports._scrollers[i], exports._scrollers[i + 2]);
16024          }
16025        }
16026      }
16027    };
16028
16029    ScrollTrigger.config = function config(vars) {
16030      "limitCallbacks" in vars && (_limitCallbacks = !!vars.limitCallbacks);
16031      var ms = vars.syncInterval;
16032      ms && clearInterval(_syncInterval) || (_syncInterval = ms) && setInterval(_sync, ms);
16033      "ignoreMobileResize" in vars && (_ignoreMobileResize = ScrollTrigger.isTouch === 1 && vars.ignoreMobileResize);
16034
16035      if ("autoRefreshEvents" in vars) {
16036        _iterateAutoRefresh(_removeListener$2) || _iterateAutoRefresh(_addListener$2, vars.autoRefreshEvents || "none");
16037        _ignoreResize = (vars.autoRefreshEvents + "").indexOf("resize") === -1;
16038      }
16039    };
16040
16041    ScrollTrigger.scrollerProxy = function scrollerProxy(target, vars) {
16042      var t = _getTarget(target),
16043          i = exports._scrollers.indexOf(t),
16044          isViewport = _isViewport$1(t);
16045
16046      if (~i) {
16047        exports._scrollers.splice(i, isViewport ? 6 : 2);
16048      }
16049
16050      if (vars) {
16051        isViewport ? exports._proxies.unshift(_win$6, vars, _body$5, vars, _docEl$2, vars) : exports._proxies.unshift(t, vars);
16052      }
16053    };
16054
16055    ScrollTrigger.clearMatchMedia = function clearMatchMedia(query) {
16056      _triggers.forEach(function (t) {
16057        return t._ctx && t._ctx.query === query && t._ctx.kill(true, true);
16058      });
16059    };
16060
16061    ScrollTrigger.isInViewport = function isInViewport(element, ratio, horizontal) {
16062      var bounds = (_isString$4(element) ? _getTarget(element) : element).getBoundingClientRect(),
16063          offset = bounds[horizontal ? _width : _height] * ratio || 0;
16064      return horizontal ? bounds.right - offset > 0 && bounds.left + offset < _win$6.innerWidth : bounds.bottom - offset > 0 && bounds.top + offset < _win$6.innerHeight;
16065    };
16066
16067    ScrollTrigger.positionInViewport = function positionInViewport(element, referencePoint, horizontal) {
16068      _isString$4(element) && (element = _getTarget(element));
16069      var bounds = element.getBoundingClientRect(),
16070          size = bounds[horizontal ? _width : _height],
16071          offset = referencePoint == null ? size / 2 : referencePoint in _keywords ? _keywords[referencePoint] * size : ~referencePoint.indexOf("%") ? parseFloat(referencePoint) * size / 100 : parseFloat(referencePoint) || 0;
16072      return horizontal ? (bounds.left + offset) / _win$6.innerWidth : (bounds.top + offset) / _win$6.innerHeight;
16073    };
16074
16075    ScrollTrigger.killAll = function killAll(allowListeners) {
16076      _triggers.slice(0).forEach(function (t) {
16077        return t.vars.id !== "ScrollSmoother" && t.kill();
16078      });
16079
16080      if (allowListeners !== true) {
16081        var listeners = _listeners$1.killAll || [];
16082        _listeners$1 = {};
16083        listeners.forEach(function (f) {
16084          return f();
16085        });
16086      }
16087    };
16088
16089    return ScrollTrigger;
16090  }();
16091  ScrollTrigger$2.version = "3.12.5";
16092
16093  ScrollTrigger$2.saveStyles = function (targets) {
16094    return targets ? _toArray$4(targets).forEach(function (target) {
16095      if (target && target.style) {
16096        var i = _savedStyles.indexOf(target);
16097
16098        i >= 0 && _savedStyles.splice(i, 5);
16099
16100        _savedStyles.push(target, target.style.cssText, target.getBBox && target.getAttribute("transform"), gsap$b.core.getCache(target), _context$3());
16101      }
16102    }) : _savedStyles;
16103  };
16104
16105  ScrollTrigger$2.revert = function (soft, media) {
16106    return _revertAll(!soft, media);
16107  };
16108
16109  ScrollTrigger$2.create = function (vars, animation) {
16110    return new ScrollTrigger$2(vars, animation);
16111  };
16112
16113  ScrollTrigger$2.refresh = function (safe) {
16114    return safe ? _onResize(

vendor: 12,843 bytes, lines 16114-16488

16114) : (_coreInitted$8 || ScrollTrigger$2.register()) && _refreshAll(true);
16115  };
16116
16117  ScrollTrigger$2.update = function (force) {
16118    return ++exports._scrollers.cache && _updateAll(force === true ? 2 : 0);
16119  };
16120
16121  ScrollTrigger$2.clearScrollMemory = _clearScrollMemory;
16122
16123  ScrollTrigger$2.maxScroll = function (element, horizontal) {
16124    return _maxScroll(element, horizontal ? _horizontal : _vertical);
16125  };
16126
16127  ScrollTrigger$2.getScrollFunc = function (element, horizontal) {
16128    return _getScrollFunc(_getTarget(element), horizontal ? _horizontal : _vertical);
16129  };
16130
16131  ScrollTrigger$2.getById = function (id) {
16132    return _ids[id];
16133  };
16134
16135  ScrollTrigger$2.getAll = function () {
16136    return _triggers.filter(function (t) {
16137      return t.vars.id !== "ScrollSmoother";
16138    });
16139  };
16140
16141  ScrollTrigger$2.isScrolling = function () {
16142    return !!_lastScrollTime;
16143  };
16144
16145  ScrollTrigger$2.snapDirectional = _snapDirectional;
16146
16147  ScrollTrigger$2.addEventListener = function (type, callback) {
16148    var a = _listeners$1[type] || (_listeners$1[type] = []);
16149    ~a.indexOf(callback) || a.push(callback);
16150  };
16151
16152  ScrollTrigger$2.removeEventListener = function (type, callback) {
16153    var a = _listeners$1[type],
16154        i = a && a.indexOf(callback);
16155    i >= 0 && a.splice(i, 1);
16156  };
16157
16158  ScrollTrigger$2.batch = function (targets, vars) {
16159    var result = [],
16160        varsCopy = {},
16161        interval = vars.interval || 0.016,
16162        batchMax = vars.batchMax || 1e9,
16163        proxyCallback = function proxyCallback(type, callback) {
16164      var elements = [],
16165          triggers = [],
16166          delay = gsap$b.delayedCall(interval, function () {
16167        callback(elements, triggers);
16168        elements = [];
16169        triggers = [];
16170      }).pause();
16171      return function (self) {
16172        elements.length || delay.restart(true);
16173        elements.push(self.trigger);
16174        triggers.push(self);
16175        batchMax <= elements.length && delay.progress(1);
16176      };
16177    },
16178        p;
16179
16180    for (p in vars) {
16181      varsCopy[p] = p.substr(0, 2) === "on" && _isFunction$4(vars[p]) && p !== "onRefreshInit" ? proxyCallback(p, vars[p]) : vars[p];
16182    }
16183
16184    if (_isFunction$4(batchMax)) {
16185      batchMax = batchMax();
16186
16187      _addListener$2(ScrollTrigger$2, "refresh", function () {
16188        return batchMax = vars.batchMax();
16189      });
16190    }
16191
16192    _toArray$4(targets).forEach(function (target) {
16193      var config = {};
16194
16195      for (p in varsCopy) {
16196        config[p] = varsCopy[p];
16197      }
16198
16199      config.trigger = target;
16200      result.push(ScrollTrigger$2.create(config));
16201    });
16202
16203    return result;
16204  };
16205
16206  var _clampScrollAndGetDurationMultiplier = function _clampScrollAndGetDurationMultiplier(scrollFunc, current, end, max) {
16207    current > max ? scrollFunc(max) : current < 0 && scrollFunc(0);
16208    return end > max ? (max - current) / (end - current) : end < 0 ? current / (current - end) : 1;
16209  },
16210      _allowNativePanning = function _allowNativePanning(target, direction) {
16211    if (direction === true) {
16212      target.style.removeProperty("touch-action");
16213    } else {
16214      target.style.touchAction = direction === true ? "auto" : direction ? "pan-" + direction + (Observer.isTouch ? " pinch-zoom" : "") : "none";
16215    }
16216
16217    target === _docEl$2 && _allowNativePanning(_body$5, direction);
16218  },
16219      _overflow = {
16220    auto: 1,
16221    scroll: 1
16222  },
16223      _nestedScroll = function _nestedScroll(_ref5) {
16224    var event = _ref5.event,
16225        target = _ref5.target,
16226        axis = _ref5.axis;
16227
16228    var node = (event.changedTouches ? event.changedTouches[0] : event).target,
16229        cache = node._gsap || gsap$b.core.getCache(node),
16230        time = _getTime$2(),
16231        cs;
16232
16233    if (!cache._isScrollT || time - cache._isScrollT > 2000) {
16234      while (node && node !== _body$5 && (node.scrollHeight <= node.clientHeight && node.scrollWidth <= node.clientWidth || !(_overflow[(cs = _getComputedStyle$1(node)).overflowY] || _overflow[cs.overflowX]))) {
16235        node = node.parentNode;
16236      }
16237
16238      cache._isScroll = node && node !== target && !_isViewport$1(node) && (_overflow[(cs = _getComputedStyle$1(node)).overflowY] || _overflow[cs.overflowX]);
16239      cache._isScrollT = time;
16240    }
16241
16242    if (cache._isScroll || axis === "x") {
16243      event.stopPropagation();
16244      event._gsapAllow = true;
16245    }
16246  },
16247      _inputObserver = function _inputObserver(target, type, inputs, nested) {
16248    return Observer.create({
16249      target: target,
16250      capture: true,
16251      debounce: false,
16252      lockAxis: true,
16253      type: type,
16254      onWheel: nested = nested && _nestedScroll,
16255      onPress: nested,
16256      onDrag: nested,
16257      onScroll: nested,
16258      onEnable: function onEnable() {
16259        return inputs && _addListener$2(_doc$6, Observer.eventTypes[0], _captureInputs, false, true);
16260      },
16261      onDisable: function onDisable() {
16262        return _removeListener$2(_doc$6, Observer.eventTypes[0], _captureInputs, true);
16263      }
16264    });
16265  },
16266      _inputExp = /(input|label|select|textarea)/i,
16267      _inputIsFocused,
16268      _captureInputs = function _captureInputs(e) {
16269    var isInput = _inputExp.test(e.target.tagName);
16270
16271    if (isInput || _inputIsFocused) {
16272      e._gsapAllow = true;
16273      _inputIsFocused = isInput;
16274    }
16275  },
16276      _getScrollNormalizer = function _getScrollNormalizer(vars) {
16277    _isObject$2(vars) || (vars = {});
16278    vars.preventDefault = vars.isNormalizer = vars.allowClicks = true;
16279    vars.type || (vars.type = "wheel,touch");
16280    vars.debounce = !!vars.debounce;
16281    vars.id = vars.id || "normalizer";
16282
16283    var _vars2 = vars,
16284        normalizeScrollX = _vars2.normalizeScrollX,
16285        momentum = _vars2.momentum,
16286        allowNestedScroll = _vars2.allowNestedScroll,
16287        onRelease = _vars2.onRelease,
16288        self,
16289        maxY,
16290        target = _getTarget(vars.target) || _docEl$2,
16291        smoother = gsap$b.core.globals().ScrollSmoother,
16292        smootherInstance = smoother && smoother.get(),
16293        content = _fixIOSBug && (vars.content && _getTarget(vars.content) || smootherInstance && vars.content !== false && !smootherInstance.smooth() && smootherInstance.content()),
16294        scrollFuncY = _getScrollFunc(target, _vertical),
16295        scrollFuncX = _getScrollFunc(target, _horizontal),
16296        scale = 1,
16297        initialScale = (Observer.isTouch && _win$6.visualViewport ? _win$6.visualViewport.scale * _win$6.visualViewport.width : _win$6.outerWidth) / _win$6.innerWidth,
16298        wheelRefresh = 0,
16299        resolveMomentumDuration = _isFunction$4(momentum) ? function () {
16300      return momentum(self);
16301    } : function () {
16302      return momentum || 2.8;
16303    },
16304        lastRefreshID,
16305        skipTouchMove,
16306        inputObserver = _inputObserver(target, vars.type, true, allowNestedScroll),
16307        resumeTouchMove = function resumeTouchMove() {
16308      return skipTouchMove = false;
16309    },
16310        scrollClampX = _passThrough$1,
16311        scrollClampY = _passThrough$1,
16312        updateClamps = function updateClamps() {
16313      maxY = _maxScroll(target, _vertical);
16314      scrollClampY = _clamp$2(_fixIOSBug ? 1 : 0, maxY);
16315      normalizeScrollX && (scrollClampX = _clamp$2(0, _maxScroll(target, _horizontal)));
16316      lastRefreshID = _refreshID;
16317    },
16318        removeContentOffset = function removeContentOffset() {
16319      content._gsap.y = _round$5(parseFloat(content._gsap.y) + scrollFuncY.offset) + "px";
16320      content.style.transform = "matrix3d(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, " + parseFloat(content._gsap.y) + ", 0, 1)";
16321      scrollFuncY.offset = scrollFuncY.cacheID = 0;
16322    },
16323        ignoreDrag = function ignoreDrag() {
16324      if (skipTouchMove) {
16325        requestAnimationFrame(resumeTouchMove);
16326
16327        var offset = _round$5(self.deltaY / 2),
16328            scroll = scrollClampY(scrollFuncY.v - offset);
16329
16330        if (content && scroll !== scrollFuncY.v + scrollFuncY.offset) {
16331          scrollFuncY.offset = scroll - scrollFuncY.v;
16332
16333          var y = _round$5((parseFloat(content && content._gsap.y) || 0) - scrollFuncY.offset);
16334
16335          content.style.transform = "matrix3d(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, " + y + ", 0, 1)";
16336          content._gsap.y = y + "px";
16337          scrollFuncY.cacheID = exports._scrollers.cache;
16338
16339          _updateAll();
16340        }
16341
16342        return true;
16343      }
16344
16345      scrollFuncY.offset && removeContentOffset();
16346      skipTouchMove = true;
16347    },
16348        tween,
16349        startScrollX,
16350        startScrollY,
16351        onStopDelayedCall,
16352        onResize = function onResize() {
16353      updateClamps();
16354
16355      if (tween.isActive() && tween.vars.scrollY > maxY) {
16356        scrollFuncY() > maxY ? tween.progress(1) && scrollFuncY(maxY) : tween.resetTo("scrollY", maxY);
16357      }
16358    };
16359
16360    content && gsap$b.set(content, {
16361      y: "+=0"
16362    });
16363
16364    vars.ignoreCheck = function (e) {
16365      return _fixIOSBug && e.type === "touchmove" && ignoreDrag() || scale > 1.05 && e.type !== "touchstart" || self.isGesturing || e.touches && e.touches.length > 1;
16366    };
16367
16368    vars.onPress = function () {
16369      skipTouchMove = false;
16370      var prevScale = scale;
16371      scale = _round$5((_win$6.visualViewport && _win$6.visualViewport.scale || 1) / initialScale);
16372      tween.pause();
16373      prevScale !== scale && _allowNativePanning(target, scale > 1.01 ? true : normalizeScrollX ? false : "x");
16374      startScrollX = scrollFuncX();
16375      startScrollY = scrollFuncY();
16376      updateClamps();
16377      lastRefreshID = _refreshID;
16378    };
16379
16380    vars.onRelease = vars.onGestureStart = function (self, wasDragging) {
16381      scrollFuncY.offset && removeContentOffset();
16382
16383      if (!wasDragging) {
16384        onStopDelayedCall.restart(true);
16385      } else {
16386        exports._scrollers.cache++;
16387        var dur = resolveMomentumDuration(),
16388            currentScroll,
16389            endScroll;
16390
16391        if (normalizeScrollX) {
16392          currentScroll = scrollFuncX();
16393          endScroll = currentScroll + dur * 0.05 * -self.velocityX / 0.227;
16394          dur *= _clampScrollAndGetDurationMultiplier(scrollFuncX, currentScroll, endScroll, _maxScroll(target, _horizontal));
16395          tween.vars.scrollX = scrollClampX(endScroll);
16396        }
16397
16398        currentScroll = scrollFuncY();
16399        endScroll = currentScroll + dur * 0.05 * -self.velocityY / 0.227;
16400        dur *= _clampScrollAndGetDurationMultiplier(scrollFuncY, currentScroll, endScroll, _maxScroll(target, _vertical));
16401        tween.vars.scrollY = scrollClampY(endScroll);
16402        tween.invalidate().duration(dur).play(0.01);
16403
16404        if (_fixIOSBug && tween.vars.scrollY >= maxY || currentScroll >= maxY - 1) {
16405          gsap$b.to({}, {
16406            onUpdate: onResize,
16407            duration: dur
16408          });
16409        }
16410      }
16411
16412      onRelease && onRelease(self);
16413    };
16414
16415    vars.onWheel = function () {
16416      tween._ts && tween.pause();
16417
16418      if (_getTime$2() - wheelRefresh > 1000) {
16419        lastRefreshID = 0;
16420        wheelRefresh = _getTime$2();
16421      }
16422    };
16423
16424    vars.onChange = function (self, dx, dy, xArray, yArray) {
16425      _refreshID !== lastRefreshID && updateClamps();
16426      dx && normalizeScrollX && scrollFuncX(scrollClampX(xArray[2] === dx ? startScrollX + (self.startX - self.x) : scrollFuncX() + dx - xArray[1]));
16427
16428      if (dy) {
16429        scrollFuncY.offset && removeContentOffset();
16430        var isTouch = yArray[2] === dy,
16431            y = isTouch ? startScrollY + self.startY - self.y : scrollFuncY() + dy - yArray[1],
16432            yClamped = scrollClampY(y);
16433        isTouch && y !== yClamped && (startScrollY += yClamped - y);
16434        scrollFuncY(yClamped);
16435      }
16436
16437      (dy || dx) && _updateAll();
16438    };
16439
16440    vars.onEnable = function () {
16441      _allowNativePanning(target, normalizeScrollX ? false : "x");
16442
16443      ScrollTrigger$2.addEventListener("refresh", onResize);
16444
16445      _addListener$2(_win$6, "resize", onResize);
16446
16447      if (scrollFuncY.smooth) {
16448        scrollFuncY.target.style.scrollBehavior = "auto";
16449        scrollFuncY.smooth = scrollFuncX.smooth = false;
16450      }
16451
16452      inputObserver.enable();
16453    };
16454
16455    vars.onDisable = function () {
16456      _allowNativePanning(target, true);
16457
16458      _removeListener$2(_win$6, "resize", onResize);
16459
16460      ScrollTrigger$2.removeEventListener("refresh", onResize);
16461      inputObserver.kill();
16462    };
16463
16464    vars.lockAxis = vars.lockAxis !== false;
16465    self = new Observer(vars);
16466    self.iOS = _fixIOSBug;
16467    _fixIOSBug && !scrollFuncY() && scrollFuncY(1);
16468    _fixIOSBug && gsap$b.ticker.add(_passThrough$1);
16469    onStopDelayedCall = self._dc;
16470    tween = gsap$b.to(self, {
16471      ease: "power4",
16472      paused: true,
16473      inherit: false,
16474      scrollX: normalizeScrollX ? "+=0.1" : "+=0",
16475      scrollY: "+=0.1",
16476      modifiers: {
16477        scrollY: _interruptionTracker(scrollFuncY, scrollFuncY(), function () {
16478          return tween.pause();
16479        })
16480      },
16481      onUpdate: _updateAll,
16482      onComplete: onStopDelayedCall.vars.onComplete
16483    });
16484    return self;
16485  };
16486
16487  ScrollTrigger$2.sort = function (func) {
16488

16488return _triggers.sort(func || function (a, b) {
16489      return (a.vars.refreshPriority || 0) * -1e6 + a.start - (b.start + (b.vars.refreshPriority || 0) * -1e6);
16490    });
16491  };
16492
16493  ScrollTrigger$2.observe = function (vars) {
16494    return new Observer(vars);
16495  };
16496
16497  ScrollTrigger$2.normalizeScroll = function (vars) {
16498    if (typeof vars === "undefined") {
16499      return _normalizer$1;
16500    }
16501
16502    if (vars === true && _normalizer$1) {
16503      return _normalizer$1.enable();
16504    }
16505
16506    if (vars === false) {
16507      _normalizer$1 && _normalizer$1.kill();
16508      _normalizer$1 = vars;
16509      return;
16510    }
16511
16512    var normalizer = vars instanceof Observer ? vars : _getScrollNormalizer(vars);
16513    _normalizer$1 && _normalizer$1.target === normalizer.target && _normalizer$1.kill();
16514    _isViewport$1(normalizer.target) && (_normalizer$1 = normalizer);
16515    return normalizer;
16516  };
16517
16518  ScrollTrigger$2.core = {
16519    _getVelocityProp: _getVelocityProp,
16520    _inputObserver: _inputObserver,
16521    _scrollers: exports._scrollers,
16522    _proxies: exports._proxies,
16523    bridge: {
16524      ss: function ss() {
16525        _lastScrollTime || _dispatch$1("scrollStart");
16526        _lastScrollTime = _getTime$2();
16527      },
16528      ref: function ref() {
16529        return _refreshing;
16530      }
16531    }
16532  };
16533  _getGSAP$9() && gsap$b.registerPlugin(ScrollTrigger$2);
16534
16535  var _trimExp = /(?:^\s+|\s+$)/g;
16536  var emojiExp = /([\uD800-\uDBFF][\uDC00-\uDFFF](?:[\u200D\uFE0F][\uD800-\uDBFF][\uDC00-\uDFFF]){2,}|\uD83D\uDC69(?:\u200D(?:(?:\uD83D\uDC69\u200D)?\uD83D\uDC67|(?:\uD83D\uDC69\u200D)?\uD83D\uDC66)|\uD83C[\uDFFB-\uDFFF])|\uD83D\uDC69\u200D(?:\uD83D\uDC69\u200D)?\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC69\u200D(?:\uD83D\uDC69\u200D)?\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67])|\uD83C\uDFF3\uFE0F\u200D\uD83C\uDF08|(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD37-\uDD39\uDD3D\uDD3E\uDDD6-\uDDDD])(?:\uD83C[\uDFFB-\uDFFF])\u200D[\u2640\u2642]\uFE0F|\uD83D\uDC69(?:\uD83C[\uDFFB-\uDFFF])\u200D(?:\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92])|(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC6F\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD37-\uDD39\uDD3C-\uDD3E\uDDD6-\uDDDF])\u200D[\u2640\u2642]\uFE0F|\uD83C\uDDFD\uD83C\uDDF0|\uD83C\uDDF6\uD83C\uDDE6|\uD83C\uDDF4\uD83C\uDDF2|\uD83C\uDDE9(?:\uD83C[\uDDEA\uDDEC\uDDEF\uDDF0\uDDF2\uDDF4\uDDFF])|\uD83C\uDDF7(?:\uD83C[\uDDEA\uDDF4\uDDF8\uDDFA\uDDFC])|\uD83C\uDDE8(?:\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDEE\uDDF0-\uDDF5\uDDF7\uDDFA-\uDDFF])|(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)(?:\uFE0F\u200D[\u2640\u2642]|(?:\uD83C[\uDFFB-\uDFFF])\u200D[\u2640\u2642])\uFE0F|(?:\uD83D\uDC41\uFE0F\u200D\uD83D\uDDE8|\uD83D\uDC69(?:\uD83C[\uDFFB-\uDFFF])\u200D[\u2695\u2696\u2708]|\uD83D\uDC69\u200D[\u2695\u2696\u2708]|\uD83D\uDC68(?:(?:\uD83C[\uDFFB-\uDFFF])\u200D[\u2695\u2696\u2708]|\u200D[\u2695\u2696\u2708]))\uFE0F|\uD83C\uDDF2(?:\uD83C[\uDDE6\uDDE8-\uDDED\uDDF0-\uDDFF])|\uD83D\uDC69\u200D(?:\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D(?:\uD83D[\uDC68\uDC69])|\uD83D[\uDC68\uDC69]))|\uD83C\uDDF1(?:\uD83C[\uDDE6-\uDDE8\uDDEE\uDDF0\uDDF7-\uDDFB\uDDFE])|\uD83C\uDDEF(?:\uD83C[\uDDEA\uDDF2\uDDF4\uDDF5])|\uD83C\uDDED(?:\uD83C[\uDDF0\uDDF2\uDDF3\uDDF7\uDDF9\uDDFA])|\uD83C\uDDEB(?:\uD83C[\uDDEE-\uDDF0\uDDF2\uDDF4\uDDF7])|[#\*0-9]\uFE0F\u20E3|\uD83C\uDDE7(?:\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEF\uDDF1-\uDDF4\uDDF6-\uDDF9\uDDFB\uDDFC\uDDFE\uDDFF])|\uD83C\uDDE6(?:\uD83C[\uDDE8-\uDDEC\uDDEE\uDDF1\uDDF2\uDDF4\uDDF6-\uDDFA\uDDFC\uDDFD\uDDFF])|\uD83C\uDDFF(?:\uD83C[\uDDE6\uDDF2\uDDFC])|\uD83C\uDDF5(?:\uD83C[\uDDE6\uDDEA-\uDDED\uDDF0-\uDDF3\uDDF7-\uDDF9\uDDFC\uDDFE])|\uD83C\uDDFB(?:\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDEE\uDDF3\uDDFA])|\uD83C\uDDF3(?:\uD83C[\uDDE6\uDDE8\uDDEA-\uDDEC\uDDEE\uDDF1\uDDF4\uDDF5\uDDF7\uDDFA\uDDFF])|\uD83C\uDFF4\uDB40\uDC67\uDB40\uDC62(?:\uDB40\uDC77\uDB40\uDC6C\uDB40\uDC73|\uDB40\uDC73\uDB40\uDC63\uDB40\uDC74|\uDB40\uDC65\uDB40\uDC6E\uDB40\uDC67)\uDB40\uDC7F|\uD83D\uDC68(?:\u200D(?:\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83D\uDC68|(?:(?:\uD83D[\uDC68\uDC69])\u200D)?\uD83D\uDC66\u200D\uD83D\uDC66|(?:(?:\uD83D[\uDC68\uDC69])\u200D)?\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92])|(?:\uD83C[\uDFFB-\uDFFF])\u200D(?:\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]))|\uD83C\uDDF8(?:\uD83C[\uDDE6-\uDDEA\uDDEC-\uDDF4\uDDF7-\uDDF9\uDDFB\uDDFD-\uDDFF])|\uD83C\uDDF0(?:\uD83C[\uDDEA\uDDEC-\uDDEE\uDDF2\uDDF3\uDDF5\uDDF7\uDDFC\uDDFE\uDDFF])|\uD83C\uDDFE(?:\uD83C[\uDDEA\uDDF9])|\uD83C\uDDEE(?:\uD83C[\uDDE8-\uDDEA\uDDF1-\uDDF4\uDDF6-\uDDF9])|\uD83C\uDDF9(?:\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDED\uDDEF-\uDDF4\uDDF7\uDDF9\uDDFB\uDDFC\uDDFF])|\uD83C\uDDEC(?:\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEE\uDDF1-\uDDF3\uDDF5-\uDDFA\uDDFC\uDDFE])|\uD83C\uDDFA(?:\uD83C[\uDDE6\uDDEC\uDDF2\uDDF3\uDDF8\uDDFE\uDDFF])|\uD83C\uDDEA(?:\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDED\uDDF7-\uDDFA])|\uD83C\uDDFC(?:\uD83C[\uDDEB\uDDF8])|(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)(?:\uD83C[\uDFFB-\uDFFF])|(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD37-\uDD39\uDD3D\uDD3E\uDDD6-\uDDDD])(?:\uD83C[\uDFFB-\uDFFF])|(?:[\u261D\u270A-\u270D]|\uD83C[\uDF85\uDFC2\uDFC7]|\uD83D[\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC70\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDCAA\uDD74\uDD7A\uDD90\uDD95\uDD96\uDE4C\uDE4F\uDEC0\uDECC]|\uD83E[\uDD18-\uDD1C\uDD1E\uDD1F\uDD30-\uDD36\uDDD1-\uDDD5])(?:\uD83C[\uDFFB-\uDFFF])|\uD83D\uDC68(?:\u200D(?:(?:(?:\uD83D[\uDC68\uDC69])\u200D)?\uD83D\uDC67|(?:(?:\uD83D[\uDC68\uDC69])\u200D)?\uD83D\uDC66)|\uD83C[\uDFFB-\uDFFF])|(?:[\u261D\u26F9\u270A-\u270D]|\uD83C[\uDF85\uDFC2-\uD

vendor: 6,060 bytes, lines 16536-16661

16536FC4\uDFC7\uDFCA-\uDFCC]|\uD83D[\uDC42\uDC43\uDC46-\uDC50\uDC66-\uDC69\uDC6E\uDC70-\uDC78\uDC7C\uDC81-\uDC83\uDC85-\uDC87\uDCAA\uDD74\uDD75\uDD7A\uDD90\uDD95\uDD96\uDE45-\uDE47\uDE4B-\uDE4F\uDEA3\uDEB4-\uDEB6\uDEC0\uDECC]|\uD83E[\uDD18-\uDD1C\uDD1E\uDD1F\uDD26\uDD30-\uDD39\uDD3D\uDD3E\uDDD1-\uDDDD])(?:\uD83C[\uDFFB-\uDFFF])?|(?:[\u231A\u231B\u23E9-\u23EC\u23F0\u23F3\u25FD\u25FE\u2614\u2615\u2648-\u2653\u267F\u2693\u26A1\u26AA\u26AB\u26BD\u26BE\u26C4\u26C5\u26CE\u26D4\u26EA\u26F2\u26F3\u26F5\u26FA\u26FD\u2705\u270A\u270B\u2728\u274C\u274E\u2753-\u2755\u2757\u2795-\u2797\u27B0\u27BF\u2B1B\u2B1C\u2B50\u2B55]|\uD83C[\uDC04\uDCCF\uDD8E\uDD91-\uDD9A\uDDE6-\uDDFF\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF7C\uDF7E-\uDF93\uDFA0-\uDFCA\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF4\uDFF8-\uDFFF]|\uD83D[\uDC00-\uDC3E\uDC40\uDC42-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDD7A\uDD95\uDD96\uDDA4\uDDFB-\uDE4F\uDE80-\uDEC5\uDECC\uDED0-\uDED2\uDEEB\uDEEC\uDEF4-\uDEF8]|\uD83E[\uDD10-\uDD3A\uDD3C-\uDD3E\uDD40-\uDD45\uDD47-\uDD4C\uDD50-\uDD6B\uDD80-\uDD97\uDDC0\uDDD0-\uDDE6])|(?:[#\*0-9\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u231A\u231B\u2328\u23CF\u23E9-\u23F3\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB-\u25FE\u2600-\u2604\u260E\u2611\u2614\u2615\u2618\u261D\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u2648-\u2653\u2660\u2663\u2665\u2666\u2668\u267B\u267F\u2692-\u2697\u2699\u269B\u269C\u26A0\u26A1\u26AA\u26AB\u26B0\u26B1\u26BD\u26BE\u26C4\u26C5\u26C8\u26CE\u26CF\u26D1\u26D3\u26D4\u26E9\u26EA\u26F0-\u26F5\u26F7-\u26FA\u26FD\u2702\u2705\u2708-\u270D\u270F\u2712\u2714\u2716\u271D\u2721\u2728\u2733\u2734\u2744\u2747\u274C\u274E\u2753-\u2755\u2757\u2763\u2764\u2795-\u2797\u27A1\u27B0\u27BF\u2934\u2935\u2B05-\u2B07\u2B1B\u2B1C\u2B50\u2B55\u3030\u303D\u3297\u3299]|\uD83C[\uDC04\uDCCF\uDD70\uDD71\uDD7E\uDD7F\uDD8E\uDD91-\uDD9A\uDDE6-\uDDFF\uDE01\uDE02\uDE1A\uDE2F\uDE32-\uDE3A\uDE50\uDE51\uDF00-\uDF21\uDF24-\uDF93\uDF96\uDF97\uDF99-\uDF9B\uDF9E-\uDFF0\uDFF3-\uDFF5\uDFF7-\uDFFF]|\uD83D[\uDC00-\uDCFD\uDCFF-\uDD3D\uDD49-\uDD4E\uDD50-\uDD67\uDD6F\uDD70\uDD73-\uDD7A\uDD87\uDD8A-\uDD8D\uDD90\uDD95\uDD96\uDDA4\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA-\uDE4F\uDE80-\uDEC5\uDECB-\uDED2\uDEE0-\uDEE5\uDEE9\uDEEB\uDEEC\uDEF0\uDEF3-\uDEF8]|\uD83E[\uDD10-\uDD3A\uDD3C-\uDD3E\uDD40-\uDD45\uDD47-\uDD4C\uDD50-\uDD6B\uDD80-\uDD97\uDDC0\uDDD0-\uDDE6])\uFE0F)/;
16537  function getText(e) {
16538    var type = e.nodeType,
16539        result = "";
16540
16541    if (type === 1 || type === 9 || type === 11) {
16542      if (typeof e.textContent === "string") {
16543        return e.textContent;
16544      } else {
16545        for (e = e.firstChild; e; e = e.nextSibling) {
16546          result += getText(e);
16547        }
16548      }
16549    } else if (type === 3 || type === 4) {
16550      return e.nodeValue;
16551    }
16552
16553    return result;
16554  }
16555  function splitInnerHTML(element, delimiter, trim, preserveSpaces) {
16556    var node = element.firstChild,
16557        result = [],
16558        s;
16559
16560    while (node) {
16561      if (node.nodeType === 3) {
16562        s = (node.nodeValue + "").replace(/^\n+/g, "");
16563
16564        if (!preserveSpaces) {
16565          s = s.replace(/\s+/g, " ");
16566        }
16567
16568        result.push.apply(result, emojiSafeSplit(s, delimiter, trim, preserveSpaces));
16569      } else if ((node.nodeName + "").toLowerCase() === "br") {
16570        result[result.length - 1] += "<br>";
16571      } else {
16572        result.push(node.outerHTML);
16573      }
16574
16575      node = node.nextSibling;
16576    }
16577
16578    s = result.length;
16579
16580    while (s--) {
16581      result[s] === "&" && result.splice(s, 1, "&amp;");
16582    }
16583
16584    return result;
16585  }
16586  function emojiSafeSplit(text, delimiter, trim, preserveSpaces) {
16587    text += "";
16588    trim && (text = text.trim ? text.trim() : text.replace(_trimExp, ""));
16589
16590    if (delimiter && delimiter !== "") {
16591      return text.replace(/>/g, "&gt;").replace(/</g, "&lt;").split(delimiter);
16592    }
16593
16594    var result = [],
16595        l = text.length,
16596        i = 0,
16597        j,
16598        character;
16599
16600    for (; i < l; i++) {
16601      character = text.charAt(i);
16602
16603      if (character.charCodeAt(0) >= 0xD800 && character.charCodeAt(0) <= 0xDBFF || text.charCodeAt(i + 1) >= 0xFE00 && text.charCodeAt(i + 1) <= 0xFE0F) {
16604        j = ((text.substr(i, 12).split(emojiExp) || [])[1] || "").length || 2;
16605        character = text.substr(i, j);
16606        result.emoji = 1;
16607        i += j - 1;
16608      }
16609
16610      result.push(character === ">" ? "&gt;" : character === "<" ? "&lt;" : preserveSpaces && character === " " && (text.charAt(i - 1) === " " || text.charAt(i + 1) === " ") ? "&nbsp;" : character);
16611    }
16612
16613    return result;
16614  }
16615
16616  /*!
16617   * TextPlugin 3.12.5
16618   * https://gsap.com
16619   *
16620   * @license Copyright 2008-2024, GreenSock. All rights reserved.
16621   * Subject to the terms at https://gsap.com/standard-license or for
16622   * Club GSAP members, the agreement issued with that membership.
16623   * @author: Jack Doyle, [email protected]
16624  */
16625
16626  var gsap$c,
16627      _tempDiv$2,
16628      _getGSAP$a = function _getGSAP() {
16629    return gsap$c || typeof window !== "undefined" && (gsap$c = window.gsap) && gsap$c.registerPlugin && gsap$c;
16630  };
16631
16632  var TextPlugin = {
16633    version: "3.12.5",
16634    name: "text",
16635    init: function init(target, value, tween) {
16636      typeof value !== "object" && (value = {
16637        value: value
16638      });
16639
16640      var i = target.nodeName.toUpperCase(),
16641          data = this,
16642          _value = value,
16643          newClass = _value.newClass,
16644          oldClass = _value.oldClass,
16645          preserveSpaces = _value.preserveSpaces,
16646          rtl = _value.rtl,
16647          delimiter = data.delimiter = value.delimiter || "",
16648          fillChar = data.fillChar = value.fillChar || (value.padSpace ? "&nbsp;" : ""),
16649          _short,
16650          text,
16651          original,
16652          j,
16653          condensedText,
16654          condensedOriginal,
16655          aggregate,
16656          s;
16657
16658      data.svg = target.getBBox && (i === "TEXT" || i === "TSPAN");
16659
16660      if (!("innerHTML" in target) && !data.svg) {
16661        return false;

vendor: 3,527 bytes, lines 16662-16783

16662      }
16663
16664      data.target = target;
16665
16666      if (!("value" in value)) {
16667        data.text = data.original = [""];
16668        return;
16669      }
16670
16671      original = splitInnerHTML(target, delimiter, false, preserveSpaces);
16672      _tempDiv$2 || (_tempDiv$2 = document.createElement("div"));
16673      _tempDiv$2.innerHTML = value.value;
16674      text = splitInnerHTML(_tempDiv$2, delimiter, false, preserveSpaces);
16675      data.from = tween._from;
16676
16677      if ((data.from || rtl) && !(rtl && data.from)) {
16678        i = original;
16679        original = text;
16680        text = i;
16681      }
16682
16683      data.hasClass = !!(newClass || oldClass);
16684      data.newClass = rtl ? oldClass : newClass;
16685      data.oldClass = rtl ? newClass : oldClass;
16686      i = original.length - text.length;
16687      _short = i < 0 ? original : text;
16688
16689      if (i < 0) {
16690        i = -i;
16691      }
16692
16693      while (--i > -1) {
16694        _short.push(fillChar);
16695      }
16696
16697      if (value.type === "diff") {
16698        j = 0;
16699        condensedText = [];
16700        condensedOriginal = [];
16701        aggregate = "";
16702
16703        for (i = 0; i < text.length; i++) {
16704          s = text[i];
16705
16706          if (s === original[i]) {
16707            aggregate += s;
16708          } else {
16709            condensedText[j] = aggregate + s;
16710            condensedOriginal[j++] = aggregate + original[i];
16711            aggregate = "";
16712          }
16713        }
16714
16715        text = condensedText;
16716        original = condensedOriginal;
16717
16718        if (aggregate) {
16719          text.push(aggregate);
16720          original.push(aggregate);
16721        }
16722      }
16723
16724      value.speed && tween.duration(Math.min(0.05 / value.speed * _short.length, value.maxDuration || 9999));
16725      data.rtl = rtl;
16726      data.original = original;
16727      data.text = text;
16728
16729      data._props.push("text");
16730    },
16731    render: function render(ratio, data) {
16732      if (ratio > 1) {
16733        ratio = 1;
16734      } else if (ratio < 0) {
16735        ratio = 0;
16736      }
16737
16738      if (data.from) {
16739        ratio = 1 - ratio;
16740      }
16741
16742      var text = data.text,
16743          hasClass = data.hasClass,
16744          newClass = data.newClass,
16745          oldClass = data.oldClass,
16746          delimiter = data.delimiter,
16747          target = data.target,
16748          fillChar = data.fillChar,
16749          original = data.original,
16750          rtl = data.rtl,
16751          l = text.length,
16752          i = (rtl ? 1 - ratio : ratio) * l + 0.5 | 0,
16753          applyNew,
16754          applyOld,
16755          str;
16756
16757      if (hasClass && ratio) {
16758        applyNew = newClass && i;
16759        applyOld = oldClass && i !== l;
16760        str = (applyNew ? "<span class='" + newClass + "'>" : "") + text.slice(0, i).join(delimiter) + (applyNew ? "</span>" : "") + (applyOld ? "<span class='" + oldClass + "'>" : "") + delimiter + original.slice(i).join(delimiter) + (applyOld ? "</span>" : "");
16761      } else {
16762        str = text.slice(0, i).join(delimiter) + delimiter + original.slice(i).join(delimiter);
16763      }
16764
16765      if (data.svg) {
16766        target.textContent = str;
16767      } else {
16768        target.innerHTML = fillChar === "&nbsp;" && ~str.indexOf("  ") ? str.split("  ").join("&nbsp;&nbsp;") : str;
16769      }
16770    }
16771  };
16772  TextPlugin.splitInnerHTML = splitInnerHTML;
16773  TextPlugin.emojiSafeSplit = emojiSafeSplit;
16774  TextPlugin.getText = getText;
16775  _getGSAP$a() && gsap$c.registerPlugin(TextPlugin);
16776
16777  /*!
16778   * DrawSVGPlugin 3.12.5
16779   * https://gsap.com
16780   *
16781   * @license Copyright 2008-2024, GreenSock. All rights reserved.
16782   * Subject to the terms at https://gsap.com/standard-license or for
16783   * Club GSAP members, the agreement issued with that membership.

vendor: 5,669 bytes, lines 16783-16968

16783
16784   * @author: Jack Doyle, [email protected]
16785  */
16786  var gsap$d,
16787      _toArray$5,
16788      _win$7,
16789      _isEdge,
16790      _coreInitted$9,
16791      _warned,
16792      _getStyleSaver$4,
16793      _reverting$3,
16794      _windowExists$8 = function _windowExists() {
16795    return typeof window !== "undefined";
16796  },
16797      _getGSAP$b = function _getGSAP() {
16798    return gsap$d || _windowExists$8() && (gsap$d = window.gsap) && gsap$d.registerPlugin && gsap$d;
16799  },
16800      _numExp$3 = /[-+=\.]*\d+[\.e\-\+]*\d*[e\-\+]*\d*/gi,
16801      _types = {
16802    rect: ["width", "height"],
16803    circle: ["r", "r"],
16804    ellipse: ["rx", "ry"],
16805    line: ["x2", "y2"]
16806  },
16807      _round$6 = function _round(value) {
16808    return Math.round(value * 10000) / 10000;
16809  },
16810      _parseNum = function _parseNum(value) {
16811    return parseFloat(value) || 0;
16812  },
16813      _parseSingleVal = function _parseSingleVal(value, length) {
16814    var num = _parseNum(value);
16815
16816    return ~value.indexOf("%") ? num / 100 * length : num;
16817  },
16818      _getAttributeAsNumber = function _getAttributeAsNumber(target, attr) {
16819    return _parseNum(target.getAttribute(attr));
16820  },
16821      _sqrt$2 = Math.sqrt,
16822      _getDistance = function _getDistance(x1, y1, x2, y2, scaleX, scaleY) {
16823    return _sqrt$2(Math.pow((_parseNum(x2) - _parseNum(x1)) * scaleX, 2) + Math.pow((_parseNum(y2) - _parseNum(y1)) * scaleY, 2));
16824  },
16825      _warn$3 = function _warn(message) {
16826    return console.warn(message);
16827  },
16828      _hasNonScalingStroke = function _hasNonScalingStroke(target) {
16829    return target.getAttribute("vector-effect") === "non-scaling-stroke";
16830  },
16831      _bonusValidated = 1,
16832      _parse = function _parse(value, length, defaultStart) {
16833    var i = value.indexOf(" "),
16834        s,
16835        e;
16836
16837    if (i < 0) {
16838      s = defaultStart !== undefined ? defaultStart + "" : value;
16839      e = value;
16840    } else {
16841      s = value.substr(0, i);
16842      e = value.substr(i + 1);
16843    }
16844
16845    s = _parseSingleVal(s, length);
16846    e = _parseSingleVal(e, length);
16847    return s > e ? [e, s] : [s, e];
16848  },
16849      _getLength = function _getLength(target) {
16850    target = _toArray$5(target)[0];
16851
16852    if (!target) {
16853      return 0;
16854    }
16855
16856    var type = target.tagName.toLowerCase(),
16857        style = target.style,
16858        scaleX = 1,
16859        scaleY = 1,
16860        length,
16861        bbox,
16862        points,
16863        prevPoint,
16864        i,
16865        rx,
16866        ry;
16867
16868    if (_hasNonScalingStroke(target)) {
16869      scaleY = target.getScreenCTM();
16870      scaleX = _sqrt$2(scaleY.a * scaleY.a + scaleY.b * scaleY.b);
16871      scaleY = _sqrt$2(scaleY.d * scaleY.d + scaleY.c * scaleY.c);
16872    }
16873
16874    try {
16875      bbox = target.getBBox();
16876    } catch (e) {
16877      _warn$3("Some browsers won't measure invisible elements (like display:none or masks inside defs).");
16878    }
16879
16880    var _ref = bbox || {
16881      x: 0,
16882      y: 0,
16883      width: 0,
16884      height: 0
16885    },
16886        x = _ref.x,
16887        y = _ref.y,
16888        width = _ref.width,
16889        height = _ref.height;
16890
16891    if ((!bbox || !width && !height) && _types[type]) {
16892      width = _getAttributeAsNumber(target, _types[type][0]);
16893      height = _getAttributeAsNumber(target, _types[type][1]);
16894
16895      if (type !== "rect" && type !== "line") {
16896        width *= 2;
16897        height *= 2;
16898      }
16899
16900      if (type === "line") {
16901        x = _getAttributeAsNumber(target, "x1");
16902        y = _getAttributeAsNumber(target, "y1");
16903        width = Math.abs(width - x);
16904        height = Math.abs(height - y);
16905      }
16906    }
16907
16908    if (type === "path") {
16909      prevPoint = style.strokeDasharray;
16910      style.strokeDasharray = "none";
16911      length = target.getTotalLength() || 0;
16912      _round$6(scaleX) !== _round$6(scaleY) && !_warned && (_warned = 1) && _warn$3("Warning: <path> length cannot be measured when vector-effect is non-scaling-stroke and the element isn't proportionally scaled.");
16913      length *= (scaleX + scaleY) / 2;
16914      style.strokeDasharray = prevPoint;
16915    } else if (type === "rect") {
16916      length = width * 2 * scaleX + height * 2 * scaleY;
16917    } else if (type === "line") {
16918      length = _getDistance(x, y, x + width, y + height, scaleX, scaleY);
16919    } else if (type === "polyline" || type === "polygon") {
16920      points = target.getAttribute("points").match(_numExp$3) || [];
16921      type === "polygon" && points.push(points[0], points[1]);
16922      length = 0;
16923
16924      for (i = 2; i < points.length; i += 2) {
16925        length += _getDistance(points[i - 2], points[i - 1], points[i], points[i + 1], scaleX, scaleY) || 0;
16926      }
16927    } else if (type === "circle" || type === "ellipse") {
16928      rx = width / 2 * scaleX;
16929      ry = height / 2 * scaleY;
16930      length = Math.PI * (3 * (rx + ry) - _sqrt$2((3 * rx + ry) * (rx + 3 * ry)));
16931    }
16932
16933    return length || 0;
16934  },
16935      _getPosition = function _getPosition(target, length) {
16936    target = _toArray$5(target)[0];
16937
16938    if (!target) {
16939      return [0, 0];
16940    }
16941
16942    length || (length = _getLength(target) + 1);
16943
16944    var cs = _win$7.getComputedStyle(target),
16945        dash = cs.strokeDasharray || "",
16946        offset = _parseNum(cs.strokeDashoffset),
16947        i = dash.indexOf(",");
16948
16949    i < 0 && (i = dash.indexOf(" "));
16950    dash = i < 0 ? length : _parseNum(dash.substr(0, i));
16951    dash > length && (dash = length);
16952    return [-offset || 0, dash - offset || 0];
16953  },
16954      _initCore$9 = function _initCore() {
16955    if (_windowExists$8()) {
16956      _win$7 = window;
16957      _coreInitted$9 = gsap$d = _getGSAP$b();
16958      _toArray$5 = gsap$d.utils.toArray;
16959      _getStyleSaver$4 = gsap$d.core.getStyleSaver;
16960
16961      _reverting$3 = gsap$d.core.reverting || function () {};
16962
16963      _isEdge = ((_win$7.navigator || {}).userAgent || "").indexOf("Edge") !== -1;
16964    }
16965  };
16966
16967  var DrawSVGPlugin = {
16968    version: "3.1

vendor: 34,737 bytes, lines 16968-18122

169682.5",
16969    name: "drawSVG",
16970    register: function register(core) {
16971      gsap$d = core;
16972
16973      _initCore$9();
16974    },
16975    init: function init(target, value, tween, index, targets) {
16976      if (!target.getBBox) {
16977        return false;
16978      }
16979
16980      _coreInitted$9 || _initCore$9();
16981
16982      var length = _getLength(target),
16983          start,
16984          end,
16985          cs;
16986
16987      this.styles = _getStyleSaver$4 && _getStyleSaver$4(target, "strokeDashoffset,strokeDasharray,strokeMiterlimit");
16988      this.tween = tween;
16989      this._style = target.style;
16990      this._target = target;
16991
16992      if (value + "" === "true") {
16993        value = "0 100%";
16994      } else if (!value) {
16995        value = "0 0";
16996      } else if ((value + "").indexOf(" ") === -1) {
16997        value = "0 " + value;
16998      }
16999
17000      start = _getPosition(target, length);
17001      end = _parse(value, length, start[0]);
17002      this._length = _round$6(length);
17003      this._dash = _round$6(start[1] - start[0]);
17004      this._offset = _round$6(-start[0]);
17005      this._dashPT = this.add(this, "_dash", this._dash, _round$6(end[1] - end[0]), 0, 0, 0, 0, 0, 1);
17006      this._offsetPT = this.add(this, "_offset", this._offset, _round$6(-end[0]), 0, 0, 0, 0, 0, 1);
17007
17008      if (_isEdge) {
17009        cs = _win$7.getComputedStyle(target);
17010
17011        if (cs.strokeLinecap !== cs.strokeLinejoin) {
17012          end = _parseNum(cs.strokeMiterlimit);
17013          this.add(target.style, "strokeMiterlimit", end, end + 0.01);
17014        }
17015      }
17016
17017      this._live = _hasNonScalingStroke(target) || ~(value + "").indexOf("live");
17018      this._nowrap = ~(value + "").indexOf("nowrap");
17019
17020      this._props.push("drawSVG");
17021
17022      return _bonusValidated;
17023    },
17024    render: function render(ratio, data) {
17025      if (data.tween._time || !_reverting$3()) {
17026        var pt = data._pt,
17027            style = data._style,
17028            length,
17029            lengthRatio,
17030            dash,
17031            offset;
17032
17033        if (pt) {
17034          if (data._live) {
17035            length = _getLength(data._target);
17036
17037            if (length !== data._length) {
17038              lengthRatio = length / data._length;
17039              data._length = length;
17040
17041              if (data._offsetPT) {
17042                data._offsetPT.s *= lengthRatio;
17043                data._offsetPT.c *= lengthRatio;
17044              }
17045
17046              if (data._dashPT) {
17047                data._dashPT.s *= lengthRatio;
17048                data._dashPT.c *= lengthRatio;
17049              } else {
17050                data._dash *= lengthRatio;
17051              }
17052            }
17053          }
17054
17055          while (pt) {
17056            pt.r(ratio, pt.d);
17057            pt = pt._next;
17058          }
17059
17060          dash = data._dash || ratio && ratio !== 1 && 0.0001 || 0;
17061          length = data._length - dash + 0.1;
17062          offset = data._offset;
17063          dash && offset && dash + Math.abs(offset % data._length) > data._length - 0.2 && (offset += offset < 0 ? 0.1 : -0.1) && (length += 0.1);
17064          style.strokeDashoffset = dash ? offset : offset + 0.001;
17065          style.strokeDasharray = length < 0.2 ? "none" : dash ? dash + "px," + (data._nowrap ? 999999 : length) + "px" : "0px, 999999px";
17066        }
17067      } else {
17068        data.styles.revert();
17069      }
17070    },
17071    getLength: _getLength,
17072    getPosition: _getPosition
17073  };
17074  _getGSAP$b() && gsap$d.registerPlugin(DrawSVGPlugin);
17075
17076  /*!
17077   * Physics2DPlugin 3.12.5
17078   * https://gsap.com
17079   *
17080   * @license Copyright 2008-2024, GreenSock. All rights reserved.
17081   * Subject to the terms at https://gsap.com/standard-license or for
17082   * Club GSAP members, the agreement issued with that membership.
17083   * @author: Jack Doyle, [email protected]
17084  */
17085  var gsap$e,
17086      _coreInitted$a,
17087      _getUnit$1,
17088      _getStyleSaver$5,
17089      _reverting$4,
17090      _DEG2RAD$5 = Math.PI / 180,
17091      _getGSAP$c = function _getGSAP() {
17092    return gsap$e || typeof window !== "undefined" && (gsap$e = window.gsap) && gsap$e.registerPlugin && gsap$e;
17093  },
17094      _round$7 = function _round(value) {
17095    return Math.round(value * 10000) / 10000;
17096  },
17097      _initCore$a = function _initCore(core) {
17098    gsap$e = core || _getGSAP$c();
17099
17100    if (!_coreInitted$a) {
17101      _getUnit$1 = gsap$e.utils.getUnit;
17102      _getStyleSaver$5 = gsap$e.core.getStyleSaver;
17103
17104      _reverting$4 = gsap$e.core.reverting || function () {};
17105
17106      _coreInitted$a = 1;
17107    }
17108  };
17109
17110  var PhysicsProp = function PhysicsProp(target, p, velocity, acceleration, stepsPerTimeUnit) {
17111    var cache = target._gsap,
17112        curVal = cache.get(target, p);
17113    this.p = p;
17114    this.set = cache.set(target, p);
17115    this.s = this.val = parseFloat(curVal);
17116    this.u = _getUnit$1(curVal) || 0;
17117    this.vel = velocity || 0;
17118    this.v = this.vel / stepsPerTimeUnit;
17119
17120    if (acceleration || acceleration === 0) {
17121      this.acc = acceleration;
17122      this.a = this.acc / (stepsPerTimeUnit * stepsPerTimeUnit);
17123    } else {
17124      this.acc = this.a = 0;
17125    }
17126  };
17127
17128  var Physics2DPlugin = {
17129    version: "3.12.5",
17130    name: "physics2D",
17131    register: _initCore$a,
17132    init: function init(target, value, tween) {
17133      _coreInitted$a || _initCore$a();
17134      var data = this,
17135          angle = +value.angle || 0,
17136          velocity = +value.velocity || 0,
17137          acceleration = +value.acceleration || 0,
17138          xProp = value.xProp || "x",
17139          yProp = value.yProp || "y",
17140          aAngle = value.accelerationAngle || value.accelerationAngle === 0 ? +value.accelerationAngle : angle;
17141      data.styles = _getStyleSaver$5 && _getStyleSaver$5(target, value.xProp && value.xProp !== "x" ? value.xProp + "," + value.yProp : "transform");
17142      data.target = target;
17143      data.tween = tween;
17144      data.step = 0;
17145      data.sps = 30;
17146
17147      if (value.gravity) {
17148        acceleration = +value.gravity;
17149        aAngle = 90;
17150      }
17151
17152      angle *= _DEG2RAD$5;
17153      aAngle *= _DEG2RAD$5;
17154      data.fr = 1 - (+value.friction || 0);
17155
17156      data._props.push(xProp, yProp);
17157
17158      data.xp = new PhysicsProp(target, xProp, Math.cos(angle) * velocity, Math.cos(aAngle) * acceleration, data.sps);
17159      data.yp = new PhysicsProp(target, yProp, Math.sin(angle) * velocity, Math.sin(aAngle) * acceleration, data.sps);
17160      data.skipX = data.skipY = 0;
17161    },
17162    render: function render(ratio, data) {
17163      var xp = data.xp,
17164          yp = data.yp,
17165          tween = data.tween,
17166          target = data.target,
17167          step = data.step,
17168          sps = data.sps,
17169          fr = data.fr,
17170          skipX = data.skipX,
17171          skipY = data.skipY,
17172          time = tween._from ? tween._dur - tween._time : tween._time,
17173          x,
17174          y,
17175          tt,
17176          steps,
17177          remainder,
17178          i;
17179
17180      if (tween._time || !_reverting$4()) {
17181        if (fr === 1) {
17182          tt = time * time * 0.5;
17183          x = xp.s + xp.vel * time + xp.acc * tt;
17184          y = yp.s + yp.vel * time + yp.acc * tt;
17185        } else {
17186          time *= sps;
17187          steps = i = (time | 0) - step;
17188
17189          if (i < 0) {
17190            xp.v = xp.vel / sps;
17191            yp.v = yp.vel / sps;
17192            xp.val = xp.s;
17193            yp.val = yp.s;
17194            data.step = 0;
17195            steps = i = time | 0;
17196          }
17197
17198          remainder = time % 1 * fr;
17199
17200          while (i--) {
17201            xp.v += xp.a;
17202            yp.v += yp.a;
17203            xp.v *= fr;
17204            yp.v *= fr;
17205            xp.val += xp.v;
17206            yp.val += yp.v;
17207          }
17208
17209          x = xp.val + xp.v * remainder;
17210          y = yp.val + yp.v * remainder;
17211          data.step += steps;
17212        }
17213
17214        skipX || xp.set(target, xp.p, _round$7(x) + xp.u);
17215        skipY || yp.set(target, yp.p, _round$7(y) + yp.u);
17216      } else {
17217        data.styles.revert();
17218      }
17219    },
17220    kill: function kill(property) {
17221      if (this.xp.p === property) {
17222        this.skipX = 1;
17223      }
17224
17225      if (this.yp.p === property) {
17226        this.skipY = 1;
17227      }
17228    }
17229  };
17230  _getGSAP$c() && gsap$e.registerPlugin(Physics2DPlugin);
17231
17232  /*!
17233   * PhysicsPropsPlugin 3.12.5
17234   * https://gsap.com
17235   *
17236   * @license Copyright 2008-2024, GreenSock. All rights reserved.
17237   * Subject to the terms at https://gsap.com/standard-license or for
17238   * Club GSAP members, the agreement issued with that membership.
17239   * @author: Jack Doyle, [email protected]
17240  */
17241  var gsap$f,
17242      _coreInitted$b,
17243      _getUnit$2,
17244      _getStyleSaver$6,
17245      _reverting$5,
17246      _getGSAP$d = function _getGSAP() {
17247    return gsap$f || typeof window !== "undefined" && (gsap$f = window.gsap) && gsap$f.registerPlugin && gsap$f;
17248  },
17249      _round$8 = function _round(value) {
17250    return Math.round(value * 10000) / 10000;
17251  },
17252      _initCore$b = function _initCore(core) {
17253    gsap$f = core || _getGSAP$d();
17254
17255    if (!_coreInitted$b) {
17256      _getUnit$2 = gsap$f.utils.getUnit;
17257      _getStyleSaver$6 = gsap$f.core.getStyleSaver;
17258
17259      _reverting$5 = gsap$f.core.reverting || function () {};
17260
17261      _coreInitted$b = 1;
17262    }
17263  };
17264
17265  var PhysicsProp$1 = function PhysicsProp(target, p, velocity, acceleration, friction, stepsPerTimeUnit) {
17266    var cache = target._gsap,
17267        curVal = cache.get(target, p);
17268    this.p = p;
17269    this.set = cache.set(target, p);
17270    this.s = this.val = parseFloat(curVal);
17271    this.u = _getUnit$2(curVal) || 0;
17272    this.vel = velocity || 0;
17273    this.v = this.vel / stepsPerTimeUnit;
17274
17275    if (acceleration || acceleration === 0) {
17276      this.acc = acceleration;
17277      this.a = this.acc / (stepsPerTimeUnit * stepsPerTimeUnit);
17278    } else {
17279      this.acc = this.a = 0;
17280    }
17281
17282    this.fr = 1 - (friction || 0);
17283  };
17284
17285  var PhysicsPropsPlugin = {
17286    version: "3.12.5",
17287    name: "physicsProps",
17288    register: _initCore$b,
17289    init: function init(target, value, tween) {
17290      _coreInitted$b || _initCore$b();
17291      var data = this,
17292          p;
17293      data.styles = _getStyleSaver$6 && _getStyleSaver$6(target);
17294      data.target = target;
17295      data.tween = tween;
17296      data.step = 0;
17297      data.sps = 30;
17298      data.vProps = [];
17299
17300      for (p in value) {
17301        var _value$p = value[p],
17302            velocity = _value$p.velocity,
17303            acceleration = _value$p.acceleration,
17304            friction = _value$p.friction;
17305
17306        if (velocity || acceleration) {
17307          data.vProps.push(new PhysicsProp$1(target, p, velocity, acceleration, friction, data.sps));
17308
17309          data._props.push(p);
17310
17311          _getStyleSaver$6 && data.styles.save(p);
17312          friction && (data.hasFr = 1);
17313        }
17314      }
17315    },
17316    render: function render(ratio, data) {
17317      var vProps = data.vProps,
17318          tween = data.tween,
17319          target = data.target,
17320          step = data.step,
17321          hasFr = data.hasFr,
17322          sps = data.sps,
17323          i = vProps.length,
17324          time = tween._from ? tween._dur - tween._time : tween._time,
17325          curProp,
17326          steps,
17327          remainder,
17328          j,
17329          tt;
17330
17331      if (tween._time || !_reverting$5()) {
17332        if (hasFr) {
17333          time *= sps;
17334          steps = (time | 0) - step;
17335
17336          if (steps < 0) {
17337            while (i--) {
17338              curProp = vProps[i];
17339              curProp.v = curProp.vel / sps;
17340              curProp.val = curProp.s;
17341            }
17342
17343            i = vProps.length;
17344            data.step = step = 0;
17345            steps = time | 0;
17346          }
17347
17348          remainder = time % 1;
17349
17350          while (i--) {
17351            curProp = vProps[i];
17352            j = steps;
17353
17354            while (j--) {
17355              curProp.v += curProp.a;
17356              curProp.v *= curProp.fr;
17357              curProp.val += curProp.v;
17358            }
17359
17360            curProp.set(target, curProp.p, _round$8(curProp.val + curProp.v * remainder * curProp.fr) + curProp.u);
17361          }
17362
17363          data.step += steps;
17364        } else {
17365          tt = time * time * 0.5;
17366
17367          while (i--) {
17368            curProp = vProps[i];
17369            curProp.set(target, curProp.p, _round$8(curProp.s + curProp.vel * time + curProp.acc * tt) + curProp.u);
17370          }
17371        }
17372      } else {
17373        data.styles.revert();
17374      }
17375    },
17376    kill: function kill(property) {
17377      var vProps = this.vProps,
17378          i = vProps.length;
17379
17380      while (i--) {
17381        vProps[i].p === property && vProps.splice(i, 1);
17382      }
17383    }
17384  };
17385  _getGSAP$d() && gsap$f.registerPlugin(PhysicsPropsPlugin);
17386
17387  /*!
17388   * ScrambleTextPlugin 3.12.5
17389   * https://gsap.com
17390   *
17391   * @license Copyright 2008-2024, GreenSock. All rights reserved.
17392   * Subject to the terms at https://gsap.com/standard-license or for
17393   * Club GSAP members, the agreement issued with that membership.
17394   * @author: Jack Doyle, [email protected]
17395  */
17396
17397  var CharSet = function () {
17398    function CharSet(chars) {
17399      this.chars = emojiSafeSplit(chars);
17400      this.sets = [];
17401      this.length = 50;
17402
17403      for (var i = 0; i < 20; i++) {
17404        this.sets[i] = _scrambleText(80, this.chars);
17405      }
17406    }
17407
17408    var _proto = CharSet.prototype;
17409
17410    _proto.grow = function grow(newLength) {
17411      for (var i = 0; i < 20; i++) {
17412        this.sets[i] += _scrambleText(newLength - this.length, this.chars);
17413      }
17414
17415      this.length = newLength;
17416    };
17417
17418    return CharSet;
17419  }();
17420
17421  var gsap$g,
17422      _coreInitted$c,
17423      _getGSAP$e = function _getGSAP() {
17424    return gsap$g || typeof window !== "undefined" && (gsap$g = window.gsap) && gsap$g.registerPlugin && gsap$g;
17425  },
17426      _bonusValidated$1 = 1,
17427      _spacesExp = /\s+/g,
17428      _scrambleText = function _scrambleText(length, chars) {
17429    var l = chars.length,
17430        s = "";
17431
17432    while (--length > -1) {
17433      s += chars[~~(Math.random() * l)];
17434    }
17435
17436    return s;
17437  },
17438      _upper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
17439      _lower = _upper.toLowerCase(),
17440      _charsLookup = {
17441    upperCase: new CharSet(_upper),
17442    lowerCase: new CharSet(_lower),
17443    upperAndLowerCase: new CharSet(_upper + _lower)
17444  },
17445      _initCore$c = function _initCore() {
17446    _coreInitted$c = gsap$g = _getGSAP$e();
17447  };
17448
17449  var ScrambleTextPlugin = {
17450    version: "3.12.5",
17451    name: "scrambleText",
17452    register: function register(core, Plugin, propTween) {
17453      gsap$g = core;
17454
17455      _initCore$c();
17456    },
17457    init: function init(target, value, tween, index, targets) {
17458      _coreInitted$c || _initCore$c();
17459      this.prop = "innerHTML" in target ? "innerHTML" : "textContent" in target ? "textContent" : 0;
17460
17461      if (!this.prop) {
17462        return;
17463      }
17464
17465      this.target = target;
17466
17467      if (typeof value !== "object") {
17468        value = {
17469          text: value
17470        };
17471      }
17472
17473      var text = value.text || value.value || "",
17474          trim = value.trim !== false,
17475          data = this,
17476          delim,
17477          maxLength,
17478          charset,
17479          splitByChars;
17480      data.delimiter = delim = value.delimiter || "";
17481      data.original = emojiSafeSplit(getText(target).replace(_spacesExp, " ").split("&nbsp;").join(""), delim, trim);
17482
17483      if (text === "{original}" || text === true || text == null) {
17484        text = data.original.join(delim);
17485      }
17486
17487      data.text = emojiSafeSplit((text || "").replace(_spacesExp, " "), delim, trim);
17488      data.hasClass = !!(value.newClass || value.oldClass);
17489      data.newClass = value.newClass;
17490      data.oldClass = value.oldClass;
17491      splitByChars = delim === "";
17492      data.textHasEmoji = splitByChars && !!data.text.emoji;
17493      data.charsHaveEmoji = !!value.chars && !!emojiSafeSplit(value.chars).emoji;
17494      data.length = splitByChars ? data.original.length : data.original.join(delim).length;
17495      data.lengthDif = (splitByChars ? data.text.length : data.text.join(delim).length) - data.length;
17496      data.fillChar = value.fillChar || value.chars && ~value.chars.indexOf(" ") ? "&nbsp;" : "";
17497      data.charSet = charset = _charsLookup[value.chars || "upperCase"] || new CharSet(value.chars);
17498      data.speed = 0.05 / (value.speed || 1);
17499      data.prevScrambleTime = 0;
17500      data.setIndex = Math.random() * 20 | 0;
17501      maxLength = data.length + Math.max(data.lengthDif, 0);
17502
17503      if (maxLength > charset.length) {
17504        charset.grow(maxLength);
17505      }
17506
17507      data.chars = charset.sets[data.setIndex];
17508      data.revealDelay = value.revealDelay || 0;
17509      data.tweenLength = value.tweenLength !== false;
17510      data.tween = tween;
17511      data.rightToLeft = !!value.rightToLeft;
17512
17513      data._props.push("scrambleText", "text");
17514
17515      return _bonusValidated$1;
17516    },
17517    render: function render(ratio, data) {
17518      var target = data.target,
17519          prop = data.prop,
17520          text = data.text,
17521          delimiter = data.delimiter,
17522          tween = data.tween,
17523          prevScrambleTime = data.prevScrambleTime,
17524          revealDelay = data.revealDelay,
17525          setIndex = data.setIndex,
17526          chars = data.chars,
17527          charSet = data.charSet,
17528          length = data.length,
17529          textHasEmoji = data.textHasEmoji,
17530          charsHaveEmoji = data.charsHaveEmoji,
17531          lengthDif = data.lengthDif,
17532          tweenLength = data.tweenLength,
17533          oldClass = data.oldClass,
17534          newClass = data.newClass,
17535          rightToLeft = data.rightToLeft,
17536          fillChar = data.fillChar,
17537          speed = data.speed,
17538          original = data.original,
17539          hasClass = data.hasClass,
17540          l = text.length,
17541          time = tween._time,
17542          timeDif = time - prevScrambleTime,
17543          i,
17544          i2,
17545          startText,
17546          endText,
17547          applyNew,
17548          applyOld,
17549          str,
17550          startClass,
17551          endClass,
17552          position,
17553          r;
17554
17555      if (revealDelay) {
17556        if (tween._from) {
17557          time = tween._dur - time;
17558        }
17559
17560        ratio = time === 0 ? 0 : time < revealDelay ? 0.000001 : time === tween._dur ? 1 : tween._ease((time - revealDelay) / (tween._dur - revealDelay));
17561      }
17562
17563      if (ratio < 0) {
17564        ratio = 0;
17565      } else if (ratio > 1) {
17566        ratio = 1;
17567      }
17568
17569      if (rightToLeft) {
17570        ratio = 1 - ratio;
17571      }
17572
17573      i = ~~(ratio * l + 0.5);
17574
17575      if (ratio) {
17576        if (timeDif > speed || timeDif < -speed) {
17577          data.setIndex = setIndex = (setIndex + (Math.random() * 19 | 0)) % 20;
17578          data.chars = charSet.sets[setIndex];
17579          data.prevScrambleTime += timeDif;
17580        }
17581
17582        endText = chars;
17583      } else {
17584        endText = original.join(delimiter);
17585      }
17586
17587      r = tween._from ? ratio : 1 - ratio;
17588      position = length + (tweenLength ? tween._from ? r * r * r : 1 - r * r * r : 1) * lengthDif;
17589
17590      if (rightToLeft) {
17591        if (ratio === 1 && (tween._from || tween.data === "isFromStart")) {
17592          startText = "";
17593          endText = original.join(delimiter);
17594        } else {
17595          str = text.slice(i).join(delimiter);
17596
17597          if (charsHaveEmoji) {
17598            startText = emojiSafeSplit(endText).slice(0, position - (textHasEmoji ? emojiSafeSplit(str) : str).length + 0.5 | 0).join("");
17599          } else {
17600            startText = endText.substr(0, position - (textHasEmoji ? emojiSafeSplit(str) : str).length + 0.5 | 0);
17601          }
17602
17603          endText = str;
17604        }
17605      } else {
17606        startText = text.slice(0, i).join(delimiter);
17607        i2 = (textHasEmoji ? emojiSafeSplit(startText) : startText).length;
17608
17609        if (charsHaveEmoji) {
17610          endText = emojiSafeSplit(endText).slice(i2, position + 0.5 | 0).join("");
17611        } else {
17612          endText = endText.substr(i2, position - i2 + 0.5 | 0);
17613        }
17614      }
17615
17616      if (hasClass) {
17617        startClass = rightToLeft ? oldClass : newClass;
17618        endClass = rightToLeft ? newClass : oldClass;
17619        applyNew = startClass && i !== 0;
17620        applyOld = endClass && i !== l;
17621        str = (applyNew ? "<span class='" + startClass + "'>" : "") + startText + (applyNew ? "</span>" : "") + (applyOld ? "<span class='" + endClass + "'>" : "") + delimiter + endText + (applyOld ? "</span>" : "");
17622      } else {
17623        str = startText + delimiter + endText;
17624      }
17625
17626      target[prop] = fillChar === "&nbsp;" && ~str.indexOf("  ") ? str.split("  ").join("&nbsp;&nbsp;") : str;
17627    }
17628  };
17629  ScrambleTextPlugin.emojiSafeSplit = emojiSafeSplit;
17630  ScrambleTextPlugin.getText = getText;
17631  _getGSAP$e() && gsap$g.registerPlugin(ScrambleTextPlugin);
17632
17633  /*!
17634   * CustomBounce 3.12.5
17635   * https://gsap.com
17636   *
17637   * @license Copyright 2008-2024, GreenSock. All rights reserved.
17638   * Subject to the terms at https://gsap.com/standard-license or for
17639   * Club GSAP members, the agreement issued with that membership.
17640   * @author: Jack Doyle, [email protected]
17641  */
17642  var gsap$h,
17643      _coreInitted$d,
17644      createCustomEase,
17645      _getGSAP$f = function _getGSAP() {
17646    return gsap$h || typeof window !== "undefined" && (gsap$h = window.gsap) && gsap$h.registerPlugin && gsap$h;
17647  },
17648      _initCore$d = function _initCore(required) {
17649    gsap$h = _getGSAP$f();
17650    createCustomEase = gsap$h && gsap$h.parseEase("_CE");
17651
17652    if (createCustomEase) {
17653      _coreInitted$d = 1;
17654
17655      gsap$h.parseEase("bounce").config = function (vars) {
17656        return typeof vars === "object" ? _create("", vars) : _create("bounce(" + vars + ")", {
17657          strength: +vars
17658        });
17659      };
17660    } else {
17661      required && console.warn("Please gsap.registerPlugin(CustomEase, CustomBounce)");
17662    }
17663  },
17664      _normalizeX = function _normalizeX(a) {
17665    var l = a.length,
17666        s = 1 / a[l - 2],
17667        rnd = 1000,
17668        i;
17669
17670    for (i = 2; i < l; i += 2) {
17671      a[i] = ~~(a[i] * s * rnd) / rnd;
17672    }
17673
17674    a[l - 2] = 1;
17675  },
17676      _create = function _create(id, vars) {
17677    if (!_coreInitted$d) {
17678      _initCore$d(1);
17679    }
17680
17681    vars = vars || {};
17682
17683    {
17684      var max = 0.999,
17685          decay = Math.min(max, vars.strength || 0.7),
17686          decayX = decay,
17687          gap = (vars.squash || 0) / 100,
17688          originalGap = gap,
17689          slope = 1 / 0.03,
17690          w = 0.2,
17691          h = 1,
17692          prevX = 0.1,
17693          path = [0, 0, 0.07, 0, 0.1, 1, 0.1, 1],
17694          squashPath = [0, 0, 0, 0, 0.1, 0, 0.1, 0],
17695          cp1,
17696          cp2,
17697          x,
17698          y,
17699          i,
17700          nextX,
17701          squishMagnitude;
17702
17703      for (i = 0; i < 200; i++) {
17704        w *= decayX * ((decayX + 1) / 2);
17705        h *= decay * decay;
17706        nextX = prevX + w;
17707        x = prevX + w * 0.49;
17708        y = 1 - h;
17709        cp1 = prevX + h / slope;
17710        cp2 = x + (x - cp1) * 0.8;
17711
17712        if (gap) {
17713          prevX += gap;
17714          cp1 += gap;
17715          x += gap;
17716          cp2 += gap;
17717          nextX += gap;
17718          squishMagnitude = gap / originalGap;
17719          squashPath.push(prevX - gap, 0, prevX - gap, squishMagnitude, prevX - gap / 2, squishMagnitude, prevX, squishMagnitude, prevX, 0, prevX, 0, prevX, squishMagnitude * -0.6, prevX + (nextX - prevX) / 6, 0, nextX, 0);
17720          path.push(prevX - gap, 1, prevX, 1, prevX, 1);
17721          gap *= decay * decay;
17722        }
17723
17724        path.push(prevX, 1, cp1, y, x, y, cp2, y, nextX, 1, nextX, 1);
17725        decay *= 0.95;
17726        slope = h / (nextX - cp2);
17727        prevX = nextX;
17728
17729        if (y > max) {
17730          break;
17731        }
17732      }
17733
17734      if (vars.endAtStart && vars.endAtStart !== "false") {
17735        x = -0.1;
17736        path.unshift(x, 1, x, 1, -0.07, 0);
17737
17738        if (originalGap) {
17739          gap = originalGap * 2.5;
17740          x -= gap;
17741          path.unshift(x, 1, x, 1, x, 1);
17742          squashPath.splice(0, 6);
17743          squashPath.unshift(x, 0, x, 0, x, 1, x + gap / 2, 1, x + gap, 1, x + gap, 0, x + gap, 0, x + gap, -0.6, x + gap + 0.033, 0);
17744
17745          for (i = 0; i < squashPath.length; i += 2) {
17746            squashPath[i] -= x;
17747          }
17748        }
17749
17750        for (i = 0; i < path.length; i += 2) {
17751          path[i] -= x;
17752          path[i + 1] = 1 - path[i + 1];
17753        }
17754      }
17755
17756      if (gap) {
17757        _normalizeX(squashPath);
17758
17759        squashPath[2] = "C" + squashPath[2];
17760        createCustomEase(vars.squashID || id + "-squash", "M" + squashPath.join(","));
17761      }
17762
17763      _normalizeX(path);
17764
17765      path[2] = "C" + path[2];
17766      return createCustomEase(id, "M" + path.join(","));
17767    }
17768  };
17769
17770  var CustomBounce = function () {
17771    function CustomBounce(id, vars) {
17772      this.ease = _create(id, vars);
17773    }
17774
17775    CustomBounce.create = function create(id, vars) {
17776      return _create(id, vars);
17777    };
17778
17779    CustomBounce.register = function register(core) {
17780      gsap$h = core;
17781
17782      _initCore$d();
17783    };
17784
17785    return CustomBounce;
17786  }();
17787  _getGSAP$f() && gsap$h.registerPlugin(CustomBounce);
17788  CustomBounce.version = "3.12.5";
17789
17790  /*!
17791   * CustomWiggle 3.12.5
17792   * https://gsap.com
17793   *
17794   * @license Copyright 2008-2024, GreenSock. All rights reserved.
17795   * Subject to the terms at https://gsap.com/standard-license or for
17796   * Club GSAP members, the agreement issued with that membership.
17797   * @author: Jack Doyle, [email protected]
17798  */
17799  var gsap$i,
17800      _coreInitted$e,
17801      createCustomEase$1,
17802      _getGSAP$g = function _getGSAP() {
17803    return gsap$i || typeof window !== "undefined" && (gsap$i = window.gsap) && gsap$i.registerPlugin && gsap$i;
17804  },
17805      _eases = {
17806    easeOut: "M0,1,C0.7,1,0.6,0,1,0",
17807    easeInOut: "M0,0,C0.1,0,0.24,1,0.444,1,0.644,1,0.6,0,1,0",
17808    anticipate: "M0,0,C0,0.222,0.024,0.386,0,0.4,0.18,0.455,0.65,0.646,0.7,0.67,0.9,0.76,1,0.846,1,1",
17809    uniform: "M0,0,C0,0.95,0,1,0,1,0,1,1,1,1,1,1,1,1,0,1,0"
17810  },
17811      _linearEase = function _linearEase(p) {
17812    return p;
17813  },
17814      _initCore$e = function _initCore(required) {
17815    if (!_coreInitted$e) {
17816      gsap$i = _getGSAP$g();
17817      createCustomEase$1 = gsap$i && gsap$i.parseEase("_CE");
17818
17819      if (createCustomEase$1) {
17820        for (var p in _eases) {
17821          _eases[p] = createCustomEase$1("", _eases[p]);
17822        }
17823
17824        _coreInitted$e = 1;
17825
17826        _create$1("wiggle").config = function (vars) {
17827          return typeof vars === "object" ? _create$1("", vars) : _create$1("wiggle(" + vars + ")", {
17828            wiggles: +vars
17829          });
17830        };
17831      } else {
17832        required && console.warn("Please gsap.registerPlugin(CustomEase, CustomWiggle)");
17833      }
17834    }
17835  },
17836      _parseEase$1 = function _parseEase(ease, invertNonCustomEases) {
17837    if (typeof ease !== "function") {
17838      ease = gsap$i.parseEase(ease) || createCustomEase$1("", ease);
17839    }
17840
17841    return ease.custom || !invertNonCustomEases ? ease : function (p) {
17842      return 1 - ease(p);
17843    };
17844  },
17845      _create$1 = function _create(id, vars) {
17846    if (!_coreInitted$e) {
17847      _initCore$e(1);
17848    }
17849
17850    vars = vars || {};
17851    var wiggles = (vars.wiggles || 10) | 0,
17852        inc = 1 / wiggles,
17853        x = inc / 2,
17854        anticipate = vars.type === "anticipate",
17855        yEase = _eases[vars.type] || _eases.easeOut,
17856        xEase = _linearEase,
17857        rnd = 1000,
17858        nextX,
17859        nextY,
17860        angle,
17861        handleX,
17862        handleY,
17863        easedX,
17864        y,
17865        path,
17866        i;
17867
17868    {
17869      if (anticipate) {
17870        xEase = yEase;
17871        yEase = _eases.easeOut;
17872      }
17873
17874      if (vars.timingEase) {
17875        xEase = _parseEase$1(vars.timingEase);
17876      }
17877
17878      if (vars.amplitudeEase) {
17879        yEase = _parseEase$1(vars.amplitudeEase, true);
17880      }
17881
17882      easedX = xEase(x);
17883      y = anticipate ? -yEase(x) : yEase(x);
17884      path = [0, 0, easedX / 4, 0, easedX / 2, y, easedX, y];
17885
17886      if (vars.type === "random") {
17887        path.length = 4;
17888        nextX = xEase(inc);
17889        nextY = Math.random() * 2 - 1;
17890
17891        for (i = 2; i < wiggles; i++) {
17892          x = nextX;
17893          y = nextY;
17894          nextX = xEase(inc * i);
17895          nextY = Math.random() * 2 - 1;
17896          angle = Math.atan2(nextY - path[path.length - 3], nextX - path[path.length - 4]);
17897          handleX = Math.cos(angle) * inc;
17898          handleY = Math.sin(angle) * inc;
17899          path.push(x - handleX, y - handleY, x, y, x + handleX, y + handleY);
17900        }
17901
17902        path.push(nextX, 0, 1, 0);
17903      } else {
17904        for (i = 1; i < wiggles; i++) {
17905          path.push(xEase(x + inc / 2), y);
17906          x += inc;
17907          y = (y > 0 ? -1 : 1) * yEase(i * inc);
17908          easedX = xEase(x);
17909          path.push(xEase(x - inc / 2), y, easedX, y);
17910        }
17911
17912        path.push(xEase(x + inc / 4), y, xEase(x + inc / 4), 0, 1, 0);
17913      }
17914
17915      i = path.length;
17916
17917      while (--i > -1) {
17918        path[i] = ~~(path[i] * rnd) / rnd;
17919      }
17920
17921      path[2] = "C" + path[2];
17922      return createCustomEase$1(id, "M" + path.join(","));
17923    }
17924  };
17925
17926  var CustomWiggle = function () {
17927    function CustomWiggle(id, vars) {
17928      this.ease = _create$1(id, vars);
17929    }
17930
17931    CustomWiggle.create = function create(id, vars) {
17932      return _create$1(id, vars);
17933    };
17934
17935    CustomWiggle.register = function register(core) {
17936      gsap$i = core;
17937
17938      _initCore$e();
17939    };
17940
17941    return CustomWiggle;
17942  }();
17943  _getGSAP$g() && gsap$i.registerPlugin(CustomWiggle);
17944  CustomWiggle.version = "3.12.5";
17945
17946  /*!
17947   * GSDevTools 3.12.5
17948   * https://gsap.com
17949   *
17950   * @license Copyright 2008-2024, GreenSock. All rights reserved.
17951   * Subject to the terms at https://gsap.com/standard-license or for
17952   * Club GSAP members, the agreement issued with that membership.
17953   * @author: Jack Doyle, [email protected]
17954  */
17955
17956  var gsap$j,
17957      _coreInitted$f,
17958      _doc$7,
17959      _docEl$3,
17960      _win$8,
17961      _recordedRoot,
17962      Animation$1,
17963      _rootTween,
17964      _rootInstance,
17965      _keyboardInstance,
17966      _globalTimeline$1,
17967      _independentRoot,
17968      _delayedCall,
17969      _context$4,
17970      _startupPhase = true,
17971      _globalStartTime = 0,
17972      _windowExists$9 = function _windowExists() {
17973    return typeof window !== "undefined";
17974  },
17975      _getGSAP$h = function _getGSAP() {
17976    return gsap$j || _windowExists$9() && (gsap$j = window.gsap) && gsap$j.registerPlugin && gsap$j;
17977  },
17978      _isString$5 = function _isString(value) {
17979    return typeof value === "string";
17980  },
17981      _isFunction$5 = function _isFunction(value) {
17982    return typeof value === "function";
17983  },
17984      _isObject$3 = function _isObject(value) {
17985    return typeof value === "object";
17986  },
17987      _isUndefined$3 = function _isUndefined(value) {
17988    return typeof value === "undefined";
17989  },
17990      _svgNS = "http://www.w3.org/2000/svg",
17991      _domNS = "http://www.w3.org/1999/xhtml",
17992      _idSeed = 0,
17993      _lookup$1 = {},
17994      _supportsStorage = function () {
17995    try {
17996      sessionStorage.setItem("gsTest", "1");
17997      sessionStorage.removeItem("gsTest");
17998      return true;
17999    } catch (e) {
18000      return false;
18001    }
18002  }(),
18003      _parseAnimation = function _parseAnimation(animationOrId) {
18004    return animationOrId instanceof Animation$1 ? animationOrId : animationOrId ? gsap$j.getById(animationOrId) : null;
18005  },
18006      _createElement$2 = function _createElement(type, container, cssText) {
18007    var element = _doc$7.createElementNS ? _doc$7.createElementNS(type === "svg" ? _svgNS : _domNS, type) : _doc$7.createElement(type);
18008
18009    if (container) {
18010      if (_isString$5(container)) {
18011        container = _doc$7.querySelector(container);
18012      }
18013
18014      container.appendChild(element);
18015    }
18016
18017    if (type === "svg") {
18018      element.setAttribute("xmlns", _svgNS);
18019      element.setAttribute("xmlns:xlink", _domNS);
18020    }
18021
18022    cssText && (element.style.cssText = cssText);
18023    return element;
18024  },
18025      _clearSelection = function _clearSelection() {
18026    if (_doc$7.selection) {
18027      _doc$7.selection.empty();
18028    } else if (_win$8.getSelection) {
18029      _win$8.getSelection().removeAllRanges();
18030    }
18031  },
18032      _getChildrenOf = function _getChildrenOf(timeline, includeTimelines) {
18033    var a = [],
18034        cnt = 0,
18035        Tween = gsap$j.core.Tween,
18036        tween = timeline._first;
18037
18038    while (tween) {
18039      if (tween instanceof Tween) {
18040        if (tween.vars.id) {
18041          a[cnt++] = tween;
18042        }
18043      } else {
18044        if (includeTimelines && tween.vars.id) {
18045          a[cnt++] = tween;
18046        }
18047
18048        a = a.concat(_getChildrenOf(tween, includeTimelines));
18049        cnt = a.length;
18050      }
18051
18052      tween = tween._next;
18053    }
18054
18055    return a;
18056  },
18057      _getClippedDuration = function _getClippedDuration(animation, excludeRootRepeats) {
18058    var max = 0,
18059        repeat = Math.max(0, animation._repeat),
18060        t = animation._first;
18061
18062    if (!t) {
18063      max = animation.duration();
18064    }
18065
18066    while (t) {
18067      max = Math.max(max, t.totalDuration() > 999 ? t.endTime(false) : t._start + t._tDur / t._ts);
18068      t = t._next;
18069    }
18070
18071    return !excludeRootRepeats && repeat ? max * (repeat + 1) + animation._rDelay * repeat : max;
18072  },
18073      _globalizeTime = function _globalizeTime(animation, rawTime) {
18074    var a = animation,
18075        time = arguments.length > 1 ? +rawTime : a.rawTime();
18076
18077    while (a) {
18078      time = a._start + time / (a._ts || 1);
18079      a = a.parent;
18080    }
18081
18082    return time;
18083  },
18084      _timeToProgress = function _timeToProgress(time, animation, defaultValue, relativeProgress) {
18085    var add, i, a;
18086
18087    if (_isString$5(time)) {
18088      if (time.charAt(1) === "=") {
18089        add = parseInt(time.charAt(0) + "1", 10) * parseFloat(time.substr(2));
18090
18091        if (add < 0 && relativeProgress === 0) {
18092          relativeProgress = 100;
18093        }
18094
18095        time = relativeProgress / 100 * animation.duration() + add;
18096      } else if (isNaN(time) && animation.labels && animation.labels[time] !== -1) {
18097        time = animation.labels[time];
18098      } else if (animation === _recordedRoot) {
18099        i = time.indexOf("=");
18100
18101        if (i > 0) {
18102          add = parseInt(time.charAt(i - 1) + "1", 10) * parseFloat(time.substr(i + 1));
18103          time = time.substr(0, i - 1);
18104        } else {
18105          add = 0;
18106        }
18107
18108        a = gsap$j.getById(time);
18109
18110        if (a) {
18111          time = _globalizeTime(a, defaultValue / 100 * a.duration()) + add;
18112        }
18113      }
18114    }
18115
18116    time = isNaN(time) ? defaultValue : parseFloat(time);
18117    return Math.min(100, Math.max(0, time / animation.duration() * 100));
18118  },
18119      _addedCSS,
18120      _createRootElement = function _createRootElement(element, minimal, css) {
18121    if (!_addedCSS) {
18122      _createElement$2("style", _docEl$3).innerHTML = '.gs-dev-tools{height:51px;bottom:0;left:0;right:0;display:block;position:fixed;overflow:visible;padding:0}.gs-dev-tools *{box-sizing:content-box;visibility:visible}.gs-dev-tools .gs-top{position:relative;z-index:499}.gs-dev-tools .gs-bottom{display:flex;align-items:center;justify-content:space-between;background-color:rgba(0,0,0,.6);height:42px;border-top:1px solid #999;position:relative}.gs-dev-tools .timeline{position:relative;height:8px;margin-left:15px;margin-right:15px;overflow:visible}.gs-dev-tools .progress-bar,.gs-dev-tools .timeline-track{height:8px;width:100%;position:absolute;top:0;left:0}.gs-dev-tools .timeline-track{background-color:#999;opacity:.6}.gs-dev-tools .progress-bar{background-color:#91e600;height:8px;top:0;width:0;pointer-events:none}.gs-dev-tools .seek-bar{width:100%;position:absolute;height:24px;top:-12px;left:0;background-color:transparent}

18122.gs-dev-tools .in-point,.gs-dev-tools .out-point{width:15px;height:26px;position:absolute;top:-18px}.gs-dev-tools .in-point-shape{fill:#6d9900;stroke:rgba(0,0,0,.5);stroke-width:1}.gs-dev-tools .out-point-shape{fill:#994242;stroke:rgba(0,0,0,.5);stroke-width:1}.gs-dev-tools .in-point{transform:translateX(-100%)}.gs-dev-tools .out-point{left:100%}.gs-dev-tools .grab{stroke:rgba(255,255,255,.3);stroke-width:1}.gs-dev-tools .playhead{position:absolute;top:-5px;transform:translate(-50%,0);left:0;border-radius:50%;width:16px;height:16px;border:1px solid #6d9900;background-color:#91e600}.gs-dev-tools .gs-btn-white{fill:#fff}.gs-dev-tools .pause{opacity:0}.gs-dev-tools .select-animation{vertical-align:middle;position:relative;padding:6px 10px}.gs-dev-tools .select-animation-container{flex-grow:4;width:40%}.gs-dev-tools .select-arrow{display:inline-block;width:12px;height:7px;margin:0 7px;transform:translate(0,-2px)}.gs-dev-tools .select-arrow-shape{stroke:rgba(255,255,255,.6);stroke-width:2px;fill:none}.gs-dev-tools .rewind{height:16px;width:19px;padding:10px 4px;min-width:24px}.gs-dev-tools .rewind-path{opacity:.6}.gs-dev-tools .play-pause{width:24px;height:24px;padding:6px 10px;min-width:24px}.gs-dev-tools .ease{width:30px;height:30px;padding:10px;min-width:30px;display:none}.gs-dev-tools .ease-path{fill:none;stroke:rgba(255,255,255,.6);stroke-width:2px}.gs-dev-tools .ease-border{fill:rgba(255,255,255,.25)}.gs-dev-tools .time-scale{font-family:monospace;font-size:18px;text-align:center;color:rgba(255,255,255,.6);padding:4px 4px 4px 0;min-width:30px;margin-left:7px}.gs-dev-tools .loop{width:20px;padding:5px;min-width:20px}.gs-dev-tools .loop-path{fill:rgba(255,255,255,.6)}.gs-dev-tools label span{color:#fff;font-family:monospace;text-decoration:none;font-size:16px;line-height:18px}.gs-dev-tools .time-scale span{color:rgba(255,255,255,.6)}.gs-dev-tools button:focus,.gs-dev-tools select:focus{outline:0}.gs-dev-tools label{position:relative;cursor:pointer}.gs-dev-tools label.locked{text-decoration:none;cursor:auto}.gs-dev-tools label input,.gs-dev-tools label select{position:absolute;left:0;top:0;z-index:1;font:inherit;font-size:inherit;line-height:inherit;height:100%;width:100%;color:#000!important;opacity:0;background:0 0;border:none;padding:0;margin:0;-webkit-appearance:none;-moz-appearance:none;appearance:none;cursor:pointer}.gs-dev-tools label input+.display{position:relative;z-index:2}.gs-dev-tools .gs-bottom-right{vertical-align:middle;display:flex;align-items:center;flex-grow:4;width:40%;justify-content:flex-end}.gs-dev-tools .time-container{font-size:18px;font-family:monospace;color:rgba(255,255,255,.6);margin:0 5px}.gs-dev-tools .logo{width:32px;height:32px;position:relative;top:2px;margin:0 12px}.gs-dev-tools .gs-hit-area{background-color:transparent;width:100%;height:100%;top:0;position:absolute}.gs-dev-tools.minimal{height:auto;display:flex;align-items:stretch}.gs-dev-tools.minimal .gs-top{order:2;flex-grow:4;background-color:rgba(0,0,0,1)}.gs-dev-tools.minimal .gs-bottom{background-color:rgba(0,0,0,1);border-top:none}.gs-dev-tools.minimal .timeline{top:50%;transform:translate(0,-50%)}.gs-dev-tools.minimal .in-point,.gs-dev-tools.minimal .out-point{display:none}.gs-dev-tools.minimal .select-animation-container{display:none}.gs-dev-tools.minimal .rewind{display:none}.gs-dev-tools.minimal .play-pause{width:20px;height:20px;padding:4px 6px;margin-left:14px}.gs-dev-tools.minimal .time-scale{min-width:26px}.gs-dev-tools.minimal .loop{width:18px;min-width:18px;display:none}.gs-dev-tools.minimal .gs-bottom-right{display:none}@media only screen and (max-width:600px){.gs-dev-tools{height:auto;display:flex;align-items:stretch}.gs-dev-tools .gs-top{order:2;flex-grow:4;background-color:rgba(0,0,0,1);height:42px}.gs-dev-tools .gs-bottom{background-color:rgba(0,0,0,1);border-top:none}.gs-dev-tools .timeline{top:50%;transform:translate(0,-50%)}.gs-dev-tools .in-point,.gs-dev-tools .out-point{display:none}.gs-dev-tools .select-animation-container{display:none}.gs-dev-tools .rewind{display:none}.gs-dev-tools .play-pause{width:20px;height:20px;padding:4px 6px;margin-left:14px}.gs-dev-tools .time-scale{min-width:26px}.gs-dev-tools .loop{width:18px;min-width:18px;display:none}.gs-dev-tools .gs-bottom-right{display:none}}';
18123      _addedCSS = true;
18124    }
18125
18126    if (_isString$5(element)) {
18127      element = _doc$7.querySelector(element);
18128    }
18129
18130    var root = _createElement$2("div", element || _docEl$3.getElementsByTagName("body")[0] || _docEl$3);
18131
18132    root.setAttribute("class", "gs-dev-tools" + (minimal ? " minimal" : ""));
18133    root.innerHTML = '<div class=gs-hit-area></div><div class=gs-top><div class=timeline><div class=timeline-track></div><div class=progress-bar></div><div class=seek-bar></div>

18133<svg class=in-point viewBox="0 0 15 26" xmlns=http://www.w3.org/2000/svg><polygon class=in-point-shape points=".5 .5 14.5 .5 14.5 25.5 .5 17.5"/><polyline class=grab points="5.5 4 5.5 15"/><polyline class=grab points="9.5 4 9.5 17"/></svg><svg class=out-point viewBox="0 0 15 26" xmlns=http://www.w3.org/2000/svg><polygon class=out-point-shape points=".5 .5 14.5 .5 14.5 17.5 .5 25.5"/><polyline class=grab points="5.5 4 5.5 17"/><polyline class=grab points="9.5 4 9.5 15"/></svg><div class=playhead></div></div></div><div class=gs-bottom><div class=select-animation-container><label class=select-animation><select class=animation-list><option>Global Timeline<option>myTimeline</select><nobr><span class="display animation-label">Global Timeline</span><svg class=select-arrow viewBox="0 0 12.05 6.73" xmlns=http://www.w3.org/2000/svg><polyline class=select-arrow-shape points="0.35 0.35 6.03 6.03 11.7 0.35"/></svg></nobr></label></div><svg class=rewind viewBox="0 0 12 15.38" xmlns=http://www.w3.org/2000/svg><path d=M0,.38H2v15H0Zm2,7,10,7.36V0Z class="gs-btn-white rewind-path"/></svg><svg class=play-pause viewBox="0 0 20.97 25.67" xmlns=http://www.w3.org/2000/svg><g class=play><path d="M8,4.88 C8,10.18 8,15.48 8,20.79 5.33,22.41 2.66,24.04 0,25.67 0,17.11 0,8.55 0,0 2.66,1.62 5.33,3.25 8,4.88" class="gs-btn-white play-1" style=stroke:#fff;stroke-width:.6px /><path d="M14.485,8.855 C16.64,10.18 18.8,11.5 20.97,12.83 16.64,15.48 12.32,18.13 8,20.79 8,15.48 8,10.18 8,4.88 10.16,6.2 12.32,7.53 14.48,8.85" class="gs-btn-white play-2" style=stroke:#fff;stroke-width:.6px /></g></svg> <svg class=loop viewBox="0 0 29 25.38" xmlns=http://www.w3.org/2000/svg><path d=M27.44,5.44,20.19,0V3.06H9.06A9.31,9.31,0,0,0,0,12.41,9.74,9.74,0,0,0,.69,16l3.06-2.23a6,6,0,0,1-.12-1.22,5.49,5.49,0,0,1,5.43-5.5H20.19v3.81Z class=loop-path /><path d=M25.25,11.54a5.18,5.18,0,0,1,.12,1.12,5.41,5.41,0,0,1-5.43,5.41H9.19V14.5L1.94,19.94l7.25,5.44V22.06H19.94A9.2,9.2,0,0,0,29,12.84a9.42,9.42,0,0,0-.68-3.53Z class=loop-path /></svg> <svg class=ease viewBox="0 0 25.67 25.67" xmlns=http://www.w3.org/2000/svg><path d=M.48,25.12c1.74-3.57,4.28-12.6,8.8-10.7s4.75,1.43,6.5-1.11S19.89,1.19,25.2.55 class=ease-path /><path d=M24.67,1V24.67H1V1H24.67m1-1H0V25.67H25.67V0Z class=ease-border /></svg><label class=time-scale><select><option value=10>10x<option value=5>5x<option value=2>2x<option value=1 selected>1x<option value=0.5>0.5x<option value=0.25>0.25x<option value=0.1>0.1x</select><span class="display time-scale-label">1x</span></label><div class=gs-bottom-right><div class=time-container><span class=time>0.00</span> / <span class=duration>0.00</span></div><a href="https://gsap.com/docs/v3/Plugins/GSDevTools?source=GSDevTools" target=_blank title=Docs><svg class=logo viewBox="0 0 100 100" xmlns=http://www.w3.org/2000/svg><path d="M60 15.4c-.3-.4-.5-.6-.5-.7.1-.6.2-1 .2-1.7v-.4c.6.6 1.3 1.3 1.8 1.7.2.2.5.3.8.3.2 0 .3 0 .5.1h1.6c.8 0 1.6.1 2 0 .1 0 .2 0 .3-.1.6-.3 1.4-1 2.1-1.6 0 .6.1 1.2.1 1.7v1.5c0 .3 0 .5.1.7-.1.1-.2.1-.4.2-.7.4-1.7 1-2.3.9-.5-.1-1.5-.3-2.6-.7-1.2-.3-2.4-.8-3.2-1.2 0 0-.1 0-.1-.1s-.2-.4-.4-.6zm24.6 21.9c-.5-1.7-1.9-2-4.2-.7.9-1.5 2.1-1.5 2.3-2.1.9-2.5-.6-4.6-1.2-5.3.7-1.8 1.4-4.5-1-6.8-1-1-2.4-1.2-3.6-1.1 1.8 1.7 3.4 4.4 2.5 7.2-.1.3-.9.7-1.7 1 0 0 .4 2-.3 3.5-.3.6-.8 1.5-1.3 2.6 1 .9 1.6 1 3 1.3-.9.1-1.2.4-1.2.5-.7 3 1 3.4 1.4 4.8 0 .1 0 .2.1.3v.4c-.3.3-1.4.5-2.5.5s-1.8 1-1.8 1c-.2.1-.3.3-.4.4v1c0 .1 0 .4.1.6.1.5.3 1.3.4 1.8.9.6 1.4.9 2.2 1.1.5.1 1 .2 1.5.1.3-.1.7-.3 1-.7 1.5-1.7 1.9-3.2 2.2-4.1 0-.1 0-.2.1-.2 0 .1.1.1.1.2 0 0 .1-.1.1-.2l.1-.1c1.3-1.6 2.9-4.5 2.1-7zM74.3 49.9c-.1-.3-.1-.7-.2-1.1v-.2c-.1-.2-.1-.4-.2-.6 0-.1-.1-.3-.1-.5s-.1-.5-.1-.7v-.1c0-.2-.1-.5-.1-.7-.1-.3-.1-.7-.2-1.1v-.1c0-.2 0-.3-.1-.5v-.9c0-.1 0-.2.1-.3V43h-.3c-1.1.1-3.8.4-6.7.2-1.2-.1-2.4-.3-3.6-.6-1-.3-1.8-.5-2.3-.7-1.2-.4-1.6-.6-1.8-.7 0 .2-.1.4-.1.7 0 .3-.1.5-.1.8-.1.2-.1.4-.2.6l.1.1c.5.5 1.5 1.3 1.5 2.1v.2c-.1.4-.4.5-.8.9-.1.1-.6.7-1.1 1.1l-.6.6c-.1 0-.1.1-.2.1-.1.1-.3.2-.4.3-.2.1-.7.5-.8.6-.1.1-.2.1-.3.1-2.8 8.8-2.2 13.5-1.5 16.1.1.5.3 1 .4 1.3-.4.5-.8 1-1.2 1.4-1.2 1.5-2 2.6-2.6 4.2 0 .1 0 .1-.1.2 0 .1 0 .2-.1.2-.2.5-.3 1-.4 1.5-.6 2.3-.8 4.5-.9 6.6-.1 2.4-.2 4.6-.5 6.9.7.3 3.1.9 4.7.6.2

18133-.1 0-3.9.6-5.7l.6-1.5c.4-.9.9-1.9 1.3-3.1.3-.7.5-1.5.7-2.4.1-.5.2-1 .3-1.6V74v-.1c.1-.6.1-1.3.1-2 0-.2-.7.3-1.1.9.3-1.8 1.3-2.1 2-3.2.3-.5.6-1.1.6-2 2.5-1.7 4-3.7 5-5.7.2-.4.4-.9.6-1.4.3-.8.5-1.6.7-2.4.3-1.4.8-3.2 1.2-4.8v-.1c.4-1.2.8-2.2 1.2-2.6-.2.9-.4 1.7-.6 2.5v.2c-.6 3.5-.7 6.2-2 9.2 1 2.6 1.9 3.9 2 7.6-2 0-3.2 1.6-3.7 3.2 1.2.3 3.9.7 8.3.1h.3c.1-.5.3-1.1.5-1.5.3-.8.5-1.5.6-2.2.2-1.3.1-2.4 0-3.2 3.9-3.7 2.6-11 1.6-16.6zm.3-15.1c.1-.3.2-.6.4-.8.2-.3.3-.7.5-1 .1-.3.3-.6.4-.9.5-1.5.4-2.8.3-3.5-.1 0-.1-.1-.2-.1-.5-.2-.9-.4-1.4-.6-.1 0-.2-.1-.3-.1-3.8-1.2-7.9-.9-11.9.1-1 .2-1.9.5-2.9.1-2.3-.8-3.9-1.9-4.6-2.8l-.2-.2c-.1.2-.2.4-.4.6.2 2.3-.5 3.9-1.4 5.1.9 1.2 2.6 2.8 3.6 3.4 1.1.6 1.7.7 3.4.4-.6.7-1.1 1-1.9 1.4.1.7.2 2 .5 3.4.3.3 1.2.8 2.3 1.3.5.3 1.1.5 1.7.7.8.3 1.7.6 2.4.8.1 0 .2.1.3.1.5.1 1.1.2 1.8.2h.9c2.1 0 4.5-.2 5.4-.3h.1c-.1-2.7.2-4.6.7-6.2.2-.3.4-.7.5-1.1zm-23.2 9.3v.2c-.3 1.7.5 2.4 1.9 3.4.6.5 0 .5.5.8.3.2.7.3 1 .3.3 0 .5 0 .8-.1.2-.1.4-.3.6-.5.1-.1.3-.2.5-.4.3-.2.6-.5.7-.6.1-.1.2-.1.3-.2.2-.2.5-.5.6-.7.2-.2.4-.5.5-.7 0-.1.1-.1.1-.1v-.1c.1-.4-.3-.8-.8-1.3-.2-.2-.4-.3-.5-.5-.3-.3-.6-.5-1-.7-.9-.5-1.9-.7-3-.7l-.3-.3c-2.2-2.5-3.2-4.8-3.9-6.5-.9-2.1-1.9-3.3-3.9-4.9 1 .4 1.8.8 2.3 1.1.5.4 1.3.4 1.9.2.2-.1.5-.2.7-.3.2-.1.4-.2.6-.4 1.6-1.3 2.5-3.8 2.6-5.6v-.1c.2-.3.6-1.1.8-1.4l.1.1c.1.1.3.2.6.5.1 0 .1.1.2.1.1.1.2.1.2.2.8.6 1.9 1.3 2.6 1.7 1.4.7 2.3.7 5.3-.1 2.2-.6 4.8-.8 6.8-.8 1.4 0 2.7.3 4 .7.2.1.4.1.5.2.3.1.6.2.9.4 0 0 .1 0 .1.1.8.4 2.1 1.2 2.5-.3.1-2-.6-3.9-1.6-5.3 0 0-.1 0-.1-.1-.1-.1-.2-.2-.4-.3-.1-.1-.2-.1-.3-.2-.1-.1-.2-.2-.4-.2-.6-.4-1.2-.8-1.6-.9-.1-.1-.3-.1-.4-.2h-.1-.1c-.1 0-.3-.1-.4-.1-.1 0-.1 0-.2-.1h-.1l-.2-.4c-.2-.1-.4-.2-.5-.2h-.6c-.3 0-.5.1-.7.1-.7.1-1.2.3-1.7.4-.2 0-.3.1-.5.1-.5.1-1 .2-1.6.2-.4 0-.9-.1-1.5-.2-.4-.1-.8-.2-1.1-.3-.2-.1-.4-.1-.6-.2-.6-.2-1.1-.3-1.7-.4h-.2-1.8c-.3 0-.6.1-1 .1H57.9c-.8 0-1.5 0-2.3-.1-.2 0-.5-.1-.7-.1-.5-.1-.9-.2-1.3-.4-.2-.1-.3-.1-.4-.2-.1 0-.2 0-.2-.1-.3-.1-.6-.1-.9-.1H51h-.1c-.4 0-.9.1-1.4.2-1.1.2-2.1.6-3 1.3-.3.2-.6.5-.8.8-.1.1-.2.2-.2.3-.4.6-.8 1.2-.9 2 0 .2-.1.4-.1.6 0 .2 1.7.7 2.3 2.8-.8-1.2-2.3-2.5-4.1-1.4-1.5 1-1.1 3.1-2.4 5.4-.3.5-.6.9-1 1.4-.8 1-.7 2.1.2 4.4 1.4 3.4 7.6 5.3 11.5 8.3l.4.4zm8.7-36.3c0 .6.1 1 .2 1.6v.1c0 .3.1.6.1.9.1 1.2.4 2 1 2.9 0 .1.1.1.1.2.3.2.5.3.8.4 1.1.2 3.1.3 4.2 0 .2-.1.5-.3.7-.5.4-.4.7-1.1.9-1.7.1-.7.3-1.3.4-1.8 0-.2.1-.4.1-.5v-.1c0-.2 0-.3.1-.5.2-.7.2-2.4.3-2.8.1-.7 0-1.8-.1-2.5 0-.2-.1-.4-.1-.5v-.1c-.2-.5-1.4-1.4-4.3-1.4-3.1 0-4 1-4.1 1.5v.1c0 .1 0 .3-.1.5-.1.4-.2 1.4-.2 1.9v2.3zm-6 88.6c0-.1-.1-.2-.1-.3-.7-1.5-1.1-3.5-1.3-4.6.4.1.7.6.8.3.2-.5-.4-1.5-.5-2.2v-.1c-.5-.5-4-.5-3.7-.3-.4.8-1 .6-1.3 2.1-.1.7.8.1 1.7.1-1.4.9-3 2.1-3.4 3.2-.1.1-.1.2-.1.3 0 .2-.1.4-.1.5-.1 1.2.5 1.6 2 2.4H48.4c1.4.3 3 .3 4.3.3 1.2-.2 1.6-.7 1.6-1.4-.2-.1-.2-.2-.2-.3z" style=fill:#efefef /><path d="M56.1 36.5c.3 1.4.5 2.4.8 4.2h-.2c-.1.5-.1.9-.1 1.3-1-.4-2.2-.5-2.6-.5-3.7-4.4-2.9-6.1-4.4-8.3.4-.2 1-.4 1.5-.8 1.6 1.9 3.3 3 5 4.1zm-1.7 13.2s-1.4 0-2.3-1c0 0-.1-.5.1-.7 0 0-1.2-1-1.5-1.7-.2-.5-.3-1.1-.2-1.6-4.4-3.7-10.9-4.2-12.9-9.1-.5-1.2-1.3-2.9-.9-3.9-.3.1-.5.2-.8.3-2.9.9-11.7 5.3-17.9 8.8 1.6 1.7 2.6 4.3 3.2 7.2l.3 1.5c.1.5.1 1 .2 1.5.1 1.4.4 2.7.8 3.9.2.8.6 1.5.9 2.2.6 1 1.2 1.9 2.1 2.6.6.5 1.2.9 1.9 1.3 2.1 1.1 5 1.6 8.6 1.5H37.9c.5 0 1 .1 1.5.1h.1c.4.1.9.1 1.3.2h.2c.4.1.9.2 1.3.4h.1c.4.1.8.3 1.1.5h.1c.4.2.7.4 1.1.6h.1c.7.4 1.3.9 1.9 1.5l.1.1c.6.5 1.1 1.1 1.5 1.8 0 .1.1.1.1.2s.1.1.1.2c.4.6 1.2 1.1 1.9 1.3.7-.9 1.5-1.8 2.2-2.8-1.6-6 0-11.7 1.8-16.9zm-26-15.9c5-2.4 9-4.1 9.9-4.5.3-.6.6-1.4.9-2.6.1-.3.2-.5.3-.8 1-2.7 2.7-2.8 3.5-3v-.2c.1-1.1.5-2 1-2.8-8.8 2.5-18 5.5-28 11.7-.1.1-.2.2-.4.2C11.3 34.5 3 40.3 1.3 51c2.4-2.7 6-5.6 10.5-8.5.1-.1.3-.2.5-.3.2-.1.5-.3.7-.4 1.2-.7 2.4-1.4 3.6-2.2 2.2-1.2 4.5-2.4 6.7-3.5 1.8-.8 3.5-1.6 5.1-2.3zm54.9 61.3l-.3-.3c-.8-.6-4.1-1.2-5.5-2.3-.4-.3-1.1-.7-1.7-1.1-1.6-.9-3.5-1.8-3.5-2.1v-.1c-.2-1.7-.2-7 .1-8.8.3-1.8.7-4.4.8-5.1.1-.6.5-1.2.1-1.2h-.4c-.2 0-.4.1-.8.1-1.5.3-4.3.6-6.6.4-.9-.1-1.6-.2-2-.3-.5-.1-.7-.2-.9-.3H62.3c-.4.5 0 2.7.6 4.8.3 1.1.8 2 1.2 3 .3.8.6 1.8.8 3.1 0 .2.1.4.1.7.2 2.8.3 3.6-.2 4.9-.1.3-.3.6-.4 1-.4.9-.7 1.7-.6 2.3 0 .2.1.4.1.5.2.4.6.7 1.2.8.2 0 .3.1.5.

181331.3 0 .6.1.9.1 3.4 0 5.2 0 8.6.4 2.5.4 3.9.6 5.1.5.4 0 .9-.1 1.4-.1 1.2-.2 1.8-.5 1.9-.9-.1.2-.1.1-.2-.1zM60.2 16.4zm-.5 1.7zm3.8.5c.1 0 .3.1.5.1.4.1.7.2 1.2.3.3.1.6.1.9.1h1.3c.3-.1.7-.1 1-.2.7-.2 1.5-.4 2.7-.6h.3c.3 0 .6.1.9.3.1.1.2.1.4.2.3.2.8.2 1.2.4h.1c.1 0 .1.1.2.1.6.3 1.3.7 1.9 1.1l.3.3c.9-.1 1.6-.2 2.1-.2h.1c-.2-.4-.3-1.3-1.8-.6-.6-.7-.8-1.3-2.1-.9-.1-.2-.2-.3-.3-.4l-.1-.1c-.1-.1-.2-.3-.3-.4 0-.1-.1-.1-.1-.2-.2-.3-.5-.5-.9-.7-.7-.4-1.5-.6-2.3-.5-.2 0-.4.1-.6.2-.1 0-.2.1-.2.1-.1 0-.2.1-.3.2-.5.3-1.3.8-2.1 1-.1 0-.1 0-.2.1-.2 0-.4.1-.5.1H66.5h-.1c-.4-.1-1.1-.2-2-.5-.1 0-.2-.1-.3-.1-.9-.2-1.8-.5-2.7-.8-.3-.1-.7-.2-1-.3-.1 0-.1 0-.2-.1h-.1s-.1 0-.1-.1c-.3-.3-.7-.6-1.3-.8-.5-.2-1.2-.4-2.1-.5-.2 0-.5 0-.7.1-.4.2-.8.6-1.2.9.1.1.3.3.4.5.1.2.2.4.3.7l-.6-.6c-.5-.4-1.1-.8-1.7-.9-.8-.2-1.4.4-2.3.9 1 0 1.8.1 2.5.4.1 0 .1 0 .2.1h.1c.1 0 .2.1.3.1.9.4 1.8.6 2.7.6h1.3c.5 0 .8-.1 1.1-.1.1 0 .4 0 .7-.1h2.2c.4.4.9.6 1.6.8z" style=fill:#88ce02 /><path d="M100 51.8c0-19.5-12.5-36.1-30-42.1.1-1.2.2-2.4.3-3.1.1-1.5.2-3.9-.5-4.9-1.6-2.3-9.1-2.1-10.5-.1-.4.6-.7 3.6-.6 5.9-1.1-.1-2.2-.1-3.3-.1-16.5 0-30.9 9-38.6 22.3-2.4 1.4-4.7 2.8-6.1 4C5.4 38 2.2 43.2 1 47c-1.6 4.7-1.1 7.6.4 5.8 1.2-1.5 6.6-5.9 10.1-8.2-.4 2.3-.6 4.8-.6 7.2 0 21 14.5 38.5 34 43.3-.1 1.1.1 2 .7 2.6.9.8 3.2 2 6.4 1.6 2.9-.3 3.5-.5 3.2-2.9h.2c2.7 0 5.3-.2 7.8-.7.1.1.2.2.4.3 1.5 1 7.1.8 9.6.7s6.2.9 8.6.5c2.9-.5 3.4-2.3 1.6-3.2-1.5-.8-3.8-1.3-6.7-3.1C90.6 83.4 100 68.7 100 51.8zM60.1 5.5c0-.5.1-1.5.2-2.1 0-.2 0-.4.1-.5v-.1c.1-.5 1-1.5 4.1-1.5 2.9 0 4.2.9 4.3 1.4v.1c0 .1 0 .3.1.5.1.8.2 1.9.1 2.7 0 .5-.1 2.1-.2 2.9 0 .1 0 .3-.1.5v.1c0 .2-.1.3-.1.5-.1.5-.2 1.1-.4 1.8-.1.6-.5 1.2-.9 1.7-.2.3-.5.5-.7.5-1.1.3-3.1.3-4.2 0-.3-.1-.5-.2-.8-.4 0-.1-.1-.1-.1-.2-.6-.9-.9-1.7-1-2.9 0-.4-.1-.6-.1-.9v-.1c-.1-.6-.2-1-.2-1.6v-.3c-.1-1.3-.1-2.1-.1-2.1zm-.4 7.5v-.4c.6.6 1.3 1.3 1.8 1.7.2.2.5.3.8.3.2 0 .3 0 .5.1h1.6c.8 0 1.6.1 2 0 .1 0 .2 0 .3-.1.6-.3 1.4-1 2.1-1.6 0 .6.1 1.2.1 1.7v1.5c0 .3 0 .5.1.7-.1.1-.2.1-.4.2-.7.4-1.7 1-2.3.9-.5-.1-1.5-.3-2.6-.7-1.2-.3-2.4-.8-3.2-1.2 0 0-.1 0-.1-.1-.2-.3-.4-.5-.6-.7-.3-.4-.5-.6-.5-.7.3-.4.4-.9.4-1.6zm.5 3.4zm-7.3-.3c.6.1 1.2.5 1.7.9.2.2.5.4.6.6-.1-.2-.2-.5-.3-.7-.1-.2-.3-.4-.4-.5.4-.3.8-.7 1.2-.9.2-.1.4-.1.7-.1.9.1 1.6.2 2.1.5.6.2 1 .5 1.3.8 0 0 .1 0 .1.1h.1c.1 0 .1 0 .2.1.3.1.6.2 1 .3.9.3 1.9.6 2.7.8.1 0 .2.1.3.1.9.2 1.6.4 2 .5h.4c.2 0 .4 0 .5-.1.1 0 .1 0 .2-.1.7-.2 1.5-.7 2.1-1 .1-.1.2-.1.3-.2.1 0 .2-.1.2-.1.2-.1.4-.2.6-.2.8-.2 1.7.1 2.3.5.3.2.6.4.9.7 0 .1.1.1.1.2.1.2.2.3.3.4l.1.1c.1.1.2.2.3.4 1.3-.4 1.5.2 2.1.9 1.6-.7 1.7.2 1.8.6h-.1c-.5 0-1.2 0-2.1.2l-.3-.3c-.5-.4-1.2-.8-1.9-1.1-.1 0-.1-.1-.2-.1h-.1c-.4-.2-.8-.2-1.2-.4-.1-.1-.2-.1-.4-.2-.3-.1-.6-.3-.9-.3h-.3c-1.2.1-2 .4-2.7.6-.3.1-.7.2-1 .2-.4.1-.8.1-1.3 0-.3 0-.6-.1-.9-.1-.5-.1-.8-.2-1.2-.3-.2 0-.3-.1-.5-.1h-.1c-.6-.2-1.2-.3-1.8-.4h-.1-2.1c-.4.1-.6.1-.7.1-.3 0-.7.1-1.1.1h-1.3c-.9 0-1.9-.2-2.7-.6-.1 0-.2-.1-.3-.1H53c-.1 0-.1 0-.2-.1-.7-.3-1.6-.4-2.5-.4 1.2-.8 1.8-1.4 2.6-1.3zm6.8 2zm-15.2 4.1c.1-.7.4-1.4.9-2 .1-.1.2-.2.2-.3l.8-.8c.9-.6 1.9-1.1 3-1.3.5-.1 1-.2 1.4-.2H52c.3 0 .6.1.9.1.1 0 .2 0 .2.1.1.1.2.1.4.2.4.2.8.3 1.3.4.2 0 .5.1.7.1.7.1 1.5.1 2.3.1H58.7c.4 0 .7-.1 1-.1H61.7c.6.1 1.1.2 1.7.4.2 0 .4.1.6.2.3.1.7.2 1.1.3.6.1 1.1.2 1.5.2.6 0 1.1-.1 1.6-.2.2 0 .3-.1.5-.1.5-.1 1-.3 1.7-.4.2 0 .5-.1.7-.1h.6c.2 0 .4.1.5.2l.1.1h.1c.1 0 .1 0 .2.1.2.1.3.1.4.1h.2c.1.1.3.1.4.2.4.2 1 .6 1.6.9.1.1.2.2.4.2.1.1.2.1.3.2.2.1.3.3.4.3l.1.1c1.1 1.4 1.8 3.3 1.6 5.3-.3 1.5-1.6.7-2.5.3 0 0-.1 0-.1-.1-.3-.1-.6-.2-.9-.4-.2-.1-.4-.1-.5-.2-1.2-.4-2.5-.7-4-.7-2 0-4.6.1-6.8.8-3 .8-4 .8-5.3.1-.8-.4-1.8-1.1-2.6-1.7-.1-.1-.2-.1-.2-.2-.1-.1-.1-.1-.2-.1-.3-.2-.6-.4-.6-.5l-.1-.1c-.2.3-.6 1-.8 1.4v.1c-.1 1.7-1 4.2-2.6 5.6-.2.1-.4.3-.6.4-.2.1-.5.2-.7.3-.7.2-1.4.2-1.9-.2-.5-.3-1.3-.7-2.3-1.1 2 1.6 3 2.8 3.9 4.9.7 1.7 1.7 4 3.9 6.5l.3.3c1.1 0 2.1.2 3 .7.4.2.7.4 1 .7.2.2.4.3.5.5.5.4.9.8.8 1.3v.1s0 .1-.1.1c-.1.2-.3.5-.5.7-.1.1-.4.4-.6.7-.1.1-.2.2-.3.2-.1.1-.4.3-.7.6-.2.2-.4.3-.5.4-.2.1-.4.4-.6.5-.3.1-.5.2-.8.1-.3 0-.7-.2-1-.3-.5-.3.1-.3-.5-.8-1.4-1-2.2-1.7-1.9-3.4v-.2c-.2-.1-.3-.3-.5-.4-3.9-3-10.1-4.9-11.5-8.3-.9-2.3-1-3.4-.2-4.4.4-.5.8-1 1-1.4 1.3-2.3.9-4.4 2.4

18133-5.4 1.8-1.2 3.3.2 4.1 1.4-.5-2.1-2.3-2.6-2.3-2.8.3.1.3-.1.3-.3zm29 20s-.1 0 0 0c-.1 0-.1 0 0 0-.9.1-3.3.3-5.4.3h-.9c-.7 0-1.3-.1-1.8-.2-.1 0-.2 0-.3-.1-.7-.2-1.6-.5-2.4-.8-.6-.2-1.2-.5-1.7-.7-1.1-.5-2.1-1.1-2.3-1.3-.5-1.4-.7-2.7-.7-3.4.8-.4 1.3-.7 1.9-1.4-1.7.3-2.4.2-3.4-.4-1-.5-2.6-2.2-3.6-3.4 1-1.2 1.7-2.9 1.4-5.1.1-.2.3-.4.4-.6 0 .1.1.1.2.2.7.9 2.4 2 4.6 2.8 1.1.4 2 .1 2.9-.1 4-1 8.1-1.3 11.9-.1.1 0 .2.1.3.1.5.2.9.4 1.4.6.1 0 .1.1.2.1.1.7.2 2-.3 3.5-.1.3-.2.6-.4.9-.2.3-.3.6-.5 1-.1.3-.2.5-.4.8-.2.4-.3.8-.5 1.3-.4 1.4-.7 3.4-.6 6zm-23.9-9c.4-.2 1-.4 1.5-.8 1.6 1.8 3.3 3 5 4.1.3 1.4.5 2.4.8 4.2h-.2c-.1.5-.1.9-.1 1.3-1-.4-2.2-.5-2.6-.5-3.7-4.3-3-6-4.4-8.3zm-32.9 6.5c-1.3.7-2.5 1.4-3.6 2.2-.2.1-.5.3-.7.4-.1.1-.3.2-.5.3-4.5 2.9-8.1 5.8-10.5 8.5 1.7-10.8 10-16.5 14.3-19.2.1-.1.2-.2.4-.2 10-6.2 19.2-9.2 28-11.7-.5.8-.9 1.7-1 2.8v.2c-.8.1-2.5.2-3.5 3-.1.2-.2.5-.3.8-.3 1.2-.6 2-.9 2.6-.9.4-5 2.2-9.9 4.5-1.6.8-3.3 1.6-5 2.4-2.3 1-4.6 2.2-6.8 3.4zm28 24.8s0-.1 0 0c-.4-.3-.8-.5-1.2-.7h-.1c-.4-.2-.7-.3-1.1-.5h-.1c-.4-.1-.8-.3-1.3-.4h-.2c-.4-.1-.8-.2-1.3-.2h-.1c-.5-.1-1-.1-1.5-.1H35.9c-3.7.1-6.5-.4-8.6-1.5-.7-.4-1.4-.8-1.9-1.3-.9-.7-1.5-1.6-2.1-2.6-.4-.7-.7-1.4-.9-2.2-.4-1.2-.6-2.5-.8-3.9 0-.5-.1-1-.2-1.5l-.3-1.5c-.6-2.9-1.6-5.5-3.2-7.2 6.3-3.5 15-7.9 17.8-8.8.3-.1.6-.2.8-.3-.3 1.1.4 2.7.9 3.9 2.1 4.9 8.6 5.4 12.9 9.1 0 .5 0 1.1.2 1.6.5.6 1.7 1.6 1.7 1.6-.2.2-.1.7-.1.7.9 1 2.3 1 2.3 1-1.8 5.2-3.4 10.9-1.9 16.9-.7 1-1.5 1.8-2.2 2.8-.7-.2-1.4-.6-1.9-1.3 0-.1-.1-.1-.1-.2s-.1-.1-.1-.2l-1.5-1.8-.1-.1c-.5-.4-1.2-.9-1.9-1.3zm7.9 33.6c-1.3.1-2.9 0-4.3-.3h-.2-.1c-1.5-.8-2.1-1.2-2-2.4 0-.2 0-.3.1-.5 0-.1.1-.2.1-.3.5-1.1 2.1-2.2 3.4-3.2-.8 0-1.8.7-1.7-.1.2-1.5.9-1.3 1.3-2.1-.2-.3 3.3-.2 3.8.3v.1c0 .7.7 1.7.5 2.2-.1.3-.4-.2-.8-.3.2 1.1.6 3.1 1.3 4.6.1.1.1.2.1.3 0 .1.1.2.1.3 0 .7-.4 1.2-1.6 1.4zM59 67.7c0 .9-.3 1.6-.6 2-.7 1.1-1.7 1.4-2 3.2.4-.6 1.1-1.1 1.1-.9 0 .8-.1 1.4-.1 2v.2c-.1.6-.2 1.1-.3 1.6-.2.9-.5 1.7-.7 2.4-.4 1.2-.9 2.1-1.3 3.1l-.6 1.5c-.6 1.7-.4 5.6-.6 5.7-1.6.3-4.1-.3-4.7-.6.3-2.2.4-4.5.5-6.9.1-2.1.3-4.3.9-6.6.1-.5.3-1 .4-1.5 0-.1 0-.2.1-.2 0-.1 0-.1.1-.2.5-1.6 1.4-2.7 2.6-4.2.4-.4.7-.9 1.2-1.4-.1-.4-.2-.8-.4-1.3-.7-2.6-1.3-7.3 1.5-16.1.1 0 .2-.1.3-.1.2-.1.7-.5.8-.6.1-.1.3-.2.4-.3.1 0 .1-.1.2-.1l.6-.6 1.1-1.1c.4-.4.7-.5.8-.9v-.2c0-.8-1.1-1.5-1.5-2.1l-.1-.1c.1-.2.1-.4.2-.6 0-.2.1-.5.1-.8 0-.2.1-.5.1-.7.1.1.6.4 1.8.7.6.2 1.3.4 2.3.7 1.1.3 2.4.5 3.6.6 2.9.2 5.6 0 6.7-.2h.3v.1c0 .1 0 .2-.1.3v.9c0 .2 0 .3.1.5v.1c0 .4.1.7.2 1.1 0 .3.1.5.1.7v.1c0 .3.1.5.1.7 0 .2.1.3.1.5.1.2.1.4.2.6v.2c.1.4.2.8.2 1.1 1 5.7 2.3 12.9-1.1 16.7.2.8.3 1.9 0 3.2-.1.7-.3 1.4-.6 2.2-.2.5-.3 1-.5 1.5h-.3c-4.5.6-7.1.2-8.3-.1.5-1.6 1.7-3.3 3.7-3.2-.1-3.7-1.1-5-2-7.6 1.3-3 1.3-5.7 2-9.2v-.2c.2-.8.3-1.6.6-2.5-.4.5-.8 1.5-1.2 2.6v.1c-.5 1.5-.9 3.4-1.2 4.8-.2.8-.4 1.6-.7 2.4-.2.5-.4.9-.6 1.4-1.5 1.9-3 3.9-5.5 5.6zm18.5 24.9c1.5 1.1 4.7 1.8 5.5 2.3l.3.3c.1.1.1.2.1.3-.1.4-.7.7-1.9.9-.5.1-.9.1-1.4.1-1.3 0-2.6-.2-5.1-.5-3.4-.5-5.2-.4-8.6-.4-.3 0-.6 0-.9-.1-.2 0-.4-.1-.5-.1-.6-.2-1-.5-1.2-.8-.1-.2-.1-.3-.1-.5-.1-.7.2-1.5.6-2.3.2-.4.3-.7.4-1 .5-1.3.4-2.1.2-4.9 0-.2-.1-.4-.1-.7-.2-1.3-.5-2.3-.8-3.1-.4-1.1-.9-1.9-1.2-3-.6-2.1-1-4.3-.6-4.8H62.5c.2.1.5.2.9.3.5.1 1.1.2 2 .3 2.2.2 5.1-.2 6.6-.4.3-.1.6-.1.8-.1h.4c.4 0 .1.6-.1 1.2-.1.7-.5 3.3-.8 5.1-.3 1.8-.2 7.1-.1 8.8v.1c0 .3 1.9 1.2 3.5 2.1.7.2 1.4.5 1.8.9zm4.8-48.2c0 .1 0 .1 0 0-.1.1-.2.2-.2.3 0-.1-.1-.1-.1-.2 0 .1 0 .2-.1.2-.2.9-.6 2.4-2.2 4.1-.4.4-.7.6-1 .7-.5.1-.9 0-1.5-.1-.9-.2-1.3-.6-2.2-1.1-.1-.6-.3-1.3-.4-1.8 0-.3-.1-.5-.1-.6v-1l.4-.4s.7-1 1.8-1 2.2-.2 2.5-.5v-.1-.3c0-.1 0-.2-.1-.3-.4-1.4-2.1-1.8-1.4-4.8 0-.2.3-.5 1.2-.5-1.4-.3-2-.4-3-1.3.5-1.1 1-1.9 1.3-2.6.8-1.5.3-3.5.3-3.5.8-.3 1.6-.7 1.7-1 .9-2.8-.7-5.5-2.5-7.2 1.2-.1 2.6.1 3.6 1.1 2.4 2.4 1.8 5 1 6.8.6.7 2.1 2.9 1.2 5.3-.2.6-1.4.6-2.3 2.1 2.3-1.3 3.7-1 4.2.7 1 2.4-.6 5.3-2.1 7z"/><path d="M22 53.4v-.2c0-.2-.1-.5-.2-.9s-.1-.8-.2-1.3c-.5-4.7-1.9-9.4-4.9-11.3 3.7-2 16.8-8.5 21.9-10.5 2.9-1.2.8-.4-.2 1.4-.8 1.4-.3 2.9-.5 3.2-.6.8-12.6 10.5-15.9 19.6zm32.2-2.3c-3.4 3.8-12 11-18.2 11.4 8.7-.2 12.2 4.1 14.7 9.7 2.6-5.2 2.7-10.3 2.6-16.1 0-2.6 1.8-6 .9-5zm5.3-23L54.3 24s-1.1 3.1-1 4.6c.1 1.6-1.8 2.7-.9 3.6.9.9 3.2 2.5 4 3.4.7.9 1.1 7.1 1.1 7.1l2.2 2.7s1-1.8 1.1-6.3c.2-5.4-2.9-7.1-3.3-8.6-.4-1.4.6-2.9 2-2.4zm3.1 45.6l3.9.3s1.2-2.2 2.1-3.5c.9-1.4.4-1.6 0-4.6-.4-3-1.4-9.3-1.2-13.6l-3.1 10.2s1.8 5.6 1.6 6.4c-.1.8-3.3 4.8-3.3 4.8zm5 18.8c-1.1 0-2.5-.4-3.5-.8l-1 .3.2 4s5.2.7 4.6-.4c-.6-1.2-.3-3.1-.3-3.1zm12 .6c-1 0-.3.2.4 1.2.8 1 .1 2-.8 2.3l3.2.5 1.9-1.7c.1 0-3.7-2.3-4.7-2.3zM73 76c-1.6.5-4.2.8-5.9.8-1.7.1-3.7-.1-5-.5v1.4s1.2.5 5.4.5c3.5.1 5.7-.8 5.7-.8l.9-.8c-.1.1.5-1.1-1.1-.6zm-.2 3.1c-1.6.6-3.9.6-5.6.7-1.7.1-3.7-.1-5-.5l.1 1.4s.7.3 4.9.4c3.5.1 5.7-.7 5.7-.7l.3-.5c-.1-.1.3-1-.4-.8zm5.9-42.7c-.9-.8-1.4-2.4-1.5-3.3l-1.9 2.5.7 1.2s2.5.1 2.8.1c.4 0 .3-.1-.1-.5zM69 14.7c.6-.7.2-2.7.2-2.7L66 14.6l-4.4-.8-.5-1.3-1.3-.1c.8 1.8 1.8 2.5 3.3 3.1.9.4 4.5.9 5.9-.8z" style=opacity:.4;fill-rule:evenodd;clip-rule:evenodd

vendor: 26,308 bytes, lines 18133-19001

18133/></svg></a></div></div>';
18134
18135    if (element) {
18136      root.style.position = "absolute";
18137      root.style.top = minimal ? "calc(100% - 42px)" : "calc(100% - 51px)";
18138    }
18139
18140    if (css) {
18141      if (_isString$5(css)) {
18142        root.style.cssText = css;
18143      } else if (_isObject$3(css)) {
18144        css.data = "root";
18145        gsap$j.set(root, css).kill();
18146      }
18147
18148      if (root.style.top) {
18149        root.style.bottom = "auto";
18150      }
18151
18152      if (root.style.width) {
18153        gsap$j.set(root, {
18154          xPercent: -50,
18155          left: "50%",
18156          right: "auto",
18157          data: "root"
18158        }).kill();
18159      }
18160    }
18161
18162    if (!minimal && root.offsetWidth < 600) {
18163      root.setAttribute("class", "gs-dev-tools minimal");
18164
18165      if (element) {
18166        root.style.top = "calc(100% - 42px)";
18167      }
18168    }
18169
18170    return root;
18171  },
18172      _clickedOnce = true,
18173      _addListener$3 = function _addListener(e, type, callback, capture) {
18174    var handler, altType;
18175
18176    if (type === "mousedown" || type === "mouseup") {
18177      e.style.cursor = "pointer";
18178    }
18179
18180    if (type === "mousedown") {
18181      altType = !_isUndefined$3(e.onpointerdown) ? "pointerdown" : !_isUndefined$3(e.ontouchstart) ? "touchstart" : null;
18182
18183      if (altType) {
18184        handler = function handler(event) {
18185          if (event.target.nodeName.toLowerCase() !== "select" && event.type === altType) {
18186            event.stopPropagation();
18187
18188            if (_clickedOnce) {
18189              event.preventDefault();
18190              callback.call(e, event);
18191            }
18192          } else if (event.type !== altType) {
18193            callback.call(e, event);
18194          }
18195
18196          _clickedOnce = true;
18197        };
18198
18199        e.addEventListener(altType, handler, capture);
18200
18201        if (altType !== "pointerdown") {
18202          e.addEventListener(type, handler, capture);
18203        }
18204
18205        return;
18206      }
18207    }
18208
18209    e.addEventListener(type, callback, capture);
18210  },
18211      _removeListener$3 = function _removeListener(e, type, callback) {
18212    e.removeEventListener(type, callback);
18213    type = type !== "mousedown" ? null : !_isUndefined$3(e.onpointerdown) ? "pointerdown" : !_isUndefined$3(e.ontouchstart) ? "touchstart" : null;
18214
18215    if (type) {
18216      e.removeEventListener(type, callback);
18217    }
18218  },
18219      _selectValue = function _selectValue(element, value, label, insertIfAbsent) {
18220    var options = element.options,
18221        i = options.length,
18222        option;
18223    value += "";
18224
18225    while (--i > -1) {
18226      if (options[i].innerHTML === value || options[i].value === value) {
18227        element.selectedIndex = i;
18228        label.innerHTML = options[i].innerHTML;
18229        return options[i];
18230      }
18231    }
18232
18233    if (insertIfAbsent) {
18234      option = _createElement$2("option", element);
18235      option.setAttribute("value", value);
18236      option.innerHTML = label.innerHTML = _isString$5(insertIfAbsent) ? insertIfAbsent : value;
18237      element.selectedIndex = options.length - 1;
18238    }
18239  },
18240      _shiftSelectedValue = function _shiftSelectedValue(element, amount, label) {
18241    var options = element.options,
18242        i = Math.min(options.length - 1, Math.max(0, element.selectedIndex + amount));
18243    element.selectedIndex = i;
18244
18245    if (label) {
18246      label.innerHTML = options[i].innerHTML;
18247    }
18248
18249    return options[i].value;
18250  },
18251      _merge$1 = function _merge() {
18252    var t = _globalTimeline$1._first,
18253        duration,
18254        next,
18255        target;
18256
18257    if (_rootInstance) {
18258      duration = _recordedRoot._dur;
18259
18260      while (t) {
18261        next = t._next;
18262        target = t._targets && t._targets[0];
18263
18264        if (!(_isFunction$5(target) && target === t.vars.onComplete && !t._dur) && !(target && target._gsIgnore)) {
18265          _recordedRoot.add(t, t._start - t._delay);
18266        }
18267
18268        t = next;
18269      }
18270
18271      return duration !== _recordedRoot.duration();
18272    }
18273  },
18274      _buildPlayPauseMorph = function _buildPlayPauseMorph(svg) {
18275    var tl = gsap$j.timeline({
18276      data: "root",
18277      parent: _independentRoot,
18278      onComplete: function onComplete() {
18279        return tl.kill();
18280      }
18281    }, _independentRoot._time);
18282    tl.to(svg.querySelector(".play-1"), {
18283      duration: 0.4,
18284      attr: {
18285        d: "M5.75,3.13 C5.75,9.79 5.75,16.46 5.75,23.13 4.08,23.13 2.41,23.13 0.75,23.13 0.75,16.46 0.75,9.79 0.75,3.12 2.41,3.12 4.08,3.12 5.75,3.12"
18286      },
18287      ease: "power2.inOut",
18288      rotation: 360,
18289      transformOrigin: "50% 50%"
18290    }).to(svg.querySelector(".play-2"), {
18291      duration: 0.4,
18292      attr: {
18293        d: "M16.38,3.13 C16.38,9.79 16.38,16.46 16.38,23.13 14.71,23.13 13.04,23.13 11.38,23.13 11.38,16.46 11.38,9.79 11.38,3.12 13.04,3.12 14.71,3.12 16.38,3.12"
18294      },
18295      ease: "power2.inOut",
18296      rotation: 360,
18297      transformOrigin: "50% 50%"
18298    }, 0.05);
18299    return tl;
18300  },
18301      _buildLoopAnimation = function _buildLoopAnimation(svg) {
18302    var tl = gsap$j.timeline({
18303      data: "root",
18304      id: "loop",
18305      parent: _independentRoot,
18306      paused: true,
18307      onComplete: function onComplete() {
18308        return tl.kill();
18309      }
18310    }, _independentRoot._time);
18311    tl.to(svg, {
18312      duration: 0.5,
18313      rotation: 360,
18314      ease: "power3.inOut",
18315      transformOrigin: "50% 50%"
18316    }).to(svg.querySelectorAll(".loop-path"), {
18317      duration: 0.5,
18318      fill: "#91e600",
18319      ease: "none"
18320    }, 0);
18321    return tl;
18322  },
18323      _getAnimationById = function _getAnimationById(id) {
18324    return gsap$j.getById(id) || _independentRoot.getById(id) || id === _recordedRoot.vars.id && _recordedRoot;
18325  },
18326      _initCore$f = function _initCore(core) {
18327    gsap$j = core || _getGSAP$h();
18328
18329    if (!_coreInitted$f) {
18330      if (gsap$j && _windowExists$9()) {
18331        _doc$7 = document;
18332        _docEl$3 = _doc$7.documentElement;
18333        _win$8 = window;
18334
18335        _context$4 = gsap$j.core.context || function () {};
18336
18337        gsap$j.registerPlugin(Draggable);
18338        _globalTimeline$1 = gsap$j.globalTimeline;
18339        _globalTimeline$1._sort = true;
18340        _globalTimeline$1.autoRemoveChildren = false;
18341        Animation$1 = gsap$j.core.Animation;
18342        _independentRoot = gsap$j.timeline({
18343          data: "indy",
18344          autoRemoveChildren: true,
18345          smoothChildTiming: true
18346        });
18347
18348        _independentRoot.kill();
18349
18350        _independentRoot._dp = 0;
18351
18352        _independentRoot.to({}, {
18353          duration: 1e12
18354        });
18355
18356        _recordedRoot = gsap$j.timeline({
18357          data: "root",
18358          id: "Global Timeline",
18359          autoRemoveChildren: false,
18360          smoothChildTiming: true,
18361          parent: _independentRoot
18362        }, 0);
18363        _rootTween = gsap$j.to(_recordedRoot, {
18364          duration: 1,
18365          time: 1,
18366          ease: "none",
18367          data: "root",
18368          id: "_rootTween",
18369          paused: true,
18370          immediateRender: false,
18371          parent: _independentRoot
18372        }, 0);
18373
18374        _globalTimeline$1.killTweensOf = function (targets, props, onlyActive) {
18375          _recordedRoot.killTweensOf(targets, props, onlyActive);
18376
18377          _recordedRoot.killTweensOf.call(_globalTimeline$1, targets, props, onlyActive);
18378        };
18379
18380        _independentRoot._start = gsap$j.ticker.time;
18381        gsap$j.ticker.add(function (time) {
18382          return _independentRoot.render(time - _independentRoot._start);
18383        });
18384        _globalTimeline$1._start += _globalTimeline$1._time;
18385        _recordedRoot._start = _globalTimeline$1._time = _globalTimeline$1._tTime = 0;
18386
18387        _delayedCall = function _delayedCall(delay, callback, params, scope) {
18388          return gsap$j.to(callback, {
18389            delay: delay,
18390            duration: 0,
18391            onComplete: callback,
18392            onReverseComplete: callback,
18393            onCompleteParams: params,
18394            onReverseCompleteParams: params,
18395            callbackScope: scope,
18396            parent: _independentRoot
18397          }, _independentRoot._time);
18398        };
18399
18400        _delayedCall(0.01, function () {
18401          return _rootInstance ? _rootInstance.update() : _merge$1();
18402        });
18403
18404        _delayedCall(2, function () {
18405          var t, next, offset;
18406
18407          if (!_rootInstance) {
18408            _merge$1();
18409
18410            t = _recordedRoot._first;
18411            offset = _recordedRoot._start;
18412
18413            while (t) {
18414              next = t._next;
18415
18416              if (t._tDur !== t._tTime || !t._dur && t.progress() !== 1) {
18417                _globalTimeline$1.add(t, t._start - t._delay + offset);
18418              } else {
18419                t.kill();
18420              }
18421
18422              t = next;
18423            }
18424          }
18425
18426          if (GSDevTools.globalRecordingTime > 2) {
18427            _delayedCall(GSDevTools.globalRecordingTime - 2, function () {
18428              _rootInstance && _rootInstance.update();
18429              _globalTimeline$1.autoRemoveChildren = true;
18430            });
18431          } else {
18432            _globalTimeline$1.autoRemoveChildren = true;
18433          }
18434
18435          _startupPhase = false;
18436        });
18437
18438        _coreInitted$f = 1;
18439      }
18440    }
18441  },
18442      _checkIndependence = function _checkIndependence(animation, vars) {
18443    if (!vars.globalSync && animation.parent !== _globalTimeline$1) {
18444      _globalTimeline$1.add(animation, _globalTimeline$1.time());
18445    }
18446  },
18447      GSDevTools = function GSDevTools(vars) {
18448    if (!_coreInitted$f) {
18449      _initCore$f();
18450
18451      gsap$j || console.warn("Please gsap.registerPlugin(GSDevTools)");
18452    }
18453
18454    this.vars = vars = vars || {};
18455
18456    if (vars.animation) {
18457      (GSDevTools.getByAnimation(vars.animation) || {
18458        kill: function kill() {
18459          return 0;
18460        }
18461      }).kill();
18462    }
18463
18464    vars.id = vars.id || (_isString$5(vars.animation) ? vars.animation : _idSeed++);
18465    _lookup$1[vars.id + ""] = this;
18466    "globalSync" in vars || (vars.globalSync = !vars.animation);
18467
18468    var _self = this,
18469        root = _createRootElement(vars.container, vars.minimal, vars.css),
18470        find = function find(s) {
18471      return root.querySelector(s);
18472    },
18473        record = function record(key, value) {
18474      if (vars.persist !== false && _supportsStorage) {
18475        sessionStorage.setItem("gs-dev-" + key + vars.id, value);
18476      }
18477
18478      return value;
18479    },
18480        recall = function recall(key) {
18481      var value;
18482
18483      if (vars.persist !== false && _supportsStorage) {
18484        value = sessionStorage.getItem("gs-dev-" + key + vars.id);
18485        return key === "animation" ? value : key === "loop" ? value === "true" : parseFloat(value);
18486      }
18487    },
18488        playhead = find(".playhead"),
18489        timelineTrack = find(".timeline-track"),
18490        progressBar = find(".progress-bar"),
18491        timeLabel = find(".time"),
18492        durationLabel = find(".duration"),
18493        pixelToTimeRatio,
18494        timeAtDragStart,
18495        dragged,
18496        skipDragUpdates,
18497        progress = 0,
18498        inPoint = find(".in-point"),
18499        outPoint = find(".out-point"),
18500        inProgress = 0,
18501        outProgress = 100,
18502        pausedWhenDragStarted,
18503        list = find(".animation-list"),
18504        animationLabel = find(".animation-label"),
18505        selectedAnimation,
18506        linkedAnimation,
18507        declaredAnimation,
18508        startTime,
18509        endTime,
18510        _fullyInitialized,
18511        keyboardHandler,
18512        playPauseButton = find(".play-pause"),
18513        playPauseMorph = _buildPlayPauseMorph(playPauseButton),
18514        paused = false,
18515        loopButton = find(".loop"),
18516        loopAnimation = _buildLoopAnimation(loopButton),
18517        loopEnabled,
18518        timeScale = find(".time-scale select"),
18519        timeScaleLabel = find(".time-scale-label"),
18520        onPressTimeline = function onPressTimeline(element, originRatio, limitToInOut) {
18521      return function (e) {
18522        var trackBounds = timelineTrack.getBoundingClientRect(),
18523            elementBounds = element.getBoundingClientRect(),
18524            left = elementBounds.width * originRatio,
18525            x = gsap$j.getProperty(element, "x"),
18526            minX = trackBounds.left - elementBounds.left - left + x,
18527            maxX = trackBounds.right - elementBounds.right + (elementBounds.width - left) + x,
18528            unlimitedMinX = minX,
18529            limitBounds;
18530
18531        if (limitToInOut) {
18532          if (element !== inPoint) {
18533            limitBounds = inPoint.getBoundingClientRect();
18534
18535            if (limitBounds.left) {
18536              minX += limitBounds.left + limitBounds.width - trackBounds.left;
18537            }
18538          }
18539
18540          if (element !== outPoint) {
18541            limitBounds = outPoint.getBoundingClientRect();
18542
18543            if (limitBounds.left) {
18544              maxX -= trackBounds.left + trackBounds.width - limitBounds.left;
18545            }
18546          }
18547        }
18548
18549        pausedWhenDragStarted = paused;
18550        this.applyBounds({
18551          minX: minX,
18552          maxX: maxX
18553        });
18554        pixelToTimeRatio = linkedAnimation.duration() / trackBounds.width;
18555        timeAtDragStart = -unlimitedMinX * pixelToTimeRatio;
18556
18557        if (!skipDragUpdates) {
18558          linkedAnimation.pause(timeAtDragStart + pixelToTimeRatio * this.x);
18559        } else {
18560          linkedAnimation.pause();
18561        }
18562
18563        if (this.target === playhead) {
18564          if (this.activated) {
18565            this.allowEventDefault = false;
18566          }
18567
18568          this.activated = true;
18569        }
18570
18571        dragged = true;
18572      };
18573    },
18574        progressDrag = Draggable.create(playhead, {
18575      type: "x",
18576      cursor: "ew-resize",
18577      allowNativeTouchScrolling: false,
18578      allowEventDefault: true,
18579      onPress: onPressTimeline(playhead, 0.5, true),
18580      onDrag: function onDrag() {
18581        var time = timeAtDragStart + pixelToTimeRatio * this.x;
18582
18583        if (time < 0) {
18584          time = 0;
18585        } else if (time > linkedAnimation._dur) {
18586          time = linkedAnimation._dur;
18587        }
18588
18589        if (!skipDragUpdates) {
18590          linkedAnimation.time(time);
18591        }
18592
18593        progressBar.style.width = Math.min(outProgress - inProgress, Math.max(0, time / linkedAnimation._dur * 100 - inProgress)) + "%";
18594        timeLabel.innerHTML = time.toFixed(2);
18595      },
18596      onRelease: function onRelease() {
18597        paused || linkedAnimation.resume();
18598      }
18599    })[0],
18600        resetInOut = function resetInOut() {
18601      inProgress = 0;
18602      outProgress = 100;
18603      inPoint.style.left = "0%";
18604      outPoint.style.left = "100%";
18605      record("in", inProgress);
18606      record("out", outProgress);
18607      updateProgress(true);
18608    },
18609        inDrag = Draggable.create(inPoint, {
18610      type: "x",
18611      cursor: "ew-resize",
18612      zIndexBoost: false,
18613      allowNativeTouchScrolling: false,
18614      allowEventDefault: true,
18615      onPress: onPressTimeline(inPoint, 1, true),
18616      onDoubleClick: resetInOut,
18617      onDrag: function onDrag() {
18618        inProgress = (timeAtDragStart + pixelToTimeRatio * this.x) / linkedAnimation.duration() * 100;
18619        linkedAnimation.progress(inProgress / 100);
18620        updateProgress(true);
18621      },
18622      onRelease: function onRelease() {
18623        if (inProgress < 0) {
18624          inProgress = 0;
18625        }
18626
18627        _clearSelection();
18628
18629        inPoint.style.left = inProgress + "%";
18630        record("in", inProgress);
18631        gsap$j.set(inPoint, {
18632          x: 0,
18633          data: "root",
18634          display: "block"
18635        });
18636
18637        if (!paused) {
18638          linkedAnimation.resume();
18639        }
18640      }
18641    })[0],
18642        outDrag = Draggable.create(outPoint, {
18643      type: "x",
18644      cursor: "ew-resize",
18645      allowNativeTouchScrolling: false,
18646      allowEventDefault: true,
18647      zIndexBoost: false,
18648      onPress: onPressTimeline(outPoint, 0, true),
18649      onDoubleClick: resetInOut,
18650      onDrag: function onDrag() {
18651        outProgress = (timeAtDragStart + pixelToTimeRatio * this.x) / linkedAnimation.duration() * 100;
18652        linkedAnimation.progress(outProgress / 100);
18653        updateProgress(true);
18654      },
18655      onRelease: function onRelease() {
18656        if (outProgress > 100) {
18657          outProgress = 100;
18658        }
18659
18660        _clearSelection();
18661
18662        outPoint.style.left = outProgress + "%";
18663        record("out", outProgress);
18664        gsap$j.set(outPoint, {
18665          x: 0,
18666          data: "root",
18667          display: "block"
18668        });
18669
18670        if (!pausedWhenDragStarted) {
18671          play();
18672          linkedAnimation.resume();
18673        }
18674      }
18675    })[0],
18676        updateProgress = function updateProgress(force) {
18677      if (progressDrag.isPressed && force !== true) {
18678        return;
18679      }
18680
18681      var p = !loopEnabled && selectedAnimation._repeat === -1 ? selectedAnimation.totalTime() / selectedAnimation.duration() * 100 : linkedAnimation.progress() * 100 || 0,
18682          repeatDelayPhase = selectedAnimation._repeat && selectedAnimation._rDelay && selectedAnimation.totalTime() % (selectedAnimation.duration() + selectedAnimation._rDelay) > selectedAnimation.duration(),
18683          target;
18684
18685      if (p > 100) {
18686        p = 100;
18687      }
18688
18689      if (p >= outProgress) {
18690        if (loopEnabled && !linkedAnimation.paused() && !progressDrag.isDragging) {
18691          if (!repeatDelayPhase) {
18692            p = inProgress;
18693            target = linkedAnimation._targets && linkedAnimation._targets[0];
18694
18695            if (target === selectedAnimation) {
18696              target.seek(startTime + (endTime - startTime) * inProgress / 100);
18697            }
18698
18699            if (selectedAnimation._repeat > 0 && !inProgress && outProgress === 100) {
18700              if (selectedAnimation.totalProgress() === 1) {
18701                linkedAnimation.totalProgress(0, true).resume();
18702              }
18703            } else {
18704              linkedAnimation.progress(p / 100, true).resume();
18705            }
18706          }
18707        } else {
18708          if (p !== outProgress || selectedAnimation._repeat === -1) {
18709            p = outProgress;
18710            linkedAnimation.progress(p / 100);
18711          }
18712
18713          if (!paused && (outProgress < 100 || selectedAnimation.totalProgress() === 1 || selectedAnimation._repeat === -1)) {
18714            pause();
18715          }
18716        }
18717      } else if (p < inProgress) {
18718        p = inProgress;
18719        linkedAnimation.progress(p / 100, true);
18720      }
18721
18722      if (p !== progress || force === true) {
18723        progressBar.style.left = inProgress + "%";
18724        progressBar.style.width = Math.max(0, p - inProgress) + "%";
18725        playhead.style.left = p + "%";
18726        timeLabel.innerHTML = linkedAnimation._time.toFixed(2);
18727        durationLabel.innerHTML = linkedAnimation._dur.toFixed(2);
18728
18729        if (dragged) {
18730          playhead.style.transform = "translate(-50%,0)";
18731          playhead._gsap.x = "0px";
18732          playhead._gsap.xPercent = -50;
18733          dragged = false;
18734        }
18735
18736        progress = p;
18737      }
18738
18739      linkedAnimation.paused() !== paused && togglePlayPause();
18740    },
18741        onPressSeekBar = function onPressSeekBar(e) {
18742      if (progressDrag.isPressed) {
18743        return;
18744      }
18745
18746      var bounds = e.target.getBoundingClientRect(),
18747          x = (e.changedTouches ? e.changedTouches[0] : e).clientX,
18748          p = (x - bounds.left) / bounds.width * 100;
18749
18750      if (p < inProgress) {
18751        inProgress = p = Math.max(0, p);
18752        inPoint.style.left = inProgress + "%";
18753        inDrag.startDrag(e);
18754        return;
18755      } else if (p > outProgress) {
18756        outProgress = p = Math.min(100, p);
18757        outPoint.style.left = outProgress + "%";
18758        outDrag.startDrag(e);
18759        return;
18760      }
18761
18762      linkedAnimation.progress(p / 100).pause();
18763      updateProgress(true);
18764      progressDrag.startDrag(e);
18765    },
18766        play = function play() {
18767      if (linkedAnimation.progress() >= outProgress / 100) {
18768        _checkIndependence(linkedAnimation, vars);
18769
18770        var target = linkedAnimation._targets && linkedAnimation._targets[0];
18771
18772        if (target === selectedAnimation) {
18773          target.seek(startTime + (endTime - startTime) * inProgress / 100);
18774        }
18775
18776        if (linkedAnimation._repeat && !inProgress) {
18777          linkedAnimation.totalProgress(0, true);
18778        } else if (!linkedAnimation.reversed()) {
18779          linkedAnimation.progress(inProgress / 100, true);
18780        }
18781      }
18782
18783      playPauseMorph.play();
18784      linkedAnimation.resume();
18785
18786      if (paused) {
18787        _self.update();
18788      }
18789
18790      paused = false;
18791    },
18792        pause = function pause() {
18793      playPauseMorph.reverse();
18794
18795      if (linkedAnimation) {
18796        linkedAnimation.pause();
18797      }
18798
18799      paused = true;
18800    },
18801        togglePlayPause = function togglePlayPause() {
18802      if (paused) {
18803        play();
18804      } else {
18805        pause();
18806      }
18807    },
18808        onPressRewind = function onPressRewind(e) {
18809      if (progressDrag.isPressed) {
18810        return;
18811      }
18812
18813      _checkIndependence(linkedAnimation, vars);
18814
18815      var target = linkedAnimation._targets && linkedAnimation._targets[0];
18816
18817      if (target === selectedAnimation) {
18818        target.seek(startTime + (endTime - startTime) * inProgress / 100);
18819      }
18820
18821      linkedAnimation.progress(inProgress / 100, true);
18822
18823      if (!paused) {
18824        linkedAnimation.resume();
18825      }
18826    },
18827        loop = function loop(value) {
18828      loopEnabled = value;
18829      record("loop", loopEnabled);
18830
18831      if (loopEnabled) {
18832        loopAnimation.play();
18833
18834        if (linkedAnimation.progress() >= outProgress / 100) {
18835          var target = linkedAnimation._targets && linkedAnimation._targets[0];
18836
18837          if (target === selectedAnimation) {
18838            target.seek(startTime + (endTime - startTime) * inProgress / 100);
18839          }
18840
18841          if (selectedAnimation._repeat && !inProgress && outProgress === 100) {
18842            linkedAnimation.totalProgress(0, true);
18843          } else {
18844            linkedAnimation.progress(inProgress / 100, true);
18845          }
18846
18847          play();
18848        }
18849      } else {
18850        loopAnimation.reverse();
18851      }
18852    },
18853        toggleLoop = function toggleLoop() {
18854      return loop(!loopEnabled);
18855    },
18856        updateList = function updateList() {
18857      var animations = _getChildrenOf(declaredAnimation && !vars.globalSync ? declaredAnimation : _recordedRoot, true),
18858          options = list.children,
18859          matches = 0,
18860          option,
18861          i;
18862
18863      if (declaredAnimation && !vars.globalSync) {
18864        animations.unshift(declaredAnimation);
18865      } else if (!vars.hideGlobalTimeline) {
18866        animations.unshift(_recordedRoot);
18867      }
18868
18869      for (i = 0; i < animations.length; i++) {
18870        option = options[i] || _createElement$2("option", list);
18871        option.animation = animations[i];
18872        matches = i && animations[i].vars.id === animations[i - 1].vars.id ? matches + 1 : 0;
18873        option.setAttribute("value", option.innerHTML = animations[i].vars.id + (matches ? " [" + matches + "]" : animations[i + 1] && animations[i + 1].vars.id === animations[i].vars.id ? " [0]" : ""));
18874      }
18875
18876      for (; i < options.length; i++) {
18877        list.removeChild(options[i]);
18878      }
18879    },
18880        animation = function animation(anim) {
18881      var ts = parseFloat(timeScale.options[timeScale.selectedIndex].value) || 1,
18882          tl,
18883          maxDuration;
18884
18885      if (!arguments.length) {
18886        return selectedAnimation;
18887      }
18888
18889      if (_isString$5(anim)) {
18890        anim = _getAnimationById(anim);
18891      }
18892
18893      if (!(anim instanceof Animation$1)) {
18894        console.warn("GSDevTools error: invalid animation.");
18895      }
18896
18897      if (anim.scrollTrigger) {
18898        console.warn("GSDevTools can't work with ScrollTrigger-based animations; either the scrollbar -OR- the GSDevTools scrubber can control the animation.");
18899      }
18900
18901      if (anim === selectedAnimation) {
18902        return;
18903      }
18904
18905      if (selectedAnimation) {
18906        selectedAnimation._inProgress = inProgress;
18907        selectedAnimation._outProgress = outProgress;
18908      }
18909
18910      selectedAnimation = anim;
18911
18912      if (linkedAnimation) {
18913        ts = linkedAnimation.timeScale();
18914
18915        if (linkedAnimation._targets && linkedAnimation._targets[0] === declaredAnimation) {
18916          declaredAnimation.resume();
18917          linkedAnimation.kill();
18918        }
18919      }
18920
18921      inProgress = selectedAnimation._inProgress || 0;
18922      outProgress = selectedAnimation._outProgress || 100;
18923      inPoint.style.left = inProgress + "%";
18924      outPoint.style.left = outProgress + "%";
18925
18926      if (_fullyInitialized) {
18927        record("animation", selectedAnimation.vars.id);
18928        record("in", inProgress);
18929        record("out", outProgress);
18930      }
18931
18932      startTime = 0;
18933      maxDuration = vars.maxDuration || Math.min(1000, _getClippedDuration(selectedAnimation));
18934
18935      if (selectedAnimation === _recordedRoot || vars.globalSync) {
18936        _merge$1();
18937
18938        linkedAnimation = _rootTween;
18939        _rootInstance && _rootInstance !== _self && console.warn("Error: GSDevTools can only have one instance that's globally synchronized.");
18940        _rootInstance = _self;
18941
18942        if (selectedAnimation !== _recordedRoot) {
18943          tl = selectedAnimation;
18944          endTime = tl.totalDuration();
18945
18946          if (endTime > 99999999) {
18947            endTime = tl.duration();
18948          }
18949
18950          while (tl.parent) {
18951            startTime = startTime / tl._ts + tl._start;
18952            endTime = endTime / tl._ts + tl._start;
18953            tl = tl.parent;
18954          }
18955        } else {
18956          endTime = _recordedRoot.duration();
18957        }
18958
18959        if (endTime - startTime > maxDuration) {
18960          endTime = startTime + maxDuration;
18961        }
18962
18963        _recordedRoot.pause(startTime);
18964
18965        _rootTween.vars.time = endTime;
18966
18967        _rootTween.invalidate();
18968
18969        _rootTween.duration(endTime - startTime).timeScale(ts);
18970
18971        if (paused) {
18972          _rootTween.progress(1, true).pause(0, true);
18973        } else {
18974          _delayedCall(0.01, function () {
18975            _rootTween.resume().progress(inProgress / 100);
18976
18977            paused && play();
18978          });
18979        }
18980      } else {
18981        if (_rootInstance === _self) {
18982          _rootInstance = null;
18983        }
18984
18985        startTime = Math.min(inProgress * selectedAnimation.duration(), selectedAnimation.time());
18986
18987        if (selectedAnimation === declaredAnimation || !declaredAnimation) {
18988          linkedAnimation = selectedAnimation;
18989
18990          if (!loopEnabled && linkedAnimation._repeat) {
18991            loop(true);
18992          }
18993        } else {
18994          tl = selectedAnimation;
18995          endTime = tl.totalDuration();
18996
18997          if (endTime > 99999999) {
18998            endTime = tl.duration();
18999          }
19000
19001          while (tl.parent

19001.parent && tl !== declaredAnimation) {
19002            startTime = startTime / (tl._ts || tl._pauseTS) + tl._start;
19003            endTime = endTime / (tl._ts || tl._pauseTS

vendor: 11,468 bytes, lines 19003-19396

19003) + tl._start;
19004            tl = tl.parent;
19005          }
19006
19007          if (endTime - startTime > maxDuration) {
19008            endTime = startTime + maxDuration;
19009          }
19010
19011          declaredAnimation.pause(startTime);
19012          linkedAnimation = gsap$j.to(declaredAnimation, {
19013            duration: endTime - startTime,
19014            time: endTime,
19015            ease: "none",
19016            data: "root",
19017            parent: _independentRoot
19018          }, _independentRoot._time);
19019        }
19020
19021        linkedAnimation.timeScale(ts);
19022
19023        _rootTween.pause();
19024
19025        _recordedRoot.resume();
19026
19027        linkedAnimation.seek(0);
19028      }
19029
19030      durationLabel.innerHTML = linkedAnimation.duration().toFixed(2);
19031
19032      _selectValue(list, selectedAnimation.vars.id, animationLabel);
19033    },
19034        updateRootDuration = function updateRootDuration() {
19035      var time, ratio, duration;
19036
19037      if (selectedAnimation === _recordedRoot) {
19038        time = _recordedRoot._time;
19039
19040        _recordedRoot.progress(1, true).time(time, true);
19041
19042        time = (_rootTween._dp._time - _rootTween._start) * _rootTween._ts;
19043        duration = Math.min(1000, _recordedRoot.duration());
19044
19045        if (duration === 1000) {
19046          duration = Math.min(1000, _getClippedDuration(_recordedRoot));
19047        }
19048
19049        ratio = _rootTween.duration() / duration;
19050
19051        if (ratio !== 1 && duration) {
19052          inProgress *= ratio;
19053
19054          if (outProgress < 100) {
19055            outProgress *= ratio;
19056          }
19057
19058          _rootTween.seek(0);
19059
19060          _rootTween.vars.time = duration;
19061
19062          _rootTween.invalidate();
19063
19064          _rootTween.duration(duration);
19065
19066          _rootTween.time(time);
19067
19068          durationLabel.innerHTML = duration.toFixed(2);
19069          inPoint.style.left = inProgress + "%";
19070          outPoint.style.left = outProgress + "%";
19071          updateProgress(true);
19072        }
19073      }
19074    },
19075        onChangeAnimation = function onChangeAnimation(e) {
19076      animation(list.options[list.selectedIndex].animation);
19077
19078      if (e.target && e.target.blur) {
19079        e.target.blur();
19080      }
19081
19082      paused && play();
19083    },
19084        onChangeTimeScale = function onChangeTimeScale(e) {
19085      var ts = parseFloat(timeScale.options[timeScale.selectedIndex].value) || 1,
19086          target;
19087      linkedAnimation.timeScale(ts);
19088      record("timeScale", ts);
19089
19090      if (!paused) {
19091        if (linkedAnimation.progress() >= outProgress / 100) {
19092          target = linkedAnimation._targets && linkedAnimation._targets[0];
19093
19094          if (target === selectedAnimation) {
19095            target.seek(startTime + (endTime - startTime) * inProgress / 100);
19096          }
19097
19098          linkedAnimation.progress(inProgress / 100, true).pause();
19099        } else {
19100          linkedAnimation.pause();
19101        }
19102
19103        _delayedCall(0.01, function () {
19104          return linkedAnimation.resume();
19105        });
19106      }
19107
19108      timeScaleLabel.innerHTML = ts + "x";
19109
19110      if (timeScale.blur) {
19111        timeScale.blur();
19112      }
19113    },
19114        autoHideTween = gsap$j.to([find(".gs-bottom"), find(".gs-top")], {
19115      duration: 0.3,
19116      autoAlpha: 0,
19117      y: 50,
19118      ease: "power2.in",
19119      data: "root",
19120      paused: true,
19121      parent: _independentRoot
19122    }, _independentRoot._time),
19123        hidden = false,
19124        onMouseOut = function onMouseOut(e) {
19125      if (!Draggable.hitTest(e, root) && !progressDrag.isDragging && !inDrag.isDragging && !outDrag.isDragging) {
19126        autoHideDelayedCall.restart(true);
19127      }
19128    },
19129        hide = function hide() {
19130      if (!hidden) {
19131        autoHideTween.play();
19132        autoHideDelayedCall.pause();
19133        hidden = true;
19134      }
19135    },
19136        show = function show() {
19137      autoHideDelayedCall.pause();
19138
19139      if (hidden) {
19140        autoHideTween.reverse();
19141        hidden = false;
19142      }
19143    },
19144        toggleHide = function toggleHide() {
19145      if (hidden) {
19146        show();
19147      } else {
19148        hide();
19149      }
19150    },
19151        autoHideDelayedCall = _delayedCall(1.3, hide).pause(),
19152        initialize = function initialize(preliminary) {
19153      if (_startupPhase && !_globalStartTime) {
19154        _globalStartTime = _recordedRoot._start;
19155      }
19156
19157      _fullyInitialized = !preliminary;
19158      declaredAnimation = _parseAnimation(vars.animation);
19159
19160      if (declaredAnimation && !declaredAnimation.vars.id) {
19161        declaredAnimation.vars.id = "[no id]";
19162      }
19163
19164      _merge$1();
19165
19166      updateList();
19167
19168      var savedAnimation = _getAnimationById(recall("animation"));
19169
19170      if (savedAnimation) {
19171        savedAnimation._inProgress = recall("in") || 0;
19172        savedAnimation._outProgress = recall("out") || 100;
19173      }
19174
19175      vars.paused && pause();
19176      selectedAnimation = null;
19177      animation(declaredAnimation || savedAnimation || _recordedRoot);
19178      var ts = vars.timeScale || recall("timeScale"),
19179          savedInOut = savedAnimation === selectedAnimation;
19180
19181      if (ts) {
19182        _selectValue(timeScale, ts, timeScaleLabel, ts + "x");
19183
19184        linkedAnimation.timeScale(ts);
19185      }
19186
19187      inProgress = ("inTime" in vars ? _timeToProgress(vars.inTime, selectedAnimation, 0, 0) : savedInOut ? savedAnimation._inProgress : 0) || 0;
19188
19189      if (inProgress === 100 && !vars.animation && savedAnimation) {
19190        animation(_recordedRoot);
19191        inProgress = _timeToProgress(vars.inTime, selectedAnimation, 0, 0) || 0;
19192      }
19193
19194      if (inProgress) {
19195        inPoint.style.left = inProgress + "%";
19196        inPoint.style.display = outPoint.style.display = "block";
19197      }
19198
19199      outProgress = ("outTime" in vars ? _timeToProgress(vars.outTime, selectedAnimation, 100, inProgress) : savedInOut ? savedAnimation._outProgress : 0) || 100;
19200
19201      if (outProgress < inProgress) {
19202        outProgress = 100;
19203      }
19204
19205      if (outProgress !== 100) {
19206        outPoint.style.left = outProgress + "%";
19207        inPoint.style.display = outPoint.style.display = "block";
19208      }
19209
19210      loopEnabled = "loop" in vars ? vars.loop : recall("loop");
19211      loopEnabled && loop(true);
19212      vars.paused && linkedAnimation.progress(inProgress / 100, true).pause();
19213
19214      if (_startupPhase && selectedAnimation === _recordedRoot && _globalStartTime && vars.globalSync && !paused) {
19215        linkedAnimation.time(-_globalStartTime, true);
19216      }
19217
19218      updateProgress(true);
19219    };
19220
19221    _addListener$3(list, "change", onChangeAnimation);
19222
19223    _addListener$3(list, "mousedown", updateList);
19224
19225    _addListener$3(playPauseButton, "mousedown", togglePlayPause);
19226
19227    _addListener$3(find(".seek-bar"), "mousedown", onPressSeekBar);
19228
19229    _addListener$3(find(".rewind"), "mousedown", onPressRewind);
19230
19231    _addListener$3(loopButton, "mousedown", toggleLoop);
19232
19233    _addListener$3(timeScale, "change", onChangeTimeScale);
19234
19235    if (vars.visibility === "auto") {
19236      _addListener$3(root, "mouseout", onMouseOut);
19237
19238      _addListener$3(root, "mouseover", show);
19239    } else if (vars.visibility === "hidden") {
19240      hidden = true;
19241      autoHideTween.progress(1);
19242    }
19243
19244    if (vars.keyboard !== false) {
19245      if (_keyboardInstance && vars.keyboard) {
19246        console.warn("[GSDevTools warning] only one instance can be affected by keyboard shortcuts. There is already one active.");
19247      } else {
19248        _keyboardInstance = _self;
19249
19250        keyboardHandler = function keyboardHandler(e) {
19251          var key = e.keyCode ? e.keyCode : e.which,
19252              ts;
19253
19254          if (key === 32) {
19255            togglePlayPause();
19256          } else if (key === 38) {
19257            ts = parseFloat(_shiftSelectedValue(timeScale, -1, timeScaleLabel));
19258            linkedAnimation.timeScale(ts);
19259            record("timeScale", ts);
19260          } else if (key === 40) {
19261            ts = parseFloat(_shiftSelectedValue(timeScale, 1, timeScaleLabel));
19262            linkedAnimation.timeScale(ts);
19263            record("timeScale", ts);
19264          } else if (key === 37) {
19265            onPressRewind();
19266          } else if (key === 39) {
19267            linkedAnimation.progress(outProgress / 100);
19268          } else if (key === 76) {
19269            toggleLoop();
19270          } else if (key === 72) {
19271            toggleHide();
19272          } else if (key === 73) {
19273            inProgress = linkedAnimation.progress() * 100;
19274            record("in", inProgress);
19275            inPoint.style.left = inProgress + "%";
19276            updateProgress(true);
19277          } else if (key === 79) {
19278            outProgress = linkedAnimation.progress() * 100;
19279            record("out", outProgress);
19280            outPoint.style.left = outProgress + "%";
19281            updateProgress(true);
19282          }
19283        };
19284
19285        _addListener$3(_docEl$3, "keydown", keyboardHandler);
19286      }
19287    }
19288
19289    gsap$j.set(playhead, {
19290      xPercent: -50,
19291      x: 0,
19292      data: "root"
19293    });
19294    gsap$j.set(inPoint, {
19295      xPercent: -100,
19296      x: 0,
19297      data: "root"
19298    });
19299    inPoint._gsIgnore = outPoint._gsIgnore = playhead._gsIgnore = playPauseButton._gsIgnore = loopButton._gsIgnore = true;
19300    gsap$j.killTweensOf([inPoint, outPoint, playhead]);
19301    initialize(_startupPhase);
19302
19303    if (_startupPhase) {
19304      _delayedCall(0.0001, initialize, [false], this);
19305    }
19306
19307    gsap$j.ticker.add(updateProgress);
19308
19309    this.update = function (forceMerge) {
19310      if (_rootInstance === _self) {
19311        if (!_rootTween.paused() || forceMerge) {
19312          _merge$1();
19313        }
19314
19315        updateRootDuration();
19316      }
19317    };
19318
19319    this.kill = this.revert = function () {
19320      _removeListener$3(list, "change", onChangeAnimation);
19321
19322      _removeListener$3(list, "mousedown", updateList);
19323
19324      _removeListener$3(playPauseButton, "mousedown", togglePlayPause);
19325
19326      _removeListener$3(find(".seek-bar"), "mousedown", onPressSeekBar);
19327
19328      _removeListener$3(find(".rewind"), "mousedown", onPressRewind);
19329
19330      _removeListener$3(loopButton, "mousedown", toggleLoop);
19331
19332      _removeListener$3(timeScale, "change", onChangeTimeScale);
19333
19334      progressDrag.disable();
19335      inDrag.disable();
19336      outDrag.disable();
19337      gsap$j.ticker.remove(updateProgress);
19338
19339      _removeListener$3(root, "mouseout", onMouseOut);
19340
19341      _removeListener$3(root, "mouseover", show);
19342
19343      root.parentNode.removeChild(root);
19344
19345      if (_rootInstance === _self) {
19346        _rootInstance = null;
19347      }
19348
19349      if (_keyboardInstance === _self) {
19350        _keyboardInstance = null;
19351
19352        _removeListener$3(_docEl$3, "keydown", keyboardHandler);
19353      }
19354
19355      delete _lookup$1[vars.id + ""];
19356    };
19357
19358    this.minimal = function (value) {
19359      var isMinimal = root.classList.contains("minimal"),
19360          p;
19361
19362      if (!arguments.length || isMinimal === value) {
19363        return isMinimal;
19364      }
19365
19366      if (value) {
19367        root.classList.add("minimal");
19368      } else {
19369        root.classList.remove("minimal");
19370      }
19371
19372      if (vars.container) {
19373        root.style.top = value ? "calc(100% - 42px)" : "calc(100% - 51px)";
19374      }
19375
19376      if (progressDrag.isPressed) {
19377        skipDragUpdates = true;
19378        progressDrag.endDrag(progressDrag.pointerEvent);
19379        skipDragUpdates = false;
19380        p = linkedAnimation.progress() * 100;
19381        progressBar.style.width = Math.max(0, p - inProgress) + "%";
19382        playhead.style.left = p + "%";
19383        playhead.style.transform = "translate(-50%,0)";
19384        playhead._gsap.x = "0px";
19385        playhead._gsap.xPercent = -50;
19386        progressDrag.startDrag(progressDrag.pointerEvent, true);
19387      }
19388    };
19389
19390    this.animation = animation;
19391    this.updateList = updateList;
19392
19393    _context$4(this);
19394  };
19395
19396  GSDevTools.version = "3.1

vendor: 6,582 bytes, lines 19396-19667

193962.5";
19397  GSDevTools.globalRecordingTime = 2;
19398
19399  GSDevTools.getById = function (id) {
19400    return id ? _lookup$1[id] : _rootInstance;
19401  };
19402
19403  GSDevTools.getByAnimation = function (animation) {
19404    if (_isString$5(animation)) {
19405      animation = gsap$j.getById(animation);
19406    }
19407
19408    for (var p in _lookup$1) {
19409      if (_lookup$1[p].animation() === animation) {
19410        return _lookup$1[p];
19411      }
19412    }
19413  };
19414
19415  GSDevTools.create = function (vars) {
19416    return new GSDevTools(vars);
19417  };
19418
19419  GSDevTools.register = _initCore$f;
19420  _getGSAP$h() && gsap$j.registerPlugin(GSDevTools);
19421
19422  var gsap$k,
19423      _coreInitted$g,
19424      _toArray$6,
19425      _getUnit$3,
19426      _first,
19427      _ticker$1,
19428      _time1$1,
19429      _time2$1,
19430      _getCache$1,
19431      _getGSAP$i = function _getGSAP() {
19432    return gsap$k || typeof window !== "undefined" && (gsap$k = window.gsap);
19433  },
19434      _lookup$2 = {},
19435      _round$9 = function _round(value) {
19436    return Math.round(value * 10000) / 10000;
19437  },
19438      _getID$1 = function _getID(target) {
19439    return _getCache$1(target).id;
19440  },
19441      _getByTarget = function _getByTarget(target) {
19442    return _lookup$2[_getID$1(typeof target === "string" ? _toArray$6(target)[0] : target)];
19443  },
19444      _onTick = function _onTick(time) {
19445    var pt = _first,
19446        val;
19447
19448    if (time - _time1$1 >= 0.05) {
19449      _time2$1 = _time1$1;
19450      _time1$1 = time;
19451
19452      while (pt) {
19453        val = pt.g(pt.t, pt.p);
19454
19455        if (val !== pt.v1 || time - pt.t1 > 0.2) {
19456          pt.v2 = pt.v1;
19457          pt.v1 = val;
19458          pt.t2 = pt.t1;
19459          pt.t1 = time;
19460        }
19461
19462        pt = pt._next;
19463      }
19464    }
19465  },
19466      _types$1 = {
19467    deg: 360,
19468    rad: Math.PI * 2
19469  },
19470      _initCore$g = function _initCore() {
19471    gsap$k = _getGSAP$i();
19472
19473    if (gsap$k) {
19474      _toArray$6 = gsap$k.utils.toArray;
19475      _getUnit$3 = gsap$k.utils.getUnit;
19476      _getCache$1 = gsap$k.core.getCache;
19477      _ticker$1 = gsap$k.ticker;
19478      _coreInitted$g = 1;
19479    }
19480  };
19481
19482  var PropTracker = function PropTracker(target, property, type, next) {
19483    this.t = target;
19484    this.p = property;
19485    this.g = target._gsap.get;
19486    this.rCap = _types$1[type || _getUnit$3(this.g(target, property))];
19487    this.v1 = this.v2 = 0;
19488    this.t1 = this.t2 = _ticker$1.time;
19489
19490    if (next) {
19491      this._next = next;
19492      next._prev = this;
19493    }
19494  };
19495
19496  var VelocityTracker = function () {
19497    function VelocityTracker(target, property) {
19498      if (!_coreInitted$g) {
19499        _initCore$g();
19500      }
19501
19502      this.target = _toArray$6(target)[0];
19503      _lookup$2[_getID$1(this.target)] = this;
19504      this._props = {};
19505      property && this.add(property);
19506    }
19507
19508    VelocityTracker.register = function register(core) {
19509      gsap$k = core;
19510
19511      _initCore$g();
19512    };
19513
19514    var _proto = VelocityTracker.prototype;
19515
19516    _proto.get = function get(property, skipRecentTick) {
19517      var pt = this._props[property] || console.warn("Not tracking " + property + " velocity."),
19518          val,
19519          dif,
19520          rotationCap;
19521      val = parseFloat(skipRecentTick ? pt.v1 : pt.g(pt.t, pt.p));
19522      dif = val - parseFloat(pt.v2);
19523      rotationCap = pt.rCap;
19524
19525      if (rotationCap) {
19526        dif = dif % rotationCap;
19527
19528        if (dif !== dif % (rotationCap / 2)) {
19529          dif = dif < 0 ? dif + rotationCap : dif - rotationCap;
19530        }
19531      }
19532
19533      return _round$9(dif / ((skipRecentTick ? pt.t1 : _ticker$1.time) - pt.t2));
19534    };
19535
19536    _proto.getAll = function getAll() {
19537      var result = {},
19538          props = this._props,
19539          p;
19540
19541      for (p in props) {
19542        result[p] = this.get(p);
19543      }
19544
19545      return result;
19546    };
19547
19548    _proto.isTracking = function isTracking(property) {
19549      return property in this._props;
19550    };
19551
19552    _proto.add = function add(property, type) {
19553      if (!(property in this._props)) {
19554        if (!_first) {
19555          _ticker$1.add(_onTick);
19556
19557          _time1$1 = _time2$1 = _ticker$1.time;
19558        }
19559
19560        _first = this._props[property] = new PropTracker(this.target, property, type, _first);
19561      }
19562    };
19563
19564    _proto.remove = function remove(property) {
19565      var pt = this._props[property],
19566          prev,
19567          next;
19568
19569      if (pt) {
19570        prev = pt._prev;
19571        next = pt._next;
19572
19573        if (prev) {
19574          prev._next = next;
19575        }
19576
19577        if (next) {
19578          next._prev = prev;
19579        } else if (_first === pt) {
19580          _ticker$1.remove(_onTick);
19581
19582          _first = 0;
19583        }
19584
19585        delete this._props[property];
19586      }
19587    };
19588
19589    _proto.kill = function kill(shallow) {
19590      for (var p in this._props) {
19591        this.remove(p);
19592      }
19593
19594      if (!shallow) {
19595        delete _lookup$2[_getID$1(this.target)];
19596      }
19597    };
19598
19599    VelocityTracker.track = function track(targets, properties, types) {
19600      if (!_coreInitted$g) {
19601        _initCore$g();
19602      }
19603
19604      var result = [],
19605          targs = _toArray$6(targets),
19606          a = properties.split(","),
19607          t = (types || "").split(","),
19608          i = targs.length,
19609          tracker,
19610          j;
19611
19612      while (i--) {
19613        tracker = _getByTarget(targs[i]) || new VelocityTracker(targs[i]);
19614        j = a.length;
19615
19616        while (j--) {
19617          tracker.add(a[j], t[j] || t[0]);
19618        }
19619
19620        result.push(tracker);
19621      }
19622
19623      return result;
19624    };
19625
19626    VelocityTracker.untrack = function untrack(targets, properties) {
19627      var props = (properties || "").split(",");
19628
19629      _toArray$6(targets).forEach(function (target) {
19630        var tracker = _getByTarget(target);
19631
19632        if (tracker) {
19633          if (!props.length) {
19634            tracker.kill(1);
19635          } else {
19636            props.forEach(function (p) {
19637              return tracker.remove(p);
19638            });
19639          }
19640        }
19641      });
19642    };
19643
19644    VelocityTracker.isTracking = function isTracking(target, property) {
19645      var tracker = _getByTarget(target);
19646
19647      return tracker && tracker.isTracking(property);
19648    };
19649
19650    VelocityTracker.getVelocity = function getVelocity(target, property) {
19651      var tracker = _getByTarget(target);
19652
19653      return !tracker || !tracker.isTracking(property) ? console.warn("Not tracking velocity of " + property) : tracker.get(property);
19654    };
19655
19656    return VelocityTracker;
19657  }();
19658  VelocityTracker.getByTarget = _getByTarget;
19659  _getGSAP$i() && gsap$k.registerPlugin(VelocityTracker);
19660
19661  /*!
19662   * InertiaPlugin 3.12.5
19663   * https://gsap.com
19664   *
19665   * @license Copyright 2008-2024, GreenSock. All rights reserved.
19666   * Subject to the terms at https://gsap.com/standard-license or for
19667   * Club GSAP members, the agreement issued with that membership.

vendor: 10,032 bytes, lines 19667-20004

19667
19668   * @author: Jack Doyle, [email protected]
19669  */
19670
19671  var gsap$l,
19672      _coreInitted$h,
19673      _parseEase$2,
19674      _toArray$7,
19675      _power3,
19676      _config$2,
19677      _getUnit$4,
19678      PropTween$3,
19679      _getCache$2,
19680      _checkPointRatio,
19681      _clamp$3,
19682      _processingVars,
19683      _getStyleSaver$7,
19684      _reverting$6,
19685      _getTracker = VelocityTracker.getByTarget,
19686      _getGSAP$j = function _getGSAP() {
19687    return gsap$l || typeof window !== "undefined" && (gsap$l = window.gsap) && gsap$l.registerPlugin && gsap$l;
19688  },
19689      _isString$6 = function _isString(value) {
19690    return typeof value === "string";
19691  },
19692      _isNumber$3 = function _isNumber(value) {
19693    return typeof value === "number";
19694  },
19695      _isObject$4 = function _isObject(value) {
19696    return typeof value === "object";
19697  },
19698      _isFunction$6 = function _isFunction(value) {
19699    return typeof value === "function";
19700  },
19701      _bonusValidated$2 = 1,
19702      _isArray$2 = Array.isArray,
19703      _emptyFunc$3 = function _emptyFunc(p) {
19704    return p;
19705  },
19706      _bigNum$4 = 1e10,
19707      _tinyNum$1 = 1 / _bigNum$4,
19708      _checkPoint = 0.05,
19709      _round$a = function _round(value) {
19710    return Math.round(value * 10000) / 10000;
19711  },
19712      _extend$1 = function _extend(obj, defaults, exclude) {
19713    for (var p in defaults) {
19714      if (!(p in obj) && p !== exclude) {
19715        obj[p] = defaults[p];
19716      }
19717    }
19718
19719    return obj;
19720  },
19721      _deepClone = function _deepClone(obj) {
19722    var copy = {},
19723        p,
19724        v;
19725
19726    for (p in obj) {
19727      copy[p] = _isObject$4(v = obj[p]) && !_isArray$2(v) ? _deepClone(v) : v;
19728    }
19729
19730    return copy;
19731  },
19732      _getClosest = function _getClosest(n, values, max, min, radius) {
19733    var i = values.length,
19734        closest = 0,
19735        absDif = _bigNum$4,
19736        val,
19737        dif,
19738        p,
19739        dist;
19740
19741    if (_isObject$4(n)) {
19742      while (i--) {
19743        val = values[i];
19744        dif = 0;
19745
19746        for (p in n) {
19747          dist = val[p] - n[p];
19748          dif += dist * dist;
19749        }
19750
19751        if (dif < absDif) {
19752          closest = i;
19753          absDif = dif;
19754        }
19755      }
19756
19757      if ((radius || _bigNum$4) < _bigNum$4 && radius < Math.sqrt(absDif)) {
19758        return n;
19759      }
19760    } else {
19761      while (i--) {
19762        val = values[i];
19763        dif = val - n;
19764
19765        if (dif < 0) {
19766          dif = -dif;
19767        }
19768
19769        if (dif < absDif && val >= min && val <= max) {
19770          closest = i;
19771          absDif = dif;
19772        }
19773      }
19774    }
19775
19776    return values[closest];
19777  },
19778      _parseEnd = function _parseEnd(curProp, end, max, min, name, radius, velocity) {
19779    if (curProp.end === "auto") {
19780      return curProp;
19781    }
19782
19783    var endVar = curProp.end,
19784        adjustedEnd,
19785        p;
19786    max = isNaN(max) ? _bigNum$4 : max;
19787    min = isNaN(min) ? -_bigNum$4 : min;
19788
19789    if (_isObject$4(end)) {
19790      adjustedEnd = end.calculated ? end : (_isFunction$6(endVar) ? endVar(end, velocity) : _getClosest(end, endVar, max, min, radius)) || end;
19791
19792      if (!end.calculated) {
19793        for (p in adjustedEnd) {
19794          end[p] = adjustedEnd[p];
19795        }
19796
19797        end.calculated = true;
19798      }
19799
19800      adjustedEnd = adjustedEnd[name];
19801    } else {
19802      adjustedEnd = _isFunction$6(endVar) ? endVar(end, velocity) : _isArray$2(endVar) ? _getClosest(end, endVar, max, min, radius) : parseFloat(endVar);
19803    }
19804
19805    if (adjustedEnd > max) {
19806      adjustedEnd = max;
19807    } else if (adjustedEnd < min) {
19808      adjustedEnd = min;
19809    }
19810
19811    return {
19812      max: adjustedEnd,
19813      min: adjustedEnd,
19814      unitFactor: curProp.unitFactor
19815    };
19816  },
19817      _getNumOrDefault = function _getNumOrDefault(vars, property, defaultValue) {
19818    return isNaN(vars[property]) ? defaultValue : +vars[property];
19819  },
19820      _calculateChange = function _calculateChange(velocity, duration) {
19821    return duration * _checkPoint * velocity / _checkPointRatio;
19822  },
19823      _calculateDuration = function _calculateDuration(start, end, velocity) {
19824    return Math.abs((end - start) * _checkPointRatio / velocity / _checkPoint);
19825  },
19826      _reservedProps$1 = {
19827    resistance: 1,
19828    checkpoint: 1,
19829    preventOvershoot: 1,
19830    linkedProps: 1,
19831    radius: 1,
19832    duration: 1
19833  },
19834      _processLinkedProps = function _processLinkedProps(target, vars, getVal, resistance) {
19835    if (vars.linkedProps) {
19836      var linkedPropNames = vars.linkedProps.split(","),
19837          linkedProps = {},
19838          i,
19839          p,
19840          curProp,
19841          curVelocity,
19842          tracker,
19843          curDuration;
19844
19845      for (i = 0; i < linkedPropNames.length; i++) {
19846        p = linkedPropNames[i];
19847        curProp = vars[p];
19848
19849        if (curProp) {
19850          if (_isNumber$3(curProp.velocity)) {
19851            curVelocity = curProp.velocity;
19852          } else {
19853            tracker = tracker || _getTracker(target);
19854            curVelocity = tracker && tracker.isTracking(p) ? tracker.get(p) : 0;
19855          }
19856
19857          curDuration = Math.abs(curVelocity / _getNumOrDefault(curProp, "resistance", resistance));
19858          linkedProps[p] = parseFloat(getVal(target, p)) + _calculateChange(curVelocity, curDuration);
19859        }
19860      }
19861
19862      return linkedProps;
19863    }
19864  },
19865      _calculateTweenDuration = function _calculateTweenDuration(target, vars, maxDuration, minDuration, overshootTolerance, recordEnd) {
19866    if (maxDuration === void 0) {
19867      maxDuration = 10;
19868    }
19869
19870    if (minDuration === void 0) {
19871      minDuration = 0.2;
19872    }
19873
19874    if (overshootTolerance === void 0) {
19875      overshootTolerance = 1;
19876    }
19877
19878    if (recordEnd === void 0) {
19879      recordEnd = 0;
19880    }
19881
19882    _isString$6(target) && (target = _toArray$7(target)[0]);
19883
19884    if (!target) {
19885      return 0;
19886    }
19887
19888    var duration = 0,
19889        clippedDuration = _bigNum$4,
19890        inertiaVars = vars.inertia || vars,
19891        getVal = _getCache$2(target).get,
19892        resistance = _getNumOrDefault(inertiaVars, "resistance", _config$2.resistance),
19893        p,
19894        curProp,
19895        curDuration,
19896        curVelocity,
19897        curVal,
19898        end,
19899        curClippedDuration,
19900        tracker,
19901        unitFactor,
19902        linkedProps;
19903
19904    linkedProps = _processLinkedProps(target, inertiaVars, getVal, resistance);
19905
19906    for (p in inertiaVars) {
19907      if (!_reservedProps$1[p]) {
19908        curProp = inertiaVars[p];
19909
19910        if (!_isObject$4(curProp)) {
19911          tracker = tracker || _getTracker(target);
19912
19913          if (tracker && tracker.isTracking(p)) {
19914            curProp = _isNumber$3(curProp) ? {
19915              velocity: curProp
19916            } : {
19917              velocity: tracker.get(p)
19918            };
19919          } else {
19920            curVelocity = +curProp || 0;
19921            curDuration = Math.abs(curVelocity / resistance);
19922          }
19923        }
19924
19925        if (_isObject$4(curProp)) {
19926          if (_isNumber$3(curProp.velocity)) {
19927            curVelocity = curProp.velocity;
19928          } else {
19929            tracker = tracker || _getTracker(target);
19930            curVelocity = tracker && tracker.isTracking(p) ? tracker.get(p) : 0;
19931          }
19932
19933          curDuration = _clamp$3(minDuration, maxDuration, Math.abs(curVelocity / _getNumOrDefault(curProp, "resistance", resistance)));
19934          curVal = parseFloat(getVal(target, p)) || 0;
19935          end = curVal + _calculateChange(curVelocity, curDuration);
19936
19937          if ("end" in curProp) {
19938            curProp = _parseEnd(curProp, linkedProps && p in linkedProps ? linkedProps : end, curProp.max, curProp.min, p, inertiaVars.radius, curVelocity);
19939
19940            if (recordEnd) {
19941              _processingVars === vars && (_processingVars = inertiaVars = _deepClone(vars));
19942              inertiaVars[p] = _extend$1(curProp, inertiaVars[p], "end");
19943            }
19944          }
19945
19946          if ("max" in curProp && end > +curProp.max + _tinyNum$1) {
19947            unitFactor = curProp.unitFactor || _config$2.unitFactors[p] || 1;
19948            curClippedDuration = curVal > curProp.max && curProp.min !== curProp.max || curVelocity * unitFactor > -15 && curVelocity * unitFactor < 45 ? minDuration + (maxDuration - minDuration) * 0.1 : _calculateDuration(curVal, curProp.max, curVelocity);
19949
19950            if (curClippedDuration + overshootTolerance < clippedDuration) {
19951              clippedDuration = curClippedDuration + overshootTolerance;
19952            }
19953          } else if ("min" in curProp && end < +curProp.min - _tinyNum$1) {
19954            unitFactor = curProp.unitFactor || _config$2.unitFactors[p] || 1;
19955            curClippedDuration = curVal < curProp.min && curProp.min !== curProp.max || curVelocity * unitFactor > -45 && curVelocity * unitFactor < 15 ? minDuration + (maxDuration - minDuration) * 0.1 : _calculateDuration(curVal, curProp.min, curVelocity);
19956
19957            if (curClippedDuration + overshootTolerance < clippedDuration) {
19958              clippedDuration = curClippedDuration + overshootTolerance;
19959            }
19960          }
19961
19962          curClippedDuration > duration && (duration = curClippedDuration);
19963        }
19964
19965        curDuration > duration && (duration = curDuration);
19966      }
19967    }
19968
19969    duration > clippedDuration && (duration = clippedDuration);
19970    return duration > maxDuration ? maxDuration : duration < minDuration ? minDuration : duration;
19971  },
19972      _initCore$h = function _initCore() {
19973    gsap$l = _getGSAP$j();
19974
19975    if (gsap$l) {
19976      _parseEase$2 = gsap$l.parseEase;
19977      _toArray$7 = gsap$l.utils.toArray;
19978      _getUnit$4 = gsap$l.utils.getUnit;
19979      _getCache$2 = gsap$l.core.getCache;
19980      _clamp$3 = gsap$l.utils.clamp;
19981      _getStyleSaver$7 = gsap$l.core.getStyleSaver;
19982
19983      _reverting$6 = gsap$l.core.reverting || function () {};
19984
19985      _power3 = _parseEase$2("power3");
19986      _checkPointRatio = _power3(0.05);
19987      PropTween$3 = gsap$l.core.PropTween;
19988      gsap$l.config({
19989        resistance: 100,
19990        unitFactors: {
19991          time: 1000,
19992          totalTime: 1000,
19993          progress: 1000,
19994          totalProgress: 1000
19995        }
19996      });
19997      _config$2 = gsap$l.config();
19998      gsap$l.registerPlugin(VelocityTracker);
19999      _coreInitted$h = 1;
20000    }
20001  };
20002
20003  var InertiaPlugin$1 = {
20004    version: "3.1

vendor: 3,293 bytes, lines 20004-20099

200042.5",
20005    name: "inertia",
20006    register: function register(core) {
20007      gsap$l = core;
20008
20009      _initCore$h();
20010    },
20011    init: function init(target, vars, tween, index, targets) {
20012      _coreInitted$h || _initCore$h();
20013
20014      var tracker = _getTracker(target);
20015
20016      if (vars === "auto") {
20017        if (!tracker) {
20018          console.warn("No inertia tracking on " + target + ". InertiaPlugin.track(target) first.");
20019          return;
20020        }
20021
20022        vars = tracker.getAll();
20023      }
20024
20025      this.styles = _getStyleSaver$7 && typeof target.style === "object" && _getStyleSaver$7(target);
20026      this.target = target;
20027      this.tween = tween;
20028      _processingVars = vars;
20029
20030      var cache = target._gsap,
20031          getVal = cache.get,
20032          dur = vars.duration,
20033          durIsObj = _isObject$4(dur),
20034          preventOvershoot = vars.preventOvershoot || durIsObj && dur.overshoot === 0,
20035          resistance = _getNumOrDefault(vars, "resistance", _config$2.resistance),
20036          duration = _isNumber$3(dur) ? dur : _calculateTweenDuration(target, vars, durIsObj && dur.max || 10, durIsObj && dur.min || 0.2, durIsObj && "overshoot" in dur ? +dur.overshoot : preventOvershoot ? 0 : 1, true),
20037          p,
20038          curProp,
20039          curVal,
20040          unit,
20041          velocity,
20042          change1,
20043          end,
20044          change2,
20045          linkedProps;
20046
20047      vars = _processingVars;
20048      _processingVars = 0;
20049      linkedProps = _processLinkedProps(target, vars, getVal, resistance);
20050
20051      for (p in vars) {
20052        if (!_reservedProps$1[p]) {
20053          curProp = vars[p];
20054          _isFunction$6(curProp) && (curProp = curProp(index, target, targets));
20055
20056          if (_isNumber$3(curProp)) {
20057            velocity = curProp;
20058          } else if (_isObject$4(curProp) && !isNaN(curProp.velocity)) {
20059            velocity = +curProp.velocity;
20060          } else {
20061            if (tracker && tracker.isTracking(p)) {
20062              velocity = tracker.get(p);
20063            } else {
20064              console.warn("ERROR: No velocity was defined for " + target + " property: " + p);
20065            }
20066          }
20067
20068          change1 = _calculateChange(velocity, duration);
20069          change2 = 0;
20070          curVal = getVal(target, p);
20071          unit = _getUnit$4(curVal);
20072          curVal = parseFloat(curVal);
20073
20074          if (_isObject$4(curProp)) {
20075            end = curVal + change1;
20076
20077            if ("end" in curProp) {
20078              curProp = _parseEnd(curProp, linkedProps && p in linkedProps ? linkedProps : end, curProp.max, curProp.min, p, vars.radius, velocity);
20079            }
20080
20081            if ("max" in curProp && +curProp.max < end) {
20082              if (preventOvershoot || curProp.preventOvershoot) {
20083                change1 = curProp.max - curVal;
20084              } else {
20085                change2 = curProp.max - curVal - change1;
20086              }
20087            } else if ("min" in curProp && +curProp.min > end) {
20088              if (preventOvershoot || curProp.preventOvershoot) {
20089                change1 = curProp.min - curVal;
20090              } else {
20091                change2 = curProp.min - curVal - change1;
20092              }
20093            }
20094          }
20095
20096          this._props.push(p);
20097
20098          this.styles && this.styles.save(p);
20099          this._pt = new PropTween$3(this._pt, target, p, curVal,

vendor: 12,848 bytes, lines 20099-20572

200990, _emptyFunc$3, 0, cache.set(target, p, this));
20100          this._pt.u = unit || 0;
20101          this._pt.c1 = change1;
20102          this._pt.c2 = change2;
20103        }
20104      }
20105
20106      tween.duration(duration);
20107      return _bonusValidated$2;
20108    },
20109    render: function render(ratio, data) {
20110      var pt = data._pt;
20111      ratio = _power3(data.tween._time / data.tween._dur);
20112
20113      if (ratio || !_reverting$6()) {
20114        while (pt) {
20115          pt.set(pt.t, pt.p, _round$a(pt.s + pt.c1 * ratio + pt.c2 * ratio * ratio) + pt.u, pt.d, ratio);
20116          pt = pt._next;
20117        }
20118      } else {
20119        data.styles.revert();
20120      }
20121    }
20122  };
20123  "track,untrack,isTracking,getVelocity,getByTarget".split(",").forEach(function (name) {
20124    return InertiaPlugin$1[name] = VelocityTracker[name];
20125  });
20126  _getGSAP$j() && gsap$l.registerPlugin(InertiaPlugin$1);
20127
20128  /*!
20129   * MorphSVGPlugin 3.12.5
20130   * https://gsap.com
20131   *
20132   * @license Copyright 2008-2024, GreenSock. All rights reserved.
20133   * Subject to the terms at https://gsap.com/standard-license or for
20134   * Club GSAP members, the agreement issued with that membership.
20135   * @author: Jack Doyle, [email protected]
20136  */
20137
20138  var gsap$m,
20139      _toArray$8,
20140      _lastLinkedAnchor,
20141      _coreInitted$i,
20142      PluginClass,
20143      _getGSAP$k = function _getGSAP() {
20144    return gsap$m || typeof window !== "undefined" && (gsap$m = window.gsap) && gsap$m.registerPlugin && gsap$m;
20145  },
20146      _isFunction$7 = function _isFunction(value) {
20147    return typeof value === "function";
20148  },
20149      _atan2$2 = Math.atan2,
20150      _cos$2 = Math.cos,
20151      _sin$2 = Math.sin,
20152      _sqrt$3 = Math.sqrt,
20153      _PI = Math.PI,
20154      _2PI$1 = _PI * 2,
20155      _angleMin = _PI * 0.3,
20156      _angleMax = _PI * 0.7,
20157      _bigNum$5 = 1e20,
20158      _numExp$4 = /[-+=\.]*\d+[\.e\-\+]*\d*[e\-\+]*\d*/gi,
20159      _selectorExp$1 = /(^[#\.][a-z]|[a-y][a-z])/i,
20160      _commands = /[achlmqstvz]/i,
20161      _log = function _log(message) {
20162    return console && console.warn(message);
20163  },
20164      _bonusValidated$3 = 1,
20165      _getAverageXY = function _getAverageXY(segment) {
20166    var l = segment.length,
20167        x = 0,
20168        y = 0,
20169        i;
20170
20171    for (i = 0; i < l; i++) {
20172      x += segment[i++];
20173      y += segment[i];
20174    }
20175
20176    return [x / (l / 2), y / (l / 2)];
20177  },
20178      _getSize$1 = function _getSize(segment) {
20179    var l = segment.length,
20180        xMax = segment[0],
20181        xMin = xMax,
20182        yMax = segment[1],
20183        yMin = yMax,
20184        x,
20185        y,
20186        i;
20187
20188    for (i = 6; i < l; i += 6) {
20189      x = segment[i];
20190      y = segment[i + 1];
20191
20192      if (x > xMax) {
20193        xMax = x;
20194      } else if (x < xMin) {
20195        xMin = x;
20196      }
20197
20198      if (y > yMax) {
20199        yMax = y;
20200      } else if (y < yMin) {
20201        yMin = y;
20202      }
20203    }
20204
20205    segment.centerX = (xMax + xMin) / 2;
20206    segment.centerY = (yMax + yMin) / 2;
20207    return segment.size = (xMax - xMin) * (yMax - yMin);
20208  },
20209      _getTotalSize = function _getTotalSize(rawPath, samplesPerBezier) {
20210    if (samplesPerBezier === void 0) {
20211      samplesPerBezier = 3;
20212    }
20213
20214    var j = rawPath.length,
20215        xMax = rawPath[0][0],
20216        xMin = xMax,
20217        yMax = rawPath[0][1],
20218        yMin = yMax,
20219        inc = 1 / samplesPerBezier,
20220        l,
20221        x,
20222        y,
20223        i,
20224        segment,
20225        k,
20226        t,
20227        inv,
20228        x1,
20229        y1,
20230        x2,
20231        x3,
20232        x4,
20233        y2,
20234        y3,
20235        y4;
20236
20237    while (--j > -1) {
20238      segment = rawPath[j];
20239      l = segment.length;
20240
20241      for (i = 6; i < l; i += 6) {
20242        x1 = segment[i];
20243        y1 = segment[i + 1];
20244        x2 = segment[i + 2] - x1;
20245        y2 = segment[i + 3] - y1;
20246        x3 = segment[i + 4] - x1;
20247        y3 = segment[i + 5] - y1;
20248        x4 = segment[i + 6] - x1;
20249        y4 = segment[i + 7] - y1;
20250        k = samplesPerBezier;
20251
20252        while (--k > -1) {
20253          t = inc * k;
20254          inv = 1 - t;
20255          x = (t * t * x4 + 3 * inv * (t * x3 + inv * x2)) * t + x1;
20256          y = (t * t * y4 + 3 * inv * (t * y3 + inv * y2)) * t + y1;
20257
20258          if (x > xMax) {
20259            xMax = x;
20260          } else if (x < xMin) {
20261            xMin = x;
20262          }
20263
20264          if (y > yMax) {
20265            yMax = y;
20266          } else if (y < yMin) {
20267            yMin = y;
20268          }
20269        }
20270      }
20271    }
20272
20273    rawPath.centerX = (xMax + xMin) / 2;
20274    rawPath.centerY = (yMax + yMin) / 2;
20275    rawPath.left = xMin;
20276    rawPath.width = xMax - xMin;
20277    rawPath.top = yMin;
20278    rawPath.height = yMax - yMin;
20279    return rawPath.size = (xMax - xMin) * (yMax - yMin);
20280  },
20281      _sortByComplexity = function _sortByComplexity(a, b) {
20282    return b.length - a.length;
20283  },
20284      _sortBySize = function _sortBySize(a, b) {
20285    var sizeA = a.size || _getSize$1(a),
20286        sizeB = b.size || _getSize$1(b);
20287
20288    return Math.abs(sizeB - sizeA) < (sizeA + sizeB) / 20 ? b.centerX - a.centerX || b.centerY - a.centerY : sizeB - sizeA;
20289  },
20290      _offsetSegment = function _offsetSegment(segment, shapeIndex) {
20291    var a = segment.slice(0),
20292        l = segment.length,
20293        wrap = l - 2,
20294        i,
20295        index;
20296    shapeIndex = shapeIndex | 0;
20297
20298    for (i = 0; i < l; i++) {
20299      index = (i + shapeIndex) % wrap;
20300      segment[i++] = a[index];
20301      segment[i] = a[index + 1];
20302    }
20303  },
20304      _getTotalMovement = function _getTotalMovement(sb, eb, shapeIndex, offsetX, offsetY) {
20305    var l = sb.length,
20306        d = 0,
20307        wrap = l - 2,
20308        index,
20309        i,
20310        x,
20311        y;
20312    shapeIndex *= 6;
20313
20314    for (i = 0; i < l; i += 6) {
20315      index = (i + shapeIndex) % wrap;
20316      y = sb[index] - (eb[i] - offsetX);
20317      x = sb[index + 1] - (eb[i + 1] - offsetY);
20318      d += _sqrt$3(x * x + y * y);
20319    }
20320
20321    return d;
20322  },
20323      _getClosestShapeIndex = function _getClosestShapeIndex(sb, eb, checkReverse) {
20324    var l = sb.length,
20325        sCenter = _getAverageXY(sb),
20326        eCenter = _getAverageXY(eb),
20327        offsetX = eCenter[0] - sCenter[0],
20328        offsetY = eCenter[1] - sCenter[1],
20329        min = _getTotalMovement(sb, eb, 0, offsetX, offsetY),
20330        minIndex = 0,
20331        copy,
20332        d,
20333        i;
20334
20335    for (i = 6; i < l; i += 6) {
20336      d = _getTotalMovement(sb, eb, i / 6, offsetX, offsetY);
20337
20338      if (d < min) {
20339        min = d;
20340        minIndex = i;
20341      }
20342    }
20343
20344    if (checkReverse) {
20345      copy = sb.slice(0);
20346      reverseSegment(copy);
20347
20348      for (i = 6; i < l; i += 6) {
20349        d = _getTotalMovement(copy, eb, i / 6, offsetX, offsetY);
20350
20351        if (d < min) {
20352          min = d;
20353          minIndex = -i;
20354        }
20355      }
20356    }
20357
20358    return minIndex / 6;
20359  },
20360      _getClosestAnchor = function _getClosestAnchor(rawPath, x, y) {
20361    var j = rawPath.length,
20362        closestDistance = _bigNum$5,
20363        closestX = 0,
20364        closestY = 0,
20365        segment,
20366        dx,
20367        dy,
20368        d,
20369        i,
20370        l;
20371
20372    while (--j > -1) {
20373      segment = rawPath[j];
20374      l = segment.length;
20375
20376      for (i = 0; i < l; i += 6) {
20377        dx = segment[i] - x;
20378        dy = segment[i + 1] - y;
20379        d = _sqrt$3(dx * dx + dy * dy);
20380
20381        if (d < closestDistance) {
20382          closestDistance = d;
20383          closestX = segment[i];
20384          closestY = segment[i + 1];
20385        }
20386      }
20387    }
20388
20389    return [closestX, closestY];
20390  },
20391      _getClosestSegment = function _getClosestSegment(bezier, pool, startIndex, sortRatio, offsetX, offsetY) {
20392    var l = pool.length,
20393        index = 0,
20394        minSize = Math.min(bezier.size || _getSize$1(bezier), pool[startIndex].size || _getSize$1(pool[startIndex])) * sortRatio,
20395        min = _bigNum$5,
20396        cx = bezier.centerX + offsetX,
20397        cy = bezier.centerY + offsetY,
20398        size,
20399        i,
20400        dx,
20401        dy,
20402        d;
20403
20404    for (i = startIndex; i < l; i++) {
20405      size = pool[i].size || _getSize$1(pool[i]);
20406
20407      if (size < minSize) {
20408        break;
20409      }
20410
20411      dx = pool[i].centerX - cx;
20412      dy = pool[i].centerY - cy;
20413      d = _sqrt$3(dx * dx + dy * dy);
20414
20415      if (d < min) {
20416        index = i;
20417        min = d;
20418      }
20419    }
20420
20421    d = pool[index];
20422    pool.splice(index, 1);
20423    return d;
20424  },
20425      _subdivideSegmentQty = function _subdivideSegmentQty(segment, quantity) {
20426    var tally = 0,
20427        max = 0.999999,
20428        l = segment.length,
20429        newPointsPerSegment = quantity / ((l - 2) / 6),
20430        ax,
20431        ay,
20432        cp1x,
20433        cp1y,
20434        cp2x,
20435        cp2y,
20436        bx,
20437        by,
20438        x1,
20439        y1,
20440        x2,
20441        y2,
20442        i,
20443        t;
20444
20445    for (i = 2; i < l; i += 6) {
20446      tally += newPointsPerSegment;
20447
20448      while (tally > max) {
20449        ax = segment[i - 2];
20450        ay = segment[i - 1];
20451        cp1x = segment[i];
20452        cp1y = segment[i + 1];
20453        cp2x = segment[i + 2];
20454        cp2y = segment[i + 3];
20455        bx = segment[i + 4];
20456        by = segment[i + 5];
20457        t = 1 / ((Math.floor(tally) || 1) + 1);
20458        x1 = ax + (cp1x - ax) * t;
20459        x2 = cp1x + (cp2x - cp1x) * t;
20460        x1 += (x2 - x1) * t;
20461        x2 += (cp2x + (bx - cp2x) * t - x2) * t;
20462        y1 = ay + (cp1y - ay) * t;
20463        y2 = cp1y + (cp2y - cp1y) * t;
20464        y1 += (y2 - y1) * t;
20465        y2 += (cp2y + (by - cp2y) * t - y2) * t;
20466        segment.splice(i, 4, ax + (cp1x - ax) * t, ay + (cp1y - ay) * t, x1, y1, x1 + (x2 - x1) * t, y1 + (y2 - y1) * t, x2, y2, cp2x + (bx - cp2x) * t, cp2y + (by - cp2y) * t);
20467        i += 6;
20468        l += 6;
20469        tally--;
20470      }
20471    }
20472
20473    return segment;
20474  },
20475      _equalizeSegmentQuantity = function _equalizeSegmentQuantity(start, end, shapeIndex, map, fillSafe) {
20476    var dif = end.length - start.length,
20477        longer = dif > 0 ? end : start,
20478        shorter = dif > 0 ? start : end,
20479        added = 0,
20480        sortMethod = map === "complexity" ? _sortByComplexity : _sortBySize,
20481        sortRatio = map === "position" ? 0 : typeof map === "number" ? map : 0.8,
20482        i = shorter.length,
20483        shapeIndices = typeof shapeIndex === "object" && shapeIndex.push ? shapeIndex.slice(0) : [shapeIndex],
20484        reverse = shapeIndices[0] === "reverse" || shapeIndices[0] < 0,
20485        log = shapeIndex === "log",
20486        eb,
20487        sb,
20488        b,
20489        x,
20490        y,
20491        offsetX,
20492        offsetY;
20493
20494    if (!shorter[0]) {
20495      return;
20496    }
20497
20498    if (longer.length > 1) {
20499      start.sort(sortMethod);
20500      end.sort(sortMethod);
20501      offsetX = longer.size || _getTotalSize(longer);
20502      offsetX = shorter.size || _getTotalSize(shorter);
20503      offsetX = longer.centerX - shorter.centerX;
20504      offsetY = longer.centerY - shorter.centerY;
20505
20506      if (sortMethod === _sortBySize) {
20507        for (i = 0; i < shorter.length; i++) {
20508          longer.splice(i, 0, _getClosestSegment(shorter[i], longer, i, sortRatio, offsetX, offsetY));
20509        }
20510      }
20511    }
20512
20513    if (dif) {
20514      if (dif < 0) {
20515        dif = -dif;
20516      }
20517
20518      if (longer[0].length > shorter[0].length) {
20519        _subdivideSegmentQty(shorter[0], (longer[0].length - shorter[0].length) / 6 | 0);
20520      }
20521
20522      i = shorter.length;
20523
20524      while (added < dif) {
20525        x = longer[i].size || _getSize$1(longer[i]);
20526        b = _getClosestAnchor(shorter, longer[i].centerX, longer[i].centerY);
20527        x = b[0];
20528        y = b[1];
20529        shorter[i++] = [x, y, x, y, x, y, x, y];
20530        shorter.totalPoints += 8;
20531        added++;
20532      }
20533    }
20534
20535    for (i = 0; i < start.length; i++) {
20536      eb = end[i];
20537      sb = start[i];
20538      dif = eb.length - sb.length;
20539
20540      if (dif < 0) {
20541        _subdivideSegmentQty(eb, -dif / 6 | 0);
20542      } else if (dif > 0) {
20543        _subdivideSegmentQty(sb, dif / 6 | 0);
20544      }
20545
20546      if (reverse && fillSafe !== false && !sb.reversed) {
20547        reverseSegment(sb);
20548      }
20549
20550      shapeIndex = shapeIndices[i] || shapeIndices[i] === 0 ? shapeIndices[i] : "auto";
20551
20552      if (shapeIndex) {
20553        if (sb.closed || Math.abs(sb[0] - sb[sb.length - 2]) < 0.5 && Math.abs(sb[1] - sb[sb.length - 1]) < 0.5) {
20554          if (shapeIndex === "auto" || shapeIndex === "log") {
20555            shapeIndices[i] = shapeIndex = _getClosestShapeIndex(sb, eb, !i || fillSafe === false);
20556
20557            if (shapeIndex < 0) {
20558              reverse = true;
20559              reverseSegment(sb);
20560              shapeIndex = -shapeIndex;
20561            }
20562
20563            _offsetSegment(sb, shapeIndex * 6);
20564          } else if (shapeIndex !== "reverse") {
20565            if (i && shapeIndex < 0) {
20566              reverseSegment(sb);
20567            }
20568
20569            _offsetSegment(sb, (shapeIndex < 0 ? -shapeIndex : shapeIndex) * 6);
20570          }
20571        } else if (!reverse && (shapeIndex === "auto" && Math.abs(eb[0] - sb[0]) + Math.abs(eb[1] - sb[1]) + Math.abs(eb[eb.length - 2] - sb[sb.length - 2]) + Math.abs(eb[eb.length - 1] - sb[sb.length - 1]) > Math.abs(eb[0] - sb[sb.length - 2]) + Math.abs(eb[1] - sb[sb.length - 1]) + Math.abs(eb[eb.length - 2] - sb[0]) + Math.abs(eb[eb.length - 1] - sb[1]) || shapeIndex % 2)) {
20572          reverseSegment(sb);

vendor: 3,683 bytes, lines 20573-20714

20573          shapeIndices[i] = -1;
20574          reverse = true;
20575        } else if (shapeIndex === "auto") {
20576          shapeIndices[i] = 0;
20577        } else if (shapeIndex === "reverse") {
20578          shapeIndices[i] = -1;
20579        }
20580
20581        if (sb.closed !== eb.closed) {
20582          sb.closed = eb.closed = false;
20583        }
20584      }
20585    }
20586
20587    log && _log("shapeIndex:[" + shapeIndices.join(",") + "]");
20588    start.shapeIndex = shapeIndices;
20589    return shapeIndices;
20590  },
20591      _pathFilter = function _pathFilter(a, shapeIndex, map, precompile, fillSafe) {
20592    var start = stringToRawPath(a[0]),
20593        end = stringToRawPath(a[1]);
20594
20595    if (!_equalizeSegmentQuantity(start, end, shapeIndex || shapeIndex === 0 ? shapeIndex : "auto", map, fillSafe)) {
20596      return;
20597    }
20598
20599    a[0] = rawPathToString(start);
20600    a[1] = rawPathToString(end);
20601
20602    if (precompile === "log" || precompile === true) {
20603      _log('precompile:["' + a[0] + '","' + a[1] + '"]');
20604    }
20605  },
20606      _offsetPoints = function _offsetPoints(text, offset) {
20607    if (!offset) {
20608      return text;
20609    }
20610
20611    var a = text.match(_numExp$4) || [],
20612        l = a.length,
20613        s = "",
20614        inc,
20615        i,
20616        j;
20617
20618    if (offset === "reverse") {
20619      i = l - 1;
20620      inc = -2;
20621    } else {
20622      i = ((parseInt(offset, 10) || 0) * 2 + 1 + l * 100) % l;
20623      inc = 2;
20624    }
20625
20626    for (j = 0; j < l; j += 2) {
20627      s += a[i - 1] + "," + a[i] + " ";
20628      i = (i + inc) % l;
20629    }
20630
20631    return s;
20632  },
20633      _equalizePointQuantity = function _equalizePointQuantity(a, quantity) {
20634    var tally = 0,
20635        x = parseFloat(a[0]),
20636        y = parseFloat(a[1]),
20637        s = x + "," + y + " ",
20638        max = 0.999999,
20639        newPointsPerSegment,
20640        i,
20641        l,
20642        j,
20643        factor,
20644        nextX,
20645        nextY;
20646    l = a.length;
20647    newPointsPerSegment = quantity * 0.5 / (l * 0.5 - 1);
20648
20649    for (i = 0; i < l - 2; i += 2) {
20650      tally += newPointsPerSegment;
20651      nextX = parseFloat(a[i + 2]);
20652      nextY = parseFloat(a[i + 3]);
20653
20654      if (tally > max) {
20655        factor = 1 / (Math.floor(tally) + 1);
20656        j = 1;
20657
20658        while (tally > max) {
20659          s += (x + (nextX - x) * factor * j).toFixed(2) + "," + (y + (nextY - y) * factor * j).toFixed(2) + " ";
20660          tally--;
20661          j++;
20662        }
20663      }
20664
20665      s += nextX + "," + nextY + " ";
20666      x = nextX;
20667      y = nextY;
20668    }
20669
20670    return s;
20671  },
20672      _pointsFilter = function _pointsFilter(a) {
20673    var startNums = a[0].match(_numExp$4) || [],
20674        endNums = a[1].match(_numExp$4) || [],
20675        dif = endNums.length - startNums.length;
20676
20677    if (dif > 0) {
20678      a[0] = _equalizePointQuantity(startNums, dif);
20679    } else {
20680      a[1] = _equalizePointQuantity(endNums, -dif);
20681    }
20682  },
20683      _buildPointsFilter = function _buildPointsFilter(shapeIndex) {
20684    return !isNaN(shapeIndex) ? function (a) {
20685      _pointsFilter(a);
20686
20687      a[1] = _offsetPoints(a[1], parseInt(shapeIndex, 10));
20688    } : _pointsFilter;
20689  },
20690      _parseShape = function _parseShape(shape, forcePath, target) {
20691    var isString = typeof shape === "string",
20692        e,
20693        type;
20694
20695    if (!isString || _selectorExp$1.test(shape) || (shape.match(_numExp$4) || []).length < 3) {
20696      e = _toArray$8(shape)[0];
20697
20698      if (e) {
20699        type = (e.nodeName + "").toUpperCase();
20700
20701        if (forcePath && type !== "PATH") {
20702          e = convertToPath(e, false);
20703          type = "PATH";
20704        }
20705
20706        shape = e.getAttribute(type === "PATH" ? "d" : "points") || "";
20707
20708        if (e === target) {
20709          shape = e.getAttributeNS(null, "data-original") || shape;
20710        }
20711      } else {
20712        _log("WARNING: invalid morph to: " + shape);
20713
20714        shape = false;

vendor: 5,241 bytes, lines 20715-20883

20715      }
20716    }
20717
20718    return shape;
20719  },
20720      _populateSmoothData = function _populateSmoothData(rawPath, tolerance) {
20721    var j = rawPath.length,
20722        limit = 0.2 * (tolerance || 1),
20723        smooth,
20724        segment,
20725        x,
20726        y,
20727        x2,
20728        y2,
20729        i,
20730        l,
20731        a,
20732        a2,
20733        isSmooth,
20734        smoothData;
20735
20736    while (--j > -1) {
20737      segment = rawPath[j];
20738      isSmooth = segment.isSmooth = segment.isSmooth || [0, 0, 0, 0];
20739      smoothData = segment.smoothData = segment.smoothData || [0, 0, 0, 0];
20740      isSmooth.length = 4;
20741      l = segment.length - 2;
20742
20743      for (i = 6; i < l; i += 6) {
20744        x = segment[i] - segment[i - 2];
20745        y = segment[i + 1] - segment[i - 1];
20746        x2 = segment[i + 2] - segment[i];
20747        y2 = segment[i + 3] - segment[i + 1];
20748        a = _atan2$2(y, x);
20749        a2 = _atan2$2(y2, x2);
20750        smooth = Math.abs(a - a2) < limit;
20751
20752        if (smooth) {
20753          smoothData[i - 2] = a;
20754          smoothData[i + 2] = a2;
20755          smoothData[i - 1] = _sqrt$3(x * x + y * y);
20756          smoothData[i + 3] = _sqrt$3(x2 * x2 + y2 * y2);
20757        }
20758
20759        isSmooth.push(smooth, smooth, 0, 0, smooth, smooth);
20760      }
20761
20762      if (segment[l] === segment[0] && segment[l + 1] === segment[1]) {
20763        x = segment[0] - segment[l - 2];
20764        y = segment[1] - segment[l - 1];
20765        x2 = segment[2] - segment[0];
20766        y2 = segment[3] - segment[1];
20767        a = _atan2$2(y, x);
20768        a2 = _atan2$2(y2, x2);
20769
20770        if (Math.abs(a - a2) < limit) {
20771          smoothData[l - 2] = a;
20772          smoothData[2] = a2;
20773          smoothData[l - 1] = _sqrt$3(x * x + y * y);
20774          smoothData[3] = _sqrt$3(x2 * x2 + y2 * y2);
20775          isSmooth[l - 2] = isSmooth[l - 1] = true;
20776        }
20777      }
20778    }
20779
20780    return rawPath;
20781  },
20782      _parseOriginFactors = function _parseOriginFactors(v) {
20783    var a = v.trim().split(" "),
20784        x = ~v.indexOf("left") ? 0 : ~v.indexOf("right") ? 100 : isNaN(parseFloat(a[0])) ? 50 : parseFloat(a[0]),
20785        y = ~v.indexOf("top") ? 0 : ~v.indexOf("bottom") ? 100 : isNaN(parseFloat(a[1])) ? 50 : parseFloat(a[1]);
20786    return {
20787      x: x / 100,
20788      y: y / 100
20789    };
20790  },
20791      _shortAngle = function _shortAngle(dif) {
20792    return dif !== dif % _PI ? dif + (dif < 0 ? _2PI$1 : -_2PI$1) : dif;
20793  },
20794      _morphMessage = "Use MorphSVGPlugin.convertToPath() to convert to a path before morphing.",
20795      _tweenRotation = function _tweenRotation(start, end, i, linkedPT) {
20796    var so = this._origin,
20797        eo = this._eOrigin,
20798        dx = start[i] - so.x,
20799        dy = start[i + 1] - so.y,
20800        d = _sqrt$3(dx * dx + dy * dy),
20801        sa = _atan2$2(dy, dx),
20802        angleDif,
20803        _short;
20804
20805    dx = end[i] - eo.x;
20806    dy = end[i + 1] - eo.y;
20807    angleDif = _atan2$2(dy, dx) - sa;
20808    _short = _shortAngle(angleDif);
20809
20810    if (!linkedPT && _lastLinkedAnchor && Math.abs(_short + _lastLinkedAnchor.ca) < _angleMin) {
20811      linkedPT = _lastLinkedAnchor;
20812    }
20813
20814    return this._anchorPT = _lastLinkedAnchor = {
20815      _next: this._anchorPT,
20816      t: start,
20817      sa: sa,
20818      ca: linkedPT && _short * linkedPT.ca < 0 && Math.abs(_short) > _angleMax ? angleDif : _short,
20819      sl: d,
20820      cl: _sqrt$3(dx * dx + dy * dy) - d,
20821      i: i
20822    };
20823  },
20824      _initCore$i = function _initCore(required) {
20825    gsap$m = _getGSAP$k();
20826    PluginClass = PluginClass || gsap$m && gsap$m.plugins.morphSVG;
20827
20828    if (gsap$m && PluginClass) {
20829      _toArray$8 = gsap$m.utils.toArray;
20830      PluginClass.prototype._tweenRotation = _tweenRotation;
20831      _coreInitted$i = 1;
20832    } else if (required) {
20833      _log("Please gsap.registerPlugin(MorphSVGPlugin)");
20834    }
20835  };
20836
20837  var MorphSVGPlugin = {
20838    version: "3.12.5",
20839    name: "morphSVG",
20840    rawVars: 1,
20841    register: function register(core, Plugin) {
20842      gsap$m = core;
20843      PluginClass = Plugin;
20844
20845      _initCore$i();
20846    },
20847    init: function init(target, value, tween, index, targets) {
20848      _coreInitted$i || _initCore$i(1);
20849
20850      if (!value) {
20851        _log("invalid shape");
20852
20853        return false;
20854      }
20855
20856      _isFunction$7(value) && (value = value.call(tween, index, target, targets));
20857      var type, p, pt, shape, isPoly, shapeIndex, map, startSmooth, endSmooth, start, end, i, j, l, startSeg, endSeg, precompiled, sData, eData, originFactors, useRotation, offset;
20858
20859      if (typeof value === "string" || value.getBBox || value[0]) {
20860        value = {
20861          shape: value
20862        };
20863      } else if (typeof value === "object") {
20864        type = {};
20865
20866        for (p in value) {
20867          type[p] = _isFunction$7(value[p]) && p !== "render" ? value[p].call(tween, index, target, targets) : value[p];
20868        }
20869
20870        value = type;
20871      }
20872
20873      var cs = target.nodeType ? window.getComputedStyle(target) : {},
20874          fill = cs.fill + "",
20875          fillSafe = !(fill === "none" || (fill.match(_numExp$4) || [])[3] === "0" || cs.fillRule === "evenodd"),
20876          origins = (value.origin || "50 50").split(",");
20877      type = (target.nodeName + "").toUpperCase();
20878      isPoly = type === "POLYLINE" || type === "POLYGON";
20879
20880      if (type !== "PATH" && !isPoly && !value.prop) {
20881        _log("Cannot morph a <" + type + "> element. " + _morphMessage);
20882
20883        return false;

20884      }
20885
20886      p = type === "PATH" ? "d" : "points";
20887
20888      if (!value.prop && !_isFunction$7(target.setAttribute)) {
20889        return false;
20890      }
20891
20892      shape = _parseShape(value.shape || value.d || value.points || "", p === "d", target);
20893
20894      if (isPoly && _commands.test(shape)) {
20895        _log("A <" + type + "> cannot accept path data. " + _morphMessage);
20896
20897        return false;
20898      }
20899
20900      shapeIndex = value.shapeIndex || value.shapeIndex === 0 ? value.shapeIndex : "auto";
20901      map = value.map || MorphSVGPlugin.defaultMap;
20902      this._prop = value.prop;
20903      this._render = value.render || MorphSVGPlugin.defaultRender;
20904      this._apply = "updateTarget" in value ? value.updateTarget : MorphSVGPlugin.defaultUpdateTarget;
20905      this._rnd = Math.pow(10, isNaN(value.precision) ? 2 : +value.precision);
20906      this._tween = tween;
20907
20908      if (shape) {
20909        this._target = target;
20910        precompiled = typeof value.precompile === "object";
20911        start = this._prop ? target[this._prop] : target.getAttribute(p);
20912
20913        if (!this._prop && !target.getAttributeNS(null, "data-original")) {
20914          target.setAttributeNS(null, "data-original", start);
20915        }
20916
20917        if (p === "d" || this._prop) {
20918          start = stringToRawPath(precompiled ? value.precompile[0] : start);
20919          end = stringToRawPath(precompiled ? value.precompile[1] : shape);
20920
20921          if (!precompiled && !_equalizeSegmentQuantity(start, end, shapeIndex, map, fillSafe)) {
20922            return false;
20923          }
20924
20925          if (value.precompile === "log" || value.precompile === true) {
20926            _log('precompile:["' + rawPathToString(start) + '","' + rawPathToString(end) + '"]');
20927          }
20928
20929          useRotation = (value.type || MorphSVGPlugin.defaultType) !== "linear";
20930
20931          if (useRotation) {
20932            start = _populateSmoothData(start, value.smoothTolerance);
20933            end = _populateSmoothData(end, value.smoothTolerance);
20934
20935            if (!start.size) {
20936              _getTotalSize(start);
20937            }
20938
20939            if (!end.size) {
20940              _getTotalSize(end);
20941            }
20942
20943            originFactors = _parseOriginFactors(origins[0]);
20944            this._origin = start.origin = {
20945              x: start.left + originFactors.x * start.width,
20946              y: start.top + originFactors.y * start.height
20947            };
20948
20949            if (origins[1]) {
20950              originFactors = _parseOriginFactors(origins[1]);
20951            }
20952
20953            this._eOrigin = {
20954              x: end.left + originFactors.x * end.width,
20955              y: end.top + originFactors.y * end.height
20956            };
20957          }
20958
20959          this._rawPath = target._gsRawPath = start;
20960          j = start.length;
20961
20962          while (--j > -1) {
20963            startSeg = start[j];
20964            endSeg = end[j];
20965            startSmooth = startSeg.isSmooth || [];
20966            endSmooth = endSeg.isSmooth || [];
20967            l = startSeg.length;
20968            _lastLinkedAnchor = 0;
20969
20970            for (i = 0; i < l; i += 2) {
20971              if (endSeg[i] !== startSeg[i] || endSeg[i + 1] !== startSeg[i + 1]) {
20972                if (useRotation) {
20973                  if (startSmooth[i] && endSmooth[i]) {
20974                    sData = startSeg.smoothData;
20975                    eData = endSeg.smoothData;
20976                    offset = i + (i === l - 4 ? 7 - l : 5);
20977                    this._controlPT = {
20978                      _next: this._controlPT,
20979                      i: i,
20980                      j: j,
20981                      l1s: sData[i + 1],
20982                      l1c: eData[i + 1] - sData[i + 1],
20983                      l2s: sData[offset],
20984                      l2c: eData[offset] - sData[offset]
20985                    };
20986                    pt = this._tweenRotation(startSeg, endSeg, i + 2);
20987
20988                    this._tweenRotation(startSeg, endSeg, i, pt);
20989
20990                    this._tweenRotation(startSeg, endSeg, offset - 1, pt);
20991
20992                    i += 4;
20993                  } else {
20994                    this._tweenRotation(startSeg, endSeg, i);
20995                  }
20996                } else {
20997                  pt = this.add(startSeg, i, startSeg[i], endSeg[i], 0, 0, 0, 0, 0, 1);
20998                  pt = this.add(startSeg, i + 1, startSeg[i + 1], endSeg[i + 1], 0, 0, 0, 0, 0, 1) || pt;
20999                }
21000              }
21001            }
21002          }
21003        } else {
21004          pt = this.add(target, "setAttribute", target.getAttribute(p) + "", shape + "", index, targets, 0, _buildPointsFilter(shapeIndex), p);
21005        }
21006
21007        if (useRotation) {
21008          this.add(this._origin, "x", this._origin.x, this._eOrigin.x, 0, 0, 0, 0, 0, 1);
21009          pt = this.add(this._origin, "y", this._origin.y, this._eOrigin.y, 0, 0, 0, 0, 0, 1);
21010        }
21011
21012        if (pt) {
21013          this._props.push("morphSVG");
21014
21015          pt.end = shape;
21016          pt.endProp = p;
21017        }
21018      }
21019
21020      return _bonusValidated$3;
21021    },
21022    render: function render(ratio, data) {
21023      var rawPath = data._rawPath,
21024          controlPT = data._controlPT,
21025          anchorPT = data._anchorPT,
21026          rnd = data._rnd,
21027          target = data._target,
21028          pt = data._pt,
21029          s,
21030          space,
21031          easeInOut,
21032          segment,
21033          l,
21034          angle,
21035          i,
21036          j,
21037          x,
21038          y,
21039          sin,
21040          cos,
21041          offset;
21042
21043      while (pt) {
21044        pt.r(ratio, pt.d);
21045        pt = pt._next;
21046      }
21047
21048      if (ratio === 1 && data._apply) {
21049        pt = data._pt;
21050
21051        while (pt) {
21052          if (pt.end) {
21053            if (data._prop) {
21054              target[data._prop] = pt.end;
21055            } else {
21056              target.setAttribute(pt.endProp, pt.end);
21057            }
21058          }
21059
21060          pt = pt._next;
21061        }
21062      } else if (rawPath) {
21063        while (anchorPT) {

21064          angle = anchorPT.sa + ratio * anchorPT.ca;
21065          l = anchorPT.sl + ratio * anchorPT.cl;
21066          anchorPT.t[anchorPT.i] = data._origin.x + _cos$2(angle) * l;
21067          anchorPT.t[anchorPT.i + 1] = data._origin.y + _sin$2(angle) * l;
21068          anchorPT = anchorPT._next;
21069        }
21070
21071        easeInOut = ratio < 0.5 ? 2 * ratio * ratio : (4 - 2 * ratio) * ratio - 1;
21072
21073        while (controlPT) {
21074          i = controlPT.i;
21075          segment = rawPath[controlPT.j];
21076          offset = i + (i === segment.length - 4 ? 7 - segment.length : 5);
21077          angle = _atan2$2(segment[offset] - segment[i + 1], segment[offset - 1] - segment[i]);
21078          sin = _sin$2(angle);
21079          cos = _cos$2(angle);
21080          x = segment[i + 2];
21081          y = segment[i + 3];
21082          l = controlPT.l1s + easeInOut * controlPT.l1c;
21083          segment[i] = x - cos * l;
21084          segment[i + 1] = y - sin * l;
21085          l = controlPT.l2s + easeInOut * controlPT.l2c;
21086          segment[offset - 1] = x + cos * l;
21087          segment[offset] = y + sin * l;
21088          controlPT = controlPT._next;
21089        }
21090
21091        target._gsRawPath = rawPath;
21092
21093        if (data._apply) {
21094          s = "";
21095          space = " ";
21096
21097          for (j = 0; j < rawPath.length; j++) {
21098            segment = rawPath[j];
21099            l = segment.length;
21100            s += "M" + (segment[0] * rnd | 0) / rnd + space + (segment[1] * rnd | 0) / rnd + " C";
21101
21102            for (i = 2; i < l; i++) {
21103              s += (segment[i] * rnd | 0) / rnd + space;
21104            }
21105          }
21106
21107          if (data._prop) {
21108            target[data._prop] = s;
21109          } else {
21110            target.setAttribute("d", s);
21111          }
21112        }
21113      }
21114
21115      data._render && rawPath && data._render.call(data._tween, rawPath, target);
21116    },
21117    kill: function kill(property) {
21118      this._pt = this._rawPath = 0;
21119    },
21120    getRawPath: getRawPath,
21121    stringToRawPath: stringToRawPath,
21122    rawPathToString: rawPathToString,
21123    normalizeStrings: function normalizeStrings(shape1, shape2, _ref) {
21124      var shapeIndex = _ref.shapeIndex,
21125          map = _ref.map;
21126      var result = [shape1, shape2];
21127
21128      _pathFilter(result, shapeIndex, map);
21129
21130      return result;
21131    },
21132    pathFilter: _pathFilter,
21133    pointsFilter: _pointsFilter,
21134    getTotalSize: _getTotalSize,
21135    equalizeSegmentQuantity: _equalizeSegmentQuantity,
21136    convertToPath: function convertToPath$1(targets, swap) {
21137      return _toArray$8(targets).map(function (target) {
21138        return convertToPath(target, swap !== false);
21139      });
21140    },
21141    defaultType: "linear",
21142    defaultUpdateTarget: true,
21143    defaultMap: "size"
21144  };
21145  _getGSAP$k() && gsap$m.registerPlugin(MorphSVGPlugin);
21146
21147  var _numbersExp$1 = /(?:(-)?\d*\.?\d*(?:e[\-+]?\d+)?)[0-9]/ig,
21148      _doc$8,
21149      _supportsPointer$1,
21150      _win$9,
21151      _body$6,
21152      gsap$n,
21153      _context$5,
21154      _selectionColor = "#4e7fff",
21155      _minimumMovement = 1,
21156      _DEG2RAD$6 = Math.PI / 180,
21157      _getTime$3 = Date.now || function () {
21158    return new Date().getTime();
21159  },
21160      _lastInteraction = 0,
21161      _isPressed = 0,
21162      _emptyFunc$4 = function _emptyFunc() {
21163    return false;
21164  },
21165      _interacted = function _interacted() {
21166    return _lastInteraction = _getTime$3();
21167  },
21168      _CTRL,
21169      _ALT,
21170      _SHIFT,
21171      _CMD,
21172      _recentlyAddedAnchor,
21173      _editingAxis = {},
21174      _history = [],
21175      _point = {},
21176      _temp$1 = [],
21177      _comma = ",",
21178      _selectedPaths = [],
21179      _preventDefault$1 = function _preventDefault(event) {
21180    if (event.preventDefault) {
21181      event.preventDefault();
21182
21183      if (event.preventManipulation) {
21184        event.preventManipulation();
21185      }
21186    }
21187  },
21188      _createElement$3 = function _createElement(type) {
21189    return _doc$8.createElementNS ? _doc$8.createElementNS("http://www.w3.org/1999/xhtml", type) : _doc$8.createElement(type);
21190  },
21191      _createSVG = function _createSVG(type, container, attributes) {
21192    var element = _doc$8.createElementNS("http://www.w3.org/2000/svg", type),
21193        reg = /([a-z])([A-Z])/g,
21194        p;
21195
21196    attributes = attributes || {};
21197    attributes["class"] = attributes["class"] || "path-editor";
21198
21199    for (p in attributes) {
21200      if (element.style[p] !== undefined) {
21201        element.style[p] = attributes[p];
21202      } else {
21203        element.setAttributeNS(null, p.replace(reg, "$1-$2").toLowerCase(), attributes[p]);
21204      }
21205    }
21206
21207    container.appendChild(element);
21208    return element;
21209  },
21210      _identityMatrixObject = {
21211    matrix: new Matrix2D()
21212  },
21213      _getConsolidatedMatrix = function _getConsolidatedMatrix(target) {
21214    return (target.transform && target.transform.baseVal.consolidate() || _identityMatrixObject).matrix;
21215  },
21216      _getConcatenatedTransforms = function _getConcatenatedTransforms(target) {
21217    var m = _getConsolidatedMatrix(target),
21218        owner = target.ownerSVGElement;
21219
21220    while ((target = target.parentNode) && target.ownerSVGElement === owner) {
21221      m.multiply(_getConsolidatedMatrix(target));
21222    }
21223

vendor: 1,038 bytes, lines 21224-21257

21224    return "matrix(" + m.a + "," + m.b + "," + m.c + "," + m.d + "," + m.e + "," + m.f + ")";
21225  },
21226      _addHistory = function _addHistory(pathEditor) {
21227    var selectedIndexes = [],
21228        a = pathEditor._selectedAnchors,
21229        i;
21230
21231    for (i = 0; i < a.length; i++) {
21232      selectedIndexes[i] = a[i].i;
21233    }
21234
21235    _history.unshift({
21236      path: pathEditor,
21237      d: pathEditor.path.getAttribute("d"),
21238      transform: pathEditor.path.getAttribute("transform") || "",
21239      selectedIndexes: selectedIndexes
21240    });
21241
21242    if (_history.length > 30) {
21243      _history.length = 30;
21244    }
21245  },
21246      _round$b = function _round(value) {
21247    return ~~(value * 1000 + (value < 0 ? -.5 : .5)) / 1000;
21248  },
21249      _getSquarePathData = function _getSquarePathData(size) {
21250    size = _round$b(size);
21251    return ["M-" + size, -size, size, -size, size, size, -size, size + "z"].join(_comma);
21252  },
21253      _getCirclePathData = function _getCirclePathData(size) {
21254    var circ = 0.552284749831,
21255        rcirc = _round$b(size * circ);
21256
21257    size = _round$b

vendor: 23,031 bytes, lines 21257-22010

21257(size);
21258    return "M" + size + ",0C" + [size, rcirc, rcirc, size, 0, size, -rcirc, size, -size, rcirc, -size, 0, -size, -rcirc, -rcirc, -size, 0, -size, rcirc, -size, size, -rcirc, size, 0].join(_comma) + "z";
21259  },
21260      _checkDeselect = function _checkDeselect(e) {
21261    if (!e.target._gsSelection && !_isPressed && _getTime$3() - _lastInteraction > 100) {
21262      var i = _selectedPaths.length;
21263
21264      while (--i > -1) {
21265        _selectedPaths[i].deselect();
21266      }
21267
21268      _selectedPaths.length = 0;
21269    }
21270  },
21271      _tempDiv$3,
21272      _touchEventLookup$1,
21273      _isMultiTouching$1 = 0,
21274      _addListener$4 = function _addListener(element, type, func, capture) {
21275    if (element.addEventListener) {
21276      var touchType = _touchEventLookup$1[type];
21277      capture = capture || {
21278        passive: false
21279      };
21280      element.addEventListener(touchType || type, func, capture);
21281
21282      if (touchType && type !== touchType && touchType.substr(0, 7) !== "pointer") {
21283        element.addEventListener(type, func, capture);
21284      }
21285    } else if (element.attachEvent) {
21286      element.attachEvent("on" + type, func);
21287    }
21288  },
21289      _removeListener$4 = function _removeListener(element, type, func) {
21290    if (element.removeEventListener) {
21291      var touchType = _touchEventLookup$1[type];
21292      element.removeEventListener(touchType || type, func);
21293
21294      if (touchType && type !== touchType && touchType.substr(0, 7) !== "pointer") {
21295        element.removeEventListener(type, func);
21296      }
21297    } else if (element.detachEvent) {
21298      element.detachEvent("on" + type, func);
21299    }
21300  },
21301      _hasTouchID$1 = function _hasTouchID(list, ID) {
21302    var i = list.length;
21303
21304    while (--i > -1) {
21305      if (list[i].identifier === ID) {
21306        return true;
21307      }
21308    }
21309
21310    return false;
21311  },
21312      _onMultiTouchDocumentEnd$1 = function _onMultiTouchDocumentEnd(e) {
21313    _isMultiTouching$1 = e.touches && _dragCount < e.touches.length;
21314
21315    _removeListener$4(e.target, "touchend", _onMultiTouchDocumentEnd);
21316  },
21317      _onMultiTouchDocument$1 = function _onMultiTouchDocument(e) {
21318    _isMultiTouching$1 = e.touches && _dragCount < e.touches.length;
21319
21320    _addListener$4(e.target, "touchend", _onMultiTouchDocumentEnd$1);
21321  },
21322      _bind = function _bind(func, scope) {
21323    return function (e) {
21324      return func.call(scope, e);
21325    };
21326  },
21327      _callback$2 = function _callback(type, self, param) {
21328    var callback = self.vars[type];
21329
21330    if (callback) {
21331      callback.call(self.vars.callbackScope || self, param || self);
21332    }
21333
21334    return self;
21335  },
21336      _copyElement,
21337      _resetSelection = function _resetSelection() {
21338    _copyElement.style.display = "block";
21339
21340    _copyElement.select();
21341
21342    _copyElement.style.display = "none";
21343  },
21344      _coreInitted$j,
21345      _initCore$j = function _initCore(core) {
21346    _doc$8 = document;
21347    _win$9 = window;
21348    _body$6 = _doc$8.body;
21349    gsap$n = gsap$n || core || _win$9.gsap || console.warn("Please gsap.registerPlugin(PathEditor)");
21350
21351    _context$5 = gsap$n && gsap$n.core.context || function () {};
21352
21353    _tempDiv$3 = _createElement$3("div");
21354    _copyElement = _createElement$3("textarea");
21355    _copyElement.style.display = "none";
21356    _body$6 && _body$6.appendChild(_copyElement);
21357
21358    _touchEventLookup$1 = function (types) {
21359      var standard = types.split(","),
21360          converted = (_tempDiv$3.onpointerdown !== undefined ? "pointerdown,pointermove,pointerup,pointercancel" : _tempDiv$3.onmspointerdown !== undefined ? "MSPointerDown,MSPointerMove,MSPointerUp,MSPointerCancel" : types).split(","),
21361          obj = {},
21362          i = 4;
21363
21364      while (--i > -1) {
21365        obj[standard[i]] = converted[i];
21366        obj[converted[i]] = standard[i];
21367      }
21368
21369      return obj;
21370    }("touchstart,touchmove,touchend,touchcancel");
21371
21372    SVGElement.prototype.getTransformToElement = SVGElement.prototype.getTransformToElement || function (e) {
21373      return e.getScreenCTM().inverse().multiply(this.getScreenCTM());
21374    };
21375
21376    _doc$8.addEventListener("keydown", function (e) {
21377      var key = e.keyCode || e.which,
21378          keyString = e.key || key,
21379          i,
21380          state,
21381          a,
21382          path;
21383
21384      if (keyString === "Shift" || key === 16) {
21385        _SHIFT = true;
21386      } else if (keyString === "Control" || key === 17) {
21387        _CTRL = true;
21388      } else if (keyString === "Meta" || key === 91) {
21389        _CMD = true;
21390      } else if (keyString === "Alt" || key === 18) {
21391        _ALT = true;
21392        i = _selectedPaths.length;
21393
21394        while (--i > -1) {
21395          _selectedPaths[i]._onPressAlt();
21396        }
21397      } else if ((keyString === "z" || key === 90) && (_CTRL || _CMD) && _history.length > 1) {
21398        _history.shift();
21399
21400        state = _history[0];
21401
21402        if (state) {
21403          path = state.path;
21404          path.path.setAttribute("d", state.d);
21405          path.path.setAttribute("transform", state.transform);
21406          path.init();
21407          a = path._anchors;
21408
21409          for (i = 0; i < a.length; i++) {
21410            if (state.selectedIndexes.indexOf(a[i].i) !== -1) {
21411              path._selectedAnchors.push(a[i]);
21412            }
21413          }
21414
21415          path._updateAnchors();
21416
21417          path.update();
21418
21419          if (path.vars.onUndo) {
21420            path.vars.onUndo.call(path);
21421          }
21422        }
21423      } else if (keyString === "Delete" || keyString === "Backspace" || key === 8 || key === 46 || key === 63272 || key === "d" && (_CTRL || _CMD)) {
21424        i = _selectedPaths.length;
21425
21426        while (--i > -1) {
21427          _selectedPaths[i]._deleteSelectedAnchors();
21428        }
21429      } else if ((keyString === "a" || key === 65) && (_CMD || _CTRL)) {
21430        i = _selectedPaths.length;
21431
21432        while (--i > -1) {
21433          _selectedPaths[i].select(true);
21434        }
21435      }
21436    }, true);
21437
21438    _doc$8.addEventListener("keyup", function (e) {
21439      var key = e.key || e.keyCode || e.which;
21440
21441      if (key === "Shift" || key === 16) {
21442        _SHIFT = false;
21443      } else if (key === "Control" || key === 17) {
21444        _CTRL = false;
21445      } else if (key === "Meta" || key === 91) {
21446        _CMD = false;
21447      } else if (key === "Alt" || key === 18) {
21448        _ALT = false;
21449        var i = _selectedPaths.length;
21450
21451        while (--i > -1) {
21452          _selectedPaths[i]._onReleaseAlt();
21453        }
21454      }
21455    }, true);
21456
21457    _supportsPointer$1 = !!_win$9.PointerEvent;
21458
21459    _addListener$4(_doc$8, "mouseup", _checkDeselect);
21460
21461    _addListener$4(_doc$8, "touchend", _checkDeselect);
21462
21463    _addListener$4(_doc$8, "touchcancel", _emptyFunc$4);
21464
21465    _addListener$4(_win$9, "touchmove", _emptyFunc$4);
21466
21467    _body$6 && _body$6.addEventListener("touchstart", _emptyFunc$4);
21468    _coreInitted$j = 1;
21469  },
21470      _onPress = function _onPress(e) {
21471    var self = this,
21472        ctm = getGlobalMatrix(self.target.parentNode, true),
21473        touchEventTarget,
21474        temp;
21475    this._matrix = this.target.transform.baseVal.getItem(0).matrix;
21476    this._ctm = ctm;
21477
21478    if (_touchEventLookup$1[e.type]) {
21479      touchEventTarget = e.type.indexOf("touch") !== -1 ? e.currentTarget || e.target : _doc$8;
21480
21481      _addListener$4(touchEventTarget, "touchend", self._onRelease);
21482
21483      _addListener$4(touchEventTarget, "touchmove", self._onMove);
21484
21485      _addListener$4(touchEventTarget, "touchcancel", self._onRelease);
21486
21487      _addListener$4(_doc$8, "touchstart", _onMultiTouchDocument$1);
21488
21489      _addListener$4(_win$9, "touchforcechange", _preventDefault$1);
21490    } else {
21491      touchEventTarget = null;
21492
21493      _addListener$4(_doc$8, "mousemove", self._onMove);
21494    }
21495
21496    if (!_supportsPointer$1) {
21497      _addListener$4(_doc$8, "mouseup", self._onRelease);
21498    }
21499
21500    _preventDefault$1(e);
21501
21502    _resetSelection();
21503
21504    if (e.changedTouches) {
21505      e = self.touch = e.changedTouches[0];
21506      self.touchID = e.identifier;
21507    } else if (e.pointerId) {
21508      self.touchID = e.pointerId;
21509    } else {
21510      self.touch = self.touchID = null;
21511    }
21512
21513    self._startPointerY = self.pointerY = e.pageY;
21514    self._startPointerX = self.pointerX = e.pageX;
21515    self._startElementX = self._matrix.e;
21516    self._startElementY = self._matrix.f;
21517
21518    if (this._ctm.a === 1 && this._ctm.b === 0 && this._ctm.c === 0 && this._ctm.d === 1) {
21519      this._ctm = null;
21520    } else {
21521      temp = self._startPointerX * this._ctm.a + self._startPointerY * this._ctm.c + this._ctm.e;
21522      self._startPointerY = self._startPointerX * this._ctm.b + self._startPointerY * this._ctm.d + this._ctm.f;
21523      self._startPointerX = temp;
21524    }
21525
21526    self.isPressed = _isPressed = true;
21527    self.touchEventTarget = touchEventTarget;
21528
21529    if (self.vars.onPress) {
21530      self.vars.onPress.call(self.vars.callbackScope || self, self.pointerEvent);
21531    }
21532  },
21533      _onMove = function _onMove(e) {
21534    var self = this,
21535        originalEvent = e,
21536        touches,
21537        i;
21538
21539    if (!self._enabled || _isMultiTouching$1 || !self.isPressed || !e) {
21540      return;
21541    }
21542
21543    self.pointerEvent = e;
21544    touches = e.changedTouches;
21545
21546    if (touches) {
21547      e = touches[0];
21548
21549      if (e !== self.touch && e.identifier !== self.touchID) {
21550        i = touches.length;
21551
21552        while (--i > -1 && (e = touches[i]).identifier !== self.touchID) {}
21553
21554        if (i < 0) {
21555          return;
21556        }
21557      }
21558    } else if (e.pointerId && self.touchID && e.pointerId !== self.touchID) {
21559      return;
21560    }
21561
21562    _preventDefault$1(originalEvent);
21563
21564    self.setPointerPosition(e.pageX, e.pageY);
21565
21566    if (self.vars.onDrag) {
21567      self.vars.onDrag.call(self.vars.callbackScope || self, self.pointerEvent);
21568    }
21569  },
21570      _onRelease = function _onRelease(e, force) {
21571    var self = this;
21572
21573    if (!self._enabled || !self.isPressed || e && self.touchID != null && !force && (e.pointerId && e.pointerId !== self.touchID || e.changedTouches && !_hasTouchID$1(e.changedTouches, self.touchID))) {
21574      return;
21575    }
21576
21577    _interacted();
21578
21579    self.isPressed = _isPressed = false;
21580    var originalEvent = e,
21581        wasDragging = self.isDragging,
21582        touchEventTarget = self.touchEventTarget,
21583        touches,
21584        i;
21585
21586    if (touchEventTarget) {
21587      _removeListener$4(touchEventTarget, "touchend", self._onRelease);
21588
21589      _removeListener$4(touchEventTarget, "touchmove", self._onMove);
21590
21591      _removeListener$4(touchEventTarget, "touchcancel", self._onRelease);
21592
21593      _removeListener$4(_doc$8, "touchstart", _onMultiTouchDocument$1);
21594    } else {
21595      _removeListener$4(_doc$8, "mousemove", self._onMove);
21596    }
21597
21598    if (!_supportsPointer$1) {
21599      _removeListener$4(_doc$8, "mouseup", self._onRelease);
21600
21601      if (e && e.target) {
21602        _removeListener$4(e.target, "mouseup", self._onRelease);
21603      }
21604    }
21605
21606    if (wasDragging) {
21607      self.isDragging = false;
21608    } else if (self.vars.onClick) {
21609      self.vars.onClick.call(self.vars.callbackScope || self, originalEvent);
21610    }
21611
21612    if (e) {
21613      touches = e.changedTouches;
21614
21615      if (touches) {
21616        e = touches[0];
21617
21618        if (e !== self.touch && e.identifier !== self.touchID) {
21619          i = touches.length;
21620
21621          while (--i > -1 && (e = touches[i]).identifier !== self.touchID) {}
21622
21623          if (i < 0) {
21624            return;
21625          }
21626        }
21627      }
21628
21629      self.pointerEvent = originalEvent;
21630      self.pointerX = e.pageX;
21631      self.pointerY = e.pageY;
21632    }
21633
21634    if (originalEvent && !wasDragging && self.vars.onDragRelease) {
21635      self.vars.onDragRelease.call(self, self.pointerEvent);
21636    } else {
21637      if (originalEvent) {
21638        _preventDefault$1(originalEvent);
21639      }
21640
21641      if (self.vars.onRelease) {
21642        self.vars.onRelease.call(self.vars.callbackScope || self, self.pointerEvent);
21643      }
21644    }
21645
21646    if (wasDragging && self.vars.onDragEnd) {
21647      self.vars.onDragEnd.call(self.vars.callbackScope || self, self.pointerEvent);
21648    }
21649
21650    return true;
21651  },
21652      _createSegmentAnchors = function _createSegmentAnchors(rawPath, j, editor, vars) {
21653    var segment = rawPath[j],
21654        l = segment.length - (segment.closed ? 6 : 0),
21655        a = [],
21656        i;
21657
21658    for (i = 0; i < l; i += 6) {
21659      a.push(new Anchor(editor, rawPath, j, i, vars));
21660    }
21661
21662    segment.closed && (a[0].isClosedStart = true);
21663    return a;
21664  },
21665      _getLength$1 = function _getLength(segment, i, i2) {
21666    var x = segment[i2] - segment[i],
21667        y = segment[i2 + 1] - segment[i + 1];
21668    return Math.sqrt(x * x + y * y);
21669  };
21670
21671  var DraggableSVG = function () {
21672    function DraggableSVG(target, vars) {
21673      this.target = typeof target === "string" ? _doc$8.querySelectorAll(target)[0] : target;
21674      this.vars = vars || {};
21675      this._onPress = _bind(_onPress, this);
21676      this._onMove = _bind(_onMove, this);
21677      this._onRelease = _bind(_onRelease, this);
21678      this.target.setAttribute("transform", (this.target.getAttribute("transform") || "") + " translate(0,0)");
21679      this._matrix = _getConsolidatedMatrix(this.target);
21680      this.x = this._matrix.e;
21681      this.y = this._matrix.f;
21682      this.snap = vars.snap;
21683
21684      if (!isNaN(vars.maxX) || !isNaN(vars.minX)) {
21685        this._bounds = 1;
21686        this.maxX = +vars.maxX;
21687        this.minX = +vars.minX;
21688      } else {
21689        this._bounds = 0;
21690      }
21691
21692      this.enabled(true);
21693    }
21694
21695    var _proto = DraggableSVG.prototype;
21696
21697    _proto.setPointerPosition = function setPointerPosition(pointerX, pointerY) {
21698      var rnd = 1000,
21699          xChange,
21700          yChange,
21701          x,
21702          y,
21703          temp;
21704      this.pointerX = pointerX;
21705      this.pointerY = pointerY;
21706
21707      if (this._ctm) {
21708        temp = pointerX * this._ctm.a + pointerY * this._ctm.c + this._ctm.e;
21709        pointerY = pointerX * this._ctm.b + pointerY * this._ctm.d + this._ctm.f;
21710        pointerX = temp;
21711      }
21712
21713      yChange = pointerY - this._startPointerY;
21714      xChange = pointerX - this._startPointerX;
21715
21716      if (yChange < _minimumMovement && yChange > -_minimumMovement) {
21717        yChange = 0;
21718      }
21719
21720      if (xChange < _minimumMovement && xChange > -_minimumMovement) {
21721        xChange = 0;
21722      }
21723
21724      x = ((this._startElementX + xChange) * rnd | 0) / rnd;
21725      y = ((this._startElementY + yChange) * rnd | 0) / rnd;
21726
21727      if (this.snap && !_SHIFT) {
21728        _point.x = x;
21729        _point.y = y;
21730        this.snap.call(this, _point);
21731        x = _point.x;
21732        y = _point.y;
21733      }
21734
21735      if (this.x !== x || this.y !== y) {
21736        this._matrix.f = this.y = y;
21737        this._matrix.e = this.x = x;
21738
21739        if (!this.isDragging && this.isPressed) {
21740          this.isDragging = true;
21741
21742          _callback$2("onDragStart", this, this.pointerEvent);
21743        }
21744      }
21745    };
21746
21747    _proto.enabled = function enabled(_enabled) {
21748      if (!arguments.length) {
21749        return this._enabled;
21750      }
21751
21752      var dragging;
21753      this._enabled = _enabled;
21754
21755      if (_enabled) {
21756        if (!_supportsPointer$1) {
21757          _addListener$4(this.target, "mousedown", this._onPress);
21758        }
21759
21760        _addListener$4(this.target, "touchstart", this._onPress);
21761
21762        _addListener$4(this.target, "click", this._onClick, true);
21763      } else {
21764        dragging = this.isDragging;
21765
21766        _removeListener$4(this.target, "mousedown", this._onPress);
21767
21768        _removeListener$4(this.target, "touchstart", this._onPress);
21769
21770        _removeListener$4(_win$9, "touchforcechange", _preventDefault$1);
21771
21772        _removeListener$4(this.target, "click", this._onClick);
21773
21774        if (this.touchEventTarget) {
21775          _removeListener$4(this.touchEventTarget, "touchcancel", this._onRelease);
21776
21777          _removeListener$4(this.touchEventTarget, "touchend", this._onRelease);
21778
21779          _removeListener$4(this.touchEventTarget, "touchmove", this._onMove);
21780        }
21781
21782        _removeListener$4(_doc$8, "mouseup", this._onRelease);
21783
21784        _removeListener$4(_doc$8, "mousemove", this._onMove);
21785
21786        this.isDragging = this.isPressed = false;
21787
21788        if (dragging) {
21789          _callback$2("onDragEnd", this, this.pointerEvent);
21790        }
21791      }
21792
21793      return this;
21794    };
21795
21796    _proto.endDrag = function endDrag(e) {
21797      this._onRelease(e);
21798    };
21799
21800    return DraggableSVG;
21801  }();
21802
21803  var Anchor = function () {
21804    function Anchor(editor, rawPath, j, i, vars) {
21805      this.editor = editor;
21806      this.element = _createSVG("path", editor._selection, {
21807        fill: _selectionColor,
21808        stroke: _selectionColor,
21809        strokeWidth: 2,
21810        vectorEffect: "non-scaling-stroke"
21811      });
21812      this.update(rawPath, j, i);
21813      this.element._gsSelection = true;
21814      this.vars = vars || {};
21815      this._draggable = new DraggableSVG(this.element, {
21816        callbackScope: this,
21817        onDrag: this.onDrag,
21818        snap: this.vars.snap,
21819        onPress: this.onPress,
21820        onRelease: this.onRelease,
21821        onClick: this.onClick,
21822        onDragEnd: this.onDragEnd
21823      });
21824    }
21825
21826    var _proto2 = Anchor.prototype;
21827
21828    _proto2.onPress = function onPress() {
21829      _callback$2("onPress", this);
21830    };
21831
21832    _proto2.onClick = function onClick() {
21833      _callback$2("onClick", this);
21834    };
21835
21836    _proto2.onDrag = function onDrag() {
21837      var s = this.segment;
21838      this.vars.onDrag.call(this.vars.callbackScope || this, this, this._draggable.x - s[this.i], this._draggable.y - s[this.i + 1]);
21839    };
21840
21841    _proto2.onDragEnd = function onDragEnd() {
21842      _callback$2("onDragEnd", this);
21843    };
21844
21845    _proto2.onRelease = function onRelease() {
21846      _callback$2("onRelease", this);
21847    };
21848
21849    _proto2.update = function update(rawPath, j, i) {
21850      if (rawPath) {
21851        this.rawPath = rawPath;
21852      }
21853
21854      if (arguments.length <= 1) {
21855        j = this.j;
21856        i = this.i;
21857      } else {
21858        this.j = j;
21859        this.i = i;
21860      }
21861
21862      var prevSmooth = this.smooth,
21863          segment = this.rawPath[j],
21864          pi = i === 0 && segment.closed ? segment.length - 4 : i - 2;
21865      this.segment = segment;
21866      this.smooth = i > 0 && i < segment.length - 2 && Math.abs(Math.atan2(segment[i + 1] - segment[pi + 1], segment[i] - segment[pi]) - Math.atan2(segment[i + 3] - segment[i + 1], segment[i + 2] - segment[i])) < 0.09 ? 2 : 0;
21867
21868      if (this.smooth !== prevSmooth) {
21869        this.element.setAttribute("d", this.smooth ? this.editor._circleHandle : this.editor._squareHandle);
21870      }
21871
21872      this.element.setAttribute("transform", "translate(" + segment[i] + "," + segment[i + 1] + ")");
21873    };
21874
21875    return Anchor;
21876  }();
21877
21878  var PathEditor = function () {
21879    function PathEditor(target, vars) {
21880      vars = vars || {};
21881      _coreInitted$j || _initCore$j();
21882      this.vars = vars;
21883      this.path = typeof target === "string" ? _doc$8.querySelectorAll(target)[0] : target;
21884      this._g = _createSVG("g", this.path.ownerSVGElement, {
21885        "class": "path-editor-g path-editor"
21886      });
21887      this._selectionHittest = _createSVG("path", this._g, {
21888        stroke: "transparent",
21889        strokeWidth: 16,
21890        fill: "none",
21891        vectorEffect: "non-scaling-stroke"
21892      });
21893      this._selection = vars._selection || _createSVG("g", this._g, {
21894        "class": "path-editor-selection path-editor"
21895      });
21896      this._selectionPath = _createSVG("path", this._selection, {
21897        stroke: _selectionColor,
21898        strokeWidth: 2,
21899        fill: "none",
21900        vectorEffect: "non-scaling-stroke"
21901      });
21902      this._selectedAnchors = [];
21903      this._line1 = _createSVG("polyline", this._selection, {
21904        stroke: _selectionColor,
21905        strokeWidth: 2,
21906        vectorEffect: "non-scaling-stroke"
21907      });
21908      this._line2 = _createSVG("polyline", this._selection, {
21909        stroke: _selectionColor,
21910        strokeWidth: 2,
21911        vectorEffect: "non-scaling-stroke"
21912      });
21913      this._line1.style.pointerEvents = this._line2.style.pointerEvents = this._selectionPath.style.pointerEvents = "none";
21914      this._enabled = true;
21915      var ctm = this.path.parentNode.getScreenCTM().inverse(),
21916          size = (ctm.a + ctm.d) / 2 * (vars.handleSize || 5);
21917      this._squareHandle = _getSquarePathData(size);
21918      this._circleHandle = _getCirclePathData(size * 1.15);
21919      this._handle1 = _createSVG("path", this._selection, {
21920        d: this._squareHandle,
21921        fill: _selectionColor,
21922        stroke: "transparent",
21923        strokeWidth: 6
21924      });
21925      this._handle2 = _createSVG("path", this._selection, {
21926        d: this._squareHandle,
21927        fill: _selectionColor,
21928        stroke: "transparent",
21929        strokeWidth: 6
21930      });
21931      this._handle1._draggable = new DraggableSVG(this._handle1, {
21932        onDrag: this._onDragHandle1,
21933        callbackScope: this,
21934        onPress: this._onPressHandle1,
21935        onRelease: this._onReleaseHandle,
21936        onClick: this._onClickHandle1,
21937        snap: vars.handleSnap
21938      });
21939      this._handle2._draggable = new DraggableSVG(this._handle2, {
21940        onDrag: this._onDragHandle2,
21941        callbackScope: this,
21942        onPress: this._onPressHandle2,
21943        onRelease: this._onReleaseHandle,
21944        onClick: this._onClickHandle2,
21945        snap: vars.handleSnap
21946      });
21947      this._handle1.style.visibility = this._handle2.style.visibility = "hidden";
21948      var selectionItems = [this._handle1, this._handle2, this._line1, this._line2, this._selection, this._selectionPath, this._selectionHittest],
21949          i = selectionItems.length;
21950
21951      while (--i > -1) {
21952        selectionItems[i]._gsSelection = true;
21953      }
21954
21955      if (vars.draggable !== false) {
21956        this._draggable = new DraggableSVG(this._selectionHittest, {
21957          callbackScope: this,
21958          onPress: this.select,
21959          onRelease: this._onRelease,
21960          onDrag: this._onDragPath,
21961          onDragEnd: this._saveState,
21962          maxX: this.vars.maxX,
21963          minX: this.vars.minX
21964        });
21965      }
21966
21967      this.init();
21968      this._selection.style.visibility = vars.selected === false ? "hidden" : "visible";
21969
21970      if (vars.selected !== false) {
21971        this.path._gsSelection = true;
21972
21973        _selectedPaths.push(this);
21974      }
21975
21976      this._saveState();
21977
21978      if (!_supportsPointer$1) {
21979        _addListener$4(this._selectionHittest, "mousedown", _bind(this._onClickSelectionPath, this));
21980
21981        _addListener$4(this._selectionHittest, "mouseup", _bind(this._onRelease, this));
21982      }
21983
21984      _addListener$4(this._selectionHittest, "touchstart", _bind(this._onClickSelectionPath, this));
21985
21986      _addListener$4(this._selectionHittest, "touchend", _bind(this._onRelease, this));
21987
21988      _context$5(this);
21989    }
21990
21991    var _proto3 = PathEditor.prototype;
21992
21993    _proto3._onRelease = function _onRelease(e) {
21994      var anchor = this._editingAnchor;
21995
21996      if (anchor) {
21997        _editingAxis.x = anchor.segment[anchor.i];
21998        _editingAxis.y = anchor.segment[anchor.i + 1];
21999      }
22000
22001      _removeListener$4(_win$9, "touchforcechange", _preventDefault$1);
22002
22003      _callback$2("onRelease", this, e);
22004    };
22005
22006    _proto3.init = function init() {
22007      var pathData = this.path.getAttribute("d"),
22008          rawPath = stringToRawPath(pathData),
22009          transform = this.path.getAttribute("transform") || "translate(0,0)",
22010          createAnchors = !this._rawPath || rawPath.totalPoints !== this._rawPath.totalPoints || rawPath.

vendor: 4,071 bytes, lines 22010-22155

22010length !== this._rawPath.length,
22011          anchorVars = {
22012        callbackScope: this,
22013        snap: this.vars.anchorSnap,
22014        onDrag: this._onDragAnchor,
22015        onPress: this._onPressAnchor,
22016        onRelease: this._onRelease,
22017        onClick: this._onClickAnchor,
22018        onDragEnd: this._onDragEndAnchor,
22019        maxX: this.vars.maxX,
22020        minX: this.vars.minX
22021      },
22022          l,
22023          i;
22024
22025      if (createAnchors && this._anchors && this._anchors.length) {
22026        for (i = 0; i < this._anchors.length; i++) {
22027          this._anchors[i].element.parentNode.removeChild(this._anchors[i].element);
22028
22029          this._anchors[i]._draggable.enabled(false);
22030        }
22031
22032        this._selectedAnchors.length = 0;
22033      }
22034
22035      this._rawPath = rawPath;
22036
22037      if (createAnchors) {
22038        this._anchors = _createSegmentAnchors(rawPath, 0, this, anchorVars);
22039        l = rawPath.length;
22040
22041        if (l > 1) {
22042          for (i = 1; i < l; i++) {
22043            this._anchors = this._anchors.concat(_createSegmentAnchors(rawPath, i, this, anchorVars));
22044          }
22045        }
22046      } else {
22047        i = this._anchors.length;
22048
22049        while (--i > -1) {
22050          this._anchors[i].update(rawPath);
22051        }
22052      }
22053
22054      this._selection.appendChild(this._handle1);
22055
22056      this._selection.appendChild(this._handle2);
22057
22058      this._selectionPath.setAttribute("d", pathData);
22059
22060      this._selectionHittest.setAttribute("d", pathData);
22061
22062      this._g.setAttribute("transform", _getConcatenatedTransforms(this.path.parentNode) || "translate(0,0)");
22063
22064      this._selection.setAttribute("transform", transform);
22065
22066      this._selectionHittest.setAttribute("transform", transform);
22067
22068      this._updateAnchors();
22069
22070      return this;
22071    };
22072
22073    _proto3._saveState = function _saveState() {
22074      _addHistory(this);
22075    };
22076
22077    _proto3._onClickSelectionPath = function _onClickSelectionPath(e) {
22078      if (this._selection.style.visibility === "hidden") {
22079        this.select();
22080      } else if (_ALT || e && e.altKey) {
22081        var anchorVars = {
22082          callbackScope: this,
22083          snap: this.vars.anchorSnap,
22084          onDrag: this._onDragAnchor,
22085          onPress: this._onPressAnchor,
22086          onRelease: this._onRelease,
22087          onClick: this._onClickAnchor,
22088          onDragEnd: this._onDragEndAnchor,
22089          maxX: this.vars.maxX,
22090          minX: this.vars.minX
22091        },
22092            ctm = this._selection.getScreenCTM().inverse(),
22093            newIndex,
22094            _i,
22095            anchor,
22096            x,
22097            y,
22098            closestData;
22099
22100        if (this._draggable) {
22101          this._draggable._onRelease(e);
22102        }
22103
22104        if (ctm) {
22105          x = e.clientX * ctm.a + e.clientY * ctm.c + ctm.e;
22106          y = e.clientX * ctm.b + e.clientY * ctm.d + ctm.f;
22107        }
22108
22109        closestData = getClosestData(this._rawPath, x, y);
22110        subdivideSegment(this._rawPath[closestData.j], closestData.i, closestData.t);
22111        newIndex = closestData.i + 6;
22112
22113        for (_i = 0; _i < this._anchors.length; _i++) {
22114          if (this._anchors[_i].i >= newIndex) {
22115            this._anchors[_i].i += 6;
22116          }
22117        }
22118
22119        anchor = new Anchor(this, this._rawPath, closestData.j, newIndex, anchorVars);
22120
22121        this._selection.appendChild(this._handle1);
22122
22123        this._selection.appendChild(this._handle2);
22124
22125        anchor._draggable._onPress(e);
22126
22127        _recentlyAddedAnchor = anchor;
22128
22129        this._anchors.push(anchor);
22130
22131        this._selectedAnchors.length = 0;
22132
22133        this._selectedAnchors.push(anchor);
22134
22135        this._updateAnchors();
22136
22137        this.update();
22138
22139        this._saveState();
22140      }
22141
22142      _resetSelection();
22143
22144      _addListener$4(_win$9, "touchforcechange", _preventDefault$1);
22145
22146      _callback$2("onPress", this);
22147    };
22148
22149    _proto3._onClickHandle1 = function _onClickHandle1() {
22150      var anchor = this._editingAnchor,
22151          i = anchor.i,
22152          s = anchor.segment,
22153          pi = anchor.isClosedStart ? s.length - 4 : i - 2;
22154
22155      if (_ALT && Math.abs(s[i] - s[pi]) < 5 && Math.abs(s[i + 1] - s[pi + 1]) < 5) {

vendor: 10,334 bytes, lines 22156-22490

22156        this._onClickAnchor(anchor);
22157      }
22158    };
22159
22160    _proto3._onClickHandle2 = function _onClickHandle2() {
22161      var anchor = this._editingAnchor,
22162          i = anchor.i,
22163          s = anchor.segment;
22164
22165      if (_ALT && Math.abs(s[i] - s[i + 2]) < 5 && Math.abs(s[i + 1] - s[i + 3]) < 5) {
22166        this._onClickAnchor(anchor);
22167      }
22168    };
22169
22170    _proto3._onDragEndAnchor = function _onDragEndAnchor(e) {
22171      _recentlyAddedAnchor = null;
22172
22173      this._saveState();
22174    };
22175
22176    _proto3.isSelected = function isSelected() {
22177      return this._selectedAnchors.length > 0 || this._selection.style.visibility === "visible";
22178    };
22179
22180    _proto3.select = function select(allAnchors) {
22181      this._selection.style.visibility = "visible";
22182      this._editingAnchor = null;
22183      this.path._gsSelection = true;
22184
22185      if (allAnchors === true) {
22186        var _i2 = this._anchors.length;
22187
22188        while (--_i2 > -1) {
22189          this._selectedAnchors[_i2] = this._anchors[_i2];
22190        }
22191      }
22192
22193      if (_selectedPaths.indexOf(this) === -1) {
22194        _selectedPaths.push(this);
22195      }
22196
22197      this._updateAnchors();
22198
22199      return this;
22200    };
22201
22202    _proto3.deselect = function deselect() {
22203      this._selection.style.visibility = "hidden";
22204      this._selectedAnchors.length = 0;
22205      this._editingAnchor = null;
22206      this.path._gsSelection = false;
22207
22208      _selectedPaths.splice(_selectedPaths.indexOf(this), 1);
22209
22210      this._updateAnchors();
22211
22212      return this;
22213    };
22214
22215    _proto3._onDragPath = function _onDragPath(e) {
22216      var transform = this._selectionHittest.getAttribute("transform") || "translate(0,0)";
22217
22218      this._selection.setAttribute("transform", transform);
22219
22220      this.path.setAttribute("transform", transform);
22221    };
22222
22223    _proto3._onPressAnchor = function _onPressAnchor(anchor) {
22224      if (this._selectedAnchors.indexOf(anchor) === -1) {
22225        if (!_SHIFT) {
22226          this._selectedAnchors.length = 0;
22227        }
22228
22229        this._selectedAnchors.push(anchor);
22230      } else if (_SHIFT) {
22231        this._selectedAnchors.splice(this._selectedAnchors.indexOf(anchor), 1);
22232
22233        anchor._draggable.endDrag();
22234      }
22235
22236      _editingAxis.x = anchor.segment[anchor.i];
22237      _editingAxis.y = anchor.segment[anchor.i + 1];
22238
22239      this._updateAnchors();
22240
22241      _callback$2("onPress", this);
22242    };
22243
22244    _proto3._deleteSelectedAnchors = function _deleteSelectedAnchors() {
22245      var anchors = this._selectedAnchors,
22246          i = anchors.length,
22247          anchor,
22248          index,
22249          j;
22250
22251      while (--i > -1) {
22252        anchor = anchors[i];
22253        anchor.element.parentNode.removeChild(anchor.element);
22254
22255        anchor._draggable.enabled(false);
22256
22257        index = anchor.i;
22258
22259        if (!index) {
22260          anchor.segment.splice(index, 6);
22261        } else if (index < anchor.segment.length - 2) {
22262          anchor.segment.splice(index - 2, 6);
22263        } else {
22264          anchor.segment.splice(index - 4, 6);
22265        }
22266
22267        anchors.splice(i, 1);
22268
22269        this._anchors.splice(this._anchors.indexOf(anchor), 1);
22270
22271        for (j = 0; j < this._anchors.length; j++) {
22272          if (this._anchors[j].i >= index) {
22273            this._anchors[j].i -= 6;
22274          }
22275        }
22276      }
22277
22278      this._updateAnchors();
22279
22280      this.update();
22281
22282      this._saveState();
22283
22284      if (this.vars.onDeleteAnchor) {
22285        this.vars.onDeleteAnchor.call(this.vars.callbackScope || this);
22286      }
22287    };
22288
22289    _proto3._onClickAnchor = function _onClickAnchor(anchor) {
22290      var i = anchor.i,
22291          segment = anchor.segment,
22292          pi = anchor.isClosedStart ? segment.length - 4 : i - 2,
22293          rnd = 1000,
22294          isEnd = !i || i >= segment.length - 2,
22295          angle1,
22296          angle2,
22297          length1,
22298          length2,
22299          sin,
22300          cos;
22301
22302      if (_ALT && _recentlyAddedAnchor !== anchor && this._editingAnchor) {
22303        anchor.smooth = !anchor.smooth;
22304
22305        if (isEnd && !anchor.isClosedStart) {
22306          anchor.smooth = false;
22307        }
22308
22309        anchor.element.setAttribute("d", anchor.smooth ? this._circleHandle : this._squareHandle);
22310
22311        if (anchor.smooth && (!isEnd || anchor.isClosedStart)) {
22312          angle1 = Math.atan2(segment[i + 1] - segment[pi + 1], segment[i] - segment[pi]);
22313          angle2 = Math.atan2(segment[i + 3] - segment[i + 1], segment[i + 2] - segment[i]);
22314          angle1 = (angle1 + angle2) / 2;
22315          length1 = _getLength$1(segment, pi, i);
22316          length2 = _getLength$1(segment, i, i + 2);
22317
22318          if (length1 < 0.2) {
22319            length1 = _getLength$1(segment, i, pi - 4) / 4;
22320            angle1 = angle2 || Math.atan2(segment[i + 7] - segment[pi - 3], segment[i + 6] - segment[pi - 4]);
22321          }
22322
22323          if (length2 < 0.2) {
22324            length2 = _getLength$1(segment, i, i + 6) / 4;
22325            angle2 = angle1 || Math.atan2(segment[i + 7] - segment[pi - 3], segment[i + 6] - segment[pi - 4]);
22326          }
22327
22328          sin = Math.sin(angle1);
22329          cos = Math.cos(angle1);
22330
22331          if (Math.abs(angle2 - angle1) < Math.PI / 2) {
22332            sin = -sin;
22333            cos = -cos;
22334          }
22335
22336          segment[pi] = ((segment[i] + cos * length1) * rnd | 0) / rnd;
22337          segment[pi + 1] = ((segment[i + 1] + sin * length1) * rnd | 0) / rnd;
22338          segment[i + 2] = ((segment[i] - cos * length2) * rnd | 0) / rnd;
22339          segment[i + 3] = ((segment[i + 1] - sin * length2) * rnd | 0) / rnd;
22340
22341          this._updateAnchors();
22342
22343          this.update();
22344
22345          this._saveState();
22346        } else if (!anchor.smooth && (!isEnd || anchor.isClosedStart)) {
22347          if (i || anchor.isClosedStart) {
22348            segment[pi] = segment[i];
22349            segment[pi + 1] = segment[i + 1];
22350          }
22351
22352          if (i < segment.length - 2) {
22353            segment[i + 2] = segment[i];
22354            segment[i + 3] = segment[i + 1];
22355          }
22356
22357          this._updateAnchors();
22358
22359          this.update();
22360
22361          this._saveState();
22362        }
22363      } else if (!_SHIFT) {
22364        this._selectedAnchors.length = 0;
22365
22366        this._selectedAnchors.push(anchor);
22367      }
22368
22369      _recentlyAddedAnchor = null;
22370
22371      this._updateAnchors();
22372    };
22373
22374    _proto3._updateAnchors = function _updateAnchors() {
22375      var anchor = this._selectedAnchors.length === 1 ? this._selectedAnchors[0] : null,
22376          segment = anchor ? anchor.segment : null,
22377          i,
22378          x,
22379          y;
22380      this._editingAnchor = anchor;
22381
22382      for (i = 0; i < this._anchors.length; i++) {
22383        this._anchors[i].element.style.fill = this._selectedAnchors.indexOf(this._anchors[i]) !== -1 ? _selectionColor : "white";
22384      }
22385
22386      if (anchor) {
22387        this._handle1.setAttribute("d", anchor.smooth ? this._circleHandle : this._squareHandle);
22388
22389        this._handle2.setAttribute("d", anchor.smooth ? this._circleHandle : this._squareHandle);
22390      }
22391
22392      i = anchor ? anchor.i : 0;
22393
22394      if (anchor && (i || anchor.isClosedStart)) {
22395        x = anchor.isClosedStart ? segment[segment.length - 4] : segment[i - 2];
22396        y = anchor.isClosedStart ? segment[segment.length - 3] : segment[i - 1];
22397        this._handle1.style.visibility = this._line1.style.visibility = !_ALT && x === segment[i] && y === segment[i + 1] ? "hidden" : "visible";
22398
22399        this._handle1.setAttribute("transform", "translate(" + x + _comma + y + ")");
22400
22401        this._line1.setAttribute("points", x + _comma + y + _comma + segment[i] + _comma + segment[i + 1]);
22402      } else {
22403        this._handle1.style.visibility = this._line1.style.visibility = "hidden";
22404      }
22405
22406      if (anchor && i < segment.length - 2) {
22407        x = segment[i + 2];
22408        y = segment[i + 3];
22409        this._handle2.style.visibility = this._line2.style.visibility = !_ALT && x === segment[i] && y === segment[i + 1] ? "hidden" : "visible";
22410
22411        this._handle2.setAttribute("transform", "translate(" + x + _comma + y + ")");
22412
22413        this._line2.setAttribute("points", segment[i] + _comma + segment[i + 1] + _comma + x + _comma + y);
22414      } else {
22415        this._handle2.style.visibility = this._line2.style.visibility = "hidden";
22416      }
22417    };
22418
22419    _proto3._onPressAlt = function _onPressAlt() {
22420      var anchor = this._editingAnchor;
22421
22422      if (anchor) {
22423        if (anchor.i || anchor.isClosedStart) {
22424          this._handle1.style.visibility = this._line1.style.visibility = "visible";
22425        }
22426
22427        if (anchor.i < anchor.segment.length - 2) {
22428          this._handle2.style.visibility = this._line2.style.visibility = "visible";
22429        }
22430      }
22431    };
22432
22433    _proto3._onReleaseAlt = function _onReleaseAlt() {
22434      var anchor = this._editingAnchor,
22435          s,
22436          i,
22437          pi;
22438
22439      if (anchor) {
22440        s = anchor.segment;
22441        i = anchor.i;
22442        pi = anchor.isClosedStart ? s.length - 4 : i - 2;
22443
22444        if (s[i] === s[pi] && s[i + 1] === s[pi + 1]) {
22445          this._handle1.style.visibility = this._line1.style.visibility = "hidden";
22446        }
22447
22448        if (s[i] === s[i + 2] && s[i + 1] === s[i + 3]) {
22449          this._handle2.style.visibility = this._line2.style.visibility = "hidden";
22450        }
22451      }
22452    };
22453
22454    _proto3._onPressHandle1 = function _onPressHandle1() {
22455      if (this._editingAnchor.smooth) {
22456        this._oppositeHandleLength = _getLength$1(this._editingAnchor.segment, this._editingAnchor.i, this._editingAnchor.i + 2);
22457      }
22458
22459      _callback$2("onPress", this);
22460    };
22461
22462    _proto3._onPressHandle2 = function _onPressHandle2() {
22463      if (this._editingAnchor.smooth) {
22464        this._oppositeHandleLength = _getLength$1(this._editingAnchor.segment, this._editingAnchor.isClosedStart ? this._editingAnchor.segment.length - 4 : this._editingAnchor.i - 2, this._editingAnchor.i);
22465      }
22466
22467      _callback$2("onPress", this);
22468    };
22469
22470    _proto3._onReleaseHandle = function _onReleaseHandle(e) {
22471      this._onRelease(e);
22472
22473      this._saveState();
22474    };
22475
22476    _proto3._onDragHandle1 = function _onDragHandle1() {
22477      var anchor = this._editingAnchor,
22478          s = anchor.segment,
22479          i = anchor.i,
22480          pi = anchor.isClosedStart ? s.length - 4 : i - 2,
22481          rnd = 1000,
22482          x = this._handle1._draggable.x,
22483          y = this._handle1._draggable.y,
22484          angle;
22485      s[pi] = x = (x * rnd | 0) / rnd;
22486      s[pi + 1] = y = (y * rnd | 0) / rnd;
22487
22488      if (anchor.smooth) {
22489        if (_ALT) {
22490          anchor.smooth = false;

vendor: 19,270 bytes, lines 22491-23147

22491          anchor.element.setAttribute("d", this._squareHandle);
22492
22493          this._handle1.setAttribute("d", this._squareHandle);
22494
22495          this._handle2.setAttribute("d", this._squareHandle);
22496        } else {
22497          angle = Math.atan2(s[i + 1] - y, s[i] - x);
22498          x = this._oppositeHandleLength * Math.cos(angle);
22499          y = this._oppositeHandleLength * Math.sin(angle);
22500          s[i + 2] = ((s[i] + x) * rnd | 0) / rnd;
22501          s[i + 3] = ((s[i + 1] + y) * rnd | 0) / rnd;
22502        }
22503      }
22504
22505      this.update();
22506    };
22507
22508    _proto3._onDragHandle2 = function _onDragHandle2() {
22509      var anchor = this._editingAnchor,
22510          s = anchor.segment,
22511          i = anchor.i,
22512          pi = anchor.isClosedStart ? s.length - 4 : i - 2,
22513          rnd = 1000,
22514          x = this._handle2._draggable.x,
22515          y = this._handle2._draggable.y,
22516          angle;
22517      s[i + 2] = x = (x * rnd | 0) / rnd;
22518      s[i + 3] = y = (y * rnd | 0) / rnd;
22519
22520      if (anchor.smooth) {
22521        if (_ALT) {
22522          anchor.smooth = false;
22523          anchor.element.setAttribute("d", this._squareHandle);
22524
22525          this._handle1.setAttribute("d", this._squareHandle);
22526
22527          this._handle2.setAttribute("d", this._squareHandle);
22528        } else {
22529          angle = Math.atan2(s[i + 1] - y, s[i] - x);
22530          x = this._oppositeHandleLength * Math.cos(angle);
22531          y = this._oppositeHandleLength * Math.sin(angle);
22532          s[pi] = ((s[i] + x) * rnd | 0) / rnd;
22533          s[pi + 1] = ((s[i + 1] + y) * rnd | 0) / rnd;
22534        }
22535      }
22536
22537      this.update();
22538    };
22539
22540    _proto3._onDragAnchor = function _onDragAnchor(anchor, changeX, changeY) {
22541      var anchors = this._selectedAnchors,
22542          l = anchors.length,
22543          rnd = 1000,
22544          i,
22545          j,
22546          s,
22547          a,
22548          pi;
22549
22550      for (j = 0; j < l; j++) {
22551        a = anchors[j];
22552        i = a.i;
22553        s = a.segment;
22554
22555        if (i) {
22556          s[i - 2] = ((s[i - 2] + changeX) * rnd | 0) / rnd;
22557          s[i - 1] = ((s[i - 1] + changeY) * rnd | 0) / rnd;
22558        } else if (a.isClosedStart) {
22559          pi = s.length - 2;
22560          s[pi] = _round$b(s[pi] + changeX);
22561          s[pi + 1] = _round$b(s[pi + 1] + changeY);
22562          s[pi - 2] = _round$b(s[pi - 2] + changeX);
22563          s[pi - 1] = _round$b(s[pi - 1] + changeY);
22564        }
22565
22566        s[i] = ((s[i] + changeX) * rnd | 0) / rnd;
22567        s[i + 1] = ((s[i + 1] + changeY) * rnd | 0) / rnd;
22568
22569        if (i < s.length - 2) {
22570          s[i + 2] = ((s[i + 2] + changeX) * rnd | 0) / rnd;
22571          s[i + 3] = ((s[i + 3] + changeY) * rnd | 0) / rnd;
22572        }
22573
22574        if (a !== anchor) {
22575          a.element.setAttribute("transform", "translate(" + s[i] + _comma + s[i + 1] + ")");
22576        }
22577      }
22578
22579      this.update();
22580    };
22581
22582    _proto3.enabled = function enabled(_enabled2) {
22583      if (!arguments.length) {
22584        return this._enabled;
22585      }
22586
22587      var i = this._anchors.length;
22588
22589      while (--i > -1) {
22590        this._anchors[i]._draggable.enabled(_enabled2);
22591      }
22592
22593      this._enabled = _enabled2;
22594
22595      this._handle1._draggable.enabled(_enabled2);
22596
22597      this._handle2._draggable.enabled(_enabled2);
22598
22599      if (this._draggable) {
22600        this._draggable.enabled(_enabled2);
22601      }
22602
22603      if (!_enabled2) {
22604        this.deselect();
22605        this._selectionHittest.parentNode && this._selectionHittest.parentNode.removeChild(this._selectionHittest);
22606        this._selection.parentNode && this._selection.parentNode.removeChild(this._selection);
22607      } else if (!this._selection.parentNode) {
22608        this.path.ownerSVGElement.appendChild(this._selectionHittest);
22609        this.path.ownerSVGElement.appendChild(this._selection);
22610        this.init();
22611
22612        this._saveState();
22613      }
22614
22615      this._updateAnchors();
22616
22617      return this.update();
22618    };
22619
22620    _proto3.update = function update(readPath) {
22621      var d = "",
22622          anchor = this._editingAnchor,
22623          i,
22624          s,
22625          x,
22626          y,
22627          pi;
22628
22629      if (readPath) {
22630        this.init();
22631      }
22632
22633      if (anchor) {
22634        i = anchor.i;
22635        s = anchor.segment;
22636
22637        if (i || anchor.isClosedStart) {
22638          pi = anchor.isClosedStart ? s.length - 4 : i - 2;
22639          x = s[pi];
22640          y = s[pi + 1];
22641
22642          this._handle1.setAttribute("transform", "translate(" + x + _comma + y + ")");
22643
22644          this._line1.setAttribute("points", x + _comma + y + _comma + s[i] + _comma + s[i + 1]);
22645        }
22646
22647        if (i < s.length - 2) {
22648          x = s[i + 2];
22649          y = s[i + 3];
22650
22651          this._handle2.setAttribute("transform", "translate(" + x + _comma + y + ")");
22652
22653          this._line2.setAttribute("points", s[i] + _comma + s[i + 1] + _comma + x + _comma + y);
22654        }
22655      }
22656
22657      if (readPath) {
22658        d = this.path.getAttribute("d");
22659      } else {
22660        for (i = 0; i < this._rawPath.length; i++) {
22661          s = this._rawPath[i];
22662
22663          if (s.length > 7) {
22664            d += "M" + s[0] + _comma + s[1] + "C" + s.slice(2).join(_comma);
22665          }
22666        }
22667
22668        this.path.setAttribute("d", d);
22669
22670        this._selectionPath.setAttribute("d", d);
22671
22672        this._selectionHittest.setAttribute("d", d);
22673      }
22674
22675      if (this.vars.onUpdate && this._enabled) {
22676        _callback$2("onUpdate", this, d);
22677      }
22678
22679      return this;
22680    };
22681
22682    _proto3.getRawPath = function getRawPath(applyTransforms, offsetX, offsetY) {
22683      if (applyTransforms) {
22684        var m = _getConsolidatedMatrix(this.path);
22685
22686        return transformRawPath(copyRawPath(this._rawPath), 1, 0, 0, 1, m.e + (offsetX || 0), m.f + (offsetY || 0));
22687      }
22688
22689      return this._rawPath;
22690    };
22691
22692    _proto3.getString = function getString(applyTransforms, offsetX, offsetY) {
22693      if (applyTransforms) {
22694        var m = _getConsolidatedMatrix(this.path);
22695
22696        return rawPathToString(transformRawPath(copyRawPath(this._rawPath), 1, 0, 0, 1, m.e + (offsetX || 0), m.f + (offsetY || 0)));
22697      }
22698
22699      return this.path.getAttribute("d");
22700    };
22701
22702    _proto3.getNormalizedSVG = function getNormalizedSVG(height, originY, shorten, onEaseError) {
22703      var s = this._rawPath[0],
22704          tx = s[0] * -1,
22705          ty = originY === 0 ? 0 : -(originY || s[1]),
22706          l = s.length,
22707          sx = 1 / (s[l - 2] + tx),
22708          sy = -height || s[l - 1] + ty,
22709          rnd = 1000,
22710          points,
22711          i,
22712          x1,
22713          y1,
22714          x2,
22715          y2;
22716      _temp$1.length = 0;
22717
22718      if (sy) {
22719        sy = 1 / sy;
22720      } else {
22721        sy = -sx;
22722      }
22723
22724      sx *= rnd;
22725      sy *= rnd;
22726
22727      for (i = 0; i < l; i += 2) {
22728        _temp$1[i] = ((s[i] + tx) * sx | 0) / rnd;
22729        _temp$1[i + 1] = ((s[i + 1] + ty) * sy | 0) / rnd;
22730      }
22731
22732      if (onEaseError) {
22733        points = [];
22734        l = _temp$1.length;
22735
22736        for (i = 2; i < l; i += 6) {
22737          x1 = _temp$1[i - 2];
22738          y1 = _temp$1[i - 1];
22739          x2 = _temp$1[i + 4];
22740          y2 = _temp$1[i + 5];
22741          points.push(x1, y1, x2, y2);
22742          bezierToPoints(x1, y1, _temp$1[i], _temp$1[i + 1], _temp$1[i + 2], _temp$1[i + 3], x2, y2, 0.001, points, points.length - 2);
22743        }
22744
22745        x1 = points[0];
22746        l = points.length;
22747
22748        for (i = 2; i < l; i += 2) {
22749          x2 = points[i];
22750
22751          if (x2 < x1 || x2 > 1 || x2 < 0) {
22752            onEaseError();
22753            break;
22754          }
22755
22756          x1 = x2;
22757        }
22758      }
22759
22760      if (shorten && l === 8 && _temp$1[0] === 0 && _temp$1[1] === 0 && _temp$1[l - 2] === 1 && _temp$1[l - 1] === 1) {
22761        return _temp$1.slice(2, 6).join(",");
22762      }
22763
22764      _temp$1[2] = "C" + _temp$1[2];
22765      return "M" + _temp$1.join(",");
22766    };
22767
22768    _proto3.kill = function kill() {
22769      this.enabled(false);
22770      this._g.parentNode && this._g.parentNode.removeChild(this._g);
22771    };
22772
22773    _proto3.revert = function revert() {
22774      this.kill();
22775    };
22776
22777    return PathEditor;
22778  }();
22779  PathEditor.simplifyPoints = simplifyPoints;
22780  PathEditor.pointsToSegment = pointsToSegment;
22781
22782  PathEditor.simplifySVG = function (data, vars) {
22783    var element, points, i, x1, x2, y1, y2, bezier, precision, tolerance, l, cornerThreshold;
22784    vars = vars || {};
22785    tolerance = vars.tolerance || 1;
22786    precision = vars.precision || 1 / tolerance;
22787    cornerThreshold = (vars.cornerThreshold === undefined ? 18 : +vars.cornerThreshold) * _DEG2RAD$6;
22788
22789    if (typeof data !== "string") {
22790      element = data;
22791      data = element.getAttribute("d");
22792    }
22793
22794    if (data.charAt(0) === "#" || data.charAt(0) === ".") {
22795      element = _doc$8.querySelector(data);
22796
22797      if (element) {
22798        data = element.getAttribute("d");
22799      }
22800    }
22801
22802    points = vars.curved === false && !/[achqstvz]/ig.test(data) ? data.match(_numbersExp$1) : stringToRawPath(data)[0];
22803
22804    if (vars.curved !== false) {
22805      bezier = points;
22806      points = [];
22807      l = bezier.length;
22808
22809      for (i = 2; i < l; i += 6) {
22810        x1 = +bezier[i - 2];
22811        y1 = +bezier[i - 1];
22812        x2 = +bezier[i + 4];
22813        y2 = +bezier[i + 5];
22814        points.push(_round$b(x1), _round$b(y1), _round$b(x2), _round$b(y2));
22815        bezierToPoints(x1, y1, +bezier[i], +bezier[i + 1], +bezier[i + 2], +bezier[i + 3], x2, y2, 1 / (precision * 200000), points, points.length - 2);
22816      }
22817
22818      points = pointsToSegment(simplifyPoints(points, tolerance), vars.curviness);
22819      points[2] = "C" + points[2];
22820    } else {
22821      points = simplifyPoints(points, tolerance);
22822    }
22823
22824    data = "M" + points.join(",");
22825
22826    if (element) {
22827      element.setAttribute("d", data);
22828    }
22829
22830    return data;
22831  };
22832
22833  PathEditor.create = function (target, vars) {
22834    return new PathEditor(target, vars);
22835  };
22836
22837  PathEditor.editingAxis = _editingAxis;
22838
22839  PathEditor.getSnapFunction = function (vars) {
22840    var r = vars.radius || 2,
22841        big = 1e20,
22842        minX = vars.x || vars.x === 0 ? vars.x : vars.width ? 0 : -big,
22843        minY = vars.y || vars.y === 0 ? vars.y : vars.height ? 0 : -big,
22844        maxX = minX + (vars.width || big * big),
22845        maxY = minY + (vars.height || big * big),
22846        containX = vars.containX !== false,
22847        containY = vars.containY !== false,
22848        axis = vars.axis,
22849        grid = vars.gridSize;
22850    r *= r;
22851    return function (p) {
22852      var x = p.x,
22853          y = p.y,
22854          gridX,
22855          gridY,
22856          dx,
22857          dy;
22858
22859      if (containX && x < minX || (dx = x - minX) * dx < r) {
22860        x = minX;
22861      } else if (containX && x > maxX || (dx = maxX - x) * dx < r) {
22862        x = maxX;
22863      }
22864
22865      if (containY && y < minY || (dy = y - minY) * dy < r) {
22866        y = minY;
22867      } else if (containY && y > maxY || (dy = maxY - y) * dy < r) {
22868        y = maxY;
22869      }
22870
22871      if (axis) {
22872        dx = x - axis.x;
22873        dy = y - axis.y;
22874
22875        if (dx * dx < r) {
22876          x = axis.x;
22877        }
22878
22879        if (dy * dy < r) {
22880          y = axis.y;
22881        }
22882      }
22883
22884      if (grid) {
22885        gridX = minX + Math.round((x - minX) / grid) * grid;
22886        dx = gridX - x;
22887        gridY = minY + Math.round((y - minY) / grid) * grid;
22888        dy = gridY - y;
22889
22890        if (dx * dx + dy * dy < r) {
22891          x = gridX;
22892          y = gridY;
22893        }
22894      }
22895
22896      p.x = x;
22897      p.y = y;
22898    };
22899  };
22900
22901  PathEditor.version = "3.12.5";
22902  PathEditor.register = _initCore$j;
22903
22904  /*!
22905   * MotionPathHelper 3.12.5
22906   * https://gsap.com
22907   *
22908   * @license Copyright 2008-2024, GreenSock. All rights reserved.
22909   * Subject to the terms at https://gsap.com/standard-license or for
22910   * Club GSAP members, the agreement issued with that membership.
22911   * @author: Jack Doyle, [email protected]
22912  */
22913
22914  var gsap$o,
22915      _win$a,
22916      _doc$9,
22917      _docEl$4,
22918      _body$7,
22919      MotionPathPlugin$1,
22920      _arrayToRawPath,
22921      _rawPathToString,
22922      _context$6,
22923      _selectorExp$2 = /(^[#\.][a-z]|[a-y][a-z])/i,
22924      _isString$7 = function _isString(value) {
22925    return typeof value === "string";
22926  },
22927      _createElement$4 = function _createElement(type, ns) {
22928    var e = _doc$9.createElementNS ? _doc$9.createElementNS((ns || "http://www.w3.org/1999/xhtml").replace(/^https/, "http"), type) : _doc$9.createElement(type);
22929    return e.style ? e : _doc$9.createElement(type);
22930  },
22931      _getPositionOnPage = function _getPositionOnPage(target) {
22932    var bounds = target.getBoundingClientRect(),
22933        windowOffsetY = _docEl$4.clientTop - (_win$a.pageYOffset || _docEl$4.scrollTop || _body$7.scrollTop || 0),
22934        windowOffsetX = _docEl$4.clientLeft - (_win$a.pageXOffset || _docEl$4.scrollLeft || _body$7.scrollLeft || 0);
22935    return {
22936      left: bounds.left + windowOffsetX,
22937      top: bounds.top + windowOffsetY,
22938      right: bounds.right + windowOffsetX,
22939      bottom: bounds.bottom + windowOffsetY
22940    };
22941  },
22942      _getInitialPath = function _getInitialPath(x, y) {
22943    var coordinates = [0, 31, 8, 58, 24, 75, 40, 90, 69, 100, 100, 100],
22944        i;
22945
22946    for (i = 0; i < coordinates.length; i += 2) {
22947      coordinates[i] += x;
22948      coordinates[i + 1] += y;
22949    }
22950
22951    return "M" + x + "," + y + "C" + coordinates.join(",");
22952  },
22953      _getGlobalTime = function _getGlobalTime(animation) {
22954    var time = animation.totalTime();
22955
22956    while (animation) {
22957      time = animation.startTime() + time / (animation.timeScale() || 1);
22958      animation = animation.parent;
22959    }
22960
22961    return time;
22962  },
22963      _copyElement$1,
22964      _initCopyToClipboard = function _initCopyToClipboard() {
22965    _copyElement$1 = _createElement$4("textarea");
22966    _copyElement$1.style.display = "none";
22967
22968    _body$7.appendChild(_copyElement$1);
22969  },
22970      _parsePath = function _parsePath(path, target, vars) {
22971    return _isString$7(path) && _selectorExp$2.test(path) ? _doc$9.querySelector(path) : Array.isArray(path) ? _rawPathToString(_arrayToRawPath([{
22972      x: gsap$o.getProperty(target, "x"),
22973      y: gsap$o.getProperty(target, "y")
22974    }].concat(path), vars)) : _isString$7(path) || path && (path.tagName + "").toLowerCase() === "path" ? path : 0;
22975  },
22976      _addCopyToClipboard = function _addCopyToClipboard(target, getter, onComplete) {
22977    target.addEventListener('click', function (e) {
22978      if (e.target._gsHelper) {
22979        var c = getter(e.target);
22980        _copyElement$1.value = c;
22981
22982        if (c && _copyElement$1.select) {
22983          console.log(c);
22984          _copyElement$1.style.display = "block";
22985
22986          _copyElement$1.select();
22987
22988          try {
22989            _doc$9.execCommand('copy');
22990
22991            _copyElement$1.blur();
22992
22993            onComplete && onComplete(target);
22994          } catch (err) {
22995            console.warn("Copy didn't work; this browser doesn't permit that.");
22996          }
22997
22998          _copyElement$1.style.display = "none";
22999        }
23000      }
23001    });
23002  },
23003      _identityMatrixObject$1 = {
23004    matrix: {
23005      a: 1,
23006      b: 0,
23007      c: 0,
23008      d: 1,
23009      e: 0,
23010      f: 0
23011    }
23012  },
23013      _getConsolidatedMatrix$1 = function _getConsolidatedMatrix(target) {
23014    return (target.transform.baseVal.consolidate() || _identityMatrixObject$1).matrix;
23015  },
23016      _findMotionPathTween = function _findMotionPathTween(target) {
23017    var tweens = gsap$o.getTweensOf(target),
23018        i = 0;
23019
23020    for (; i < tweens.length; i++) {
23021      if (tweens[i].vars.motionPath) {
23022        return tweens[i];
23023      } else if (tweens[i].timeline) {
23024        tweens.push.apply(tweens, tweens[i].timeline.getChildren());
23025      }
23026    }
23027  },
23028      _initCore$k = function _initCore(core, required) {
23029    var message = "Please gsap.registerPlugin(MotionPathPlugin)";
23030    _win$a = window;
23031    gsap$o = gsap$o || core || _win$a.gsap || console.warn(message);
23032    gsap$o && PathEditor.register(gsap$o);
23033    _doc$9 = document;
23034    _body$7 = _doc$9.body;
23035    _docEl$4 = _doc$9.documentElement;
23036
23037    if (gsap$o) {
23038      MotionPathPlugin$1 = gsap$o.plugins.motionPath;
23039      MotionPathHelper.PathEditor = PathEditor;
23040
23041      _context$6 = gsap$o.core.context || function () {};
23042    }
23043
23044    if (!MotionPathPlugin$1) {
23045      required === true && console.warn(message);
23046    } else {
23047      _initCopyToClipboard();
23048
23049      _arrayToRawPath = MotionPathPlugin$1.arrayToRawPath;
23050      _rawPathToString = MotionPathPlugin$1.rawPathToString;
23051    }
23052  };
23053
23054  var MotionPathHelper = function () {
23055    function MotionPathHelper(targetOrTween, vars) {
23056      var _this = this;
23057
23058      if (vars === void 0) {
23059        vars = {};
23060      }
23061
23062      if (!MotionPathPlugin$1) {
23063        _initCore$k(vars.gsap, 1);
23064      }
23065
23066      var copyButton = _createElement$4("div"),
23067          self = this,
23068          offset = {
23069        x: 0,
23070        y: 0
23071      },
23072          target,
23073          path,
23074          isSVG,
23075          startX,
23076          startY,
23077          position,
23078          svg,
23079          animation,
23080          svgNamespace,
23081          temp,
23082          matrix,
23083          refreshPath,
23084          animationToScrub,
23085          createdSVG;
23086
23087      if (targetOrTween instanceof gsap$o.core.Tween) {
23088        animation = targetOrTween;
23089        target = animation.targets()[0];
23090      } else {
23091        target = gsap$o.utils.toArray(targetOrTween)[0];
23092        animation = _findMotionPathTween(target);
23093      }
23094
23095      path = _parsePath(vars.path, target, vars);
23096      this.offset = offset;
23097      position = _getPositionOnPage(target);
23098      startX = parseFloat(gsap$o.getProperty(target, "x", "px"));
23099      startY = parseFloat(gsap$o.getProperty(target, "y", "px"));
23100      isSVG = target.getCTM && target.tagName.toLowerCase() !== "svg";
23101
23102      if (animation && !path) {
23103        path = _parsePath(animation.vars.motionPath.path || animation.vars.motionPath, target, animation.vars.motionPath);
23104      }
23105
23106      copyButton.setAttribute("class", "copy-motion-path");
23107      copyButton.style.cssText = "border-radius:8px; background-color:rgba(85, 85, 85, 0.7); color:#fff; cursor:pointer; padding:6px 12px; font-family:Signika Negative, Arial, sans-serif; position:fixed; left:50%; transform:translate(-50%, 0); font-size:19px; bottom:10px";
23108      copyButton.innerText = "COPY MOTION PATH";
23109      copyButton._gsHelper = self;
23110
23111      (gsap$o.utils.toArray(vars.container)[0] || _body$7).appendChild(copyButton);
23112
23113      _addCopyToClipboard(copyButton, function () {
23114        return self.getString();
23115      }, function () {
23116        return gsap$o.fromTo(copyButton, {
23117          backgroundColor: "white"
23118        }, {
23119          duration: 0.5,
23120          backgroundColor: "rgba(85, 85, 85, 0.6)"
23121        });
23122      });
23123
23124      svg = path && path.ownerSVGElement;
23125
23126      if (!svg) {
23127        svgNamespace = isSVG && target.ownerSVGElement && target.ownerSVGElement.getAttribute("xmlns") || "http://www.w3.org/2000/svg";
23128
23129        if (isSVG) {
23130          svg = target.ownerSVGElement;
23131          temp = target.getBBox();
23132          matrix = _getConsolidatedMatrix$1(target);
23133          startX = matrix.e;
23134          startY = matrix.f;
23135          offset.x = temp.x;
23136          offset.y = temp.y;
23137        } else {
23138          svg = _createElement$4("svg", svgNamespace);
23139          createdSVG = true;
23140
23141          _body$7.appendChild(svg);
23142
23143          svg.setAttribute("viewBox", "0 0 100 100");
23144          svg.setAttribute("class", "motion-path-helper");
23145          svg.style.cssText = "overflow:visible; background-color: transparent; position:absolute; z-index:5000; width:100px; height:100px; top:" + (position.top - startY) + "px; left:" + (position.left - startX) + "px;";
23146        }
23147

vendor: 4,132 bytes, lines 23148-23291

23148        temp = _isString$7(path) && !_selectorExp$2.test(path) ? path : _getInitialPath(startX, startY);
23149        path = _createElement$4("path", svgNamespace);
23150        path.setAttribute("d", temp);
23151        path.setAttribute("vector-effect", "non-scaling-stroke");
23152        path.style.cssText = "fill:transparent; stroke-width:" + (vars.pathWidth || 3) + "; stroke:" + (vars.pathColor || "#555") + "; opacity:" + (vars.pathOpacity || 0.6);
23153        svg.appendChild(path);
23154      } else {
23155        vars.pathColor && gsap$o.set(path, {
23156          stroke: vars.pathColor
23157        });
23158        vars.pathWidth && gsap$o.set(path, {
23159          strokeWidth: vars.pathWidth
23160        });
23161        vars.pathOpacity && gsap$o.set(path, {
23162          opacity: vars.pathOpacity
23163        });
23164      }
23165
23166      if (offset.x || offset.y) {
23167        gsap$o.set(path, {
23168          x: offset.x,
23169          y: offset.y
23170        });
23171      }
23172
23173      if (!("selected" in vars)) {
23174        vars.selected = true;
23175      }
23176
23177      if (!("anchorSnap" in vars)) {
23178        vars.anchorSnap = function (p) {
23179          if (p.x * p.x + p.y * p.y < 16) {
23180            p.x = p.y = 0;
23181          }
23182        };
23183      }
23184
23185      animationToScrub = animation && animation.parent && animation.parent.data === "nested" ? animation.parent.parent : animation;
23186
23187      vars.onPress = function () {
23188        animationToScrub.pause(0);
23189      };
23190
23191      refreshPath = function refreshPath() {
23192        animation.invalidate();
23193        animationToScrub.restart();
23194      };
23195
23196      vars.onRelease = vars.onDeleteAnchor = refreshPath;
23197      this.editor = PathEditor.create(path, vars);
23198
23199      if (vars.center) {
23200        gsap$o.set(target, {
23201          transformOrigin: "50% 50%",
23202          xPercent: -50,
23203          yPercent: -50
23204        });
23205      }
23206
23207      if (animation) {
23208        if (animation.vars.motionPath.path) {
23209          animation.vars.motionPath.path = path;
23210        } else {
23211          animation.vars.motionPath = {
23212            path: path
23213          };
23214        }
23215
23216        if (animationToScrub.parent !== gsap$o.globalTimeline) {
23217          gsap$o.globalTimeline.add(animationToScrub, _getGlobalTime(animationToScrub) - animationToScrub.delay());
23218        }
23219
23220        animationToScrub.repeat(-1).repeatDelay(1);
23221      } else {
23222        animation = animationToScrub = gsap$o.to(target, {
23223          motionPath: {
23224            path: path,
23225            start: vars.start || 0,
23226            end: "end" in vars ? vars.end : 1,
23227            autoRotate: "autoRotate" in vars ? vars.autoRotate : false,
23228            align: path,
23229            alignOrigin: vars.alignOrigin
23230          },
23231          duration: vars.duration || 5,
23232          ease: vars.ease || "power1.inOut",
23233          repeat: -1,
23234          repeatDelay: 1,
23235          paused: !vars.path
23236        });
23237      }
23238
23239      this.animation = animation;
23240
23241      _context$6(this);
23242
23243      this.kill = this.revert = function () {
23244        _this.editor.kill();
23245
23246        copyButton.parentNode && copyButton.parentNode.removeChild(copyButton);
23247        createdSVG && svg.parentNode && svg.parentNode.removeChild(svg);
23248        animationToScrub && animationToScrub.revert();
23249      };
23250    }
23251
23252    var _proto = MotionPathHelper.prototype;
23253
23254    _proto.getString = function getString() {
23255      return this.editor.getString(true, -this.offset.x, -this.offset.y);
23256    };
23257
23258    return MotionPathHelper;
23259  }();
23260  MotionPathHelper.register = _initCore$k;
23261
23262  MotionPathHelper.create = function (target, vars) {
23263    return new MotionPathHelper(target, vars);
23264  };
23265
23266  MotionPathHelper.editPath = function (path, vars) {
23267    return PathEditor.create(path, vars);
23268  };
23269
23270  MotionPathHelper.version = "3.12.5";
23271
23272  /*!
23273   * ScrollSmoother 3.12.5
23274   * https://gsap.com
23275   *
23276   * @license Copyright 2008-2024, GreenSock. All rights reserved.
23277   * Subject to the terms at https://gsap.com/standard-license or for
23278   * Club GSAP members, the agreement issued with that membership.
23279   * @author: Jack Doyle, [email protected]
23280  */
23281  var gsap$p,
23282      _coreInitted$k,
23283      _win$b,
23284      _doc$a,
23285      _docEl$5,
23286      _body$8,
23287      _toArray$9,
23288      _clamp$4,
23289      ScrollTrigger$3,
23290      _mainInstance,
23291      _expo,

23292      _getVelocityProp$1,
23293      _inputObserver$1,
23294      _context$7,
23295      _onResizeDelayedCall,
23296      _windowExists$a = function _windowExists() {
23297    return typeof window !== "undefined";
23298  },
23299      _getGSAP$l = function _getGSAP() {
23300    return gsap$p || _windowExists$a() && (gsap$p = window.gsap) && gsap$p.registerPlugin && gsap$p;
23301  },
23302      _round$c

vendor: 8,391 bytes, lines 23302-23537

23302 = function _round(value) {
23303    return Math.round(value * 100000) / 100000 || 0;
23304  },
23305      _maxScroll$1 = function _maxScroll(scroller) {
23306    return ScrollTrigger$3.maxScroll(scroller || _win$b);
23307  },
23308      _autoDistance = function _autoDistance(el, progress) {
23309    var parent = el.parentNode || _docEl$5,
23310        b1 = el.getBoundingClientRect(),
23311        b2 = parent.getBoundingClientRect(),
23312        gapTop = b2.top - b1.top,
23313        gapBottom = b2.bottom - b1.bottom,
23314        change = (Math.abs(gapTop) > Math.abs(gapBottom) ? gapTop : gapBottom) / (1 - progress),
23315        offset = -change * progress,
23316        ratio,
23317        extraChange;
23318
23319    if (change > 0) {
23320      ratio = b2.height / (_win$b.innerHeight + b2.height);
23321      extraChange = ratio === 0.5 ? b2.height * 2 : Math.min(b2.height, Math.abs(-change * ratio / (2 * ratio - 1))) * 2 * (progress || 1);
23322      offset += progress ? -extraChange * progress : -extraChange / 2;
23323      change += extraChange;
23324    }
23325
23326    return {
23327      change: change,
23328      offset: offset
23329    };
23330  },
23331      _wrap = function _wrap(el) {
23332    var wrapper = _doc$a.querySelector(".ScrollSmoother-wrapper");
23333
23334    if (!wrapper) {
23335      wrapper = _doc$a.createElement("div");
23336      wrapper.classList.add("ScrollSmoother-wrapper");
23337      el.parentNode.insertBefore(wrapper, el);
23338      wrapper.appendChild(el);
23339    }
23340
23341    return wrapper;
23342  };
23343
23344  var ScrollSmoother = function () {
23345    function ScrollSmoother(vars) {
23346      var _this = this;
23347
23348      _coreInitted$k || ScrollSmoother.register(gsap$p) || console.warn("Please gsap.registerPlugin(ScrollSmoother)");
23349      vars = this.vars = vars || {};
23350      _mainInstance && _mainInstance.kill();
23351      _mainInstance = this;
23352
23353      _context$7(this);
23354
23355      var _vars = vars,
23356          smoothTouch = _vars.smoothTouch,
23357          _onUpdate = _vars.onUpdate,
23358          onStop = _vars.onStop,
23359          smooth = _vars.smooth,
23360          onFocusIn = _vars.onFocusIn,
23361          normalizeScroll = _vars.normalizeScroll,
23362          wholePixels = _vars.wholePixels,
23363          content,
23364          wrapper,
23365          height,
23366          mainST,
23367          effects,
23368          sections,
23369          intervalID,
23370          wrapperCSS,
23371          contentCSS,
23372          paused,
23373          pausedNormalizer,
23374          recordedRefreshScroll,
23375          recordedRefreshScrub,
23376          allowUpdates,
23377          self = this,
23378          effectsPrefix = vars.effectsPrefix || "",
23379          scrollFunc = ScrollTrigger$3.getScrollFunc(_win$b),
23380          smoothDuration = ScrollTrigger$3.isTouch === 1 ? smoothTouch === true ? 0.8 : parseFloat(smoothTouch) || 0 : smooth === 0 || smooth === false ? 0 : parseFloat(smooth) || 0.8,
23381          speed = smoothDuration && +vars.speed || 1,
23382          currentY = 0,
23383          delta = 0,
23384          startupPhase = 1,
23385          tracker = _getVelocityProp$1(0),
23386          updateVelocity = function updateVelocity() {
23387        return tracker.update(-currentY);
23388      },
23389          scroll = {
23390        y: 0
23391      },
23392          removeScroll = function removeScroll() {
23393        return content.style.overflow = "visible";
23394      },
23395          isProxyScrolling,
23396          killScrub = function killScrub(trigger) {
23397        trigger.update();
23398        var scrub = trigger.getTween();
23399
23400        if (scrub) {
23401          scrub.pause();
23402          scrub._time = scrub._dur;
23403          scrub._tTime = scrub._tDur;
23404        }
23405
23406        isProxyScrolling = false;
23407        trigger.animation.progress(trigger.progress, true);
23408      },
23409          render = function render(y, force) {
23410        if (y !== currentY && !paused || force) {
23411          wholePixels && (y = Math.round(y));
23412
23413          if (smoothDuration) {
23414            content.style.transform = "matrix3d(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, " + y + ", 0, 1)";
23415            content._gsap.y = y + "px";
23416          }
23417
23418          delta = y - currentY;
23419          currentY = y;
23420          ScrollTrigger$3.isUpdating || ScrollSmoother.isRefreshing || ScrollTrigger$3.update();
23421        }
23422      },
23423          scrollTop = function scrollTop(value) {
23424        if (arguments.length) {
23425          value < 0 && (value = 0);
23426          scroll.y = -value;
23427          isProxyScrolling = true;
23428          paused ? currentY = -value : render(-value);
23429          ScrollTrigger$3.isRefreshing ? mainST.update() : scrollFunc(value / speed);
23430          return this;
23431        }
23432
23433        return -currentY;
23434      },
23435          resizeObserver = typeof ResizeObserver !== "undefined" && vars.autoResize !== false && new ResizeObserver(function () {
23436        if (!ScrollTrigger$3.isRefreshing) {
23437          var max = _maxScroll$1(wrapper) * speed;
23438          max < -currentY && scrollTop(max);
23439
23440          _onResizeDelayedCall.restart(true);
23441        }
23442      }),
23443          lastFocusElement,
23444          _onFocusIn = function _onFocusIn(e) {
23445        wrapper.scrollTop = 0;
23446
23447        if (e.target.contains && e.target.contains(wrapper) || onFocusIn && onFocusIn(_this, e) === false) {
23448          return;
23449        }
23450
23451        ScrollTrigger$3.isInViewport(e.target) || e.target === lastFocusElement || _this.scrollTo(e.target, false, "center center");
23452        lastFocusElement = e.target;
23453      },
23454          _transformPosition = function _transformPosition(position, st) {
23455        if (position < st.start) {
23456          return position;
23457        }
23458
23459        var ratio = isNaN(st.ratio) ? 1 : st.ratio,
23460            change = st.end - st.start,
23461            distance = position - st.start,
23462            offset = st.offset || 0,
23463            pins = st.pins || [],
23464            pinOffset = pins.offset || 0,
23465            progressOffset = st._startClamp && st.start <= 0 || st.pins && st.pins.offset ? 0 : st._endClamp && st.end === _maxScroll$1() ? 1 : 0.5;
23466        pins.forEach(function (p) {
23467          change -= p.distance;
23468
23469          if (p.nativeStart <= position) {
23470            distance -= p.distance;
23471          }
23472        });
23473
23474        if (pinOffset) {
23475          distance *= (change - pinOffset / ratio) / change;
23476        }
23477
23478        return position + (distance - offset * progressOffset) / ratio - distance;
23479      },
23480          adjustEffectRelatedTriggers = function adjustEffectRelatedTriggers(st, triggers, partial) {
23481        partial || (st.pins.length = st.pins.offset = 0);
23482        var pins = st.pins,
23483            markers = st.markers,
23484            dif,
23485            isClamped,
23486            start,
23487            end,
23488            nativeStart,
23489            nativeEnd,
23490            i,
23491            trig;
23492
23493        for (i = 0; i < triggers.length; i++) {
23494          trig = triggers[i];
23495
23496          if (st.trigger && trig.trigger && st !== trig && (trig.trigger === st.trigger || trig.pinnedContainer === st.trigger || st.trigger.contains(trig.trigger))) {
23497            nativeStart = trig._startNative || trig._startClamp || trig.start;
23498            nativeEnd = trig._endNative || trig._endClamp || trig.end;
23499            start = _transformPosition(nativeStart, st);
23500            end = trig.pin && nativeEnd > 0 ? start + (nativeEnd - nativeStart) : _transformPosition(nativeEnd, st);
23501            trig.setPositions(start, end, true, (trig._startClamp ? Math.max(0, start) : start) - nativeStart);
23502            trig.markerStart && markers.push(gsap$p.quickSetter([trig.markerStart, trig.markerEnd], "y", "px"));
23503
23504            if (trig.pin && trig.end > 0 && !partial) {
23505              dif = trig.end - trig.start;
23506              isClamped = st._startClamp && trig.start < 0;
23507
23508              if (isClamped) {
23509                if (st.start > 0) {
23510                  st.setPositions(0, st.end + (st._startNative - st.start), true);
23511                  adjustEffectRelatedTriggers(st, triggers);
23512                  return;
23513                }
23514
23515                dif += trig.start;
23516                pins.offset = -trig.start;
23517              }
23518
23519              pins.push({
23520                start: trig.start,
23521                nativeStart: nativeStart,
23522                end: trig.end,
23523                distance: dif,
23524                trig: trig
23525              });
23526              st.setPositions(st.start, st.end + (isClamped ? -trig.start : dif), true);
23527            }
23528          }
23529        }
23530      },
23531          adjustParallaxPosition = function adjustParallaxPosition(triggers, createdAfterEffectWasApplied) {
23532        effects.forEach(function (st) {
23533          return adjustEffectRelatedTriggers(st, triggers, createdAfterEffectWasApplied);
23534        });
23535      },
23536          onRefresh = function onRefresh() {
23537

vendor: 6,869 bytes, lines 23537-23722

23537removeScroll();
23538        requestAnimationFrame(removeScroll);
23539
23540        if (effects) {
23541          ScrollTrigger$3.getAll().forEach(function (st) {
23542            st._startNative = st.start;
23543            st._endNative = st.end;
23544          });
23545          effects.forEach(function (st) {
23546            var start = st._startClamp || st.start,
23547                end = st.autoSpeed ? Math.min(_maxScroll$1(), st.end) : start + Math.abs((st.end - start) / st.ratio),
23548                offset = end - st.end;
23549            start -= offset / 2;
23550            end -= offset / 2;
23551
23552            if (start > end) {
23553              var s = start;
23554              start = end;
23555              end = s;
23556            }
23557
23558            if (st._startClamp && start < 0) {
23559              end = st.ratio < 0 ? _maxScroll$1() : st.end / st.ratio;
23560              offset = end - st.end;
23561              start = 0;
23562            } else if (st.ratio < 0 || st._endClamp && end >= _maxScroll$1()) {
23563              end = _maxScroll$1();
23564              start = st.ratio < 0 ? 0 : st.ratio > 1 ? 0 : end - (end - st.start) / st.ratio;
23565              offset = (end - start) * st.ratio - (st.end - st.start);
23566            }
23567
23568            st.offset = offset || 0.0001;
23569            st.pins.length = st.pins.offset = 0;
23570            st.setPositions(start, end, true);
23571          });
23572          adjustParallaxPosition(ScrollTrigger$3.sort());
23573        }
23574
23575        tracker.reset();
23576      },
23577          addOnRefresh = function addOnRefresh() {
23578        return ScrollTrigger$3.addEventListener("refresh", onRefresh);
23579      },
23580          restoreEffects = function restoreEffects() {
23581        return effects && effects.forEach(function (st) {
23582          return st.vars.onRefresh(st);
23583        });
23584      },
23585          revertEffects = function revertEffects() {
23586        effects && effects.forEach(function (st) {
23587          return st.vars.onRefreshInit(st);
23588        });
23589        return restoreEffects;
23590      },
23591          effectValueGetter = function effectValueGetter(name, value, index, el) {
23592        return function () {
23593          var v = typeof value === "function" ? value(index, el) : value;
23594          v || v === 0 || (v = el.getAttribute("data-" + effectsPrefix + name) || (name === "speed" ? 1 : 0));
23595          el.setAttribute("data-" + effectsPrefix + name, v);
23596          var clamp = (v + "").substr(0, 6) === "clamp(";
23597          return {
23598            clamp: clamp,
23599            value: clamp ? v.substr(6, v.length - 7) : v
23600          };
23601        };
23602      },
23603          createEffect = function createEffect(el, speed, lag, index, effectsPadding) {
23604        effectsPadding = (typeof effectsPadding === "function" ? effectsPadding(index, el) : effectsPadding) || 0;
23605
23606        var getSpeed = effectValueGetter("speed", speed, index, el),
23607            getLag = effectValueGetter("lag", lag, index, el),
23608            startY = gsap$p.getProperty(el, "y"),
23609            cache = el._gsap,
23610            ratio,
23611            st,
23612            autoSpeed,
23613            scrub,
23614            progressOffset,
23615            yOffset,
23616            pins = [],
23617            initDynamicValues = function initDynamicValues() {
23618          speed = getSpeed();
23619          lag = parseFloat(getLag().value);
23620          ratio = parseFloat(speed.value) || 1;
23621          autoSpeed = speed.value === "auto";
23622          progressOffset = autoSpeed || st && st._startClamp && st.start <= 0 || pins.offset ? 0 : st && st._endClamp && st.end === _maxScroll$1() ? 1 : 0.5;
23623          scrub && scrub.kill();
23624          scrub = lag && gsap$p.to(el, {
23625            ease: _expo,
23626            overwrite: false,
23627            y: "+=0",
23628            duration: lag
23629          });
23630
23631          if (st) {
23632            st.ratio = ratio;
23633            st.autoSpeed = autoSpeed;
23634          }
23635        },
23636            revert = function revert() {
23637          cache.y = startY + "px";
23638          cache.renderTransform(1);
23639          initDynamicValues();
23640        },
23641            markers = [],
23642            change = 0,
23643            updateChange = function updateChange(self) {
23644          if (autoSpeed) {
23645            revert();
23646
23647            var auto = _autoDistance(el, _clamp$4(0, 1, -self.start / (self.end - self.start)));
23648
23649            change = auto.change;
23650            yOffset = auto.offset;
23651          } else {
23652            yOffset = pins.offset || 0;
23653            change = (self.end - self.start - yOffset) * (1 - ratio);
23654          }
23655
23656          pins.forEach(function (p) {
23657            return change -= p.distance * (1 - ratio);
23658          });
23659          self.offset = change || 0.001;
23660          self.vars.onUpdate(self);
23661          scrub && scrub.progress(1);
23662        };
23663
23664        initDynamicValues();
23665
23666        if (ratio !== 1 || autoSpeed || scrub) {
23667          st = ScrollTrigger$3.create({
23668            trigger: autoSpeed ? el.parentNode : el,
23669            start: function start() {
23670              return speed.clamp ? "clamp(top bottom+=" + effectsPadding + ")" : "top bottom+=" + effectsPadding;
23671            },
23672            end: function end() {
23673              return speed.value < 0 ? "max" : speed.clamp ? "clamp(bottom top-=" + effectsPadding + ")" : "bottom top-=" + effectsPadding;
23674            },
23675            scroller: wrapper,
23676            scrub: true,
23677            refreshPriority: -999,
23678            onRefreshInit: revert,
23679            onRefresh: updateChange,
23680            onKill: function onKill(self) {
23681              var i = effects.indexOf(self);
23682              i >= 0 && effects.splice(i, 1);
23683              revert();
23684            },
23685            onUpdate: function onUpdate(self) {
23686              var y = startY + change * (self.progress - progressOffset),
23687                  i = pins.length,
23688                  extraY = 0,
23689                  pin,
23690                  scrollY,
23691                  end;
23692
23693              if (self.offset) {
23694                if (i) {
23695                  scrollY = -currentY;
23696                  end = self.end;
23697
23698                  while (i--) {
23699                    pin = pins[i];
23700
23701                    if (pin.trig.isActive || scrollY >= pin.start && scrollY <= pin.end) {
23702                      if (scrub) {
23703                        pin.trig.progress += pin.trig.direction < 0 ? 0.001 : -0.001;
23704                        pin.trig.update(0, 0, 1);
23705                        scrub.resetTo("y", parseFloat(cache.y), -delta, true);
23706                        startupPhase && scrub.progress(1);
23707                      }
23708
23709                      return;
23710                    }
23711
23712                    scrollY > pin.end && (extraY += pin.distance);
23713                    end -= pin.distance;
23714                  }
23715
23716                  y = startY + extraY + change * ((gsap$p.utils.clamp(self.start, self.end, scrollY) - self.start - extraY) / (end - self.start) - progressOffset);
23717                }
23718
23719                markers.length && !autoSpeed && markers.forEach(function (setter) {
23720                  return setter(y - extraY);
23721                });
23722                y = _round$c

vendor: 8,738 bytes, lines 23722-24013

23722(y + yOffset);
23723
23724                if (scrub) {
23725                  scrub.resetTo("y", y, -delta, true);
23726                  startupPhase && scrub.progress(1);
23727                } else {
23728                  cache.y = y + "px";
23729                  cache.renderTransform(1);
23730                }
23731              }
23732            }
23733          });
23734          updateChange(st);
23735          gsap$p.core.getCache(st.trigger).stRevert = revertEffects;
23736          st.startY = startY;
23737          st.pins = pins;
23738          st.markers = markers;
23739          st.ratio = ratio;
23740          st.autoSpeed = autoSpeed;
23741          el.style.willChange = "transform";
23742        }
23743
23744        return st;
23745      };
23746
23747      addOnRefresh();
23748      ScrollTrigger$3.addEventListener("killAll", addOnRefresh);
23749      gsap$p.delayedCall(0.5, function () {
23750        return startupPhase = 0;
23751      });
23752      this.scrollTop = scrollTop;
23753
23754      this.scrollTo = function (target, smooth, position) {
23755        var p = gsap$p.utils.clamp(0, _maxScroll$1(), isNaN(target) ? _this.offset(target, position, !!smooth && !paused) : +target);
23756        !smooth ? scrollTop(p) : paused ? gsap$p.to(_this, {
23757          duration: smoothDuration,
23758          scrollTop: p,
23759          overwrite: "auto",
23760          ease: _expo
23761        }) : scrollFunc(p);
23762      };
23763
23764      this.offset = function (target, position, ignoreSpeed) {
23765        target = _toArray$9(target)[0];
23766        var cssText = target.style.cssText,
23767            st = ScrollTrigger$3.create({
23768          trigger: target,
23769          start: position || "top top"
23770        }),
23771            y;
23772
23773        if (effects) {
23774          startupPhase ? ScrollTrigger$3.refresh() : adjustParallaxPosition([st], true);
23775        }
23776
23777        y = st.start / (ignoreSpeed ? speed : 1);
23778        st.kill(false);
23779        target.style.cssText = cssText;
23780        gsap$p.core.getCache(target).uncache = 1;
23781        return y;
23782      };
23783
23784      function refreshHeight() {
23785        height = content.clientHeight;
23786        content.style.overflow = "visible";
23787        _body$8.style.height = _win$b.innerHeight + (height - _win$b.innerHeight) / speed + "px";
23788        return height - _win$b.innerHeight;
23789      }
23790
23791      this.content = function (element) {
23792        if (arguments.length) {
23793          var newContent = _toArray$9(element || "#smooth-content")[0] || console.warn("ScrollSmoother needs a valid content element.") || _body$8.children[0];
23794
23795          if (newContent !== content) {
23796            content = newContent;
23797            contentCSS = content.getAttribute("style") || "";
23798            resizeObserver && resizeObserver.observe(content);
23799            gsap$p.set(content, {
23800              overflow: "visible",
23801              width: "100%",
23802              boxSizing: "border-box",
23803              y: "+=0"
23804            });
23805            smoothDuration || gsap$p.set(content, {
23806              clearProps: "transform"
23807            });
23808          }
23809
23810          return this;
23811        }
23812
23813        return content;
23814      };
23815
23816      this.wrapper = function (element) {
23817        if (arguments.length) {
23818          wrapper = _toArray$9(element || "#smooth-wrapper")[0] || _wrap(content);
23819          wrapperCSS = wrapper.getAttribute("style") || "";
23820          refreshHeight();
23821          gsap$p.set(wrapper, smoothDuration ? {
23822            overflow: "hidden",
23823            position: "fixed",
23824            height: "100%",
23825            width: "100%",
23826            top: 0,
23827            left: 0,
23828            right: 0,
23829            bottom: 0
23830          } : {
23831            overflow: "visible",
23832            position: "relative",
23833            width: "100%",
23834            height: "auto",
23835            top: "auto",
23836            bottom: "auto",
23837            left: "auto",
23838            right: "auto"
23839          });
23840          return this;
23841        }
23842
23843        return wrapper;
23844      };
23845
23846      this.effects = function (targets, config) {
23847        var _effects;
23848
23849        effects || (effects = []);
23850
23851        if (!targets) {
23852          return effects.slice(0);
23853        }
23854
23855        targets = _toArray$9(targets);
23856        targets.forEach(function (target) {
23857          var i = effects.length;
23858
23859          while (i--) {
23860            effects[i].trigger === target && effects[i].kill();
23861          }
23862        });
23863        config = config || {};
23864        var _config = config,
23865            speed = _config.speed,
23866            lag = _config.lag,
23867            effectsPadding = _config.effectsPadding,
23868            effectsToAdd = [],
23869            i,
23870            st;
23871
23872        for (i = 0; i < targets.length; i++) {
23873          st = createEffect(targets[i], speed, lag, i, effectsPadding);
23874          st && effectsToAdd.push(st);
23875        }
23876
23877        (_effects = effects).push.apply(_effects, effectsToAdd);
23878
23879        config.refresh !== false && ScrollTrigger$3.refresh();
23880        return effectsToAdd;
23881      };
23882
23883      this.sections = function (targets, config) {
23884        var _sections;
23885
23886        sections || (sections = []);
23887
23888        if (!targets) {
23889          return sections.slice(0);
23890        }
23891
23892        var newSections = _toArray$9(targets).map(function (el) {
23893          return ScrollTrigger$3.create({
23894            trigger: el,
23895            start: "top 120%",
23896            end: "bottom -20%",
23897            onToggle: function onToggle(self) {
23898              el.style.opacity = self.isActive ? "1" : "0";
23899              el.style.pointerEvents = self.isActive ? "all" : "none";
23900            }
23901          });
23902        });
23903
23904        config && config.add ? (_sections = sections).push.apply(_sections, newSections) : sections = newSections.slice(0);
23905        return newSections;
23906      };
23907
23908      this.content(vars.content);
23909      this.wrapper(vars.wrapper);
23910
23911      this.render = function (y) {
23912        return render(y || y === 0 ? y : currentY);
23913      };
23914
23915      this.getVelocity = function () {
23916        return tracker.getVelocity(-currentY);
23917      };
23918
23919      ScrollTrigger$3.scrollerProxy(wrapper, {
23920        scrollTop: scrollTop,
23921        scrollHeight: function scrollHeight() {
23922          return refreshHeight() && _body$8.scrollHeight;
23923        },
23924        fixedMarkers: vars.fixedMarkers !== false && !!smoothDuration,
23925        content: content,
23926        getBoundingClientRect: function getBoundingClientRect() {
23927          return {
23928            top: 0,
23929            left: 0,
23930            width: _win$b.innerWidth,
23931            height: _win$b.innerHeight
23932          };
23933        }
23934      });
23935      ScrollTrigger$3.defaults({
23936        scroller: wrapper
23937      });
23938      var existingScrollTriggers = ScrollTrigger$3.getAll().filter(function (st) {
23939        return st.scroller === _win$b || st.scroller === wrapper;
23940      });
23941      existingScrollTriggers.forEach(function (st) {
23942        return st.revert(true, true);
23943      });
23944      mainST = ScrollTrigger$3.create({
23945        animation: gsap$p.fromTo(scroll, {
23946          y: function y() {
23947            allowUpdates = 0;
23948            return 0;
23949          }
23950        }, {
23951          y: function y() {
23952            allowUpdates = 1;
23953            return -refreshHeight();
23954          },
23955          immediateRender: false,
23956          ease: "none",
23957          data: "ScrollSmoother",
23958          duration: 100,
23959          onUpdate: function onUpdate() {
23960            if (allowUpdates) {
23961              var force = isProxyScrolling;
23962
23963              if (force) {
23964                killScrub(mainST);
23965                scroll.y = currentY;
23966              }
23967
23968              render(scroll.y, force);
23969              updateVelocity();
23970              _onUpdate && !paused && _onUpdate(self);
23971            }
23972          }
23973        }),
23974        onRefreshInit: function onRefreshInit(self) {
23975          if (ScrollSmoother.isRefreshing) {
23976            return;
23977          }
23978
23979          ScrollSmoother.isRefreshing = true;
23980
23981          if (effects) {
23982            var _pins = ScrollTrigger$3.getAll().filter(function (st) {
23983              return !!st.pin;
23984            });
23985
23986            effects.forEach(function (st) {
23987              if (!st.vars.pinnedContainer) {
23988                _pins.forEach(function (pinST) {
23989                  if (pinST.pin.contains(st.trigger)) {
23990                    var v = st.vars;
23991                    v.pinnedContainer = pinST.pin;
23992                    st.vars = null;
23993                    st.init(v, st.animation);
23994                  }
23995                });
23996              }
23997            });
23998          }
23999
24000          var scrub = self.getTween();
24001          recordedRefreshScrub = scrub && scrub._end > scrub._dp._time;
24002          recordedRefreshScroll = currentY;
24003          scroll.y = 0;
24004
24005          if (smoothDuration) {
24006            ScrollTrigger$3.isTouch === 1 && (wrapper.style.position = "absolute");
24007            wrapper.scrollTop = 0;
24008            ScrollTrigger$3.isTouch === 1 && (wrapper.style.position = "fixed");
24009          }
24010        },
24011        onRefresh: function onRefresh(self) {
24012          self.animation.invalidate();
24013          s

vendor: 5,964 bytes, lines 24013-24185

24013elf.setPositions(self.start, refreshHeight() / speed);
24014          recordedRefreshScrub || killScrub(self);
24015          scroll.y = -scrollFunc() * speed;
24016          render(scroll.y);
24017
24018          if (!startupPhase) {
24019            recordedRefreshScrub && (isProxyScrolling = false);
24020            self.animation.progress(gsap$p.utils.clamp(0, 1, recordedRefreshScroll / speed / -self.end));
24021          }
24022
24023          if (recordedRefreshScrub) {
24024            self.progress -= 0.001;
24025            self.update();
24026          }
24027
24028          ScrollSmoother.isRefreshing = false;
24029        },
24030        id: "ScrollSmoother",
24031        scroller: _win$b,
24032        invalidateOnRefresh: true,
24033        start: 0,
24034        refreshPriority: -9999,
24035        end: function end() {
24036          return refreshHeight() / speed;
24037        },
24038        onScrubComplete: function onScrubComplete() {
24039          tracker.reset();
24040          onStop && onStop(_this);
24041        },
24042        scrub: smoothDuration || true
24043      });
24044
24045      this.smooth = function (value) {
24046        if (arguments.length) {
24047          smoothDuration = value || 0;
24048          speed = smoothDuration && +vars.speed || 1;
24049          mainST.scrubDuration(value);
24050        }
24051
24052        return mainST.getTween() ? mainST.getTween().duration() : 0;
24053      };
24054
24055      mainST.getTween() && (mainST.getTween().vars.ease = vars.ease || _expo);
24056      this.scrollTrigger = mainST;
24057      vars.effects && this.effects(vars.effects === true ? "[data-" + effectsPrefix + "speed], [data-" + effectsPrefix + "lag]" : vars.effects, {
24058        effectsPadding: vars.effectsPadding,
24059        refresh: false
24060      });
24061      vars.sections && this.sections(vars.sections === true ? "[data-section]" : vars.sections);
24062      existingScrollTriggers.forEach(function (st) {
24063        st.vars.scroller = wrapper;
24064        st.revert(false, true);
24065        st.init(st.vars, st.animation);
24066      });
24067
24068      this.paused = function (value, allowNestedScroll) {
24069        if (arguments.length) {
24070          if (!!paused !== value) {
24071            if (value) {
24072              mainST.getTween() && mainST.getTween().pause();
24073              scrollFunc(-currentY / speed);
24074              tracker.reset();
24075              pausedNormalizer = ScrollTrigger$3.normalizeScroll();
24076              pausedNormalizer && pausedNormalizer.disable();
24077              paused = ScrollTrigger$3.observe({
24078                preventDefault: true,
24079                type: "wheel,touch,scroll",
24080                debounce: false,
24081                allowClicks: true,
24082                onChangeY: function onChangeY() {
24083                  return scrollTop(-currentY);
24084                }
24085              });
24086              paused.nested = _inputObserver$1(_docEl$5, "wheel,touch,scroll", true, allowNestedScroll !== false);
24087            } else {
24088              paused.nested.kill();
24089              paused.kill();
24090              paused = 0;
24091              pausedNormalizer && pausedNormalizer.enable();
24092              mainST.progress = (-currentY / speed - mainST.start) / (mainST.end - mainST.start);
24093              killScrub(mainST);
24094            }
24095          }
24096
24097          return this;
24098        }
24099
24100        return !!paused;
24101      };
24102
24103      this.kill = this.revert = function () {
24104        _this.paused(false);
24105
24106        killScrub(mainST);
24107        mainST.kill();
24108        var triggers = (effects || []).concat(sections || []),
24109            i = triggers.length;
24110
24111        while (i--) {
24112          triggers[i].kill();
24113        }
24114
24115        ScrollTrigger$3.scrollerProxy(wrapper);
24116        ScrollTrigger$3.removeEventListener("killAll", addOnRefresh);
24117        ScrollTrigger$3.removeEventListener("refresh", onRefresh);
24118        wrapper.style.cssText = wrapperCSS;
24119        content.style.cssText = contentCSS;
24120        var defaults = ScrollTrigger$3.defaults({});
24121        defaults && defaults.scroller === wrapper && ScrollTrigger$3.defaults({
24122          scroller: _win$b
24123        });
24124        _this.normalizer && ScrollTrigger$3.normalizeScroll(false);
24125        clearInterval(intervalID);
24126        _mainInstance = null;
24127        resizeObserver && resizeObserver.disconnect();
24128
24129        _body$8.style.removeProperty("height");
24130
24131        _win$b.removeEventListener("focusin", _onFocusIn);
24132      };
24133
24134      this.refresh = function (soft, force) {
24135        return mainST.refresh(soft, force);
24136      };
24137
24138      if (normalizeScroll) {
24139        this.normalizer = ScrollTrigger$3.normalizeScroll(normalizeScroll === true ? {
24140          debounce: true,
24141          content: !smoothDuration && content
24142        } : normalizeScroll);
24143      }
24144
24145      ScrollTrigger$3.config(vars);
24146      "overscrollBehavior" in _win$b.getComputedStyle(_body$8) && gsap$p.set([_body$8, _docEl$5], {
24147        overscrollBehavior: "none"
24148      });
24149      "scrollBehavior" in _win$b.getComputedStyle(_body$8) && gsap$p.set([_body$8, _docEl$5], {
24150        scrollBehavior: "auto"
24151      });
24152
24153      _win$b.addEventListener("focusin", _onFocusIn);
24154
24155      intervalID = setInterval(updateVelocity, 250);
24156      _doc$a.readyState === "loading" || requestAnimationFrame(function () {
24157        return ScrollTrigger$3.refresh();
24158      });
24159    }
24160
24161    ScrollSmoother.register = function register(core) {
24162      if (!_coreInitted$k) {
24163        gsap$p = core || _getGSAP$l();
24164
24165        if (_windowExists$a() && window.document) {
24166          _win$b = window;
24167          _doc$a = document;
24168          _docEl$5 = _doc$a.documentElement;
24169          _body$8 = _doc$a.body;
24170        }
24171
24172        if (gsap$p) {
24173          _toArray$9 = gsap$p.utils.toArray;
24174          _clamp$4 = gsap$p.utils.clamp;
24175          _expo = gsap$p.parseEase("expo");
24176
24177          _context$7 = gsap$p.core.context || function () {};
24178
24179          ScrollTrigger$3 = gsap$p.core.globals().ScrollTrigger;
24180          gsap$p.core.globals("ScrollSmoother", ScrollSmoother);
24181
24182          if (_body$8 && ScrollTrigger$3) {
24183            _onResizeDelayedCall = gsap$p.delayedCall(0.2, function () {
24184              return ScrollTrigger$3.isRefreshing || _mainInstance && _mainInstance.refresh();
24185            }).pause();

24186            _getVelocityProp$1 = ScrollTrigger$3.core._getVelocityProp;
24187            _inputObserver$1 = ScrollTrigger$3.core._inputObserver;
24188            ScrollSmoother.refresh = ScrollTrigger$3.refresh;
24189            _coreInitted$k = 1;
24190          }
24191        }
24192      }
24193
24194      return _coreInitted$k;
24195    };
24196
24197    _createClass(ScrollSmoother, [{
24198      key: "progress",
24199      get: function get() {
24200        return this.scrollTrigger ? this.scrollTrigger.animation._time / 100 : 0;
24201      }
24202    }]);
24203
24204    return ScrollSmoother;
24205  }();
24206  ScrollSmoother.version = "3.12.5";
24207
24208  ScrollSmoother.create = function (vars) {
24209    return _mainInstance && vars && _mainInstance.content() === _toArray$9(vars.content)[0] ? _mainInstance : new ScrollSmoother(vars);
24210  };
24211
24212  ScrollSmoother.get = function () {
24213    return _mainInstance;
24214  };
24215
24216  _getGSAP$l() && gsap$p.registerPlugin(ScrollSmoother);
24217
24218  /*!
24219   * SplitText: 3.12.5
24220   * https://gsap.com
24221   *
24222   * @license Copyright 2008-2024, GreenSock. All rights reserved.
24223   * Subject to the terms at https://gsap.com/standard-license or for
24224   * Club GSAP members, the agreement issued with that membership.
24225   * @author: Jack Doyle, [email protected]
24226  */
24227
24228  var _doc$b,
24229      _win$c,
24230      _coreInitted$l,
24231      gsap$q,
24232      _context$8,
24233      _toArray$a,
24234      _stripExp = /(?:\r|\n|\t\t)/g,
24235      _multipleSpacesExp = /(?:\s\s+)/g,
24236      _nonBreakingSpace = String.fromCharCode(160),
24237      _initCore$l = function _initCore(core) {
24238    _doc$b = document;
24239    _win$c = window;
24240    gsap$q = gsap$q || core || _win$c.gsap || console.warn("Please gsap.registerPlugin(SplitText)");
24241
24242    if (gsap$q) {
24243      _toArray$a = gsap$q.utils.toArray;
24244
24245      _context$8 = gsap$q.core.context || function () {};
24246
24247      _coreInitted$l = 1;
24248    }
24249  },
24250      _getComputedStyle$2 = function _getComputedStyle(element) {
24251    return _win$c.getComputedStyle(element);
24252  },
24253      _isAbsolute = function _isAbsolute(vars) {
24254    return vars.position === "absolute" || vars.absolute === true;
24255  },
24256      _findSpecialChars = function _findSpecialChars(text, chars) {
24257    var i = chars.length,
24258        s;
24259
24260    while (--i > -1) {
24261      s = chars[i];
24262
24263      if (text.substr(0, s.length) === s) {
24264        return s.length;
24265      }
24266    }
24267  },
24268      _divStart = " style='position:relative;display:inline-block;'",
24269      _cssClassFunc = function _cssClassFunc(cssClass, tag) {
24270    if (cssClass === void 0) {
24271      cssClass = "";
24272    }
24273
24274    var iterate = ~cssClass.indexOf("++"),
24275        num = 1;
24276
24277    if (iterate) {
24278      cssClass = cssClass.split("++").join("");
24279    }
24280
24281    return function () {
24282      return "<" + tag + _divStart + (cssClass ? " class='" + cssClass + (iterate ? num++ : "") + "'>" : ">");
24283    };
24284  },
24285      _swapText = function _swapText(element, oldText, newText) {
24286    var type = element.nodeType;
24287
24288    if (type === 1 || type === 9 || type === 11) {
24289      for (element = element.firstChild; element; element = element.nextSibling) {
24290        _swapText(element, oldText, newText);
24291      }
24292    } else if (type === 3 || type === 4) {
24293      element.nodeValue = element.nodeValue.split(oldText).join(newText);
24294    }
24295  },
24296      _pushReversed = function _pushReversed(a, merge) {
24297    var i = merge.length;
24298
24299    while (--i > -1) {
24300      a.push(merge[i]);
24301    }
24302  },
24303      _isBeforeWordDelimiter = function _isBeforeWordDelimiter(e, root, wordDelimiter) {
24304    var next;
24305
24306    while (e && e !== root) {
24307      next = e._next || e.nextSibling;
24308
24309      if (next) {
24310        return next.textContent.charAt(0) === wordDelimiter;
24311      }
24312
24313      e = e.parentNode || e._parent;
24314    }
24315  },
24316      _deWordify = function _deWordify(e) {
24317    var children = _toArray$a(e.childNodes),
24318        l = children.length,
24319        i,
24320        child;
24321
24322    for (i = 0; i < l; i++) {
24323      child = children[i];
24324
24325      if (child._isSplit) {
24326        _deWordify(child);
24327      } else {
24328        if (i && child.previousSibling && child.previousSibling.nodeType === 3) {
24329          child.previousSibling.nodeValue += child.nodeType === 3 ? child.nodeValue : child.firstChild.nodeValue;
24330          e.removeChild(child);
24331        } else if (child.nodeType !== 3) {
24332          e.insertBefore(child.firstChild, child);
24333          e.removeChild(child);
24334        }
24335      }
24336    }
24337  },
24338      _getStyleAsNumber = function _getStyleAsNumber(name, computedStyle) {
24339    return parseFloat(computedStyle[name]) || 0;
24340  },
24341      _setPositionsAfterSplit = function _setPositionsAfterSplit(element, vars, allChars, allWords, allLines, origWidth, origHeight) {
24342    var cs = _getComputedStyle$2(element),
24343        paddingLeft = _getStyleAsNumber("paddingLeft", cs),
24344        lineOffsetY = -999,
24345        borderTopAndBottom = _getStyleAsNumber("borderBottomWidth", cs) + _get

24345StyleAsNumber("borderTopWidth", cs),
24346        borderLeftAndRight = _getStyleAsNumber("borderLeftWidth", cs) + _getStyleAsNumber("borderRightWidth", cs),
24347        padTopAndBottom = _getStyleAsNumber("paddingTop", cs) + _getStyleAsNumber("paddingBottom", cs),
24348        padLeftAndRight = _getStyleAsNumber("paddingLeft", cs) + _getStyleAsNumber("paddingRight", cs),
24349        lineThreshold = _getStyleAsNumber("fontSize", cs) * (vars.lineThreshold || 0.2),
24350        textAlign = cs.textAlign,
24351        charArray = [],
24352        wordArray = [],
24353        lineArray = [],
24354        wordDelimiter = vars.wordDelimiter || " ",
24355        tag = vars.tag ? vars.tag : vars.span ? "span" : "div",
24356        types = vars.type || vars.split || "chars,words,lines",
24357        lines = allLines && ~types.indexOf("lines") ? [] : null,
24358        words = ~types.indexOf("words"),
24359        chars = ~types.indexOf("chars"),
24360        absolute = _isAbsolute(vars),
24361        linesClass = vars.linesClass,
24362        iterateLine = ~(linesClass || "").indexOf("++"),
24363        spaceNodesToRemove = [],
24364        isFlex = cs.display === "flex",
24365        prevInlineDisplay = element.style.display,
24366        i,
24367        j,
24368        l,
24369        node,
24370        nodes,
24371        isChild,
24372        curLine,
24373        addWordSpaces,
24374        style,
24375        lineNode,
24376        lineWidth,
24377        offset;
24378
24379    iterateLine && (linesClass = linesClass.split("++").join(""));
24380    isFlex && (element.style.display = "block");
24381    j = element.getElementsByTagName("*");
24382    l = j.length;
24383    nodes = [];
24384
24385    for (i = 0; i < l; i++) {
24386      nodes[i] = j[i];
24387    }
24388
24389    if (lines || absolute) {
24390      for (i = 0; i < l; i++) {
24391        node = nodes[i];
24392        isChild = node.parentNode === element;
24393
24394        if (isChild || absolute || chars && !words) {
24395          offset = node.offsetTop;
24396
24397          if (lines && isChild && Math.abs(offset - lineOffsetY) > lineThreshold && (node.nodeName !== "BR" || i === 0)) {
24398            curLine = [];
24399            lines.push(curLine);
24400            lineOffsetY = offset;
24401          }
24402
24403          if (absolute) {
24404            node._x = node.offsetLeft;
24405            node._y = offset;
24406            node._w = node.offsetWidth;
24407            node._h = node.offsetHeight;
24408          }
24409
24410          if (lines) {
24411            if (node._isSplit && isChild || !chars && isChild || words && isChild || !words && node.parentNode.parentNode === element && !node.parentNode._isSplit) {
24412              curLine.push(node);
24413              node._x -= paddingLeft;
24414
24415              if (_isBeforeWordDelimiter(node, element, wordDelimiter)) {
24416                node._wordEnd = true;
24417              }
24418            }
24419
24420            if (node.nodeName === "BR" && (node.nextSibling && node.nextSibling.nodeName === "BR" || i === 0)) {
24421              lines.push([]);
24422            }
24423          }
24424        }
24425      }
24426    }
24427
24428    for (i = 0; i < l; i++) {
24429      node = nodes[i];
24430      isChild = node.parentNode === element;
24431
24432      if (node.nodeName === "BR") {
24433        if (lines || absolute) {
24434          node.parentNode && node.parentNode.removeChild(node);
24435          nodes.splice(i--, 1);
24436          l--;
24437        } else if (!words) {
24438          element.appendChild(node);
24439        }
24440
24441        continue;
24442      }
24443
24444      if (absolute) {
24445        style = node.style;
24446
24447        if (!words && !isChild) {
24448          node._x += node.parentNode._x;
24449          node._y += node.parentNode._y;
24450        }
24451
24452        style.left = node._x + "px";
24453        style.top = node._y + "px";
24454        style.position = "absolute";
24455        style.display = "block";
24456        style.width = node._w + 1 + "px";
24457        style.height = node._h + "px";
24458      }
24459
24460      if (!words && chars) {
24461        if (node._isSplit) {
24462          node._next = j = node.nextSibling;
24463          node.parentNode.appendChild(node);
24464
24465          while (j && j.nodeType === 3 && j.textContent === " ") {
24466            node._next = j.nextSibling;
24467            node.parentNode.appendChild(j);
24468            j = j.nextSibling;
24469          }
24470        } else if (node.parentNode._isSplit) {
24471          node._parent = node.parentNode;
24472
24473          if (!node.previousSibling && node.firstChild) {
24474            node.firstChild._isFirst = true;
24475          }
24476
24477          if (node.nextSibling && node.nextSibling.textContent === " " && !node.nextSibling.nextSibling) {
24478            spaceNodesToRemove.push(node.nextSibling);
24479          }
24480
24481          node._next = node.nextSibling && node.nextSibling._isFirst ? null : node.nextSibling;
24482          node.parentNode.removeChild(node);
24483          nodes.splice(i--, 1);
24484          l--;
24485        } else if (!isChild) {
24486          offset = !node.nextSibling && _isBeforeWordDelimiter(node.parentNode, element, wordDelimiter);
24487          node.parentNode._parent && node.parentNode._parent.appendChild(node);
24488          offset && node.parentNode.appendChild(_doc$b.createTextNode(" "));
24489
24490          if (tag === "span") {
24491            node.style.display = "inline";
24492          }
24493
24494          charArray.push(node);
24495        }
24496      } else if (node.parentNode._isSplit && !node._isSplit && node.innerHTML !== "") {
24497        wordArray.push(node);
24498      } else if (chars && !node._isSplit) {
24499        if (tag === "span") {
24500          node.style.display = "inline";
24501        }
24502
24503        charArray.push(node);
24504      }
24505    }
24506
24507    i = spaceNodesToRemove.length;
24508
24509    while (--i > -1) {
24510      spaceNodesToRemove[i].parentNode.removeChild(spaceNodesToRemove[i]);
24511    }
24512
24513    if (lines) {
24514      if (absolute) {
24515        lineNode = _doc$b.createElement(tag);
24516        element.appendChild(lineNode);
24517        lineWidth = lineNode.offsetWidth + "px";
24518        offset = lineNode.offsetParent === element ? 0 : element.offsetLeft;
24519        element.removeChild(lineNode);
24520      }
24521
24522      style = element.style.cssText;
24523      element.style.cssText = "display:none;";
24524
24525      while (element.firstChild) {
24526        element.removeChild(element.firstChild);
24527      }
24528
24529      addWordSpaces = wordDelimiter === " " && (!absolute || !words && !c

24529hars);
24530
24531      for (i = 0; i < lines.length; i++) {
24532        curLine = lines[i];
24533        lineNode = _doc$b.createElement(tag);
24534        lineNode.style.cssText = "display:block;text-align:" + textAlign + ";position:" + (absolute ? "absolute;" : "relative;");
24535
24536        if (linesClass) {
24537          lineNode.className = linesClass + (iterateLine ? i + 1 : "");
24538        }
24539
24540        lineArray.push(lineNode);
24541        l = curLine.length;
24542
24543        for (j = 0; j < l; j++) {
24544          if (curLine[j].nodeName !== "BR") {
24545            node = curLine[j];
24546            lineNode.appendChild(node);
24547            addWordSpaces && node._wordEnd && lineNode.appendChild(_doc$b.createTextNode(" "));
24548
24549            if (absolute) {
24550              if (j === 0) {
24551                lineNode.style.top = node._y + "px";
24552                lineNode.style.left = paddingLeft + offset + "px";
24553              }
24554
24555              node.style.top = "0px";
24556
24557              if (offset) {
24558                node.style.left = node._x - offset + "px";
24559              }
24560            }
24561          }
24562        }
24563
24564        if (l === 0) {
24565          lineNode.innerHTML = "&nbsp;";
24566        } else if (!words && !chars) {
24567          _deWordify(lineNode);
24568
24569          _swapText(lineNode, String.fromCharCode(160), " ");
24570        }
24571
24572        if (absolute) {
24573          lineNode.style.width = lineWidth;
24574          lineNode.style.height = node._h + "px";
24575        }
24576
24577        element.appendChild(lineNode);
24578      }
24579
24580      element.style.cssText = style;
24581    }
24582
24583    if (absolute) {
24584      if (origHeight > element.clientHeight) {
24585        element.style.height = origHeight - padTopAndBottom + "px";
24586
24587        if (element.clientHeight < origHeight) {
24588          element.style.height = origHeight + borderTopAndBottom + "px";
24589        }
24590      }
24591
24592      if (origWidth > element.clientWidth) {
24593        element.style.width = origWidth - padLeftAndRight + "px";
24594
24595        if (element.clientWidth < origWidth) {
24596          element.style.width = origWidth + borderLeftAndRight + "px";
24597        }
24598      }
24599    }
24600
24601    isFlex && (prevInlineDisplay ? element.style.display = prevInlineDisplay : element.style.removeProperty("display"));
24602
24603    _pushReversed(allChars, charArray);
24604
24605    words && _pushReversed(allWords, wordArray);
24606
24607    _pushReversed(allLines, lineArray);
24608  },
24609      _splitRawText = function _splitRawText(element, vars, wordStart, charStart) {
24610    var tag = vars.tag ? vars.tag : vars.span ? "span" : "div",
24611        types = vars.type || vars.split || "chars,words,lines",
24612        chars = ~types.indexOf("chars"),
24613        absolute = _isAbsolute(vars),
24614        wordDelimiter = vars.wordDelimiter || " ",
24615        isWordDelimiter = function isWordDelimiter(_char) {
24616      return _char === wordDelimiter || _char === _nonBreakingSpace && wordDelimiter === " ";
24617    },
24618        space = wordDelimiter !== " " ? "" : absolute ? "&#173; " : " ",
24619        wordEnd = "</" + tag + ">",
24620        wordIsOpen = 1,
24621        specialChars = vars.specialChars ? typeof vars.specialChars === "function" ? vars.specialChars : _findSpecialChars : null,
24622        text,
24623        splitText,
24624        i,
24625        j,
24626        l,
24627        character,
24628        hasTagStart,
24629        testResult,
24630        container = _doc$b.createElement("div"),
24631        parent = element.parentNode;
24632
24633    parent.insertBefore(container, element);
24634    container.textContent = element.nodeValue;
24635    parent.removeChild(element);
24636    element = container;
24637    text = getText(element);
24638    hasTagStart = text.indexOf("<") !== -1;
24639
24640    if (vars.reduceWhiteSpace !== false) {
24641      text = text.replace(_multipleSpacesExp, " ").replace(_stripExp, "");
24642    }
24643
24644    if (hasTagStart) {
24645      text = text.split("<").join("{{LT}}");
24646    }
24647
24648    l = text.length;
24649    splitText = (text.charAt(0) === " " ? space : "") + wordStart();
24650
24651    for (i = 0; i < l; i++) {
24652      character = text.charAt(i);
24653
24654      if (specialChars && (testResult = specialChars(text.substr(i), vars.specialChars))) {
24655        character = text.substr(i, testResult || 1);
24656        splitText += chars && character !== " " ? charStart() + character + "</" + tag + ">" : character;
24657        i += testResult - 1;
24658      } else if (isWordDelimiter(character) && !isWordDelimiter(text.charAt(i - 1)) && i) {
24659        splitText += wordIsOpen ? wordEnd : "";
24660        wordIsOpen = 0;
24661
24662        while (isWordDelimiter(text.charAt(i + 1))) {
24663          splitText += space;
24664          i++;
24665        }
24666
24667        if (i === l - 1) {
24668          splitText += space;
24669        } else if (text.charAt(i + 1) !== ")") {

24670          splitText += space + wordStart();
24671          wordIsOpen = 1;
24672        }
24673      } else if (character === "{" && text.substr(i, 6) === "{{LT}}") {
24674        splitText += chars ? charStart() + "{{LT}}" + "</" + tag + ">" : "{{LT}}";
24675        i += 5;
24676      } else if (character.charCodeAt(0) >= 0xD800 && character.charCodeAt(0) <= 0xDBFF || text.charCodeAt(i + 1) >= 0xFE00 && text.charCodeAt(i + 1) <= 0xFE0F) {
24677        j = ((text.substr(i, 12).split(emojiExp) || [])[1] || "").length || 2;
24678        splitText += chars && character !== " " ? charStart() + text.substr(i, j) + "</" + tag + ">" : text.substr(i, j);
24679        i += j - 1;
24680      } else {
24681        splitText += chars && character !== " " ? charStart() + character + "</" + tag + ">" : character;
24682      }
24683    }
24684
24685    element.outerHTML = splitText + (wordIsOpen ? wordEnd : "");
24686    hasTagStart && _swapText(parent, "{{LT}}", "<");
24687  },
24688      _split = function _split(element, vars, wordStart, charStart) {
24689    var children = _toArray$a(element.childNodes),
24690        l = children.length,
24691        absolute = _isAbsolute(vars),
24692        i,
24693        child;
24694
24695    if (element.nodeType !== 3 || l > 1) {
24696      vars.absolute = false;
24697
24698      for (i = 0; i < l; i++) {
24699        child = children[i];
24700        child._next = child._isFirst = child._parent = child._wordEnd = null;
24701
24702        if (child.nodeType !== 3 || /\S+/.test(child.nodeValue)) {
24703          if (absolute && child.nodeType !== 3 && _getComputedStyle$2(child).display === "inline") {
24704            child.style.display = "inline-block";
24705            child.style.position = "relative";
24706          }
24707
24708          child._isSplit = true;
24709
24710          _split(child, vars, wordStart, charStart);
24711        }
24712      }
24713
24714      vars.absolute = absolute;
24715      element._isSplit = true;
24716      return;
24717    }
24718
24719    _splitRawText(element, vars, wordStart, charStart);
24720  };
24721
24722  var SplitText = function () {
24723    function SplitText(element, vars) {
24724      _coreInitted$l || _initCore$l();
24725      this.elements = _toArray$a(element);
24726      this.chars = [];
24727      this.words = [];
24728      this.lines = [];
24729      this._originals = [];
24730      this.vars = vars || {};
24731
24732      _context$8(this);
24733
24734       this.split(vars);
24735    }
24736
24737    var _proto = SplitText.prototype;
24738
24739    _proto.split = function split(vars) {
24740      this.isSplit && this.revert();
24741      this.vars = vars = vars || this.vars;
24742      this._originals.length = this.chars.length = this.words.length = this.lines.length = 0;
24743
24744      var i = this.elements.length,
24745          tag = vars.tag ? vars.tag : vars.span ? "span" : "div",
24746          wordStart = _cssClassFunc(vars.wordsClass, tag),
24747          charStart = _cssClassFunc(vars.charsClass, tag),
24748          origHeight,
24749          origWidth,
24750          e;
24751
24752      while (--i > -1) {
24753        e = this.elements[i];
24754        this._originals[i] = {
24755          html: e.innerHTML,
24756          style: e.getAttribute("style")
24757        };
24758        origHeight = e.clientHeight;
24759        origWidth = e.clientWidth;
24760
24761        _split(e, vars, wordStart, charStart);
24762
24763        _setPositionsAfterSplit(e, vars, this.chars, this.words, this.lines, origWidth, origHeight);
24764      }
24765
24766      this.chars.reverse();
24767      this.words.reverse();
24768      this.lines.reverse();
24769      this.isSplit = true;
24770      return this;
24771    };
24772
24773    _proto.revert = function revert() {
24774      var originals = this._originals;
24775
24776      if (!originals) {
24777        throw "revert() call wasn't scoped properly.";
24778      }
24779
24780      this.elements.forEach(function (e, i) {
24781        e.innerHTML = originals[i].html;
24782        e.setAttribute("style", originals[i].style);
24783      });
24784      this.chars = [];
24785      this.words = [];
24786      this.lines = [];
24787      this.isSplit = false;
24788      return this;
24789    };
24790
24791    SplitText.create = function create(element, vars) {
24792      return new SplitText(element, vars);
24793    };
24794
24795    return SplitText;
24796  }();
24797  SplitText.version = "3.12.5";
24798  SplitText.register = _initCore$l;
24799
24800  var gsapWithCSS = gsap.registerPlugin(CSSPlugin) || gsap,
24801      TweenMaxWithCSS = gsapWithCSS.core.Tween;
24802
24803  exports.Back = Back;
24804  exports.Bounce = Bounce;
24805  exports.CSSPlugin = CSSPlugin;
24806  exports.CSSRulePlugin = CSSRulePlugin;
24807  exports.Circ = Circ;
24808  exports.Cubic = Cubic;
24809  exports.CustomBounce = CustomBounce;
24810  exports.CustomEase = CustomEase;
24811  exports.CustomWiggle = CustomWiggle;
24812  exports.Draggable = Draggable;
24813  exports.DrawSVGPlugin = DrawSVGPlugin;
24814  exports.EasePack = EasePack;
24815  exports.EaselPlugin = EaselPlugin;
24816  exports.Elastic = Elastic;
24817  exports.Expo = Expo;
24818  exports.ExpoScaleEase = ExpoScaleEase;
24819  exports.Flip = Flip;
24820  exports.GSDevTools = GSDevTools;
24821  exports.InertiaPlugin = InertiaPlugin$1;
24822  exports.Linear = Linear;
24823  exports.MorphSVGPlugin = MorphSVGPlugin;
24824  exports.MotionPathHelper = MotionPathHelper;
24825  exports.MotionPathPlugin = MotionPathPlugin;
24826  exports.Observer = Observer;
24827  exports.Physics2DPlugin = Physics2DPlugin;
24828  exports.PhysicsPropsPlugin = PhysicsPropsPlugin;
24829  exports.PixiPlugin = PixiPlugin;
24830  exports.Power0 = Power0;
24831  exports.Power1 = Power1;
24832  exports.Power2 = Power2;
24833  exports.Power3 = Power3;
24834  exports.Power4 = Power4;
24835  exports.Quad = Quad;
24836  exports.Quart = Quart;
24837  exports.Quint = Quint;
24838  exports.RoughEase = RoughEase;
24839  exports.ScrambleTextPlugin = ScrambleTextPlugin;
24840  exports.ScrollSmoother = ScrollSmoother;
24841  exports.ScrollToPlugin = ScrollToPlugin;
24842  exports.ScrollTrigger = ScrollTrigger$2;
24843  exports.Sine = Sine;
24844  exports.SlowMo = SlowMo;
24845  exports.SplitText = SplitText;
24846  exports.SteppedEase = SteppedEase;
24847  exports.Strong = Strong;
24848  exports.TextPlugin = TextPlugin;
24849  exports.TimelineLite = Timeline;
24850  exports.TimelineMax = Timeline;
24851  exports.TweenLite = Tween;
24852  exports.TweenMax = TweenMaxWithCSS;
24853  exports.VelocityTracker = VelocityTracker;
24854  exports._getProxyProp = _getProxyProp;
24855  exports._getScrollFunc = _getScrollFunc;
24856  exports._getTarget = _getTarget;
24857  exports._getVelocityProp = _getVelocityProp;
24858  exports._horizontal = _horizontal;
24859  exports._isViewport = _isViewport;
24860  exports._vertical = _vertical;
24861  exports.clamp = clamp;
24862  exports.default = gsapWithCSS;
24863  exports.distribute = distribute;
24864  exports.getUnit = getUnit;
24865  exports.gsap = gsapWithCSS;
24866  exports.interpolate = interpolate;
24867  exports.mapRange = mapRange;
24868  exports.normalize = normalize;
24869  exports.pipe = pipe;
24870  exports.random = random;
24871  exports.selector = selector;
24872  exports.shuffle = shuffle;
24873  exports.snap = snap;
24874  exports.splitColor = splitColor;
24875  exports.toArray = toArray;
24876  exports.unitize = unitize;
24877  exports.wrap = wrap;
24878  exports.wrapYoyo = wrapYoyo;
24879
24880  Object.defineProperty(exports, '__esModule', { value: true });
24881
24882})));

Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.