https://www.suchard.es/dist/main.js?v=20260910-approved-content

1/******/ (() => { // webpackBootstrap
2/******/ 	"use strict";
3/******/ 	var __webpack_modules__ = ({
4
5/***/ "./node_modules/gsap/CSSPlugin.js"
6/*!****************************************!*\
7  !*** ./node_modules/gsap/CSSPlugin.js ***!
8  \****************************************/
9(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
10
11__webpack_require__.r(__webpack_exports__);
12/* harmony export */ __webpack_require__.d(__webpack_exports__, {
13/* harmony export */   CSSPlugin: () => (/* binding */ CSSPlugin),
14/* harmony export */   _createElement: () => (/* binding */ _createElement),
15/* harmony export */   _getBBox: () => (/* binding */ _getBBox),
16/* harmony export */   checkPrefix: () => (/* binding */ _checkPropPrefix),
17/* harmony export */   "default": () => (/* binding */ CSSPlugin)
18/* harmony export */ });
19/* harmony import */ var _gsap_core_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./gsap-core.js */ "./node_modules/gsap/gsap-core.js");
20/*!
21 * CSSPlugin 3.15.0
22 * https://gsap.com
23 *
24 * Copyright 2008-2026, GreenSock. All rights reserved.
25 * Subject to the terms at https://gsap.com/standard-license
26 * @author: Jack Doyle, [email protected]
27*/
28
29/* eslint-disable */
30
31
32var _win,
33    _doc,
34    _docElement,
35    _pluginInitted,
36    _tempDiv,
37    _tempDivStyler,
38    _recentSetterPlugin,
39    _reverting,
40    _windowExists = function _windowExists() {
41  return typeof window !== "undefined";
42},
43    _transformProps = {},
44    _RAD2DEG = 180 / Math.PI,
45    _DEG2RAD = Math.PI / 180,
46    _atan2 = Math.atan2,
47    _bigNum = 1e8,
48    _capsExp = /([A-Z])/g,
49    _horizontalExp = /(left|right|width|margin|padding|x)/i,
50    _complexExp = /[\s,\(]\S/,
51    _propertyAliases = {
52  autoAlpha: "opacity,visibility",
53  scale: "scaleX,scaleY",
54  alpha: "opacity"
55},
56    _renderCSSProp = function _renderCSSProp(ratio, data) {
57  return data.set(data.t, data.p, Math.round((data.s + data.c * ratio) * 10000) / 10000 + data.u, data);
58},
59    _renderPropWithEnd = function _renderPropWithEnd(ratio, data) {
60  return data.set(data.t, data.p, ratio === 1 ? data.e : Math.round((data.s + data.c * ratio) * 10000) / 10000 + data.u, data);
61},
62    _renderCSSPropWithBeginning = function _renderCSSPropWithBeginning(ratio, data) {
63  return data.set(data.t, data.p, ratio ? Math.round((data.s + data.c * ratio) * 10000) / 10000 + data.u : data.b, data);
64},
65    //if units change, we need a way to render the original unit/value when the tween goes all the way back to the beginning (ratio:0)
66_renderCSSPropWithBeginningAndEnd = function _renderCSSPropWithBeginningAndEnd(ratio, data) {
67  return data.set(data.t, data.p, ratio === 1 ? data.e : ratio ? Math.round((data.s + data.c * ratio) * 10000) / 10000 + data.u : data.b, data);
68},
69    //if units change, we need a way to render the original unit/value when the tween goes all the way back to the beginning (ratio:0)
70_renderRoundedCSSProp = function _renderRoundedCSSProp(ratio, data) {
71  var value = data.s + data.c * ratio;
72  data.set(data.t, data.p, ~~(value + (value < 0 ? -.5 : .5)) + data.u, data);
73},
74    _renderNonTweeningValue = function _renderNonTweeningValue(ratio, data) {
75  return data.set(data.t, data.p, ratio ? data.e : data.b, data);
76},
77    _renderNonTweeningValueOnlyAtEnd = function _renderNonTweeningValueOnlyAtEnd(ratio, data) {
78  return data.set(data.t, data.p, ratio !== 1 ? data.b : data.e, data);
79},
80    _setterCSSStyle = function _setterCSSStyle(target, property, value) {
81  return target.style[property] = value;
82},
83    _setterCSSProp = function _setterCSSProp(target, property, value) {
84  return target.style.setProperty(property, value);
85},
86    _setterTransform = function _setterTransform(target, property, value) {
87  return target._gsap[property] = value;
88},
89    _setterScale = function _setterScale(target, property, value) {
90  return target._gsap.scaleX = target._gsap.scaleY = value;
91},
92    _setterScaleWithRender = function _setterScaleWithRender(target, property, value, data, ratio) {
93  var cache = target._gsap;
94  cache.scaleX = cache.scaleY = value;
95  cache.renderTransform(ratio, cache);
96},
97    _setterTransformWithRender = function _setterTransformWithRender(target, property, value, data, ratio) {
98  var cache = target._gsap;
99  cache[property] = value;
100  cache.renderTransform(ratio, cache);
101},
102    _transformProp = "transform",
103    _transformOriginProp = _transformProp + "Origin",
104    _saveStyle = function _saveStyle(property, isNotCSS) {
105  var _this = this;
106
107  var target = this.target,
108      style = target.style,
109      cache = target._gsap;
110
111  if (property in _transformProps && style) {
112    this.tfm = this.tfm || {};
113
114    if (property !== "transform") {
115      property = _propertyAliases[property] || property;
116      ~property.indexOf(",") ? property.split(",").forEach(function (a) {
117        return _this.tfm[a] = _get(target, a);
118      }) : this.tfm[property] = cache.x ? cache[property] : _get(target, property); // note: scale would map to "scaleX,scaleY", thus we loop and apply them both.
119
120      property === _transformOriginProp && (this.tfm.zOrigin = cache.zOrigin);
121    } else {
122      return _propertyAliases.transform.split(",").forEach(function (p) {
123        return _saveStyle.call(_this, p, isNotCSS);
124      });
125    }
126
127    if (this.props.indexOf(_transformProp) >= 0) {
128      return;
129    }
130
131    if (cache.svg) {
132      this.svgo = target.getAttribute("data-svg-origin");
133      this.props.push(_transformOriginProp, isNotCSS, "");
134    }
135
136    property = _transformProp;
137  }
138
139  (style || isNotCSS) && this.props.push(property, isNotCSS, style[property]);
140},
141    _removeIndependentTransforms = function _removeIndependentTransforms(style) {
142  if (style.translate) {
143    style.removeProperty("translate");
144    style.removeProperty("scale");
145    style.removeProperty("rotate");
146  }
147},
148    _revertStyle = function _revertStyle() {
149  var props = this.props,
150      target = this.target,
151      style = target.style,
152      cache = target._gsap,
153      i,
154      p;
155
156  for (i = 0; i < props.length; i += 3) {
157    // stored like this: property, isNotCSS, value
158    if (!props[i + 1]) {
159      props[i + 2] ? style[props[i]] = props[i + 2] : style.removeProperty(props[i].substr(0, 2) === "--" ? props[i] : props[i].replace(_capsExp, "-$1").toLowerCase());
160    } else if (props[i + 1] === 2) {
161      // non-CSS value (function-based)
162      target[props[i]](props[i + 2]);
163    } else {
164      // non-CSS value (not function-based)
165      target[props[i]] = props[i + 2];
166    }
167  }
168
169  if (this.tfm) {
170    for (p in this.tfm) {
171      cache[p] = this.tfm[p];
172    }
173
174    if (cache.svg) {
175      cache.renderTransform();
176      target.setAttribute("data-svg-origin", this.svgo || "");
177    }
178
179    i = _reverting();
180
181    if ((!i || !i.isStart) && !style[_transformProp]) {
182      _removeIndependentTransforms(style);
183
184      if (cache.zOrigin && style[_transformOriginProp]) {
185        style[_transformOriginProp] += " " + cache.zOrigin + "px"; // since we're uncaching, we must put the zOrigin back into the transformOrigin so that we can pull it out accurately when we parse again. Otherwise, we'd lose the z portion of the origin since we extract it to protect from Safari bugs.
186
187        cache.zOrigin = 0;
188        cache.renderTransform();
189      }
190
191      cache.uncache = 1; // if it's a startAt that's being reverted in the _initTween() of the core, we don't need to uncache transforms. This is purely a performance optimization.
192    }
193  }
194},
195    _getStyleSaver = function _getStyleSaver(target, properties) {
196  var saver = {
197    target: target,
198    props: [],
199    revert: _revertStyle,
200    save: _saveStyle
201  };
202  target._gsap || _gsap_core_js__WEBPACK_IMPORTED_MODULE_0__.gsap.core.getCache(target); // just make sure there's a _gsap cache defined because we read from it in _saveStyle() and it's more efficient to just check it here once.
203
204  properties && target.style && target.nodeType && properties.split(",").forEach(function (p) {
205    return saver.save(p);
206  }); // make sure it's a DOM node too.
207
208  return saver;
209},
210    _supports3D,
211    _createElement = function _createElement(type, ns) {
212  var e = _doc.createElementNS ? _doc.createElementNS((ns || "http://www.w3.org/1999/xhtml").replace(/^https/, "http"), type) : _doc.createElement(type); //some servers swap in https for http in the namespace which can break things, making "style" inaccessible.
213
214  return e && e.style ? e : _doc.createElement(type); //some environments won't allow access to the element's style when created with a namespace in which case we default to the standard createElement() to work around the issue. Also note that when GSAP is embedded directly inside an SVG file, createElement() won't allow access to the style object in Firefox (see https://gsap.com/forums/topic/20215-problem-using-tweenmax-in-standalone-self-containing-svg-file-err-cannot-set-property-csstext-of-undefined/).
215},
216    _getComputedProperty = function _getComputedProperty(target, property, skipPrefixFallback) {
217  var cs = getComputedStyle(target);
218  return cs[property] || cs.getPropertyValue(property.replace(_capsExp, "-$1").toLowerCase()) || cs.getPropertyValue(property) || !skipPrefixFallback && _getComputedProperty(target, _checkPropPrefix(property) || property, 1) || ""; //css variables may not need caps swapped out for dashes and lowercase.
219},
220    _prefixes = "O,Moz,ms,Ms,Webkit".split(","),
221    _checkPropPrefix = function _checkPropPrefix(property, element, preferPrefix) {
222  var e = element || _tempDiv,
223      s = e.style,
224      i = 5;
225
226  if (property in s && !preferPrefix) {
227    return property;
228  }
229
230  property = property.charAt(0).toUpperCase() + property.substr(1);
231
232  while (i-- && !(_prefixes[i] + property in s)) {}
233
234  return i < 0 ? null : (i === 3 ? "ms" : i >= 0 ? _prefixes[i] : "") + property;
235},
236    _initCore = function _initCore() {
237  if (_windowExists() && window.document) {
238    _win = window;
239    _doc = _win.document;
240    _docElement = _doc.documentElement;
241    _tempDiv = _createElement("div") || {
242      style: {}
243    };
244    _tempDivStyler = _createElement("div");
245    _transformProp = _checkPropPrefix(_transformProp);
246    _transformOriginProp = _transformProp + "Origin";
247    _tempDiv.style.cssText = "border-width:0;line-height:0;position:absolute;padding:0"; //make sure to override certain properties that may contaminate measurements, in case the user has overreaching style sheets.
248
249    _supports3D = !!_checkPropPrefix("perspective");
250    _reverting = _gsap_core_js__WEBPACK_IMPORTED_MODULE_0__.gsap.core.reverting;
251    _pluginInitted = 1;
252  }
253},
254    _getReparentedCloneBBox = function _getReparentedCloneBBox(target) {
255  //works around issues in some browsers (like Firefox) that don't correctly report getBBox() on SVG elements inside a <defs> element and/or <mask>. We try creating an SVG, adding it to the documentElement and toss the element in there so that it's definitely part of the rendering tree, then grab the bbox and if it works, we actually swap out the original getBBox() method for our own that does these extra steps whenever getBBox is needed. This helps ensure that performance is optimal (only do all these extra steps when absolutely necessary...most elements don't need it).
256  var owner = target.ownerSVGElement,
257      svg = _createElement("svg", owner && owner.getAttribute("xmlns") || "http://www.w3.org/2000/svg"),
258      clone = target.cloneNode(true),
259      bbox;
260
261  clone.style.display = "block";
262  svg.appendChild(clone);
263
264  _docElement.appendChild(svg);
265
266  try {
267    bbox = clone.getBBox();
268  } catch (e) {}
269
270  svg.removeChild(clone);
271
272  _docElement.removeChild(svg);
273
274  return bbox;
275},
276    _getAttributeFallbacks = function _getAttributeFallbacks(target, attributesArray) {
277  var i = attributesArray.length;
278
279  while (i--) {
280    if (target.hasAttribute(attributesArray[i])) {
281      return target.getAttribute(attributesArray[i]);
282    }
283  }
284},
285    _getBBox = function _getBBox(target) {
286  var bounds, cloned;
287
288  try {
289    bounds = target.getBBox(); //Firefox throws errors if you try calling getBBox() on an SVG element that's not rendered (like in a <symbol> or <defs>). https://bugzilla.mozilla.org/show_bug.cgi?id=612118
290  } catch (error) {
291    bounds = _getReparentedCloneBBox(target);
292    cloned = 1;
293  }
294
295  bounds && (bounds.width || bounds.height) || cloned || (bounds = _getReparentedCloneBBox(target)); //some browsers (like Firefox) misreport the bounds if the element has zero width and height (it just assumes it's at x:0, y:0), thus we need to manually grab the position in that case.
296
297  return bounds && !bounds.width && !bounds.x && !bounds.y ? {
298    x: +_getAttributeFallbacks(target, ["x", "cx", "x1"]) || 0,
299    y: +_getAttributeFallbacks(target, ["y", "cy", "y1"]) || 0,
300    width: 0,
301    height: 0
302  } : bounds;
303},
304    _isSVG = function _isSVG(e) {
305  return !!(e.getCTM && (!e.parentNode || e.ownerSVGElement) && _getBBox(e));
306},
307    //reports if the element is an SVG on which getBBox() actually works
308_removeProperty = function _removeProperty(target, property) {
309  if (property) {
310    var style = target.style,
311        first2Chars;
312
313    if (property in _transformProps && property !== _transformOriginProp) {
314      property = _transformProp;
315    }
316
317    if (style.removeProperty) {
318      first2Chars = property.substr(0, 2);
319
320      if (first2Chars === "ms" || property.substr(0, 6) === "webkit") {
321        //Microsoft and some Webkit browsers don't conform to the standard of capitalizing the first prefix character, so we adjust so that when we prefix the caps with a dash, it's correct (otherwise it'd be "ms-transform" instead of "-ms-transform" for IE9, for example)
322        property = "-" + property;
323      }
324
325      style.removeProperty(first2Chars === "--" ? property : property.replace(_capsExp, "-$1").toLowerCase());
326    } else {
327      //note: old versions of IE use "removeAttribute()" instead of "removeProperty()"
328      style.removeAttribute(property);
329    }
330  }
331},
332    _addNonTweeningPT = function _addNonTweeningPT(plugin, target, property, beginning, end, onlySetAtEnd) {
333  var pt = new _gsap_core_js__WEBPACK_IMPORTED_MODULE_0__.PropTween(plugin._pt, target, property, 0, 1, onlySetAtEnd ? _renderNonTweeningValueOnlyAtEnd : _renderNonTweeningValue);
334  plugin._pt = pt;
335  pt.b = beginning;
336  pt.e = end;
337
338  plugin._props.push(property);
339
340  return pt;
341},
342    _nonConvertibleUnits = {
343  deg: 1,
344  rad: 1,
345  turn: 1
346},
347    _nonStandardLayouts = {
348  grid: 1,
349  flex: 1
350},
351    //takes a single value like 20px and converts it to the unit specified, like "%", returning only the numeric amount.
352_convertToUnit = function _convertToUnit(target, property, value, unit) {
353  var curValue = parseFloat(value) || 0,
354      curUnit = (value + "").trim().substr((curValue + "").length) || "px",
355      // some browsers leave extra whitespace at the beginning of CSS variables, hence the need to trim()
356  style = _tempDiv.style,
357      horizontal = _horizontalExp.test(property),
358      isRootSVG = target.tagName.toLowerCase() === "svg",
359      measureProperty = (isRootSVG ? "client" : "offset") + (horizontal ? "Width" : "Height"),
360      amount = 100,
361      toPixels = unit === "px",
362      toPercent = unit === "%",
363      px,
364      parent,
365      cache,
366      isSVG;
367
368  if (unit === curUnit || !curValue || _nonConvertibleUnits[unit] || _nonConvertibleUnits[curUnit]) {
369    return curValue;
370  }
371
372  curUnit !== "px" && !toPixels && (curValue = _convertToUnit(target, property, value, "px"));
373  isSVG = target.getCTM && _isSVG(target);
374
375  if ((toPercent || curUnit === "%") && (_transformProps[property] || ~property.indexOf("adius"))) {
376    px = isSVG ? target.getBBox()[horizontal ? "width" : "height"] : target[measureProperty];
377    return (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._round)(toPercent ? curValue / px * amount : curValue / 100 * px);
378  }
379
380  style[horizontal ? "width" : "height"] = amount + (toPixels ? curUnit : unit);
381  parent = unit !== "rem" && ~property.indexOf("adius") || unit === "em" && target.appendChild && !isRootSVG ? target : target.parentNode;
382
383  if (isSVG) {
384    parent = (target.ownerSVGElement || {}).parentNode;
385  }
386
387  if (!parent || parent === _doc || !parent.appendChild) {
388    parent = _doc.body;
389  }
390
391  cache = parent._gsap;
392
393  if (cache && toPercent && cache.width && horizontal && cache.time === _gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._ticker.time && !cache.uncache) {
394    return (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._round)(curValue / cache.width * amount);
395  } else {
396    if (toPercent && (property === "height" || property === "width")) {
397      // if we're dealing with width/height that's inside a container with padding and/or it's a flexbox/grid container, we must apply it to the target itself rather than the _tempDiv in order to ensure complete accuracy, factoring in the parent's padding.
398      var v = target.style[property];
399      target.style[property] = amount + unit;
400      px = target[measureProperty];
401      v ? target.style[property] = v : _removeProperty(target, property);
402    } else {
403      (toPercent || curUnit === "%") && !_nonStandardLayouts[_getComputedProperty(parent, "display")] && (style.position = _getComputedProperty(target, "position"));
404      parent === target && (style.position = "static"); // like for borderRadius, if it's a % we must have it relative to the target itself but that may not have position: relative or position: absolute in which case it'd go up the chain until it finds its offsetParent (bad). position: static protects against that.
405
406      parent.appendChild(_tempDiv);
407      px = _tempDiv[measureProperty];
408      parent.removeChild(_tempDiv);
409      style.position = "absolute";
410    }
411
412    if (horizontal && toPercent) {
413      cache = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._getCache)(parent);
414      cache.time = _gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._ticker.time;
415      cache.width = parent[measureProperty];
416    }
417  }
418
419  return (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._round)(toPixels ? px * curValue / amount : px && curValue ? amount / px * curValue : 0);
420},
421    _get = function _get(target, property, unit, uncache) {
422  var value;
423  _pluginInitted || _initCore();
424
425  if (property in _propertyAliases && property !== "transform") {
426    property = _propertyAliases[property];
427
428    if (~property.indexOf(",")) {
429      property = property.split(",")[0];
430    }
431  }
432
433  if (_transformProps[property] && property !== "transform") {
434    value = _parseTransform(target, uncache);
435    value = property !== "transformOrigin" ? value[property] : value.svg ? value.origin : _firstTwoOnly(_getComputedProperty(target, _transformOriginProp)) + " " + value.zOrigin + "px";
436  } else {
437    value = target.style[property];
438
439    if (!value || value === "auto" || uncache || ~(value + "").indexOf("calc(")) {
440      value = _specialProps[property] && _specialProps[property](target, property, unit) || _getComputedProperty(target, property) || (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._getProperty)(target, property) || (property === "opacity" ? 1 : 0); // note: some browsers, like Firefox, don't report borderRadius correctly! Instead, it only reports every corner like  borderTopLeftRadius
441    }
442  }
443
444  return unit && !~(value + "").trim().indexOf(" ") ? _convertToUnit(target, property, value, unit) + unit : value;
445},
446    _tweenComplexCSSString = function _tweenComplexCSSString(target, prop, start, end) {
447  // note: we call _tweenComplexCSSString.call(pluginInstance...) to ensure that it's scoped properly. We may call it from within a plugin too, thus "this" would refer to the plugin.
448  if (!start || start === "none") {
449    // some browsers like Safari actually PREFER the prefixed property and mis-report the unprefixed value like clipPath (BUG). In other words, even though clipPath exists in the style ("clipPath" in target.style) and it's set in the CSS properly (along with -webkit-clip-path), Safari reports clipPath as "none" whereas WebkitClipPath reports accurately like "ellipse(100% 0% at 50% 0%)", so in this case we must SWITCH to using the prefixed property instead. See https://gsap.com/forums/topic/18310-clippath-doesnt-work-on-ios/
450    var p = _checkPropPrefix(prop, target, 1),
451        s = p && _getComputedProperty(target, p, 1);
452
453    if (s && s !== start) {
454      prop = p;
455      start = s;
456    } else if (prop === "borderColor") {
457      start = _getComputedProperty(target, "borderTopColor"); // Firefox bug: always reports "borderColor" as "", so we must fall back to borderTopColor. See https://gsap.com/forums/topic/24583-how-to-return-colors-that-i-had-after-reverse/
458    }
459  }
460
461  var pt = new _gsap_core_js__WEBPACK_IMPORTED_MODULE_0__.PropTween(this._pt, target.style, prop, 0, 1, _gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._renderComplexString),
462      index = 0,
463      matchIndex = 0,
464      a,
465      result,
466      startValues,
467      startNum,
468      color,
469      startValue,
470      endValue,
471      endNum,
472      chunk,
473      endUnit,
474      startUnit,
475      endValues;
476  pt.b = start;
477  pt.e = end;
478  start += ""; // ensure values are strings
479
480  end += "";
481
482  if (end.substring(0, 6) === "var(--") {
483    end = _getComputedProperty(target, end.substring(4, end.indexOf(")")));
484  }
485
486  if (end === "auto") {
487    startValue = target.style[prop];
488    target.style[prop] = end;
489    end = _getComputedProperty(target, prop) || end;
490    startValue ? target.style[prop] = startValue : _removeProperty(target, prop);
491  }
492
493  a = [start, end];
494
495  (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._colorStringFilter)(a); // pass an array with the starting and ending values and let the filter do whatever it needs to the values. If colors are found, it returns true and then we must match where the color shows up order-wise because for things like boxShadow, sometimes the browser provides the computed values with the color FIRST, but the user provides it with the color LAST, so flip them if necessary. Same for drop-shadow().
496
497
498  start = a[0];
499  end = a[1];
500  startValues = start.match(_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._numWithUnitExp) || [];
501  endValues = end.match(_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._numWithUnitExp) || [];
502
503  if (endValues.length) {
504    while (result = _gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._numWithUnitExp.exec(end)) {
505      endValue = result[0];
506      chunk = end.substring(index, result.index);
507
508      if (color) {
509        color = (color + 1) % 5;
510      } else if (chunk.substr(-5) === "rgba(" || chunk.substr(-5) === "hsla(") {
511        color = 1;
512      }
513
514      if (endValue !== (startValue = startValues[matchIndex++] || "")) {
515        startNum = parseFloat(startValue) || 0;
516        startUnit = startValue.substr((startNum + "").length);
517        endValue.charAt(1) === "=" && (endValue = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._parseRelative)(startNum, endValue) + startUnit);
518        endNum = parseFloat(endValue);
519        endUnit = endValue.substr((endNum + "").length);
520        index = _gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._numWithUnitExp.lastIndex - endUnit.length;
521
522        if (!endUnit) {
523          //if something like "perspective:300" is passed in and we must add a unit to the end
524          endUnit = endUnit || _gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._config.units[prop] || startUnit;
525
526          if (index === end.length) {
527            end += endUnit;
528            pt.e += endUnit;
529          }
530        }
531
532        if (startUnit !== endUnit) {
533          startNum = _convertToUnit(target, prop, startValue, endUnit) || 0;
534        } // these nested PropTweens are handled in a special way - we'll never actually call a render or setter method on them. We'll just loop through them in the parent complex string PropTween's render method.
535
536
537        pt._pt = {
538          _next: pt._pt,
539          p: chunk || matchIndex === 1 ? chunk : ",",
540          //note: SVG spec allows omission of comma/space when a negative sign is wedged between two numbers, like 2.5-5.3 instead of 2.5,-5.3 but when tweening, the negative value may switch to positive, so we insert the comma just in case.
541          s: startNum,
542          c: endNum - startNum,
543          m: color && color < 4 || prop === "zIndex" ? Math.round : 0
544        };
545      }
546    }
547
548    pt.c = index < end.length ? end.substring(index, end.length) : ""; //we use the "c" of the PropTween to store the final part of the string (after the last number)
549  } else {
550    pt.r = prop === "display" && end === "none" ? _renderNonTweeningValueOnlyAtEnd : _renderNonTweeningValue;
551  }
552
553  _gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._relExp.test(end) && (pt.e = 0); //if the end string contains relative values or dynamic random(...) values, delete the end it so that on the final render we don't actually set it to the string with += or -= characters (forces it to use the calculated value).
554
555  this._pt = pt; //start the linked list with this new PropTween. Remember, we call _tweenComplexCSSString.call(pluginInstance...) to ensure that it's scoped properly. We may call it from within another plugin too, thus "this" would refer to the plugin.
556
557  return pt;
558},
559    _keywordToPercent = {
560  top: "0%",
561  bottom: "100%",
562  left: "0%",
563  right: "100%",
564  center: "50%"
565},
566    _convertKeywordsToPercentages = function _convertKeywordsToPercentages(value) {
567  var split = value.split(" "),
568      x = split[0],
569      y = split[1] || "50%";
570
571  if (x === "top" || x === "bottom" || y === "left" || y === "right") {
572    //the user provided them in the wrong order, so flip them
573    value = x;
574    x = y;
575    y = value;
576  }
577
578  split[0] = _keywordToPercent[x] || x;
579  split[1] = _keywordToPercent[y] || y;
580  return split.join(" ");
581},
582    _renderClearProps = function _renderClearProps(ratio, data) {
583  if (data.tween && data.tween._time === data.tween._dur) {
584    var target = data.t,
585        style = target.style,
586        props = data.u,
587        cache = target._gsap,
588        prop,
589        clearTransforms,
590        i;
591
592    if (props === "all" || props === true) {
593      style.cssText = "";
594      clearTransforms = 1;
595    } else {
596      props = props.split(",");
597      i = props.length;
598
599      while (--i > -1) {
600        prop = props[i];
601
602        if (_transformProps[prop]) {
603          clearTransforms = 1;
604          prop = prop === "transformOrigin" ? _transformOriginProp : _transformProp;
605        }
606
607        _removeProperty(target, prop);
608      }
609    }
610
611    if (clearTransforms) {
612      _removeProperty(target, _transformProp);
613
614      if (cache) {
615        cache.svg && target.removeAttribute("transform");
616        style.scale = style.rotate = style.translate = "none";
617
618        _parseTransform(target, 1); // force all the cached values back to "normal"/identity, otherwise if there's another tween that's already set to render transforms on this element, it could display the wrong values.
619
620
621        cache.uncache = 1;
622
623        _removeIndependentTransforms(style);
624      }
625    }
626  }
627},
628    // note: specialProps should return 1 if (and only if) they have a non-zero priority. It indicates we need to sort the linked list.
629_specialProps = {
630  clearProps: function clearProps(plugin, target, property, endValue, tween) {
631    if (tween.data !== "isFromStart") {
632      var pt = plugin._pt = new _gsap_core_js__WEBPACK_IMPORTED_MODULE_0__.

632PropTween(plugin._pt, target, property, 0, 0, _renderClearProps);
633      pt.u = endValue;
634      pt.pr = -10;
635      pt.tween = tween;
636
637      plugin._props.push(property);
638
639      return 1;
640    }
641  }
642  /* className feature (about 0.4kb gzipped).
643  , className(plugin, target, property, endValue, tween) {
644  	let _renderClassName = (ratio, data) => {
645  			data.css.render(ratio, data.css);
646  			if (!ratio || ratio === 1) {
647  				let inline = data.rmv,
648  					target = data.t,
649  					p;
650  				target.setAttribute("class", ratio ? data.e : data.b);
651  				for (p in inline) {
652  					_removeProperty(target, p);
653  				}
654  			}
655  		},
656  		_getAllStyles = (target) => {
657  			let styles = {},
658  				computed = getComputedStyle(target),
659  				p;
660  			for (p in computed) {
661  				if (isNaN(p) && p !== "cssText" && p !== "length") {
662  					styles[p] = computed[p];
663  				}
664  			}
665  			_setDefaults(styles, _parseTransform(target, 1));
666  			return styles;
667  		},
668  		startClassList = target.getAttribute("class"),
669  		style = target.style,
670  		cssText = style.cssText,
671  		cache = target._gsap,
672  		classPT = cache.classPT,
673  		inlineToRemoveAtEnd = {},
674  		data = {t:target, plugin:plugin, rmv:inlineToRemoveAtEnd, b:startClassList, e:(endValue.charAt(1) !== "=") ? endValue : startClassList.replace(new RegExp("(?:\\s|^)" + endValue.substr(2) + "(?![\\w-])"), "") + ((endValue.charAt(0) === "+") ? " " + endValue.substr(2) : "")},
675  		changingVars = {},
676  		startVars = _getAllStyles(target),
677  		transformRelated = /(transform|perspective)/i,
678  		endVars, p;
679  	if (classPT) {
680  		classPT.r(1, classPT.d);
681  		_removeLinkedListItem(classPT.d.plugin, classPT, "_pt");
682  	}
683  	target.setAttribute("class", data.e);
684  	endVars = _getAllStyles(target, true);
685  	target.setAttribute("class", startClassList);
686  	for (p in endVars) {
687  		if (endVars[p] !== startVars[p] && !transformRelated.test(p)) {
688  			changingVars[p] = endVars[p];
689  			if (!style[p] && style[p] !== "0") {
690  				inlineToRemoveAtEnd[p] = 1;
691  			}
692  		}
693  	}
694  	cache.classPT = plugin._pt = new PropTween(plugin._pt, target, "className", 0, 0, _renderClassName, data, 0, -11);
695  	if (style.cssText !== cssText) { //only apply if things change. Otherwise, in cases like a background-image that's pulled dynamically, it could cause a refresh. See https://gsap.com/forums/topic/20368-possible-gsap-bug-switching-classnames-in-chrome/.
696  		style.cssText = cssText; //we recorded cssText before we swapped classes and ran _getAllStyles() because in cases when a className tween is overwritten, we remove all the related tweening properties from that class change (otherwise class-specific stuff can't override properties we've directly set on the target's style object due to specificity).
697  	}
698  	_parseTransform(target, true); //to clear the caching of transforms
699  	data.css = new gsap.plugins.css();
700  	data.css.init(target, changingVars, tween);
701  	plugin._props.push(...data.css._props);
702  	return 1;
703  }
704  */
705
706},
707
708/*
709 * --------------------------------------------------------------------------------------
710 * TRANSFORMS
711 * --------------------------------------------------------------------------------------
712 */
713_identity2DMatrix = [1, 0, 0, 1, 0, 0],
714    _rotationalProperties = {},
715    _isNullTransform = function _isNullTransform(value) {
716  return value === "matrix(1, 0, 0, 1, 0, 0)" || value === "none" || !value;
717},
718    _getComputedTransformMatrixAsArray = function _getComputedTransformMatrixAsArray(target) {
719  var matrixString = _getComputedProperty(target, _transformProp);
720
721  return _isNullTransform(matrixString) ? _identity2DMatrix : matrixString.substr(7).match(_

721gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._numExp).map(_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._round);
722},
723    _getMatrix = function _getMatrix(target, force2D) {
724  var cache = target._gsap || (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._getCache)(target),
725      style = target.style,
726      matrix = _getComputedTransformMatrixAsArray(target),
727      parent,
728      nextSibling,
729      temp,
730      addedToDOM;
731
732  if (cache.svg && target.getAttribute("transform")) {
733    temp = target.transform.baseVal.consolidate().matrix; //ensures that even complex values like "translate(50,60) rotate(135,0,0)" are parsed because it mashes it into a matrix.
734
735    matrix = [temp.a, temp.b, temp.c, temp.d, temp.e, temp.f];
736    return matrix.join(",") === "1,0,0,1,0,0" ? _identity2DMatrix : matrix;
737  } else if (matrix === _identity2DMatrix && !target.offsetParent && target !== _docElement && !cache.svg) {
738    //note: if offsetParent is null, that means the element isn't in the normal document flow, like if it has display:none or one of its ancestors has display:none). Firefox returns null for getComputedStyle() if the element is in an iframe that has display:none. https://bugzilla.mozilla.org/show_bug.cgi?id=548397
739    //browsers don't report transforms accurately unless the element is in the DOM and has a display value that's not "none". Firefox and Microsoft browsers have a partial bug where they'll report transforms even if display:none BUT not any percentage-based values like translate(-50%, 8px) will be reported as if it's translate(0, 8px).
740    temp = style.display;
741    style.display = "block";
742    parent = target.parentNode;
743
744    if (!parent || !target.offsetParent && !target.getBoundingClientRect().width) {
745      // note: in 3.3.0 we switched target.offsetParent to _doc.body.contains(target) to avoid [sometimes unnecessary] MutationObserver calls but that wasn't adequate because there are edge cases where nested position: fixed elements need to get reparented to accurately sense transforms. See https://github.com/greensock/GSAP/issues/388 and https://github.com/greensock/GSAP/issues/375. Note: position: fixed elements report a null offsetParent but they could also be invisible because they're in an ancestor with display: none, so we check getBoundingClientRect(). We only want to alter the DOM if we absolutely have to because it can cause iframe content to reload, like a Vimeo video.
746      addedToDOM = 1; //flag
747
748      nextSibling = target.nextElementSibling;
749
750      _docElement.appendChild(target); //we must add it to the DOM in order to get values properly
751
752    }
753
754    matrix = _getComputedTransformMatrixAsArray(target);
755    temp ? style.display = temp : _removeProperty(target, "display");
756
757    if (addedToDOM) {
758      nextSibling ? parent.insertBefore(target, nextSibling) : parent ? parent.appendChild(target) : _docElement.removeChild(target);
759    }
760  }
761
762  return force2D && matrix.length > 6 ? [matrix[0], matrix[1], matrix[4], matrix[5], matrix[12], matrix[13]] : matrix;
763},
764    _applySVGOrigin = function _applySVGOrigin(target, origin, originIsAbsolute, smooth, matrixArray, pluginToAddPropTweensTo) {
765  var cache = target._gsap,
766      matrix = matrixArray || _getMatrix(target, true),
767      xOriginOld = cache.xOrigin || 0,
768      yOriginOld = cache.yOrigin || 0,
769      xOffsetOld = cache.xOffset || 0,
770      yOffsetOld = cache.yOffset || 0,
771      a = matrix[0],
772      b = matrix[1],
773      c = matrix[2],
774      d = matrix[3],
775      tx = matrix[4],
776      ty = matrix[5],
777      originSplit = origin.split(" "),
778      xOrigin = parseFloat(originSplit[0]) || 0,
779      yOrigin = parseFloat(originSplit[1]) || 0,
780      bounds,
781      determinant,
782      x,
783      y;
784
785  if (!originIsAbsolute) {
786    bounds = _getBBox(target);
787    xOrigin = bounds.x + (~originSplit[0].indexOf("%") ? xOrigin / 100 * boun

787ds.width : xOrigin);
788    yOrigin = bounds.y + (~(originSplit[1] || originSplit[0]).indexOf("%") ? yOrigin / 100 * bounds.height : yOrigin); // if (!("xOrigin" in cache) && (xOrigin || yOrigin)) { // added in 3.12.3, reverted in 3.12.4; requires more exploration
789    // 	xOrigin -= bounds.x;
790    // 	yOrigin -= bounds.y;
791    // }
792  } else if (matrix !== _identity2DMatrix && (determinant = a * d - b * c)) {
793    //if it's zero (like if scaleX and scaleY are zero), skip it to avoid errors with dividing by zero.
794    x = xOrigin * (d / determinant) + yOrigin * (-c / determinant) + (c * ty - d * tx) / determinant;
795    y = xOrigin * (-b / determinant) + yOrigin * (a / determinant) - (a * ty - b * tx) / determinant;
796    xOrigin = x;
797    yOrigin = y; // theory: we only had to do this for smoothing and it assumes that the previous one was not originIsAbsolute.
798  }
799
800  if (smooth || smooth !== false && cache.smooth) {
801    tx = xOrigin - xOriginOld;
802    ty = yOrigin - yOriginOld;
803    cache.xOffset = xOffsetOld + (tx * a + ty * c) - tx;
804    cache.yOffset = yOffsetOld + (tx * b + ty * d) - ty;
805  } else {
806    cache.xOffset = cache.yOffset = 0;
807  }
808
809  cache.xOrigin = xOrigin;
810  cache.yOrigin = yOrigin;
811  cache.smooth = !!smooth;
812  cache.origin = origin;
813  cache.originIsAbsolute = !!originIsAbsolute;
814  target.style[_transformOriginProp] = "0px 0px"; //otherwise, if someone sets  an origin via CSS, it will likely interfere with the SVG transform attribute ones (because remember, we're baking the origin into the matrix() value).
815
816  if (pluginToAddPropTweensTo) {
817    _addNonTweeningPT(pluginToAddPropTweensTo, cache, "xOrigin", xOriginOld, xOrigin);
818
819    _addNonTweeningPT(pluginToAddPropTweensTo, cache, "yOrigin", yOriginOld, yOrigin);
820
821    _addNonTweeningPT(pluginToAddPropTweensTo, cache, "xOffset", xOffsetOld, cache.xOffset);
822
823    _addNonTweeningPT(pluginToAddPropTweensTo, cache, "yOffset", yOffsetOld, cache.yOffset);
824  }
825
826  target.setAttribute("data-svg-origin", xOrigin + " " + yOrigin);
827},
828    _parseTransform = function _parseTransform(target, uncache) {
829  var cache = target._gsap || new _gsap_core_js__WEBPACK_IMPORTED_MODULE_0__.GSCache(target);
830
831  if ("x" in cache && !uncache && !cache.uncache) {
832    return cache;
833  }
834
835  var style = target.style,
836      invertedScaleX = cache.scaleX < 0,
837      px = "px",
838      deg = "deg",
839      cs = getComputedStyle(target),
840      origin = _getComputedProperty(target, _transformOriginProp) || "0",
841      x,
842      y,
843      z,
844      scaleX,
845      scaleY,
846      rotation,
847      rotationX,
848      rotationY,
849      skewX,
850      skewY,
851      perspective,
852      xOrigin,
853      yOrigin,
854      matrix,
855      angle,
856      cos,
857      sin,
858      a,
859      b,
860      c,
861      d,
862      a12,
863      a22,
864      t1,
865      t2,
866      t3,
867      a13,
868      a23,
869      a33,
870      a42,
871      a43,
872      a32;
873  x = y = z = rotation = rotationX = rotationY = skewX = skewY = perspective = 0;
874  scaleX = scaleY = 1;
875  cache.svg = !!(target.getCTM && _isSVG(target));
876
877  if (cs.translate) {
878    // accommodate independent transforms by combining them into normal ones.
879    if (cs.translate !== "none" || cs.scale !== "none" || cs.rotate !== "none") {
880      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] : "");
881    }
882
883    style.scale = style.rotate = style.translate = "none";
884  }
885
886  matrix = _getMatrix(target, cache.svg);
887
888  if (cache.svg) {
889    if (cache.uncache) {
890      // if cache.uncache is true (and maybe if origin is 0,0), we need to set element.style.transformOrigin = (cache.xOrigin - bbox.x) + "px " + (cache.yOrigin - bbox.y) + "px". Previously we let the data-svg-origin stay instead, but when introducing revert(), it complicated things.
891      t2 = target.getBBox();
892      origin = cache.xOrigin - t2.x + "px " + (cache.yOrigin - t2.y) + "px";
893      t1 = "";
894    } else {
895      t1 = !uncache && target.getAttribute("data-svg-origin"); //  Remember, to work around browser inconsistencies we always force SVG elements' transformOrigin to 0,0 and offset the translation accordingly.
896    }
897
898    _applySVGOrigin(target, t1 || origin, !!t1 || cache.originIsAbsolute, cache.smooth !== false, matrix);
899  }
900
901  xOrigin = cache.xOrigin || 0;
902  yOrigin = cache.yOrigin || 0;
903
904  if (matrix !== _identity2DMatrix) {
905    a = matrix[0]; //a11
906
907    b = matrix[1]; //a21
908
909    c = matrix[2]; //a31
910
911    d = matrix[3]; //a41
912
913    x = a12 = matrix[4];
914    y = a22 = matrix[5]; //2D matrix
915
916    if (matrix.length === 6) {
917      scaleX = Math.sqrt(a * a + b * b);
918      scaleY = Math.sqrt(d * d + c * c);
919      rotation = a || b ? _atan2(b, a) * _RAD2DEG : 0; //note: if scaleX is 0, we cannot accurately measure rotation. Same for skewX with a scaleY of 0. Therefore, we default to the previously recorded value (or zero if that doesn't exist).
920
921      skewX = c || d ? _atan2(c, d) * _RAD2DEG + rotation : 0;
922      skewX && (scaleY *= Math.abs(Math.cos(skewX * _DEG2RAD)));
923
924      if (cache.svg) {
925        x -= xOrigin - (xOrigin * a + yOrigin * c);
926        y -= yOrigin - (xOrigin * b + yOrigin * d);
927      } //3D matrix
928
929    } else {
930      a32 = matrix[6];
931      a42 = matrix[7];
932      a13 = matrix[8];
933      a23 = matrix[9];
934      a33 = matrix[10];
935      a43 = matrix[11];
936      x = matrix[12];
937      y = matrix[13];
938      z = matrix[14];
939      angle = _atan2(a32, a33);
940      rotationX = angle * _RAD2DEG; //rotationX
941
942      if (angle) {
943        cos = Math.cos(-angle);
944        sin = Math.sin(-angle);
945        t1 = a12 * cos + a13 * sin;
946        t2 = a22 * cos + a23 * sin;
947        t3 = a32 * cos + a33 * sin;
948        a13 = a12 * -sin + a13 * cos;
949        a23 = a22 * -sin + a23 * cos;
950        a33 = a32 * -sin + a33 * cos;
951        a43 = a42 * -sin + a43 * cos;
952        a12 = t1;
953        a22 = t2;
954        a32 = t3;
955      } //rotationY
956
957
958      angle = _atan2(-c, a33);
959      rotationY = angle * _RAD2DEG;
960
961      if (angle) {
962        cos = Math.cos(-angle);
963        sin = Math.sin(-angle);
964        t1 = a * cos - a13 * sin;
965        t2 = b * cos - a23 * sin;
966        t3 = c * cos - a33 * sin;
967        a43 = d * sin + a43 * cos;
968        a = t1;
969        b = t2;
970        c = t3;
971      } //rotationZ
972
973
974      angle = _atan2(b, a);
975      rotation = angle * _RAD2DEG;
976
977      if (angle) {
978        cos = Math.cos(angle);
979        sin = Math.sin(angle);
980        t1 = a * cos + b * sin;
981        t2 = a12 * cos + a22 * sin;
982        b = b * cos - a * sin;
983        a22 = a22 * cos - a12 * sin;
984        a = t1;
985        a12 = t2;
986      }
987
988      if (rotationX && Math.abs(rotationX) + Math.abs(rotation) > 359.9) {
989        //when rotationY is set, it will often be parsed as 180 degrees different than it should be, and rotationX and rotation both being 180 (it looks the same), so we adjust for that here.
990        rotationX = rotation = 0;
991        rotationY = 180 - rotationY;
992      }
993
994      scaleX = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._round)(Math.sqrt(a * a + b * b + c * c));
995      scaleY = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._round)(Math.sqrt(a22 * a22 + a32 * a32));
996      angle = _atan2(a12, a22);
997      skewX = Math.abs(angle) > 0.0002 ? angle * _RAD2DEG : 0;
998      perspective = a43 ? 1 / (a43 < 0 ? -a43 : a43) : 0;
999    }
1000
1001    if (cache.svg) {
1002      //sense if there are CSS transforms applied on an SVG element in which case we must overwrite them when rendering. The transform attribute is more reliable cross-browser, but we can't just remove the CSS ones because they may be applied in a CSS rule somewhere (not just inline).
1003      t1 = target.getAttribute("transform");
1004      cache.forceCSS = target.setAttribute("transform", "") || !_isNullTransform(_getComputedProperty(target, _transformProp));
1005      t1 && target.setAttribute("transform", t1);
1006    }
1007  }
1008
1009  if (Math.abs(skewX) > 90 && Math.abs(skewX) < 270) {
1010    if (invertedScaleX) {
1011      scaleX *= -1;
1012      skewX += rotation <= 0 ? 180 : -180;
1013      rotation += rotation <= 0 ? 180 : -180;
1014    } else {
1015      scaleY *= -1;
1016      skewX += skewX <= 0 ? 180 : -180;
1017    }
1018  }
1019
1020  uncache = uncache || cache.uncache;
1021  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;
1022  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;
1023  cache.z = z + px;
1024  cache.scaleX = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._round)(scaleX);
1025  cache.scaleY = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._round)(scaleY);
1026  cache.rotation = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._round)(rotation) + deg;
1027  cache.rotationX = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._round)(rotationX) + deg;
1028  cache.rotationY = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._round)(rotationY) + deg;

1029  cache.skewX = skewX + deg;
1030  cache.skewY = skewY + deg;
1031  cache.transformPerspective = perspective + px;
1032
1033  if (cache.zOrigin = parseFloat(origin.split(" ")[2]) || !uncache && cache.zOrigin || 0) {
1034    style[_transformOriginProp] = _firstTwoOnly(origin);
1035  }
1036
1037  cache.xOffset = cache.yOffset = 0;
1038  cache.force3D = _gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._config.force3D;
1039  cache.renderTransform = cache.svg ? _renderSVGTransforms : _supports3D ? _renderCSSTransforms : _renderNon3DTransforms;
1040  cache.uncache = 0;
1041  return cache;
1042},
1043    _firstTwoOnly = function _firstTwoOnly(value) {
1044  return (value = value.split(" "))[0] + " " + value[1];
1045},
1046    //for handling transformOrigin values, stripping out the 3rd dimension
1047_addPxTranslate = function _addPxTranslate(target, start, value) {
1048  var unit = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__.getUnit)(start);
1049  return (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._round)(parseFloat(start) + parseFloat(_convertToUnit(target, "x", value + "px", unit))) + unit;
1050},
1051    _renderNon3DTransforms = function _renderNon3DTransforms(ratio, cache) {
1052  cache.z = "0px";
1053  cache.rotationY = cache.rotationX = "0deg";

1054  cache.force3D = 0;
1055
1056  _renderCSSTransforms(ratio, cache);
1057},
1058    _zeroDeg = "0deg",
1059    _zeroPx = "0px",
1060    _endParenthesis = ") ",
1061    _renderCSSTransforms = function _renderCSSTransforms(ratio, cache) {
1062  var _ref = cache || this,
1063      xPercent = _ref.xPercent,
1064      yPercent = _ref.yPercent,
1065      x = _ref.x,
1066      y = _ref.y,
1067      z = _ref.z,
1068      rotation = _ref.rotation,
1069      rotationY = _ref.rotationY,
1070      rotationX = _ref.rotationX,
1071      skewX = _ref.skewX,
1072      skewY = _ref.skewY,
1073      scaleX = _ref.scaleX,
1074      scaleY = _ref.scaleY,
1075      transformPerspective = _ref.transformPerspective,
1076      force3D = _ref.force3D,
1077      target = _ref.target,
1078      zOrigin = _ref.zOrigin,
1079      transforms = "",
1080      use3D = force3D === "auto" && ratio && ratio !== 1 || force3D === true; // Safari has a bug that causes it not to render 3D transform-origin values properly, so we force the z origin to 0, record it in the cache, and then do the math here to offset the translate values accordingly (basically do the 3D transform-origin part manually)
1081
1082
1083  if (zOrigin && (rotationX !== _zeroDeg || rotationY !== _zeroDeg)) {
1084    var angle = parseFloat(rotationY) * _DEG2RAD,
1085        a13 = Math.sin(angle),
1086        a33 = Math.cos(angle),
1087        cos;
1088
1089    angle = parseFloat(rotationX) * _DEG2RAD;
1090    cos = Math.cos(angle);
1091    x = _addPxTranslate(target, x, a13 * cos * -zOrigin);
1092    y = _addPxTranslate(target, y, -Math.sin(angle) * -zOrigin);
1093    z = _addPxTranslate(target, z, a33 * cos * -zOrigin + zOrigin);
1094  }
1095
1096  if (transformPerspective !== _zeroPx) {
1097    transforms += "perspective(" + transformPerspective + _endParenthesis;
1098  }
1099
1100  if (xPercent || yPercent) {
1101    transforms += "translate(" + xPercent + "%, " + yPercent + "%) ";
1102  }
1103
1104  if (use3D || x !== _zeroPx || y !== _zeroPx || z !== _zeroPx) {
1105    transforms += z !== _zeroPx || use3D ? "translate3d(" + x + ", " + y + ", " + z + ") " : "translate(" + x + ", " + y + _endParenthesis;
1106  }
1107
1108  if (rotation !== _zeroDeg) {
1109    transforms += "rotate(" + rotation + _endParenthesis;
1110  }
1111
1112  if (rotationY !== _zeroDeg) {
1113    transforms += "rotateY(" + rotationY + _endParenthesis;
1114  }
1115
1116  if (rotationX !== _zeroDeg) {
1117    transforms += "rotateX(" + rotationX + _endParenthesis;
1118  }
1119
1120  if (skewX !== _zeroDeg || skewY !== _zeroDeg) {
1121    transforms += "skew(" + skewX + ", " + skewY + _endParenthesis;
1122  }
1123
1124  if (scaleX !== 1 || scaleY !== 1) {
1125    transforms += "scale(" + scaleX + ", " + scaleY + _endParenthesis;
1126  }
1127
1128  target.style[_transformProp] = transforms || "translate(0, 0)";
1129},
1130    _renderSVGTransforms = function _renderSVGTransforms(ratio, cache) {
1131  var _ref2 = cache || this,
1132      xPercent = _ref2.xPercent,
1133      yPercent = _ref2.yPercent,
1134      x = _ref2.x,
1135      y = _ref2.y,
1136      rotation = _ref2.rotation,
1137      skewX = _ref2.skewX,
1138      skewY = _ref2.skewY,
1139      scaleX = _ref2.scaleX,
1140      scaleY = _ref2.scaleY,
1141      target = _ref2.target,
1142      xOrigin = _ref2.xOrigin,
1143      yOrigin = _ref2.yOrigin,
1144      xOffset = _ref2.xOffset,
1145      yOffset = _ref2.yOffset,
1146      forceCSS = _ref2.forceCSS,
1147      tx = parseFloat(x),
1148      ty = parseFloat(y),
1149      a11,
1150      a21,
1151      a12,
1152      a22,
1153      temp;
1154
1155  rotation = parseFloat(rotation);
1156  skewX = parseFloat(skewX);
1157  skewY = parseFloat(skewY);
1158
1159  if (skewY) {
1160    //for performance reasons, we combine all skewing into the skewX and rotation values. Remember, a skewY of 10 degrees looks the same as a rotation of 10 degrees plus a skewX of 10 degrees.
1161    skewY = parseFloat(skewY);
1162    skewX += skewY;
1163    rotation += skewY;
1164  }
1165
1166  if (rotation || skewX) {
1167    rotation *= _DEG2RAD;
1168    skewX *= _DEG2RAD;
1169    a11 = Math.cos(rotation) * scaleX;
1170    a21 = Math.sin(rotation) * scaleX;
1171    a12 = Math.sin(rotation - skewX) * -scaleY;
1172    a22 = Math.cos(rotation - skewX) * scaleY;
1173
1174    if (skewX) {
1175      skewY *= _DEG2RAD;
1176      temp = Math.tan(skewX - skewY);
1177      temp = Math.sqrt(1 + temp * temp);
1178      a12 *= temp;
1179      a22 *= temp;
1180
1181      if (skewY) {
1182        temp = Math.tan(skewY);
1183        temp = Math.sqrt(1 + temp * temp);
1184        a11 *= temp;
1185        a21 *= temp;
1186      }
1187    }
1188
1189    a11 = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._round)(a11);
1190    a21 = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._round)(a21);
1191    a12 = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._round)(a12);
1192    a22 = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._round)(a22);
1193  } else {
1194    a11 = scaleX;
1195    a22 = scaleY;
1196    a21 = a12 = 0;
1197  }
1198
1199  if (tx && !~(x + "").indexOf("px") || ty && !~(y + "").indexOf("px")) {
1200    tx = _convertToUnit(target, "x", x, "px");
1201    ty = _convertToUnit(target, "y", y, "px");
1202  }
1203
1204  if (xOrigin || yOrigin || xOffset || yOffset) {
1205    tx = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._round)(tx + xOrigin - (xOrigin * a11 + yOrigin * a12) + xOffset);
1206    ty = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._round)(ty + yOrigin - (xOrigin * a21 + yOrigin * a22) + yOffset);
1207  }
1208
1209  if (xPercent || yPercent) {
1210    //The SVG spec doesn't support percentage-based translation in the "transform" attribute, so we merge it into the translation to simulate it.
1211    temp = target.getBBox();
1212    tx = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._round)(tx + xPercent / 100 * temp.width);
1213    ty = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._round)(ty + yPercent / 100 * temp.height);
1214  }
1215
1216  temp = "matrix(" + a11 + "," + a21 + "," + a12 + "," + a22 + "," + tx + "," + ty + ")";
1217  target.setAttribute("transform", temp);
1218  forceCSS && (target.style[_transformProp] = temp); //some browsers prioritize CSS transforms over the transform attribute. When we sense that the user has CSS transforms applied, we must overwrite them this way (otherwise some browser simply won't render the transform attribute changes!)
1219},
1220    _addRotationalPropTween = function _addRotationalPropTween(plugin, target, property, startNum, endValue) {
1221  var cap = 360,
1222      isString = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._isString)(endValue),
1223      endNum = parseFloat(endValue) * (isString && ~endValue.indexOf("rad") ? _RAD2DEG : 1),
1224      change = endNum - startNum,
1225      finalValue = startNum + change + "deg",
1226      direction,
1227      pt;
1228
1229  if (isString) {
1230    direction = endValue.split("_")[1];
1231
1232    if (direction === "short") {
1233      change %= cap;
1234
1235      if (change !== change % (cap / 2)) {
1236        change += change < 0 ? cap : -cap;
1237      }
1238    }
1239
1240    if (direction === "cw" && change < 0) {
1241      change = (change + cap * _bigNum) % cap - ~~(change / cap) * cap;
1242    } else if (direction === "ccw" && change > 0) {
1243      change = (change - cap * _bigNum) % cap - ~~(change / cap) * cap;
1244    }
1245  }
1246
1247  plugin._pt = pt = new _gsap_core_js__WEBPACK_IMPORTED_MODULE_0__.PropTween(plugin._pt, target, property, startNum, change, _renderPropWithEnd);
1248  pt.e = finalValue;
1249  pt.u = "deg";
1250
1251  plugin._props.push(property);
1252
1253  return pt;
1254},
1255    _assign = function _assign(target, source) {
1256  // Internet Explorer doesn't have Object.assign(), so we recreate it here.
1257  for (var p in source) {
1258    target[p] = source[p];
1259  }
1260
1261  return target;
1262},
1263    _addRawTransformPTs = function _addRawTransformPTs(plugin, transforms, target) {
1264  //for handling cases where someone passes in a whole transform string, like transform: "scale(2, 3) rotate(20deg) translateY(30em)"
1265  var startCache = _assign({}, target._gsap),
1266      exclude = "perspective,force3D,transformOrigin,svgOrigin",
1267      style = target.style,
1268      endCache,
1269      p,
1270      startValue,
1271      endValue,
1272      startNum,
1273      endNum,
1274      startUnit,
1275      endUnit;
1276
1277  if (startCache.svg) {
1278    startValue = target.getAttribute("transform");
1279    target.setAttribute("transform", "");
1280    style[_transformProp] = transforms;
1281    endCache = _parseTransform(target, 1);
1282
1283    _removeProperty(target, _transformProp);
1284
1285    target.setAttribute("transform", startValue);
1286  } else {
1287    startValue = getComputedStyle(target)[_transformProp];
1288    style[_transformProp] = transforms;
1289    endCache = _parseTransform(target, 1);
1290    style[_transformProp] = startValue;
1291  }
1292
1293  for (p in _transformProps) {
1294    startValue = startCache[p];
1295    endValue = endCache[p];
1296
1297    if (startValue !== endValue && exclude.indexOf(p) < 0) {
1298      //tweening to no perspective gives very unintuitive results - just keep the same perspective in that case.
1299      startUnit = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__.getUnit)(startValue);
1300      endUnit = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__.getUnit)(endValue);
1301      startNum = startUnit !== endUnit ? _convertToUnit(target, p, startValue, endUnit) : parseFloat(startValue);
1302      endNum = parseFloat(endValue);
1303      plugin._pt = new _gsap_core_js__WEBPACK_IMPORTED_MODULE_0__.PropTween(plugin._pt, endCache, p, startNum, endNum - startNum, _renderCSSProp);
1304      plugin._pt.u = endUnit || 0;
1305
1306      plugin._props.push(p);
1307    }
1308  }
1309
1310  _assign(endCache, startCache);
1311}; // handle splitting apart padding, margin, borderWidth, and borderRadius into their 4 components. Firefox, for example, won't report borderRadius correctly - it will only do borderTopLeftRadius and the other corners. We also want to handle paddingTop, marginLeft, borderRightWidth, etc.
1312
1313
1314(0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._forEachName)("padding,margin,Width,Radius", function (name, index) {
1315  var t = "Top",
1316      r = "Right",
1317      b = "Bottom",
1318      l = "Left",
1319      props = (index < 3 ? [t, r, b, l] : [t + l, t + r, b + r, b + l]).map(function (side) {
1320    return index < 2 ? name + side : "border" + side + name;
1321  });
1322
1323  _specialProps[index >

1455        isTransformRelated = p in _transformProps; //--- TRANSFORM-RELATED ---
1456
1457        if (isTransformRelated) {
1458          this.styles.save(p);
1459          finalTransformValue = endValue; // this is always the same as endValue except when it's a var(--) value, in which case we need to calculate the end value.
1460
1461          if (type === "string" && endValue.substring(0, 6) === "var(--") {
1462            endValue = _getComputedProperty(target, endValue.substring(4, endValue.indexOf(")")));
1463
1464            if (endValue.substring(0, 5) === "calc(") {
1465              var origPerspective = target.style.perspective;
1466              target.style.perspective = endValue;
1467              endValue = _getComputedProperty(target, "perspective");
1468              origPerspective ? target.style.perspective = origPerspective : _removeProperty(target, "perspective");
1469            }
1470
1471            endNum = parseFloat(endValue);
1472          }
1473
1474          if (!transformPropTween) {
1475            cache = target._gsap;
1476            cache.renderTransform && !vars.parseTransform || _parseTransform(target, vars.parseTransform); // if, for example, gsap.set(... {transform:"translateX(50vw)"}), the _get() call doesn't parse the transform, thus cache.renderTransform won't be set yet so force the parsing of the transform here.
1477
1478            smooth = vars.smoothOrigin !== false && cache.smooth;
1479            transformPropTween = this._pt = new _gsap_core_js__WEBPACK_IMPORTED_MODULE_0__.PropTween(this._pt, style, _transformProp, 0, 1, cache.renderTransform, cache, 0, -1); //the first time through, create the rendering PropTween so that it runs LAST (in the linked list, we keep adding to the beginning)
1480
1481            transformPropTween.dep = 1; //flag it as dependent so that if things get killed/overwritten and this is the only PropTween left, we can safely kill the whole tween.
1482          }
1483
1484          if (p === "scale") {
1485            this._pt = new _gsap_core_js__WEBPACK_IMPORTED_MODULE_0__.PropTween(this._pt, cache, "scaleY", cache.scaleY, (relative ? (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._parseRelative)(cache.scaleY, relative + endNum) : endNum) - cache.scaleY || 0, _renderCSSProp);
1486            this._pt.u = 0;
1487            props.push("scaleY", p);
1488            p += "X";
1489          } else if (p === "transformOrigin") {
1490            inlineProps.push(_transformOriginProp, 0, style[_transformOriginProp]);
1491            endValue = _convertKeywordsToPercentages(endValue); //in case something like "left top" or "bottom right" is passed in. Convert to percentages.
1492
1493            if (cache.svg) {
1494              _applySVGOrigin(target, endValue, 0, smooth, 0, this);
1495            } else {
1496              endUnit = parseFloat(endValue.split(" ")[2]) || 0; //handle the zOrigin separately!
1497
1498              endUnit !== cache.zOrigin && _addNonTweeningPT(this, cache, "zOrigin", cache.zOrigin, endUnit);
1499
1500              _addNonTweeningPT(this, style, p, _firstTwoOnly(startValue), _firstTwoOnly(endValue));
1501            }
1502
1503            continue;
1504          } else if (p === "svgOrigin") {
1505            _applySVGOrigin(target, endValue, 1, smooth, 0, this);
1506
1507            continue;
1508          } else if (p in _rotationalProperties) {
1509            _addRotationalPropTween(this, cache, p, startNum, relative ? (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._parseRelative)(startNum, relative + endValue) : endValue);
1510
1511            continue;
1512          } else if (p === "smoothOrigin") {
1513            _addNonTweeningPT(this, cache, "smooth", cache.smooth, endValue);
1514
1515            continue;
1516          } else if (p === "force3D") {
1517            cache[p] = endValue;
1518            continue;
1519          } else if (p === "transform") {
1520            _addRawTransformPTs(this, endValue, target);
1521
1522            continue;
1523          }
1524        } else if (!(p in style)) {
1525          p = _checkPropPrefix(p) || p;
1526        }
1527
1528        if (isTransformRelated || (endNum || endNum === 0) && (startNum || startNum === 0) && !_complexExp.test(endValue) && p in style) {
1529          startUnit = (startValue + "").substr((startNum + "").length);
1530          endNum || (endNum = 0); // protect against NaN
1531
1532          endUnit = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__.getUnit)(endValue) || (p in _gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._config.units ? _gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._config.units[p] : startUnit);
1533          startUnit !== endUnit && (startNum = _convertToUnit(target, p, startValue, endUnit));
1534          this._pt = new _gsap_core_js__WEBPACK_IMPORTED_MODULE_0__.PropTween(this._pt, isTransformRelated ? cache : style, p, startNum, (relative ? (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._parseRelative)(startNum, relative + endNum) : endNum) - startNum, 

1534!isTransformRelated && (endUnit === "px" || p === "zIndex") && vars.autoRound !== false ? _renderRoundedCSSProp : _renderCSSProp);
1535          this._pt.u = endUnit || 0;
1536
1537          if (isTransformRelated && finalTransformValue !== endValue) {
1538            this._pt.b = startValue;
1539            this._pt.e = finalTransformValue;
1540            this._pt.r = _renderCSSPropWithBeginningAndEnd;
1541          } else if (startUnit !== endUnit && endUnit !== "%") {
1542            //when the tween goes all the way back to the beginning, we need to revert it to the OLD/ORIGINAL value (with those units). We record that as a "b" (beginning) property and point to a render method that handles that. (performance optimization)
1543            this._pt.b = startValue;
1544            this._pt.r = _renderCSSPropWithBeginning;
1545          }
1546        } else if (!(p in style)) {
1547          if (p in target) {
1548            //maybe it's not a style - it could be a property added directly to an element in which case we'll try to animate that.
1549            this.add(target, p, startValue || target[p], relative ? relative + endValue : endValue, index, targets);
1550          } else if (p !== "parseTransform") {
1551            (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._missingPlugin)(p, endValue);
1552
1553            continue;
1554          }
1555        } else {
1556          _tweenComplexCSSString.call(this, target, p, startValue, relative ? relative + endValue : endValue);
1557        }
1558
1559        isTransformRelated || (p in style ? inlineProps.push(p, 0, style[p]) : typeof target[p] === "function" ? inlineProps.push(p, 2, target[p]()) : inlineProps.push(p, 1, startValue || target[p]));
1560        props.push(p);
1561      }
1562    }
1563
1564    hasPriority && (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._sortPropTweensByPriority)(this);
1565  },
1566  render: function render(ratio, data) {
1567    if (data.tween._time || !_reverting()) {
1568      var pt = data._pt;
1569
1570      while (pt) {
1571        pt.r(ratio, pt.d);
1572        pt = pt._next;
1573      }
1574    } else {
1575      data.styles.revert();
1576    }
1577  },
1578  get: _get,
1579  aliases: _propertyAliases,
1580  getSetter: function getSetter(target, property, plugin) {
1581    //returns a setter function that accepts target, property, value and applies it accordingly. Remember, properties like "x" aren't as simple as target.style.property = value because they've got to be applied to a proxy object and then merged into a transform string in a renderer.
1582    var p = _propertyAliases[property];
1583    p && p.indexOf(",") < 0 && (property = p);
1584    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 && !(0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._isUndefined)(target.style[property]) ? _setterCSSStyle : ~property.indexOf("-") ? _setterCSSProp : (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._getSetter)(target, property);
1585  },
1586  core: {
1587    _removeProperty: _removeProperty,
1588    _getMatrix: _getMatrix
1589  }
1590};
1591_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__.gsap.utils.checkPrefix = _checkPropPrefix;
1592_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__.gsap.core.getStyleSaver = _getStyleSaver;
1593
1594(function (positionAndScale, rotation, others, aliases) {
1595  var all = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._forEachName)(positionAndScale + "," + rotation + "," + others, function (name) {
1596    _transformProps[name] = 1;
1597  });
1598
1599  (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._forEachName)(rotation, function (name) {
1600    _gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._config.units[name] = "deg";
1601    _rotationalProperties[name] = 1;
1602  });
1603
1604  _propertyAliases[all[13]] = positionAndScale + "," + rotation;
1605
1606  (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._forEachName)(aliases, function (name) {
1607    var split = name.split(":");
1608    _propertyAliases[split[1]] = all[split[0]];
1609  });
1610})("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");
1611
1612(0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._forEachName)("x,y,z,top,right,bottom,left,width,height,fontSize,padding,margin,perspective", function (name) {
1613  _gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._config.units[name] = "px";
1614});
1615
1616_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__.gsap.registerPlugin(CSSPlugin);
1617
1618
1619/***/ },
1620
1621/***/ "./node_modules/gsap/ScrollToPlugin.js"
1622/*!*********************************************!*\
1623  !*** ./node_modules/gsap/ScrollToPlugin.js ***!
1624  \*********************************************/
1625(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
1626
1627__webpack_require__.r(__webpack_exports__);
1628/* harmony export */ __webpack_require__.d(__webpack_exports__, {
1629/* harmony export */   ScrollToPlugin: () => (/* binding */ ScrollToPlugin),
1630/* harmony export */   "default": () => (/* binding */ ScrollToPlugin)
1631/* harmony export */ });
1632/*!
1633 * ScrollToPlugin 3.15.0
1634 * https://gsap.com
1635 *
1636 * @license Copyright 2008-2026, GreenSock. All rights reserved.
1637 * Subject to the terms at https://gsap.com/standard-license
1638 * @author: Jack Doyle, [email protected]
1639*/
1640
1641/* eslint-disable */
1642var gsap,
1643    _coreInitted,
1644    _window,
1645    _docEl,
1646    _body,
1647    _toArray,
1648    _config,
1649    ScrollTrigger,
1650    _windowExists = function _windowExists() {
1651  return typeof window !== "undefined";
1652},
1653    _getGSAP = function _getGSAP() {
1654  return gsap || _windowExists() && (gsap = window.gsap) && gsap.registerPlugin && gsap;
1655},
1656    _isString = function _isString(value) {
1657  return typeof value === "string";
1658},
1659    _isFunction = function _isFunction(value) {
1660  return typeof value === "function";
1661},
1662    _max = function _max(element, axis) {
1663  var dim = axis === "x" ? "Width" : "Height",
1664      scroll = "scroll" + dim,
1665      client = "client" + dim;
1666  return element === _window || element === _docEl || element === _body ? Math.max(_docEl[scroll], _body[scroll]) - (_window["inner" + dim] || _docEl[client] || _body[client]) : element[scroll] - element["offset" + dim];
1667},
1668    _buildGetter = function _buildGetter(e, axis) {
1669  //pass in an element and an axis ("x" or "y") and it'll return a getter function for the scroll position of that element (like scrollTop or scrollLeft, although if the element is the window, it'll use the pageXOffset/pageYOffset or the documentElement's scrollTop/scrollLeft or document.body's. Basically this streamlines things and makes a very fast getter across browsers.
1670  var p = "scroll" + (axis === "x" ? "Left" : "Top");
1671
1672  if (e === _window) {
1673    if (e.pageXOffset != null) {
1674      p = "page" + axis.toUpperCase() + "Offset";
1675    } else {
1676      e = _docEl[p] != null ? _docEl : _body;
1677    }
1678  }
1679
1680  return function () {
1681    return e[p];
1682  };
1683},
1684    _clean = function _clean(value, index, target, targets) {
1685  _isFunction(value) && (value = value(index, target, targets));
1686
1687  if (typeof value !== "object") {
1688    return _isString(value) && value !== "max" && value.charAt(1) !== "=" ? {
1689      x: value,
1690      y: value
1691    } : {
1692      y: value
1693    }; //if we don't receive an object as the parameter, assume the user intends "y".
1694  } else if (value.nodeType) {
1695    return {
1696      y: value,
1697      x: value
1698    };
1699  } else {
1700    var result = {},
1701        p;
1702
1703    for (p in value) {
1704      result[p] = p !== "onAutoKill" && _isFunction(value[p]) ? value[p](index, target, targets) : value[p];
1705    }
1706
1707    return result;
1708  }
1709},
1710    _getOffset = function _getOffset(element, container) {
1711  element = _toArray(element)[0];
1712
1713  if (!element || !element.getBoundingClientRect) {
1714    return console.warn("scrollTo target doesn't exist. Using 0") || {
1715      x: 0,
1716      y: 0
1717    };
1718  }
1719
1720  var rect = element.getBoundingClientRect(),
1721      isRoot = !container || container === _window || container === _body,
1722      cRect = isRoot ? {
1723    top: _docEl.clientTop - (_window.pageYOffset || _docEl.scrollTop || _body.scrollTop || 0),
1724    left: _docEl.clientLeft - (_window.pageXOffset || _docEl.scrollLeft || _body.scrollLeft || 0)
1725  } : container.getBoundingClientRect(),
1726      offsets = {
1727    x: rect.left - cRect.left,
1728    y: rect.top - cRect.top
1729  };
1730
1731  if (!isRoot && container) {
1732    //only add the current scroll position if it's not the window/body.
1733    offsets.x += _buildGetter(container, "x")();
1734    offsets.y += _buildGetter(container, "y")();
1735  }
1736
1737  return offsets;
1738},
1739    _parseVal = function _parseVal(value, target, axis, currentVal, offset) {
1740  return !isNaN(value) && typeof value !== "object" ? parseFloat(value) - offset : _isString(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);
1741},
1742    _initCore = function _initCore() {
1743  gsap = _getGSAP();
1744
1745  if (_windowExists() && gsap && typeof document !== "undefined" && document.body) {
1746    _window = window;
1747    _body = document.body;
1748    _docEl = document.documentElement;
1749    _toArray = gsap.utils.toArray;
1750    gsap.config({
1751      autoKillThreshold: 7
1752    });
1753    _config = gsap.config();
1754    _coreInitted = 1;
1755  }
1756};
1757

1758var ScrollToPlugin = {
1759  version: "3.15.0",
1760  name: "scrollTo",
1761  rawVars: 1,
1762  register: function register(core) {
1763    gsap = core;
1764
1765    _initCore();
1766  },
1767  init: function init(target, value, tween, index, targets) {
1768    _coreInitted || _initCore();
1769    var data = this,
1770        snapType = gsap.getProperty(target, "scrollSnapType");
1771    data.isWin = target === _window;
1772    data.target = target;
1773    data.tween = tween;
1774    value = _clean(value, index, target, targets);
1775    data.vars = value;
1776    data.autoKill = !!("autoKill" in value ? value : _config).autoKill;
1777    data.getX = _buildGetter(target, "x");
1778    data.getY = _buildGetter(target, "y");
1779    data.x = data.xPrev = data.getX();
1780    data.y = data.yPrev = data.getY();
1781    ScrollTrigger || (ScrollTrigger = gsap.core.globals().ScrollTrigger);
1782    gsap.getProperty(target, "scrollBehavior") === "smooth" && gsap.set(target, {
1783      scrollBehavior: "auto"
1784    });
1785
1786    if (snapType && snapType !== "none") {
1787      // disable scroll snapping to avoid strange behavior
1788      data.snap = 1;
1789      data.snapInline = target.style.scrollSnapType;
1790      target.style.scrollSnapType = "none";
1791    }
1792
1793    if (value.x != null) {
1794      data.add(data, "x", data.x, _parseVal(value.x, target, "x", data.x, value.offsetX || 0), index, targets);
1795
1796      data._props.push("scrollTo_x");
1797    } else {
1798      data.skipX = 1;
1799    }
1800
1801    if (value.y != null) {
1802      data.add(data, "y", data.y, _parseVal(value.y, target, "y", data.y, value.offsetY || 0), index, targets);
1803
1804      data._props.push("scrollTo_y");
1805    } else {
1806      data.skipY = 1;
1807    }
1808  },
1809  render: function render(ratio, data) {
1810    var pt = data._pt,
1811        target = data.target,
1812        tween = data.tween,
1813        autoKill = data.autoKill,
1814        xPrev = data.xPrev,
1815        yPrev = data.yPrev,
1816        isWin = data.isWin,
1817        snap = data.snap,
1818        snapInline = data.snapInline,
1819        x,
1820        y,
1821        yDif,
1822        xDif,
1823        threshold;
1824
1825    while (pt) {
1826      pt.r(ratio, pt.d);
1827      pt = pt._next;
1828    }
1829
1830    x = isWin || !data.skipX ? data.getX() : xPrev;
1831    y = isWin || !data.skipY ? data.getY() : yPrev;
1832    yDif = y - yPrev;
1833    xDif = x - xPrev;
1834    threshold = _config.autoKillThreshold;
1835
1836    if (data.x < 0) {
1837      //can't scroll to a position less than 0! Might happen if someone uses a Back.easeOut or Elastic.easeOut when scrolling back to the top of the page (for example)
1838      data.x = 0;
1839    }
1840
1841    if (data.y < 0) {
1842      data.y = 0;
1843    }
1844
1845    if (autoKill) {
1846      //note: iOS has a bug that throws off the scroll by several pixels, so we need to check if it's within 7 pixels of the previous one that we set instead of just looking for an exact match.
1847      if (!data.skipX && (xDif > threshold || xDif < -threshold) && x < _max(target, "x")) {
1848        data.skipX = 1; //if the user scrolls separately, we should stop tweening!
1849      }
1850
1851      if (!data.skipY && (yDif > threshold || yDif < -threshold) && y < _max(target, "y")) {
1852        data.skipY = 1; //if the user scrolls separately, we should stop tweening!
1853      }
1854
1855      if (data.skipX && data.skipY) {
1856        tween.kill();
1857        data.vars.onAutoKill && data.vars.onAutoKill.apply(tween, data.vars.onAutoKillParams || []);
1858      }
1859    }
1860
1861    if (isWin) {
1862      _window.scrollTo(!data.skipX ? data.x : x, !data.skipY ? data.y : y);
1863    } else {
1864      data.skipY || (target.scrollTop = data.y);
1865      data.skipX || (target.scrollLeft = data.x);
1866    }
1867
1868    if (snap && (ratio === 1 || ratio === 0)) {
1869      y = target.scrollTop;
1870      x = target.scrollLeft;
1871      snapInline ? target.style.scrollSnapType = snapInline : target.style.removeProperty("scroll-snap-type");
1872      target.scrollTop = y + 1; // bug in Safari causes the element to totally reset its scroll position when scroll-snap-type changes, so we need to set it to a slightly different value and then back again to work around this bug.
1873
1874      target.scrollLeft = x + 1;
1875      target.scrollTop = y;
1876      target.scrollLeft = x;
1877    }
1878
1879    data.xPrev = data.x;
1880    data.yPrev = data.y;
1881    ScrollTrigger && ScrollTrigger.update();
1882  },
1883  kill: function kill(property) {
1884    var both = property === "scrollTo",
1885        i = this._props.indexOf(property);
1886
1887    if (both || property === "scrollTo_x") {
1888      this.skipX = 1;
1889    }
1890
1891    if (both || property === "scrollTo_y") {
1892      this.skipY = 1;
1893    }
1894
1895    i > -1 && this._props.splice(i, 1);
1896    return !this._props.length;
1897  }
1898};
1899ScrollToPlugin.max = _max;
1900ScrollToPlugin.getOffset = _getOffset;
1901ScrollToPlugin.buildGetter = _buildGetter;
1902
1903ScrollToPlugin.config = function (vars) {
1904  _config || _initCore() || (_config = gsap.config()); // in case the window hasn't been defined yet.
1905
1906  for (var p in vars) {
1907    _config[p] = vars[p];
1908  }
1909};
1910
1911_getGSAP() && gsap.registerPlugin(ScrollToPlugin);

1994function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
1995
1996function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }
1997
1998/*!
1999 * GSAP 3.15.0
2000 * https://gsap.com
2001 *
2002 * @license Copyright 2008-2026, GreenSock. All rights reserved.
2003 * Subject to the terms at https://gsap.com/standard-license
2004 * @author: Jack Doyle, [email protected]
2005*/
2006
2007/* eslint-disable */
2008var _config = {
2009  autoSleep: 120,
2010  force3D: "auto",
2011  nullTargetWarn: 1,
2012  units: {
2013    lineHeight: ""
2014  }
2015},
2016    _defaults = {
2017  duration: .5,
2018  overwrite: false,
2019  delay: 0
2020},
2021    _suppressOverwrites,
2022    _reverting,
2023    _context,
2024    _bigNum = 1e8,
2025    _tinyNum = 1 / _bigNum,
2026    _2PI = Math.PI * 2,
2027    _HALF_PI = _2PI / 4,
2028    _gsID = 0,
2029    _sqrt = Math.sqrt,
2030    _cos = Math.cos,
2031    _sin = Math.sin,
2032    _isString = function _isString(value) {
2033  return typeof value === "string";
2034},
2035    _isFunction = function _isFunction(value) {
2036  return typeof value === "function";
2037},
2038    _isNumber = function _isNumber(value) {
2039  return typeof value === "number";
2040},
2041    _isUndefined = function _isUndefined(value) {
2042  return typeof value === "undefined";
2043},
2044    _isObject = function _isObject(value) {
2045  return typeof value === "object";
2046},
2047    _isNotFalse = function _isNotFalse(value) {
2048  return value !== false;
2049},
2050    _windowExists = function _windowExists() {
2051  return typeof window !== "undefined";
2052},
2053    _isFuncOrString = function _isFuncOrString(value) {
2054  return _isFunction(value) || _isString(value);
2055},
2056    _isTypedArray = typeof ArrayBuffer === "function" && ArrayBuffer.isView || function () {},
2057    // note: IE10 has ArrayBuffer, but NOT ArrayBuffer.isView().
2058_isArray = Array.isArray,
2059    _randomExp = /random\([^)]+\)/g,
2060    _commaDelimExp = /,\s*/g,
2061    _strictNumExp = /(?:-?\.?\d|\.)+/gi,
2062    //only numbers (including negatives and decimals) but NOT relative values.
2063_numExp = /[-+=.]*\d+[.e\-+]*\d*[e\-+]*\d*/g,
2064    //finds any numbers, including ones that start with += or -=, negative numbers, and ones in scientific notation like 1e-8.
2065_numWithUnitExp = /[-+=.]*\d+[.e-]*\d*[a-z%]*/g,
2066    _complexStringNumExp = /[-+=.]*\d+\.?\d*(?:e-|e\+)?\d*/gi,
2067    //duplicate so that while we're looping through matches from exec(), it doesn't contaminate the lastIndex of _numExp which we use to search for colors too.
2068_relExp = /[+-]=-?[.\d]+/,
2069    _delimitedValueExp = /[^,'"\[\]\s]+/gi,
2070    // previously /[#\-+.]*\b[a-z\d\-=+%.]+/gi but didn't catch special characters.
2071_unitExp = /^[+\-=e\s\d]*\d+[.\d]*([a-z]*|%)\s*$/i,
2072    _globalTimeline,
2073    _win,
2074    _coreInitted,
2075    _doc,
2076    _globals = {},
2077    _installScope = {},
2078    _coreReady,
2079    _install = function _install(scope) {
2080  return (_installScope = _merge(scope, _globals)) && gsap;
2081},
2082    _missingPlugin = function _missingPlugin(property, value) {
2083  return console.warn("Invalid property", property, "set to", value, "Missing plugin? gsap.registerPlugin()");
2084},
2085    _warn = function _warn(message, suppress) {
2086  return !suppress && console.warn(message);
2087},
2088    _addGlobal = function _addGlobal(name, obj) {
2089  return name && (_globals[name] = obj) && _installScope && (_installScope[name] = obj) || _globals;
2090},
2091    _emptyFunc = function _emptyFunc() {
2092  return 0;
2093},
2094    _startAtRevertConfig = {
2095  suppressEvents: true,
2096  isStart: true,
2097  kill: false
2098},
2099    _revertConfigNoKill = {
2100  suppressEvents: true,
2101  kill: false
2102},
2103    _revertConfig = {
2104  suppressEvents: true
2105},
2106    _reservedProps = {},
2107    _lazyTweens = [],
2108    _lazyLookup = {},
2109    _lastRenderedFrame,
2110    _plugins = {},
2111    _effects = {},
2112    _nextGCFrame = 30,
2113    _harnessPlugins = [],
2114    _callbackNames = "",
2115    _harness = function _harness(targets) {
2116  var target = targets[0],
2117      harnessPlugin,
2118      i;
2119  _isObject(target) || _isFunction(target) || (targets = [targets]);
2120
2121  if (!(harnessPlugin = (target._gsap || {}).harness)) {
2122    // find the first target with a harness. We assume targets passed into an animation will be of similar type, meaning the same kind of harness can be used for them all (performance optimization)
2123    i = _harnessPlugins.length;
2124
2125    while (i-- && !_harnessPlugins[i].targetTest(target)) {}
2126
2127    harnessPlugin = _harnessPlugins[i];
2128  }
2129
2130  i = targets.length;
2131
2132  while (i--) {
2133    targets[i] && (targets[i]._gsap || (targets[i]._gsap = new GSCache(targets[i], harnessPlugin))) || targets.splice(i, 1);
2134  }
2135
2136  return targets;
2137},
2138    _getCache = function _getCache(target) {
2139  return target._gsap || _harness(toArray(target))[0]._gsap;
2140},
2141    _getProperty = function _getProperty(target, property, v) {
2142  return (v = target[property]) && _isFunction(v) ? target[property]() : _isUndefined(v) && target.getAttribute && target.getAttribute(property) || v;
2143},
2144    _forEachName = function _forEachName(names, func) {
2145  return (names = names.split(",")).forEach(func) || names;
2146},
2147    //split a comma-delimited list of names into an array, then run a forEach() function and return the split array (this is just a way to consolidate/shorten some code).
2148_round = function _round(value) {
2149  return Math.round(value * 100000) / 100000 || 0;
2150},
2151    _roundPrecise = function _roundPrecise(value) {
2152  return Math.round(value * 10000000) / 10000000 || 0;
2153},
2154    // increased precision mostly for timing values.
2155_parseRelative = function _parseRelative(start, value) {
2156  var operator = value.charAt(0),
2157      end = parseFloat(value.substr(2));
2158  start = parseFloat(start);
2159  return operator === "+" ? start + end : operator === "-" ? start - end : operator === "*" ? start * end : start / end;
2160},
2161    _arrayContainsAny = function _arrayContainsAny(toSearch, toFind) {
2162  //searches one array to find matches for any of the items in the toFind array. As soon as one is found, it returns true. It does NOT return all the matches; it's simply a boolean search.
2163  var l = toFind.length,
2164      i = 0;
2165
2166  for (; toSearch.indexOf(toFind[i]) < 0 && ++i < l;) {}
2167
2168  return i < l;
2169},
2170    _lazyRender = function _lazyRender() {
2171  var l = _lazyTweens.length,
2172      a = _lazyTweens.slice(0),
2173      i,
2174      tween;
2175
2176  _lazyLookup = {};
2177  _lazyTweens.length = 0;
2178
2179  for (i = 0; i < l; i++) {
2180    tween = a[i];
2181    tween && tween._lazy && (tween.render(tween._lazy[0], tween._lazy[1], true)._lazy = 0);
2182  }
2183},
2184    _isRevertWorthy = function _isRevertWorthy(animation) {
2185  return !!(animation._initted || animation._startAt || animation.add);
2186},
2187    _lazySafeRender = function _lazySafeRender(animation, time, suppressEvents, force) {
2188  _lazyTweens.length && !_reverting && _lazyRender();
2189  animation.render(time, suppressEvents, force || !!(_reverting && time < 0 && _isRevertWorthy(animation)));
2190  _lazyTweens.length && !_reverting && _lazyRender(); //in case rendering caused any tweens to lazy-init, we should render them because typically when someone calls seek() or time() or progress(), they expect an immediate render.
2191},
2192    _numericIfPossible = function _numericIfPossible(value) {
2193  var n = parseFloat(value);
2194  return (n || n === 0) && (value + "").match(_delimitedValueExp).length < 2 ? n : _isString(value) ? value.trim() : value;
2195},
2196    _passThrough = function _passThrough(p) {
2197  return p;
2198},
2199    _setDefaults = function _setDefaults(obj, defaults) {
2200  for (var p in defaults) {
2201    p in obj || (obj[p] = defaults[p]);
2202  }
2203
2204  return obj;
2205},
2206    _setKeyframeDefaults = function _setKeyframeDefaults(excludeDuration) {
2207  return function (obj, defaults) {
2208    for (var p in defaults) {
2209      p in obj || p === "duration" && excludeDuration || p === "ease" || (obj[p] = defaults[p]);
2210    }
2211  };
2212},
2213    _merge = function _merge(base, toMerge) {
2214  for (var p in toMerge) {
2215    base[p] = toMerge[p];
2216  }
2217
2218  return base;
2219},
2220    _mergeDeep = function _mergeDeep(base, toMerge) {
2221  for (var p in toMerge) {
2222    p !== "__proto__" && p !== "constructor" && p !== "prototype" && (base[p] = _isObject(toMerge[p]) ? _mergeDeep(base[p] || (base[p] = {}), toMerge[p]) : toMerge[p]);
2223  }
2224
2225  return base;
2226},
2227    _copyExcluding = function _copyExcluding(obj, excluding) {
2228  var copy = {},
2229      p;
2230
2231  for (p in obj) {
2232    p in excluding || (copy[p] = obj[p]);
2233  }
2234
2235  return copy;
2236},
2237    _inheritDefaults = function _inheritDefaults(vars) {
2238  var parent = vars.parent || _globalTimeline,
2239      func = vars.keyframes ? _setKeyframeDefaults(_isArray(vars.keyframes)) : _setDefaults;
2240
2241  if (_isNotFalse(vars.inherit)) {
2242    while (parent) {
2243      func(vars, parent.vars.defaults);
2244      parent = parent.parent || parent._dp;
2245    }
2246  }
2247
2248  return vars;
2249},
2250    _arraysMatch = function _arraysMatch(a1, a2) {
2251  var i = a1.length,
2252      match = i === a2.length;
2253
2254  while (match && i-- && a1[i] === a2[i]) {}
2255
2256  return i < 0;
2257},
2258    _addLinkedListItem = function _addLinkedListItem(parent, child, firstProp, lastProp, sortBy) {
2259  if (firstProp === void 0) {
2260    firstProp = "_first";
2261  }
2262
2263  if (lastProp === void 0) {
2264    lastProp = "_last";
2265  }
2266
2267  var prev = parent[lastProp],
2268      t;
2269
2270  if (sortBy) {
2271    t = child[sortBy];
2272
2273    while (prev && prev[sortBy] > t) {
2274      prev = prev._prev;
2275    }
2276  }
2277
2278  if (prev) {
2279    child._next = prev._next;
2280    prev._next = child;
2281  } else {
2282    child._next = parent[firstProp];
2283    parent[firstProp] = child;
2284  }
2285
2286  if (child._next) {
2287    child._next._prev = child;
2288  } else {
2289    parent[lastProp] = child;
2290  }
2291
2292  child._prev = prev;
2293  child.parent = child._dp = parent;
2294  return child;
2295},
2296    _removeLinkedListItem = function _removeLinkedListItem(parent, child, firstProp, lastProp) {
2297  if (firstProp === void 0) {
2298    firstProp = "_first";
2299  }
2300
2301  if (lastProp === void 0) {
2302    lastProp = "_last";
2303  }
2304
2305  var prev = child._prev,
2306      next = child._next;
2307
2308  if (prev) {
2309    prev._next = next;
2310  } else if (parent[firstProp] === child) {
2311    parent[firstProp] = next;
2312  }
2313
2314  if (next) {
2315    next._prev = prev;
2316  } else if (parent[lastProp] === child) {
2317    parent[lastProp] = prev;
2318  }
2319
2320  child._next = child._prev = child.parent = null; // don't delete the _dp just so we can revert if necessary. But parent should be null to indicate the item isn't in a linked list.
2321},
2322    _removeFromParent = function _removeFromParent(child, onlyIfParentHasAutoRemove) {
2323  child.parent && (!onlyIfParentHasAutoRemove || child.parent.autoRemoveChildren) && child.parent.remove && child.parent.remove(child);
2324  child._act = 0;
2325},
2326    _uncache = function _uncache(animation, child) {
2327  if (animation && (!child || child._end > animation._dur || child._start < 0)) {
2328    // performance optimization: if a child animation is passed in we should only uncache if that child EXTENDS the animation (its end time is beyond the end)
2329    var a = animation;
2330
2331    while (a) {
2332      a._dirty = 1;
2333      a = a.parent;
2334    }
2335  }
2336
2337  return animation;
2338},
2339    _recacheAncestors = function _recacheAncestors(animation) {
2340  var parent = animation.parent;
2341
2342  while (parent && parent.parent) {
2343    //sometimes we must force a re-sort of all children and update the duration/totalDuration of all ancestor timelines immediately in case, for example, in the middle of a render loop, one tween alters another tween's timeScale which shoves its startTime before 0, forcing the parent timeline to shift around and shiftChildren() which could affect that next tween's render (startTime). Doesn't matter for the root timeline though.
2344    parent._dirty = 1;
2345    parent.totalDuration();
2346    parent = parent.parent;
2347  }
2348
2349  return animation;
2350},
2351    _rewindStartAt = function _rewindStartAt(tween, totalTime, suppressEvents, force) {
2352  return tween._startAt && (_reverting ? tween._startAt.revert(_revertConfigNoKill) : tween.vars.immediateRender && !tween.vars.autoRevert || tween._startAt.render(totalTime, true, force));
2353},
2354    _hasNoPausedAncestors = function _hasNoPausedAncestors(animation) {
2355  return !animation || animation._ts && _hasNoPausedAncestors(animation.parent);
2356},
2357    _elapsedCycleDuration = function _elapsedCycleDuration(animation) {
2358  return animation._repeat ? _animationCycle(animation._tTime, animation = animation.duration() + animation._rDelay) * animation : 0;
2359},
2360    // feed in the totalTime and cycleDuration and it'll return the cycle (iteration minus 1) and if the playhead is exactly at the very END, it will NOT bump up to the next cycle.
2361_animationCycle = function _animationCycle(tTime, cycleDuration) {
2362  var whole = Math.floor(tTime = _roundPrecise(tTime / cycleDuration));
2363  return tTime && whole === tTime ? whole - 1 : whole;
2364},
2365    _parentToChildTotalTime = function _parentToChildTotalTime(parentTime, child) {
2366  return (parentTime - child._start) * child._ts + (child._ts >= 0 ? 0 : child._dirty ? child.totalDuration() : child._tDur);
2367},
2368    _setEnd = function _setEnd(animation) {
2369  return animation._end = _roundPrecise(animation._start + (animation._tDur / Math.abs(animation._ts || animation._rts || _tinyNum) || 0));
2370},
2371    _alignPlayhead = function _alignPlayhead(animation, totalTime) {
2372  // adjusts the animation's _start and _end according to the provided totalTime (only if the parent's smoothChildTiming is true and the animation isn't paused). It doesn't do any rendering or forcing things back into parent timelines, etc. - that's what totalTime() is for.
2373  var parent = animation._dp;
2374
2375  if (parent && parent.smoothChildTiming && animation._ts) {
2376    animation._start = _roundPrecise(parent._time - (animation._ts > 0 ? totalTime / animation._ts : ((animation._dirty ? animation.totalDuration() : animation._tDur) - totalTime) / -animation._ts));
2377
2378    _setEnd(animation);
2379
2380    parent._dirty || _uncache(parent, animation); //for performance improvement. If the parent's cache is already dirty, it already took care of marking the ancestors as dirty too, so skip the function call here.
2381  }
2382
2383  return animation;
2384},
2385
2386/*
2387_totalTimeToTime = (clampedTotalTime, duration, repeat, repeatDelay, yoyo) => {
2388	let cycleDuration = duration + repeatDelay,
2389		time = _round(clampedTotalTime % cycleDuration);
2390	if (time > duration) {
2391		time = duration;
2392	}
2393	return (yoyo && (~~(clampedTotalTime / cycleDuration) & 1)) ? duration - time : time;
2394},
2395*/
2396_postAddChecks = function _postAddChecks(timeline, child) {
2397  var t;
2398
2399  if (child._time || !child._dur && child._initted || child._start < timeline._time && (child._dur || !child.add)) {
2400    // in case, for example, the _start is moved on a tween that has already rendered, or if it's being inserted into a timeline BEFORE where the playhead is currently. Imagine it's at its end state, then the startTime is moved WAY later (after the end of this timeline), it should render at its beginning. Special case: if it's a timeline (has .add() method) and no duration, we can skip rendering because the user may be populating it AFTER adding it to a parent timeline (unconventional, but possible, and we wouldn't want it to get removed if the parent's autoRemoveChildren is true).
2401    t = _parentToChildTotalTime(timeline.rawTime(), child);
2402
2403    if (!child._dur || _clamp(0, child.totalDuration(), t) - child._tTime > _tinyNum) {
2404      child.render(t, true);
2405    }
2406  } //if the timeline has already ended but the inserted tween/timeline extends the duration, we should enable this timeline again so that it renders properly. We should also align the playhead with the parent timeline's when appropriate.
2407
2408
2409  if (_uncache(timeline, child)._dp && timeline._initted && timeline._time >= timeline._dur && timeline._ts) {
2410    //in case any of the ancestors had completed but should now be enabled...
2411    if (timeline._dur < timeline.duration()) {
2412      t = timeline;
2413
2414      while (t._dp) {
2415        t.rawTime() >= 0 && t.totalTime(t._tTime); //moves the timeline (shifts its startTime) if necessary, and also enables it. If it's currently zero, though, it may not be scheduled to render until later so there's no need to force it to align with the current playhead position. Only move to catch up with the playhead.
2416
2417        t = t._dp;
2418      }
2419    }
2420
2421    timeline._zTime = -_tinyNum; // helps ensure that the next render() will be forced (crossingStart = true in render()), even if the duration hasn't changed (we're adding a child which would need to get rendered). Definitely an edge case. Note: we MUST do this AFTER the loop above where the totalTime() might trigger a render() because this _addToTimeline() method gets called from the Animation constructor, BEFORE tweens even record their targets, etc. so we wouldn't want things to get triggered in the wrong order.
2422  }
2423},
2424    _addToTimeline = function _addToTimeline(timeline, child, position, skipChecks) {
2425  child.parent && _removeFromParent(child);
2426  child._start = _roundPrecise((_isNumber(position) ? position : position || timeline !== _globalTimeline ? _parsePosition(timeline, position, child) : timeline._time) + child._delay);
2427  child._end = _roundPrecise(child._start + (child.totalDuration() / Math.abs(child.timeScale()) || 0));
2428
2429  _addLinkedListItem(timeline, child, "_first", "_last", timeline._sort ? "_start" : 0);
2430
2431  _isFromOrFromStart(child) || (timeline._recent = child);
2432  skipChecks || _postAddChecks(timeline, child);
2433  timeline._ts < 0 && _alignPlayhead(timeline, timeline._tTime); // if the timeline is reversed and the new child makes it longer, we may need to adjust the parent's _start (push it back)
2434
2435  return timeline;
2436},
2437    _scrollTrigger = function _scrollTrigger(animation, trigger) {
2438  return (_globals.ScrollTrigger || _missingPlugin("scrollTrigger", trigger)) && _globals.ScrollTrigger.create(trigger, animation);
2439},
2440    _attemptInitTween = function _attemptInitTween(tween, time, force, suppressEvents, tTime) {
2441  _initTween(tween, time, tTime);
2442
2443  if (!tween._initted) {
2444    return 1;
2445  }
2446
2447  if (!force && tween._pt && !_reverting && (tween._dur && tween.vars.lazy !== false || !tween._dur && tween.vars.lazy) && _lastRenderedFrame !== _ticker.frame) {
2448    _lazyTweens.push(tween);
2449
2450    tween._lazy = [tTime, suppressEvents];
2451    return 1;
2452  }
2453},
2454    _parentPlayheadIsBeforeStart = function _parentPlayheadIsBeforeStart(_ref) {
2455  var parent = _ref.parent;
2456  return parent && parent._ts && parent._initted && !parent._lock && (parent.rawTime() < 0 || _parentPlayheadIsBeforeStart(parent));
2457},
2458    // check parent's _lock because when a timeline repeats/yoyos and does its artificial wrapping, we shouldn't force the ratio back to 0
2459_isFromOrFromStart = function _isFromOrFromStart(_ref2) {
2460  var data = _ref2.data;
2461  return data === "isFromStart" || data === "isStart";
2462},
2463    _renderZeroDurationTween = function _renderZeroDurationTween(tween, totalTime, suppressEvents, force) {
2464  var prevRatio = tween.ratio,
2465      ratio = totalTime < 0 || !totalTime && (!tween._start && _parentPlayheadIsBeforeStart(tween) && !(!tween._initted && _isFromOrFromStart(tween)) || (tween._ts < 0 || tween._dp._ts < 0) && !_isFromOrFromStart(tween)) ? 0 : 1,
2466      // if the tween or its parent is reversed and the totalTime is 0, we should go to a ratio of 0. Edge case: if a from() or fromTo() stagger tween is placed later in a timeline, the "startAt" zero-duration tween could initially render at a time when the parent timeline's playhead is technically BEFORE where this tween is, so make sure that any "from" and "fromTo" startAt tweens are rendered the first time at a ratio of 1.
2467  repeatDelay = tween._rDelay,
2468      tTime = 0,
2469      pt,
2470      iteration,
2471      prevIteration;
2472
2473  if (repeatDelay && tween._repeat) {
2474    // in case there's a zero-duration tween that has a repeat with a repeatDelay
2475    tTime = _clamp(0, tween._tDur, totalTime);
2476    iteration = _animationCycle(tTime, repeatDelay);
2477    tween._yoyo && iteration & 1 && (ratio = 1 - ratio);
2478
2479    if (iteration !== _animationCycle(tween._tTime, repeatDelay)) {
2480      // if iteration changed
2481      prevRatio = 1 - ratio;
2482      tween.vars.repeatRefresh && tween._initted && tween.invalidate();
2483    }
2484  }
2485
2486  if (ratio !== prevRatio || _reverting || force || tween._zTime === _tinyNum || !totalTime && tween._zTime) {
2487    if (!tween._initted && _attemptInitTween(tween, totalTime, force, suppressEvents, tTime)) {
2488      // if we render the very beginning (time == 0) of a fromTo(), we must force the render (normal tweens wouldn't need to render at a time of 0 when the prevTime was also 0). This is also mandatory to make sure overwriting kicks in immediately.
2489      return;
2490    }
2491
2492    prevIteration = tween._zTime;
2493    tween._zTime = totalTime || (suppressEvents ? _tinyNum : 0); // when the playhead arrives at EXACTLY time 0 (right on top) of a zero-duration tween, we need to discern if events are suppressed so that when the playhead moves again (next time), it'll trigger the callback. If events are NOT suppressed, obviously the callback would be triggered in this render. Basically, the callback should fire either when the playhead ARRIVES or LEAVES this exact spot, not both. Imagine doing a timeline.seek(0) and there's a callback that sits at 0. Since events are suppressed on that seek() by default, nothing will fire, but when the playhead moves off of that position, the callback should fire. This behavior is what people intuitively expect.
2494
2495    suppressEvents || (suppressEvents = totalTime && !prevIteration); // if it was rendered previously at exactly 0 (_zTime) and now the playhead is moving away, DON'T fire callbacks otherwise they'll seem like duplicates.
2496
2497    tween.ratio = ratio;
2498    tween._from && (ratio = 1 - ratio);
2499    tween._time = 0;
2500    tween._tTime = tTime;
2501    pt = tween._pt;
2502
2503    while (pt) {
2504      pt.r(ratio, pt.d);
2505      pt = pt._next;
2506    }
2507
2508    totalTime < 0 && _rewindStartAt(tween, totalTime, suppressEvents, true);
2509    tween._onUpdate && !suppressEvents && _callback(tween, "onUpdate");
2510    tTime && tween._repeat && !suppressEvents && tween.parent && _callback(tween, "onRepeat");
2511
2512    if ((totalTime >= tween._tDur || totalTime < 0) && tween.ratio === ratio) {
2513      ratio && _removeFromParent(tween, 1);
2514
2515      if (!suppressEvents && !_reverting) {
2516        _callback(tween, ratio ? "onComplete" : "onReverseComplete", true);
2517
2518        tween._prom && tween._prom();
2519      }
2520    }
2521  } else if (!tween._zTime) {
2522    tween._zTime = totalTime;
2523  }
2524},
2525    _findNextPauseTween = function _findNextPauseTween(animation, prevTime, time) {
2526  var child;
2527
2528  if (time > prevTime) {
2529    child = animation._first;
2530
2531    while (child && child._start <= time) {
2532      if (child.data === "isPause" && child._start > prevTime) {
2533        return child;
2534      }
2535
2536      child = child._next;
2537    }
2538  } else {
2539    child = animation._last;
2540
2541    while (child && child._start >= time) {
2542      if (child.data === "isPause" && child._start < prevTime) {
2543        return child;
2544      }
2545
2546      child = child._prev;
2547    }
2548  }
2549},
2550    _setDuration = function _setDuration(animation, duration, skipUncache, leavePlayhead) {
2551  var repeat = animation._repeat,
2552      dur = _roundPrecise(duration) || 0,
2553      totalProgress = animation._tTime / animation._tDur;
2554  totalProgress && !leavePlayhead && (animation._time *= dur / animation._dur);
2555  animation._dur = dur;
2556  animation._tDur = !repeat ? dur : repeat < 0 ? 1e10 : _roundPrecise(dur * (repeat + 1) + animation._rDelay * repeat);
2557  totalProgress > 0 && !leavePlayhead && _alignPlayhead(animation, animation._tTime = animation._tDur * totalProgress);
2558  animation.parent && _setEnd(animation);
2559  skipUncache || _uncache(animation.parent, animation);
2560  return animation;
2561},
2562    _onUpdateTotalDuration = function _onUpdateTotalDuration(animation) {
2563  return animation instanceof Timeline ? _uncache(animation) : _setDuration(animation, animation._dur);
2564},
2565    _zeroPosition = {
2566  _start: 0,
2567  endTime: _emptyFunc,
2568  totalDuration: _emptyFunc
2569},
2570    _parsePosition = function _parsePosition(animation, position, percentAnimation) {
2571  var labels = animation.labels,
2572      recent = animation._recent || _zeroPosition,
2573      clippedDuration = animation.duration() >= _bigNum ? recent.endTime(false) : animation._dur,
2574      //in case there's a child that infinitely repeats, users almost never intend for the insertion point of a new child to be based on a SUPER long value like that so we clip it and assume the most recently-added child's endTime should be used instead.
2575  i,
2576      offset,
2577      isPercent;
2578
2579  if (_isString(position) && (isNaN(position) || position in labels)) {
2580    //if the string is a number like "1", check to see if there's a label with that name, otherwise interpret it as a number (absolute value).
2581    offset = position.charAt(0);
2582    isPercent = position.substr(-1) === "%";
2583    i = position.indexOf("=");
2584
2585    if (offset === "<" || offset === ">") {
2586      i >= 0 && (position = position.replace(/=/, ""));
2587      return (offset === "<" ? recent._start : recent.endTime(recent._repeat >= 0)) + (parseFloat(position.substr(1)) || 0) * (isPercent ? (i < 0 ? recent : percentAnimation).totalDuration() / 100 : 1);
2588    }
2589
2590    if (i < 0) {
2591      position in labels || (labels[position] = clippedDuration);
2592      return labels[position];
2593    }
2594
2595    offset = parseFloat(position.charAt(i - 1) + position.substr(i + 1));
2596
2597    if (isPercent && percentAnimation) {
2598      offset = offset / 100 * (_isArray(percentAnimation) ? percentAnimation[0] : percentAnimation).totalDuration();
2599    }
2600
2601    return i > 1 ? _parsePosition(animation, position.substr(0, i - 1), percentAnimation) + offset : clippedDuration + offset;
2602  }
2603
2604  return position == null ? clippedDuration : +position;
2605},
2606    _createTweenType = function _createTweenType(type, params, timeline) {
2607  var isLegacy = _isNumber(params[1]),
2608      varsIndex = (isLegacy ? 2 : 1) + (type < 2 ? 0 : 1),
2609      vars = params[varsIndex],
2610      irVars,
2611      parent;
2612
2613  isLegacy && (vars.duration = params[1]);
2614  vars.parent = timeline;
2615
2616  if (type) {
2617    irVars = vars;
2618    parent = timeline;
2619
2620    while (parent && !("immediateRender" in irVars)) {
2621      // inheritance hasn't happened yet, but someone may have set a default in an ancestor timeline. We could do vars.immediateRender = _isNotFalse(_inheritDefaults(vars).immediateRender) but that'd exact a slight performance penalty because _inheritDefaults() also runs in the Tween constructor. We're paying a small kb price here to gain speed.
2622      irVars = parent.vars.defaults || {};
2623      parent = _isNotFalse(parent.vars.inherit) && parent.parent;
2624    }
2625
2626    vars.immediateRender = _isNotFalse(irVars.immediateRender);
2627    type < 2 ? vars.runBackwards = 1 : vars.startAt = params[varsIndex - 1]; // "from" vars
2628  }
2629
2630  return new Tween(params[0], vars, params[varsIndex + 1]);
2631},
2632    _conditionalReturn = function _conditionalReturn(value, func) {
2633  return value || value === 0 ? func(value) : func;
2634},
2635    _clamp = function _clamp(min, max, value) {
2636  return value < min ? min : value > max ? max : value;
2637},
2638    getUnit = function getUnit(value, v) {
2639  return !_isString(value) || !(v = _unitExp.exec(value)) ? "" : v[1];
2640},
2641    // note: protect against padded numbers as strings, like "100.100". That shouldn't return "00" as the unit. If it's numeric, return no unit.
2642clamp = function clamp(min, max, value) {
2643  return _conditionalReturn(value, function (v) {
2644    return _clamp(min, max, v);
2645  });
2646},
2647    _slice = [].slice,
2648    _isArrayLike = function _isArrayLike(value, nonEmpty) {
2649  return value && _isObject(value) && "length" in value && (!nonEmpty && !value.length || value.length - 1 in value && _isObject(value[0])) && !value.nodeType && value !== _win;
2650},
2651    _flatten = function _flatten(ar, leaveStrings, accumulator) {
2652  if (accumulator === void 0) {
2653    accumulator = [];
2654  }
2655
2656  return ar.forEach(function (value) {
2657    var _accumulator;
2658
2659    return _isString(value) && !leaveStrings || _isArrayLike(value, 1) ? (_accumulator = accumulator).push.apply(_accumulator, toArray(value)) : accumulator.push(value);
2660  }) || accumulator;
2661},
2662    // takes any value and returns an Array. If it's a string (and leaveStrings isn't true), it'll use document.querySelectorAll() and convert that to an array. It'll also accept iterables like jQuery objects.
2663toArray = function toArray(value, scope, leaveStrings) {
2664  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] : [];
2665},
2666    selector = function selector(value) {
2667  value = toArray(value)[0] || _warn("Invalid scope") || {};
2668  return function (v) {
2669    var el = value.current || value.nativeElement || value;
2670    return toArray(v, el.querySelectorAll ? el : el === value ? _warn("Invalid scope") || _doc.createElement("div") : value);
2671  };
2672},
2673    shuffle = function shuffle(a) {
2674  return a.sort(function () {
2675    return .5 - Math.random();
2676  });
2677},
2678    // alternative that's a bit faster and more reliably diverse but bigger:   for (let j, v, i = a.length; i; j = (Math.random() * i) | 0, v = a[--i], a[i] = a[j], a[j] = v); return a;
2679// for distributing values across an Array. Can accept a number, a function or (most commonly) an object which can contain the following properties: {base, amount, from, ease, grid, axis, length, each}. Returns a function that expects the following parameters: index, target, array.
2680distribute = function distribute(v) {
2681  if (_isFunction(v)) {
2682    return v;
2683  }
2684
2685  var vars = _isObject(v) ? v : {
2686    each: v
2687  },
2688      //n:1 is just to indicate v was a number; we leverage that later to set v according to the length we get. If a number is passed in, we treat it like the old stagger value where 0.1, for example, would mean that things would be distributed with 0.1 between each element in the array rather than a total "amount" that's chunked out among them all.
2689  ease = _parseEase(vars.ease),
2690      from = vars.from || 0,
2691      base = parseFloat(vars.base) || 0,
2692      cache = {},
2693      isDecimal = from > 0 && from < 1,
2694      ratios = isNaN(from) || isDecimal,
2695      axis = vars.axis,
2696      ratioX = from,
2697      ratioY = from;
2698
2699  if (_isString(from)) {
2700    ratioX = ratioY = {
2701      center: .5,
2702      edges: .5,
2703      end: 1
2704    }[from] || 0;
2705  } else if (!isDecimal && ratios) {
2706    ratioX = from[0];
2707    ratioY = from[1];
2708  }
2709
2710  return function (i, target, a) {
2711    var l = (a || vars).length,
2712        distances = cache[l],
2713        originX,
2714        originY,
2715        x,
2716        y,
2717        d,
2718        j,
2719        max,
2720        min,
2721        wrapAt;
2722
2723    if (!distances) {
2724      wrapAt = vars.grid === "auto" ? 0 : (vars.grid || [1, _bigNum])[1];
2725
2726      if (!wrapAt) {
2727        max = -_bigNum;
2728
2729        while (max < (max = a[wrapAt++].getBoundingClientRect().left) && wrapAt < l) {}
2730
2731        wrapAt < l && wrapAt--;
2732      }
2733
2734      distances = cache[l] = [];
2735      originX = ratios ? Math.min(wrapAt, l) * ratioX - .5 : from % wrapAt;
2736      originY = wrapAt === _bigNum ? 0 : ratios ? l * ratioY / wrapAt - .5 : from / wrapAt | 0;
2737      max = 0;
2738      min = _bigNum;
2739
2740      for (j = 0; j < l; j++) {
2741        x = j % wrapAt - originX;
2742        y = originY - (j / wrapAt | 0);
2743        distances[j] = d = !axis ? _sqrt(x * x + y * y) : Math.abs(axis === "y" ? y : x);
2744        d > max && (max = d);
2745        d < min && (min = d);
2746      }
2747
2748      from === "random" && shuffle(distances);
2749      distances.max = max - min;
2750      distances.min = min;
2751      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);
2752      distances.b = l < 0 ? base - l : base;
2753      distances.u = getUnit(vars.amount || vars.each) || 0; //unit
2754
2755      ease = ease && l < 0 ? _invertEase(ease) : ease;
2756    }
2757
2758    l = (distances[i] - distances.min) / distances.max || 0;
2759    return _roundPrecise(distances.b + (ease ? ease(l) : l) * distances.v) + distances.u; //round in order to work around floating point errors
2760  };
2761},
2762    _roundModifier = function _roundModifier(v) {
2763  //pass in 0.1 get a function that'll round to the nearest tenth, or 5 to round to the closest 5, or 0.001 to the closest 1000th, etc.
2764  var p = Math.pow(10, ((v + "").split(".")[1] || "").length); //to avoid floating point math errors (like 24 * 0.1 == 2.4000000000000004), we chop off at a specific number of decimal places (much faster than toFixed())
2765
2766  return function (raw) {
2767    var n = _roundPrecise(Math.round(parseFloat(raw) / v) * v * p);
2768
2769    return (n - n % 1) / p + (_isNumber(raw) ? 0 : getUnit(raw)); // n - n % 1 replaces Math.floor() in order to handle negative values properly. For example, Math.floor(-150.00000000000003) is 151!
2770  };
2771},
2772    snap = function snap(snapTo, value) {
2773  var isArray = _isArray(snapTo),
2774      radius,
2775      is2D;
2776
2777  if (!isArray && _isObject(snapTo)) {
2778    radius = isArray = snapTo.radius || _bigNum;
2779
2780    if (snapTo.values) {
2781      snapTo = toArray(snapTo.values);
2782
2783      if (is2D = !_isNumber(snapTo[0])) {
2784        radius *= radius; //performance optimization so we don't have to Math.sqrt() in the loop.
2785      }
2786    } else {
2787      snapTo = _roundModifier(snapTo.increment);
2788    }
2789  }
2790
2791  return _conditionalReturn(value, !isArray ? _roundModifier(snapTo) : _isFunction(snapTo) ? function (raw) {
2792    is2D = snapTo(raw);
2793    return Math.abs(is2D - raw) <= radius ? is2D : raw;
2794  } : function (raw) {
2795    var x = parseFloat(is2D ? raw.x : raw),
2796        y = parseFloat(is2D ? raw.y : 0),
2797        min = _bigNum,
2798        closest = 0,
2799        i = snapTo.length,
2800        dx,
2801        dy;
2802
2803    while (i--) {
2804      if (is2D) {
2805        dx = snapTo[i].x - x;
2806        dy = snapTo[i].y - y;
2807        dx = dx * dx + dy * dy;
2808      } else {
2809        dx = Math.abs(snapTo[i] - x);
2810      }
2811
2812      if (dx < min) {
2813        min = dx;
2814        closest = i;
2815      }
2816    }
2817
2818    closest = !radius || min <= radius ? snapTo[closest] : raw;
2819    return is2D || closest === raw || _isNumber(raw) ? closest : closest + getUnit(raw);
2820  });
2821},
2822    random = function random(min, max, roundingIncrement, returnFunction) {
2823  return _conditionalReturn(_isArray(min) ? !max : roundingIncrement === true ? !!(roundingIncrement = 0) : !returnFunction, function () {
2824    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;
2825  });
2826},
2827    pipe = function pipe() {
2828  for (var _len = arguments.length, functions = new Array(_len), _key = 0; _key < _len; _key++) {
2829    functions[_key] = arguments[_key];
2830  }
2831
2832  return function (value) {
2833    return functions.reduce(function (v, f) {
2834      return f(v);
2835    }, value);
2836  };
2837},
2838    unitize = function unitize(func, unit) {
2839  return function (value) {
2840    return func(parseFloat(value)) + (unit || getUnit(value));
2841  };
2842},
2843    normalize = function normalize(min, max, value) {
2844  return mapRange(min, max, 0, 1, value);
2845},
2846    _wrapArray = function _wrapArray(a, wrapper, value) {
2847  return _conditionalReturn(value, function (index) {
2848    return a[~~wrapper(index)];
2849  });
2850},
2851    wrap = function wrap(min, max, value) {
2852  // NOTE: wrap() CANNOT be an arrow function! A very odd compiling bug causes problems (unrelated to GSAP).
2853  var range = max - min;
2854  return _isArray(min) ? _wrapArray(min, wrap(0, min.length), max) : _conditionalReturn(value, function (value) {
2855    return (range + (value - min) % range) % range + min;
2856  });
2857},
2858    wrapYoyo = function wrapYoyo(min, max, value) {
2859  var range = max - min,
2860      total = range * 2;
2861  return _isArray(min) ? _wrapArray(min, wrapYoyo(0, min.length - 1), max) : _conditionalReturn(value, function (value) {
2862    value = (total + (value - min) % total) % total || 0;
2863    return min + (value > range ? total - value : value);
2864  });
2865},
2866    _replaceRandom = function _replaceRandom(s) {
2867  return s.replace(_randomExp, function (match) {
2868    //replaces all occurrences of random(...) in a string with the calculated random value. can be a range like random(-100, 100, 5) or an array like random([0, 100, 500])
2869    var arIndex = match.indexOf("[") + 1,
2870        values = match.substring(arIndex || 7, arIndex ? match.indexOf("]") : match.length - 1).split(_commaDelimExp);
2871    return random(arIndex ? values : +values[0], arIndex ? 0 : +values[1], +values[2] || 1e-5);
2872  });
2873},
2874    mapRange = function mapRange(inMin, inMax, outMin, outMax, value) {
2875  var inRange = inMax - inMin,
2876      outRange = outMax - outMin;
2877  return _conditionalReturn(value, function (value) {
2878    return outMin + ((value - inMin) / inRange * outRange || 0);
2879  });
2880},
2881    interpolate = function interpolate(start, end, progress, mutate) {
2882  var func = isNaN(start + end) ? 0 : function (p) {
2883    return (1 - p) * start + p * end;
2884  };
2885
2886  if (!func) {
2887    var isString = _isString(start),
2888        master = {},
2889        p,
2890        i,
2891        interpolators,
2892        l,
2893        il;
2894
2895    progress === true && (mutate = 1) && (progress = null);
2896
2897    if (isString) {
2898      start = {
2899        p: start
2900      };
2901      end = {
2902        p: end
2903      };
2904    } else if (_isArray(start) && !_isArray(end)) {
2905      interpolators = [];
2906      l = start.length;
2907      il = l - 2;
2908
2909      for (i = 1; i < l; i++) {
2910        interpolators.push(interpolate(start[i - 1], start[i])); //build the interpolators up front as a performance optimization so that when the function is called many times, it can just reuse them.
2911      }
2912
2913      l--;
2914
2915      func = function func(p) {
2916        p *= l;
2917        var i = Math.min(il, ~~p);
2918        return interpolators[i](p - i);
2919      };
2920
2921      progress = end;
2922    } else if (!mutate) {
2923      start = _merge(_isArray(start) ? [] : {}, start);
2924    }
2925
2926    if (!interpolators) {
2927      for (p in end) {
2928        _addPropTween.call(master, start, p, "get", end[p]);
2929      }
2930
2931      func = function func(p) {
2932        return _renderPropTweens(p, master) || (isString ? start.p : start);
2933      };
2934    }
2935  }
2936
2937  return _conditionalReturn(progress, func);
2938},
2939    _getLabelInDirection = function _getLabelInDirection(timeline, fromTime, backward) {
2940  //used for nextLabel() and previousLabel()
2941  var labels = timeline.labels,
2942      min = _bigNum,
2943      p,
2944      distance,
2945      label;
2946
2947  for (p in labels) {
2948    distance = labels[p] - fromTime;
2949
2950    if (distance < 0 === !!backward && distance && min > (distance = Math.abs(distance))) {
2951      label = p;
2952      min = distance;
2953    }
2954  }
2955
2956  return label;
2957},
2958    _callback = function _callback(animation, type, executeLazyFirst) {
2959  var v = animation.vars,
2960      callback = v[type],
2961      prevContext = _context,
2962      context = animation._ctx,
2963      params,
2964      scope,
2965      result;
2966
2967  if (!callback) {
2968    return;
2969  }
2970
2971  params = v[type + "Params"];
2972  scope = v.callbackScope || animation;
2973  executeLazyFirst && _lazyTweens.length && _lazyRender(); //in case rendering caused any tweens to lazy-init, we should render them because typically when a timeline finishes, users expect things to have rendered fully. Imagine an onUpdate on a timeline that reports/checks tweened values.
2974
2975  context && (_context = context);
2976  result = params ? callback.apply(scope, params) : callback.call(scope);
2977  _context = prevContext;
2978  return result;
2979},
2980    _interrupt = function _interrupt(animation) {
2981  _removeFromParent(animation);
2982
2983  animation.scrollTrigger && animation.scrollTrigger.kill(!!_reverting);
2984  animation.progress() < 1 && _callback(animation, "onInterrupt");
2985  return animation;
2986},
2987    _quickTween,
2988    _registerPluginQueue = [],
2989    _createPlugin = function _createPlugin(config) {
2990  if (!config) return;
2991  config = !config.name && config["default"] || config; // UMD packaging wraps things oddly, so for example MotionPathHelper becomes {MotionPathHelper:MotionPathHelper, default:MotionPathHelper}.
2992
2993  if (_windowExists() || config.headless) {
2994    // edge case: some build tools may pass in a null/undefined value
2995    var name = config.name,
2996        isFunc = _isFunction(config),
2997        Plugin = name && !isFunc && config.init ? function () {
2998      this._props = [];
2999    } : config,
3000        //in case someone passes in an object that's not a plugin, like CustomEase
3001    instanceDefaults = {
3002      init: _emptyFunc,
3003      render: _renderPropTweens,
3004      add: _addPropTween,
3005      kill: _killPropTweensOf,
3006      modifier: _addPluginModifier,
3007      rawVars: 0
3008    },
3009        statics = {
3010      targetTest: 0,
3011      get: 0,
3012      getSetter: _getSetter,
3013      aliases: {},
3014      register: 0
3015    };
3016
3017    _wake();
3018
3019    if (config !== Plugin) {
3020      if (_plugins[name]) {
3021        return;
3022      }
3023
3024      _setDefaults(Plugin, _setDefaults(_copyExcluding(config, instanceDefaults), statics)); //static methods
3025
3026
3027      _merge(Plugin.prototype, _merge(instanceDefaults, _copyExcluding(config, statics))); //instance methods
3028
3029
3030      _plugins[Plugin.prop = name] = Plugin;
3031
3032      if (config.targetTest) {
3033        _harnessPlugins.push(Plugin);
3034
3035        _reservedProps[name] = 1;
3036      }
3037
3038      name = (name === "css" ? "CSS" : name.charAt(0).toUpperCase() + name.substr(1)) + "Plugin"; //for the global name. "motionPath" should become MotionPathPlugin
3039    }
3040
3041    _addGlobal(name, Plugin);
3042
3043    config.register && config.register(gsap, Plugin, PropTween);
3044  } else {
3045    _registerPluginQueue.push(config);
3046  }
3047},
3048
3049/*
3050 * --------------------------------------------------------------------------------------
3051 * COLORS
3052 * --------------------------------------------------------------------------------------
3053 */
3054_255 = 255,
3055    _colorLookup = {
3056  aqua: [0, _255, _255],
3057  lime: [0, _255, 0],
3058  silver: [192, 192, 192],
3059  black: [0, 0, 0],
3060  maroon: [128, 0, 0],
3061  teal: [0, 128, 128],
3062  blue: [0, 0, _255],
3063  navy: [0, 0, 128],
3064  white: [_255, _255, _255],
3065  olive: [128, 128, 0],
3066  yellow: [_255, _255, 0],
3067  orange: [_255, 165, 0],
3068  gray: [128, 128, 128],
3069  purple: [128, 0, 128],
3070  green: [0, 128, 0],
3071  red: [_255, 0, 0],
3072  pink: [_255, 192, 203],
3073  cyan: [0, _255, _255],
3074  transparent: [_255, _255, _255, 0]
3075},
3076    // possible future idea to replace the hard-coded color name values - put this in the ticker.wake() where we set the _doc:
3077// let ctx = _doc.createElement("canvas").getContext("2d");
3078// _forEachName("aqua,lime,silver,black,maroon,teal,blue,navy,white,olive,yellow,orange,gray,purple,green,red,pink,cyan", color => {ctx.fillStyle = color; _colorLookup[color] = splitColor(ctx.fillStyle)});
3079_hue = function _hue(h, m1, m2) {
3080  h += h < 0 ? 1 : h > 1 ? -1 : 0;
3081  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;
3082},
3083    splitColor = function splitColor(v, toHSL, forceAlpha) {
3084  var a = !v ? _colorLookup.black : _isNumber(v) ? [v >> 16, v >> 8 & _255, v & _255] : 0,
3085      r,
3086      g,
3087      b,
3088      h,
3089      s,
3090      l,
3091      max,
3092      min,
3093      d,
3094      wasHSL;
3095
3096  if (!a) {
3097    if (v.substr(-1) === ",") {
3098      //sometimes a trailing comma is included and we should chop it off (typically from a comma-delimited list of values like a textShadow:"2px 2px 2px blue, 5px 5px 5px rgb(255,0,0)" - in this example "blue," has a trailing comma. We could strip it out inside parseComplex() but we'd need to do it to the beginning and ending values plus it wouldn't provide protection from other potential scenarios like if the user passes in a similar value.
3099      v = v.substr(0, v.length - 1);
3100    }
3101
3102    if (_colorLookup[v]) {
3103      a = _colorLookup[v];
3104    } else if (v.charAt(0) === "#") {
3105      if (v.length < 6) {
3106        //for shorthand like #9F0 or #9F0F (could have alpha)
3107        r = v.charAt(1);
3108        g = v.charAt(2);
3109        b = v.charAt(3);
3110        v = "#" + r + r + g + g + b + b + (v.length === 5 ? v.charAt(4) + v.charAt(4) : "");
3111      }
3112
3113      if (v.length === 9) {
3114        // hex with alpha, like #fd5e53ff
3115        a = parseInt(v.substr(1, 6), 16);
3116        return [a >> 16, a >> 8 & _255, a & _255, parseInt(v.substr(7), 16) / 255];
3117      }
3118
3119      v = parseInt(v.substr(1), 16);
3120      a = [v >> 16, v >> 8 & _255, v & _255];
3121    } else if (v.substr(0, 3) === "hsl") {
3122      a = wasHSL = v.match(_strictNumExp);
3123
3124      if (!toHSL) {
3125        h = +a[0] % 360 / 360;
3126        s = +a[1] / 100;
3127        l = +a[2] / 100;
3128        g = l <= .5 ? l * (s + 1) : l + s - l * s;
3129        r = l * 2 - g;
3130        a.length > 3 && (a[3] *= 1); //cast as number
3131
3132        a[0] = _hue(h + 1 / 3, r, g);
3133        a[1] = _hue(h, r, g);
3134        a[2] = _hue(h - 1 / 3, r, g);
3135      } else if (~v.indexOf("=")) {
3136        //if relative values are found, just return the raw strings with the relative prefixes in place.
3137        a = v.match(_numExp);
3138        forceAlpha && a.length < 4 && (a[3] = 1);
3139        return a;
3140      }
3141    } else {
3142      a = v.match(_strictNumExp) || _colorLookup.transparent;
3143    }
3144
3145    a = a.map(Number);
3146  }
3147
3148  if (toHSL && !wasHSL) {
3149    r = a[0] / _255;
3150    g = a[1] / _255;
3151    b = a[2] / _255;
3152    max = Math.max(r, g, b);
3153    min = Math.min(r, g, b);
3154    l = (max + min) / 2;
3155
3156    if (max === min) {
3157      h = s = 0;
3158    } else {
3159      d = max - min;
3160      s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
3161      h = max === r ? (g - b) / d + (g < b ? 6 : 0) : max === g ? (b - r) / d + 2 : (r - g) / d + 4;
3162      h *= 60;
3163    }
3164
3165    a[0] = ~~(h + .5);
3166    a[1] = ~~(s * 100 + .5);
3167    a[2] = ~~(l * 100 + .5);
3168  }
3169
3170  forceAlpha && a.length < 4 && (a[3] = 1);
3171  return a;
3172},
3173    _colorOrderData = function _colorOrderData(v) {
3174  // strips out the colors from the string, finds all the numeric slots (with units) and returns an array of those. The Array also has a "c" property which is an Array of the index values where the colors belong. This is to help work around issues where there's a mis-matched order of color/numeric data like drop-shadow(#f00 0px 1px 2px) and drop-shadow(0x 1px 2px #f00). This is basically a helper function used in _formatColors()
3175  var values = [],
3176      c = [],
3177      i = -1;
3178  v.split(_colorExp).forEach(function (v) {
3179    var a = v.match(_numWithUnitExp) || [];
3180    values.push.apply(values, a);
3181    c.push(i += a.length + 1);
3182  });
3183  values.c = c;
3184  return values;
3185},
3186    _formatColors = function _formatColors(s, toHSL, orderMatchData) {
3187  var result = "",
3188      colors = (s + result).match(_colorExp),
3189      type = toHSL ? "hsla(" : "rgba(",
3190      i = 0,
3191      c,
3192      shell,
3193      d,
3194      l;
3195
3196  if (!colors) {
3197    return s;
3198  }
3199
3200  colors = colors.map(function (color) {
3201    return (color = splitColor(color, toHSL, 1)) && type + (toHSL ? color[0] + "," + color[1] + "%," + color[2] + "%," + color[3] : color.join(",")) + ")";
3202  });
3203
3204  if (orderMatchData) {
3205    d = _colorOrderData(s);
3206    c = orderMatchData.c;
3207
3208    if (c.join(result) !== d.c.join(result)) {
3209      shell = s.replace(_colorExp, "1").split(_numWithUnitExp);
3210      l = shell.length - 1;
3211
3212      for (; i < l; i++) {
3213        result += shell[i] + (~c.indexOf(i) ? colors.shift() || type + "0,0,0,0)" : (d.length ? d : colors.length ? colors : orderMatchData).shift());
3214      }
3215    }
3216  }
3217
3218  if (!shell) {
3219    shell = s.split(_colorExp);
3220    l = shell.length - 1;
3221
3222    for (; i < l; i++) {
3223      result += shell[i] + colors[i];
3224    }
3225  }
3226
3227  return result + shell[l];
3228},
3229    _colorExp = function () {
3230  var s = "(?:\\b(?:(?:rgb|rgba|hsl|hsla)\\(.+?\\))|\\B#(?:[0-9a-f]{3,4}){1,2}\\b",
3231      //we'll dynamically build this Regular Expression to conserve file size. After building it, it will be able to find rgb(), rgba(), # (hexadecimal), and named color values like red, blue, purple, etc.,
3232  p;
3233
3234  for (p in _colorLookup) {
3235    s += "|" + p + "\\b";
3236  }
3237
3238  return new RegExp(s + ")", "gi");
3239}(),
3240    _hslExp = /hsl[a]?\(/,
3241    _colorStringFilter = function _colorStringFilter(a) {
3242  var combined = a.join(" "),
3243      toHSL;
3244  _colorExp.lastIndex = 0;
3245
3246  if (_colorExp.test(combined)) {
3247    toHSL = _hslExp.test(combined);
3248    a[1] = _formatColors(a[1], toHSL);
3249    a[0] = _formatColors(a[0], toHSL, _colorOrderData(a[1])); // make sure the order of numbers/colors match with the END value.
3250
3251    return true;
3252  }
3253},
3254
3255/*
3256 * --------------------------------------------------------------------------------------
3257 * TICKER
3258 * --------------------------------------------------------------------------------------
3259 */
3260_tickerActive,
3261    _ticker = function () {
3262  var _getTime = Date.now,
3263      _lagThreshold = 500,
3264      _adjustedLag = 33,
3265      _startTime = _getTime(),
3266      _lastUpdate = _startTime,
3267      _gap = 1000 / 240,
3268      _nextTime = _gap,
3269      _listeners = [],
3270      _id,
3271      _req,
3272      _raf,
3273      _self,
3274      _delta,
3275      _i,
3276      _tick = function _tick(v) {
3277    var elapsed = _getTime() - _lastUpdate,
3278        manual = v === true,
3279        overlap,
3280        dispatch,
3281        time,
3282        frame;
3283
3284    (elapsed > _lagThreshold || elapsed < 0) && (_startTime += elapsed - _adjustedLag);
3285    _lastUpdate += elapsed;
3286    time = _lastUpdate - _startTime;
3287    overlap = time - _nextTime;
3288
3289    if (overlap > 0 || manual) {
3290      frame = ++_self.frame;
3291      _delta = time - _self.time * 1000;
3292      _self.time = time = time / 1000;
3293      _nextTime += overlap + (overlap >= _gap ? 4 : _gap - overlap);
3294      dispatch = 1;
3295    }
3296
3297    manual || (_id = _req(_tick)); //make sure the request is made before we dispatch the "tick" event so that timing is maintained. Otherwise, if processing the "tick" requires a bunch of time (like 15ms) and we're using a setTimeout() that's based on 16.7ms, it'd technically take 31.7ms between frames otherwise.
3298
3299    if (dispatch) {
3300      for (_i = 0; _i < _listeners.length; _i++) {
3301        // use _i and check _listeners.length instead of a variable because a listener could get removed during the loop, and if that happens to an element less than the current index, it'd throw things off in the loop.
3302        _listeners[_i](time, _delta, frame, v);
3303      }
3304    }
3305  };
3306
3307  _self = {
3308    time: 0,
3309    frame: 0,
3310    tick: function tick() {
3311      _tick(true);
3312    },
3313    deltaRatio: function deltaRatio(fps) {
3314      return _delta / (1000 / (fps || 60));
3315    },
3316    wake: function wake() {
3317      if (_coreReady) {
3318        if (!_coreInitted && _windowExists()) {
3319          _win = _coreInitted = window;
3320          _doc = _win.document || {};
3321          _globals.gsap = gsap;
3322          (_win.gsapVersions || (_win.gsapVersions = [])).push(gsap.version);
3323
3324          _install(_installScope || _win.GreenSockGlobals || !_win.gsap && _win || {});
3325
3326          _registerPluginQueue.forEach(_createPlugin);
3327        }
3328
3329        _raf = typeof requestAnimationFrame !== "undefined" && requestAnimationFrame;
3330        _id && _self.sleep();
3331
3332        _req = _raf || function (f) {
3333          return setTimeout(f, _nextTime - _self.time * 1000 + 1 | 0);
3334        };
3335
3336        _tickerActive = 1;
3337
3338        _tick(2);
3339      }
3340    },
3341    sleep: function sleep() {
3342      (_raf ? cancelAnimationFrame : clearTimeout)(_id);
3343      _tickerActive = 0;
3344      _req = _emptyFunc;
3345    },
3346    lagSmoothing: function lagSmoothing(threshold, adjustedLag) {
3347      _lagThreshold = threshold || Infinity; // zero should be interpreted as basically unlimited
3348
3349      _adjustedLag = Math.min(adjustedLag || 33, _lagThreshold);
3350    },
3351    fps: function fps(_fps) {
3352      _gap = 1000 / (_fps || 240);
3353      _nextTime = _self.time * 1000 + _gap;
3354    },
3355    add: function add(callback, once, prioritize) {
3356      var func = once ? function (t, d, f, v) {
3357        callback(t, d, f, v);
3358
3359        _self.remove(func);
3360      } : callback;
3361
3362      _self.remove(callback);
3363
3364      _listeners[prioritize ? "unshift" : "push"](func);
3365
3366      _wake();
3367
3368      return func;
3369    },
3370    remove: function remove(callback, i) {
3371      ~(i = _listeners.indexOf(callback)) && _listeners.splice(i, 1) && _i >= i && _i--;
3372    },
3373    _listeners: _listeners
3374  };
3375  return _self;
3376}(),
3377    _wake = function _wake() {
3378  return !_tickerActive && _ticker.wake();
3379},
3380    //also ensures the core classes are initialized.
3381
3382/*
3383* -------------------------------------------------
3384* EASING
3385* -------------------------------------------------
3386*/
3387_easeMap = {},
3388    _customEaseExp = /^[\d.\-M][\d.\-,\s]/,
3389    _quotesExp = /["']/g,
3390    _parseObjectInString = function _parseObjectInString(value) {
3391  //takes a string like "{wiggles:10, type:anticipate})" and turns it into a real object. Notice it ends in ")" and includes the {} wrappers. This is because we only use this function for parsing ease configs and prioritized optimization rather than reusability.
3392  var obj = {},
3393      split = value.substr(1, value.length - 3).split(":"),
3394      key = split[0],
3395      i = 1,
3396      l = split.length,
3397      index,
3398      val,
3399      parsedVal;
3400
3401  for (; i < l; i++) {
3402    val = split[i];
3403    index = i !== l - 1 ? val.lastIndexOf(",") : val.length;
3404    parsedVal = val.substr(0, index);
3405    obj[key] = isNaN(parsedVal) ? parsedVal.replace(_quotesExp, "").trim() : +parsedVal;
3406    key = val.substr(index + 1).trim();
3407  }
3408
3409  return obj;
3410},
3411    _valueInParentheses = function _valueInParentheses(value) {
3412  var open = value.indexOf("(") + 1,
3413      close = value.indexOf(")"),
3414      nested = value.indexOf("(", open);
3415  return value.substring(open, ~nested && nested < close ? value.indexOf(")", close + 1) : close);
3416},
3417    _configEaseFromString = function _configEaseFromString(name) {
3418  //name can be a string like "elastic.out(1,0.5)", and pass in _easeMap as obj and it'll parse it out and call the actual function like _easeMap.Elastic.easeOut.config(1,0.5). It will also parse custom ease strings as long as CustomEase is loaded and registered (internally as _easeMap._CE).
3419  var split = (name + "").split("("),
3420      ease = _easeMap[split[0]];
3421  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;
3422},
3423    _invertEase = function _invertEase(ease) {
3424  return function (p) {
3425    return 1 - ease(1 - p);
3426  };
3427},
3428    _parseEase = function _parseEase(ease, defaultEase) {
3429  return !ease ? defaultEase : (_isFunction(ease) ? ease : _easeMap[ease] || _configEaseFromString(ease)) || defaultEase;
3430},
3431    _insertEase = function _insertEase(names, easeIn, easeOut, easeInOut) {
3432  if (easeOut === void 0) {
3433    easeOut = function easeOut(p) {
3434      return 1 - easeIn(1 - p);
3435    };
3436  }
3437
3438  if (easeInOut === void 0) {
3439    easeInOut = function easeInOut(p) {
3440      return p < .5 ? easeIn(p * 2) / 2 : 1 - easeIn((1 - p) * 2) / 2;
3441    };
3442  }
3443
3444  var ease = {
3445    easeIn: easeIn,
3446    easeOut: easeOut,
3447    easeInOut: easeInOut
3448  },
3449      lowercaseName;
3450
3451  _forEachName(names, function (name) {
3452    _easeMap[name] = _globals[name] = ease;
3453    _easeMap[lowercaseName = name.toLowerCase()] = easeOut;
3454
3455    for (var p in ease) {
3456      _easeMap[lowercaseName + (p === "easeIn" ? ".in" : p === "easeOut" ? ".out" : ".inOut")] = _easeMap[name + "." + p] = ease[p];
3457    }
3458  });
3459
3460  return ease;
3461},
3462    _easeInOutFromOut = function _easeInOutFromOut(easeOut) {
3463  return function (p) {
3464    return p < .5 ? (1 - easeOut(1 - p * 2)) / 2 : .5 + easeOut((p - .5) * 2) / 2;
3465  };
3466},
3467    _configElastic = function _configElastic(type, amplitude, period) {
3468  var p1 = amplitude >= 1 ? amplitude : 1,
3469      //note: if amplitude is < 1, we simply adjust the period for a more natural feel. Otherwise the math doesn't work right and the curve starts at 1.
3470  p2 = (period || (type ? .3 : .45)) / (amplitude < 1 ? amplitude : 1),
3471      p3 = p2 / _2PI * (Math.asin(1 / p1) || 0),
3472      easeOut = function easeOut(p) {
3473    return p === 1 ? 1 : p1 * Math.pow(2, -10 * p) * _sin((p - p3) * p2) + 1;
3474  },
3475      ease = type === "out" ? easeOut : type === "in" ? function (p) {
3476    return 1 - easeOut(1 - p);
3477  } : _easeInOutFromOut(easeOut);
3478
3479  p2 = _2PI / p2; //precalculate to optimize
3480
3481  ease.config = function (amplitude, period) {
3482    return _configElastic(type, amplitude, period);
3483  };
3484
3485  return ease;
3486},
3487    _configBack = function _configBack(type, overshoot) {
3488  if (overshoot === void 0) {
3489    overshoot = 1.70158;
3490  }
3491
3492  var easeOut = function easeOut(p) {
3493    return p ? --p * p * ((overshoot + 1) * p + overshoot) + 1 : 0;
3494  },
3495      ease = type === "out" ? easeOut : type === "in" ? function (p) {
3496    return 1 - easeOut(1 - p);
3497  } : _easeInOutFromOut(easeOut);
3498
3499  ease.config = function (overshoot) {
3500    return _configBack(type, overshoot);
3501  };
3502
3503  return ease;
3504}; // a cheaper (kb and cpu) but more mild way to get a parameterized weighted ease by feeding in a value between -1 (easeIn) and 1 (easeOut) where 0 is linear.
3505// _weightedEase = ratio => {
3506// 	let y = 0.5 + ratio / 2;
3507// 	return p => (2 * (1 - p) * p * y + p * p);
3508// },
3509// a stronger (but more expensive kb/cpu) parameterized weighted ease that lets you feed in a value between -1 (easeIn) and 1 (easeOut) where 0 is linear.
3510// _weightedEaseStrong = ratio => {
3511// 	ratio = .5 + ratio / 2;
3512// 	let o = 1 / 3 * (ratio < .5 ? ratio : 1 - ratio),
3513// 		b = ratio - o,
3514// 		c = ratio + o;
3515// 	return p => p === 1 ? p : 3 * b * (1 - p) * (1 - p) * p + 3 * c * (1 - p) * p * p + p * p * p;
3516// };
3517
3518
3519_forEachName("Linear,Quad,Cubic,Quart,Quint,Strong", function (name, i) {
3520  var power = i < 5 ? i + 1 : i;
3521
3522  _insertEase(name + ",Power" + (power - 1), i ? function (p) {
3523    return Math.pow(p, power);
3524  } : function (p) {
3525    return p;
3526  }, function (p) {
3527    return 1 - Math.pow(1 - p, power);
3528  }, function (p) {
3529    return p < .5 ? Math.pow(p * 2, power) / 2 : 1 - Math.pow((1 - p) * 2, power) / 2;
3530  });
3531});
3532
3533_easeMap.Linear.easeNone = _easeMap.none = _easeMap.Linear.easeIn;
3534
3535_insertEase("Elastic", _configElastic("in"), _configElastic("out"), _configElastic());
3536
3537(function (n, c) {
3538  var n1 = 1 / c,
3539      n2 = 2 * n1,
3540      n3 = 2.5 * n1,
3541      easeOut = function easeOut(p) {
3542    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;
3543  };
3544
3545  _insertEase("Bounce", function (p) {
3546    return 1 - easeOut(1 - p);
3547  }, easeOut);
3548})(7.5625, 2.75);
3549
3550_insertEase("Expo", function (p) {
3551  return Math.pow(2, 10 * (p - 1)) * p + p * p * p * p * p * p * (1 - p);
3552}); // previously 2 ** (10 * (p - 1)) but that doesn't end up with the value quite at the right spot so we do a blended ease to ensure it lands where it should perfectly.
3553
3554
3555_insertEase("Circ", function (p) {
3556  return -(_sqrt(1 - p * p) - 1);
3557});
3558
3559_insertEase("Sine", function (p) {
3560  return p === 1 ? 1 : -_cos(p * _HALF_PI) + 1;
3561});
3562
3563_insertEase("Back", _configBack("in"), _configBack("out"), _configBack());
3564
3565_easeMap.SteppedEase = _easeMap.steps = _globals.SteppedEase = {
3566  config: function config(steps, immediateStart) {
3567    if (steps === void 0) {
3568      steps = 1;
3569    }
3570
3571    var p1 = 1 / steps,
3572        p2 = steps + (immediateStart ? 0 : 1),
3573        p3 = immediateStart ? 1 : 0,
3574        max = 1 - _tinyNum;
3575    return function (p) {
3576      return ((p2 * _clamp(0, max, p) | 0) + p3) * p1;
3577    };
3578  }
3579};
3580_defaults.ease = _easeMap["quad.out"];
3581
3582_forEachName("onComplete,onUpdate,onStart,onRepeat,onReverseComplete,onInterrupt", function (name) {
3583  return _callbackNames += name + "," + name + "Params,";
3584});
3585/*
3586 * --------------------------------------------------------------------------------------
3587 * CACHE
3588 * --------------------------------------------------------------------------------------
3589 */
3590
3591