https://ginzaplace.jp/theme/gp/assets/js/app.js

835/***/ "./node_modules/gsap/CSSPlugin.js":
836/*!****************************************!*\
837  !*** ./node_modules/gsap/CSSPlugin.js ***!
838  \****************************************/
839/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
840
841__webpack_require__.r(__webpack_exports__);
842/* harmony export */ __webpack_require__.d(__webpack_exports__, {
843/* harmony export */   CSSPlugin: function() { return /* binding */ CSSPlugin; },
844/* harmony export */   _createElement: function() { return /* binding */ _createElement; },
845/* harmony export */   _getBBox: function() { return /* binding */ _getBBox; },
846/* harmony export */   checkPrefix: function() { return /* binding */ _checkPropPrefix; },
847/* harmony export */   "default": function() { return /* binding */ CSSPlugin; }
848/* harmony export */ });
849/* harmony import */ var _gsap_core_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./gsap-core.js */ "./node_modules/gsap/gsap-core.js");
850/*!
851 * CSSPlugin 3.12.2
852 * https://greensock.com
853 *
854 * Copyright 2008-2023, GreenSock. All rights reserved.
855 * Subject to the terms at https://greensock.com/standard-license or for
856 * Club GreenSock members, the agreement issued with that membership.
857 * @author: Jack Doyle, [email protected]
858*/
859
860/* eslint-disable */
861
862
863var _win,
864    _doc,
865    _docElement,
866    _pluginInitted,
867    _tempDiv,
868    _tempDivStyler,
869    _recentSetterPlugin,
870    _reverting,
871    _windowExists = function _windowExists() {
872  return typeof window !== "undefined";
873},
874    _transformProps = {},
875    _RAD2DEG = 180 / Math.PI,
876    _DEG2RAD = Math.PI / 180,
877    _atan2 = Math.atan2,
878    _bigNum = 1e8,
879    _capsExp = /([A-Z])/g,
880    _horizontalExp = /(left|right|width|margin|padding|x)/i,
881    _complexExp = /[\s,\(]\S/,
882    _propertyAliases = {
883  autoAlpha: "opacity,visibility",
884  scale: "scaleX,scaleY",
885  alpha: "opacity"
886},
887    _renderCSSProp = function _renderCSSProp(ratio, data) {
888  return data.set(data.t, data.p, Math.round((data.s + data.c * ratio) * 10000) / 10000 + data.u, data);
889},
890    _renderPropWithEnd = function _renderPropWithEnd(ratio, data) {
891  return data.set(data.t, data.p, ratio === 1 ? data.e : Math.round((data.s + data.c * ratio) * 10000) / 10000 + data.u, data);
892},
893    _renderCSSPropWithBeginning = function _renderCSSPropWithBeginning(ratio, data) {
894  return data.set(data.t, data.p, ratio ? Math.round((data.s + data.c * ratio) * 10000) / 10000 + data.u : data.b, data);
895},
896    //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)
897_renderRoundedCSSProp = function _renderRoundedCSSProp(ratio, data) {
898  var value = data.s + data.c * ratio;
899  data.set(data.t, data.p, ~~(value + (value < 0 ? -.5 : .5)) + data.u, data);
900},
901    _renderNonTweeningValue = function _renderNonTweeningValue(ratio, data) {
902  return data.set(data.t, data.p, ratio ? data.e : data.b, data);
903},
904    _renderNonTweeningValueOnlyAtEnd = function _renderNonTweeningValueOnlyAtEnd(ratio, data) {
905  return data.set(data.t, data.p, ratio !== 1 ? data.b : data.e, data);
906},
907    _setterCSSStyle = function _setterCSSStyle(target, property, value) {
908  return target.style[property] = value;
909},
910    _setterCSSProp = function _setterCSSProp(target, property, value) {
911  return target.style.setProperty(property, value);
912},
913    _setterTransform = function _setterTransform(target, property, value) {
914  return target._gsap[property] = value;
915},
916    _setterScale = function _setterScale(target, property, value) {
917  return target._gsap.scaleX = target._gsap.scaleY = value;
918},
919    _setterScaleWithRender = function _setterScaleWithRender(target, property, value, data, ratio) {
920  var cache = target._gsap;
921  cache.scaleX = cache.scaleY = value;
922  cache.renderTransform(ratio, cache);
923},
924    _setterTransformWithRender = function _setterTransformWithRender(target, property, value, data, ratio) {
925  var cache = target._gsap;
926  cache[property] = value;
927  cache.renderTransform(ratio, cache);
928},
929    _transformProp = "transform",
930    _transformOriginProp = _transformProp + "Origin",
931    _saveStyle = function _saveStyle(property, isNotCSS) {
932  var _this = this;
933
934  var target = this.target,
935      style = target.style;
936
937  if (property in _transformProps && style) {
938    this.tfm = this.tfm || {};
939
940    if (property !== "transform") {
941      property = _propertyAliases[property] || property;
942      ~property.indexOf(",") ? property.split(",").forEach(function (a) {
943        return _this.tfm[a] = _get(target, a);
944      }) : this.tfm[property] = target._gsap.x ? target._gsap[property] : _get(target, property); // note: scale would map to "scaleX,scaleY", thus we loop and apply them both.
945    } else {
946      return _propertyAliases.transform.split(",").forEach(function (p) {
947        return _saveStyle.call(_this, p, isNotCSS);
948      });
949    }
950
951    if (this.props.indexOf(_transformProp) >= 0) {
952      return;
953    }
954
955    if (target._gsap.svg) {
956      this.svgo = target.getAttribute("data-svg-origin");
957      this.props.push(_transformOriginProp, isNotCSS, "");
958    }
959
960    property = _transformProp;
961  }
962
963  (style || isNotCSS) && this.props.push(property, isNotCSS, style[property]);
964},
965    _removeIndependentTransforms = function _removeIndependentTransforms(style) {
966  if (style.translate) {
967    style.removeProperty("translate");
968    style.removeProperty("scale");
969    style.removeProperty("rotate");
970  }
971},
972    _revertStyle = function _revertStyle() {
973  var props = this.props,
974      target = this.target,
975      style = target.style,
976      cache = target._gsap,
977      i,
978      p;
979
980  for (i = 0; i < props.length; i += 3) {
981    // stored like this: property, isNotCSS, value
982    props[i + 1] ? target[props[i]] = props[i + 2] : props[i + 2] ? style[props[i]] = props[i + 2] : style.removeProperty(props[i].substr(0, 2) === "--" ? props[i] : props[i].replace(_capsExp, "-$1").toLowerCase());
983  }
984
985  if (this.tfm) {
986    for (p in this.tfm) {
987      cache[p] = this.tfm[p];
988    }
989
990    if (cache.svg) {
991      cache.renderTransform();
992      target.setAttribute("data-svg-origin", this.svgo || "");
993    }
994
995    i = _reverting();
996
997    if ((!i || !i.isStart) && !style[_transformProp]) {
998      _removeIndependentTransforms(style);
999
1000      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.
1001    }
1002  }
1003},
1004    _getStyleSaver = function _getStyleSaver(target, properties) {
1005  var saver = {
1006    target: target,
1007    props: [],
1008    revert: _revertStyle,
1009    save: _saveStyle
1010  };
1011  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.
1012
1013  properties && properties.split(",").forEach(function (p) {
1014    return saver.save(p);
1015  });
1016  return saver;
1017},
1018    _supports3D,
1019    _createElement = function _createElement(type, ns) {
1020  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.
1021
1022  return 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://greensock.com/forums/topic/20215-problem-using-tweenmax-in-standalone-self-containing-svg-file-err-cannot-set-property-csstext-of-undefined/).
1023},
1024    _getComputedProperty = function _getComputedProperty(target, property, skipPrefixFallback) {
1025  var cs = getComputedStyle(target);
1026  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.
1027},
1028    _prefixes = "O,Moz,ms,Ms,Webkit".split(","),
1029    _checkPropPrefix = function _checkPropPrefix(property, element, preferPrefix) {
1030  var e = element || _tempDiv,
1031      s = e.style,
1032      i = 5;
1033
1034  if (property in s && !preferPrefix) {
1035    return property;
1036  }
1037
1038  property = property.charAt(0).toUpperCase() + property.substr(1);
1039
1040  while (i-- && !(_prefixes[i] + property in s)) {}
1041
1042  return i < 0 ? null : (i === 3 ? "ms" : i >= 0 ? _prefixes[i] : "") + property;
1043},
1044    _initCore = function _initCore() {
1045  if (_windowExists() && window.document) {
1046    _win = window;
1047    _doc = _win.document;
1048    _docElement = _doc.documentElement;
1049    _tempDiv = _createElement("div") || {
1050      style: {}
1051    };
1052    _tempDivStyler = _createElement("div");
1053    _transformProp = _checkPropPrefix(_transformProp);
1054    _transformOriginProp = _transformProp + "Origin";
1055    _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.
1056
1057    _supports3D = !!_checkPropPrefix("perspective");
1058    _reverting = _gsap_core_js__WEBPACK_IMPORTED_MODULE_0__.gsap.core.reverting;
1059    _pluginInitted = 1;
1060  }
1061},
1062    _getBBoxHack = function _getBBoxHack(swapIfPossible) {
1063  //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).
1064  var svg = _createElement("svg", this.ownerSVGElement && this.ownerSVGElement.getAttribute("xmlns") || "http://www.w3.org/2000/svg"),
1065      oldParent = this.parentNode,
1066      oldSibling = this.nextSibling,
1067      oldCSS = this.style.cssText,
1068      bbox;
1069
1070  _docElement.appendChild(svg);
1071
1072  svg.appendChild(this);
1073  this.style.display = "block";
1074
1075  if (swapIfPossible) {
1076    try {
1077      bbox = this.getBBox();
1078      this._gsapBBox = this.getBBox; //store the original
1079
1080      this.getBBox = _getBBoxHack;
1081    } catch (e) {}
1082  } else if (this._gsapBBox) {
1083    bbox = this._gsapBBox();
1084  }
1085
1086  if (oldParent) {
1087    if (oldSibling) {
1088      oldParent.insertBefore(this, oldSibling);
1089    } else {
1090      oldParent.appendChild(this);
1091    }
1092  }
1093
1094  _docElement.removeChild(svg);
1095
1096  this.style.cssText = oldCSS;
1097  return bbox;
1098},
1099    _getAttributeFallbacks = function _getAttributeFallbacks(target, attributesArray) {
1100  var i = attributesArray.length;
1101
1102  while (i--) {
1103    if (target.hasAttribute(attributesArray[i])) {
1104      return target.getAttribute(attributesArray[i]);
1105    }
1106  }
1107},
1108    _getBBox = function _getBBox(target) {
1109  var bounds;
1110
1111  try {
1112    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
1113  } catch (error) {
1114    bounds = _getBBoxHack.call(target, true);
1115  }
1116
1117  bounds && (bounds.width || bounds.height) || target.getBBox === _getBBoxHack || (bounds = _getBBoxHack.call(target, true)); //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.
1118
1119  return bounds && !bounds.width && !bounds.x && !bounds.y ? {
1120    x: +_getAttributeFallbacks(target, ["x", "cx", "x1"]) || 0,
1121    y: +_getAttributeFallbacks(target, ["y", "cy", "y1"]) || 0,
1122    width: 0,
1123    height: 0
1124  } : bounds;
1125},
1126    _isSVG = function _isSVG(e) {
1127  return !!(e.getCTM && (!e.parentNode || e.ownerSVGElement) && _getBBox(e));
1128},
1129    //reports if the element is an SVG on which getBBox() actually works
1130_removeProperty = function _removeProperty(target, property) {
1131  if (property) {
1132    var style = target.style;
1133
1134    if (property in _transformProps && property !== _transformOriginProp) {
1135      property = _transformProp;
1136    }
1137
1138    if (style.removeProperty) {
1139      if (property.substr(0, 2) === "ms" || property.substr(0, 6) === "webkit") {
1140        //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)
1141        property = "-" + property;
1142      }
1143
1144      style.removeProperty(property.replace(_capsExp, "-$1").toLowerCase());
1145    } else {
1146      //note: old versions of IE use "removeAttribute()" instead of "removeProperty()"
1147      style.removeAttribute(property);
1148    }
1149  }
1150},
1151    _addNonTweeningPT = function _addNonTweeningPT(plugin, target, property, beginning, end, onlySetAtEnd) {
1152  var pt = new _gsap_core_js__WEBPACK_IMPORTED_MODULE_0__.PropTween(plugin._pt, target, property, 0, 1, onlySetAtEnd ? _renderNonTweeningValueOnlyAtEnd : _renderNonTweeningValue);
1153  plugin._pt = pt;
1154  pt.b = beginning;
1155  pt.e = end;
1156
1157  plugin._props.push(property);
1158
1159  return pt;
1160},
1161    _nonConvertibleUnits = {
1162  deg: 1,
1163  rad: 1,
1164  turn: 1
1165},
1166    _nonStandardLayouts = {
1167  grid: 1,
1168  flex: 1
1169},
1170    //takes a single value like 20px and converts it to the unit specified, like "%", returning only the numeric amount.
1171_convertToUnit = function _convertToUnit(target, property, value, unit) {
1172  var curValue = parseFloat(value) || 0,
1173      curUnit = (value + "").trim().substr((curValue + "").length) || "px",
1174      // some browsers leave extra whitespace at the beginning of CSS variables, hence the need to trim()
1175  style = _tempDiv.style,
1176      horizontal = _horizontalExp.test(property),
1177      isRootSVG = target.tagName.toLowerCase() === "svg",
1178      measureProperty = (isRootSVG ? "client" : "offset") + (horizontal ? "Width" : "Height"),
1179      amount = 100,
1180      toPixels = unit === "px",
1181      toPercent = unit === "%",
1182      px,
1183      parent,
1184      cache,
1185      isSVG;
1186
1187  if (unit === curUnit || !curValue || _nonConvertibleUnits[unit] || _nonConvertibleUnits[curUnit]) {
1188    return curValue;
1189  }
1190
1191  curUnit !== "px" && !toPixels && (curValue = _convertToUnit(target, property, value, "px"));
1192  isSVG = target.getCTM && _isSVG(target);
1193
1194  if ((toPercent || curUnit === "%") && (_transformProps[property] || ~property.indexOf("adius"))) {
1195    px = isSVG ? target.getBBox()[horizontal ? "width" : "height"] : target[measureProperty];
1196    return (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._round)(toPercent ? curValue / px * amount : curValue / 100 * px);
1197  }
1198
1199  style[horizontal ? "width" : "height"] = amount + (toPixels ? curUnit : unit);
1200  parent = ~property.indexOf("adius") || unit === "em" && target.appendChild && !isRootSVG ? target : target.parentNode;
1201
1202  if (isSVG) {
1203    parent = (target.ownerSVGElement || {}).parentNode;
1204  }
1205
1206  if (!parent || parent === _doc || !parent.appendChild) {
1207    parent = _doc.body;
1208  }
1209
1210  cache = parent._gsap;
1211
1212  if (cache && toPercent && cache.width && horizontal && cache.time === _gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._ticker.time && !cache.uncache) {
1213    return (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._round)(curValue / cache.width * amount);
1214  } else {
1215    (toPercent || curUnit === "%") && !_nonStandardLayouts[_getComputedProperty(parent, "display")] && (style.position = _getComputedProperty(target, "position"));
1216    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.
1217
1218    parent.appendChild(_tempDiv);
1219    px = _tempDiv[measureProperty];
1220    parent.removeChild(_tempDiv);
1221    style.position = "absolute";
1222
1223    if (horizontal && toPercent) {
1224      cache = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._getCache)(parent);
1225      cache.time = _gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._ticker.time;
1226      cache.width = parent[measureProperty];
1227    }
1228  }
1229
1230  return (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._round)(toPixels ? px * curValue / amount : px && curValue ? amount / px * curValue : 0);
1231},
1232    _get = function _get(target, property, unit, uncache) {
1233  var value;
1234  _pluginInitted || _initCore();
1235
1236  if (property in _propertyAliases && property !== "transform") {
1237    property = _propertyAliases[property];
1238
1239    if (~property.indexOf(",")) {
1240      property = property.split(",")[0];
1241    }
1242  }
1243
1244  if (_transformProps[property] && property !== "transform") {
1245    value = _parseTransform(target, uncache);
1246    value = property !== "transformOrigin" ? value[property] : value.svg ? value.origin : _firstTwoOnly(_getComputedProperty(target, _transformOriginProp)) + " " + value.zOrigin + "px";
1247  } else {
1248    value = target.style[property];
1249
1250    if (!value || value === "auto" || uncache || ~(value + "").indexOf("calc(")) {
1251      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
1252    }
1253  }
1254
1255  return unit && !~(value + "").trim().indexOf(" ") ? _convertToUnit(target, property, value, unit) + unit : value;
1256},
1257    _tweenComplexCSSString = function _tweenComplexCSSString(target, prop, start, end) {
1258  // 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.
1259  if (!start || start === "none") {
1260    // 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://greensock.com/forums/topic/18310-clippath-doesnt-work-on-ios/
1261    var p = _checkPropPrefix(prop, target, 1),
1262        s = p && _getComputedProperty(target, p, 1);
1263
1264    if (s && s !== start) {
1265      prop = p;
1266      start = s;
1267    } else if (prop === "borderColor") {
1268      start = _getComputedProperty(target, "borderTopColor"); // Firefox bug: always reports "borderColor" as "", so we must fall back to borderTopColor. See https://greensock.com/forums/topic/24583-how-to-return-colors-that-i-had-after-reverse/
1269    }
1270  }
1271
1272  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),
1273      index = 0,
1274      matchIndex = 0,
1275      a,
1276      result,
1277      startValues,
1278      startNum,
1279      color,
1280      startValue,
1281      endValue,
1282      endNum,
1283      chunk,
1284      endUnit,
1285      startUnit,
1286      endValues;
1287  pt.b = start;
1288  pt.e = end;
1289  start += ""; // ensure values are strings
1290
1291  end += "";
1292
1293  if (end === "auto") {
1294    target.style[prop] = end;
1295    end = _getComputedProperty(target, prop) || end;
1296    target.style[prop] = start;
1297  }
1298
1299  a = [start, end];
1300
1301  (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().
1302
1303
1304  start = a[0];
1305  end = a[1];
1306  startValues = start.match(_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._numWithUnitExp) || [];
1307  endValues = end.match(_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._numWithUnitExp) || [];
1308
1309  if (endValues.length) {
1310    while (result = _gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._numWithUnitExp.exec(end)) {
1311      endValue = result[0];
1312      chunk = end.substring(index, result.index);
1313
1314      if (color) {
1315        color = (color + 1) % 5;
1316      } else if (chunk.substr(-5) === "rgba(" || chunk.substr(-5) === "hsla(") {
1317        color = 1;
1318      }
1319
1320      if (endValue !== (startValue = startValues[matchIndex++] || "")) {
1321        startNum = parseFloat(startValue) || 0;
1322        startUnit = startValue.substr((startNum + "").length);
1323        endValue.charAt(1) === "=" && (endValue = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._parseRelative)(startNum, endValue) + startUnit);
1324        endNum = parseFloat(endValue);
1325        endUnit = endValue.substr((endNum + "").length);
1326        index = _gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._numWithUnitExp.lastIndex - endUnit.length;
1327
1328        if (!endUnit) {
1329          //if something like "perspective:300" is passed in and we must add a unit to the end
1330          endUnit = endUnit || _gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._config.units[prop] || startUnit;
1331
1332          if (index === end.length) {
1333            end += endUnit;
1334            pt.e += endUnit;
1335          }
1336        }
1337
1338        if (startUnit !== endUnit) {
1339          startNum = _convertToUnit(target, prop, startValue, endUnit) || 0;
1340        } // 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.
1341
1342
1343        pt._pt = {
1344          _next: pt._pt,
1345          p: chunk || matchIndex === 1 ? chunk : ",",
1346          //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.
1347          s: startNum,
1348          c: endNum - startNum,
1349          m: color && color < 4 || prop === "zIndex" ? Math.round : 0
1350        };
1351      }
1352    }
1353
1354    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)
1355  } else {
1356    pt.r = prop === "display" && end === "none" ? _renderNonTweeningValueOnlyAtEnd : _renderNonTweeningValue;
1357  }
1358
1359  _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).
1360
1361  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.
1362
1363  return pt;
1364},
1365    _keywordToPercent = {
1366  top: "0%",
1367  bottom: "100%",
1368  left: "0%",
1369  right: "100%",
1370  center: "50%"
1371},
1372    _convertKeywordsToPercentages = function _convertKeywordsToPercentages(value) {
1373  var split = value.split(" "),
1374      x = split[0],
1375      y = split[1] || "50%";
1376
1377  if (x === "top" || x === "bottom" || y === "left" || y === "right") {
1378    //the user provided them in the wrong order, so flip them
1379    value = x;
1380    x = y;
1381    y = value;
1382  }
1383
1384  split[0] = _keywordToPercent[x] || x;
1385  split[1] = _keywordToPercent[y] || y;
1386  return split.join(" ");
1387},
1388    _renderClearProps = function _renderClearProps(ratio, data) {
1389  if (data.tween && data.tween._time === data.tween._dur) {
1390    var target = data.t,
1391        style = target.style,
1392        props = data.u,
1393        cache = target._gsap,
1394        prop,
1395        clearTransforms,
1396        i;
1397
1398    if (props === "all" || props === true) {
1399      style.cssText = "";
1400      clearTransforms = 1;
1401    } else {
1402      props = props.split(",");
1403      i = props.length;
1404
1405      while (--i > -1) {
1406        prop = props[i];
1407
1408        if (_transformProps[prop]) {
1409          clearTransforms = 1;
1410          prop = prop === "transformOrigin" ? _transformOriginProp : _transformProp;
1411        }
1412
1413        _removeProperty(target, prop);
1414      }
1415    }
1416
1417    if (clearTransforms) {
1418      _removeProperty(target, _transformProp);
1419
1420      if (cache) {
1421        cache.svg && target.removeAttribute("transform");
1422
1423        _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.
1424
1425
1426        cache.uncache = 1;
1427
1428        _removeIndependentTransforms(style);
1429      }
1430    }
1431  }
1432},
1433    // note: specialProps should return 1 if (and only if) they have a non-zero priority. It indicates we need to sort the linked list.
1434_specialProps = {
1435  clearProps: function clearProps(plugin, target, property, endValue, tween) {
1436    if (tween.data !== "isFromStart") {
1437      var pt = plugin._pt = new _gsap_core_js__WEBPACK_IMPORTED_MODULE_0__.PropTween(plugin._pt, target, property, 0, 0, _renderClearProps);
1438      pt.u = endValue;
1439      pt.pr = -10;
1440      pt.tween = tween;
1441
1442      plugin._props.push(property);
1443
1444      return 1;
1445    }
1446  }
1447  /* className feature (about 0.4kb gzipped).
1448  , className(plugin, target, property, endValue, tween) {
1449  	let _renderClassName = (ratio, data) => {
1450  			data.css.render(ratio, data.css);
1451  			if (!ratio || ratio === 1) {
1452  				let inline = data.rmv,
1453  					target = data.t,
1454  					p;
1455  				target.setAttribute("class", ratio ? data.e : data.b);
1456  				for (p in inline) {
1457  					_removeProperty(target, p);
1458  				}
1459  			}
1460  		},
1461  		_getAllStyles = (target) => {
1462  			let styles = {},
1463  				computed = getComputedStyle(target),
1464  				p;
1465  			for (p in computed) {
1466  				if (isNaN(p) && p !== "cssText" && p !== "length") {
1467  					styles[p] = computed[p];
1468  				}
1469  			}
1470  			_setDefaults(styles, _parseTransform(target, 1));
1471  			return styles;
1472  		},
1473  		startClassList = target.getAttribute("class"),
1474  		style = target.style,
1475  		cssText = style.cssText,
1476  		cache = target._gsap,
1477  		classPT = cache.classPT,
1478  		inlineToRemoveAtEnd = {},
1479  		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) : "")},
1480  		changingVars = {},
1481  		startVars = _getAllStyles(target),
1482  		transformRelated = /(transform|perspective)/i,
1483  		endVars, p;
1484  	if (classPT) {
1485  		classPT.r(1, classPT.d);
1486  		_removeLinkedListItem(classPT.d.plugin, classPT, "_pt");
1487  	}
1488  	target.setAttribute("class", data.e);
1489  	endVars = _getAllStyles(target, true);
1490  	target.setAttribute("class", startClassList);
1491  	for (p in endVars) {
1492  		if (endVars[p] !== startVars[p] && !transformRelated.test(p)) {
1493  			changingVars[p] = endVars[p];
1494  			if (!style[p] && style[p] !== "0") {
1495  				inlineToRemoveAtEnd[p] = 1;
1496  			}
1497  		}
1498  	}
1499  	cache.classPT = plugin._pt = new PropTween(plugin._pt, target, "className", 0, 0, _renderClassName, data, 0, -11);
1500  	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://greensock.com/forums/topic/20368-possible-gsap-bug-switching-classnames-in-chrome/.
1501  		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).
1502  	}
1503  	_parseTransform(target, true); //to clear the caching of transforms
1504  	data.css = new gsap.plugins.css();
1505  	data.css.init(target, changingVars, tween);
1506  	plugin._props.push(...data.css._props);
1507  	return 1;
1508  }
1509  */
1510
1511},
1512
1513/*
1514 * --------------------------------------------------------------------------------------
1515 * TRANSFORMS
1516 * --------------------------------------------------------------------------------------
1517 */
1518_identity2DMatrix = [1, 0, 0, 1, 0, 0],
1519    _rotationalProperties = {},
1520    _isNullTransform = function _isNullTransform(value) {
1521  return value === "matrix(1, 0, 0, 1, 0, 0)" || value === "none" || !value;
1522},
1523    _getComputedTransformMatrixAsArray = function _getComputedTransformMatrixAsArray(target) {
1524  var matrixString = _getComputedProperty(target, _transformProp);
1525
1526  return _isNullTransform(matrixString) ? _identity2DMatrix : matrixString.substr(7).match(_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._numExp).map(_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._round);
1527},
1528    _getMatrix = function _getMatrix(target, force2D) {
1529  var cache = target._gsap || (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._getCache)(target),
1530      style = target.style,
1531      matrix = _getComputedTransformMatrixAsArray(target),
1532      parent,
1533      nextSibling,
1534      temp,
1535      addedToDOM;
1536
1537  if (cache.svg && target.getAttribute("transform")) {
1538    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.
1539
1540    matrix = [temp.a, temp.b, temp.c, temp.d, temp.e, temp.f];
1541    return matrix.join(",") === "1,0,0,1,0,0" ? _identity2DMatrix : matrix;
1542  } else if (matrix === _identity2DMatrix && !target.offsetParent && target !== _docElement && !cache.svg) {
1543    //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
1544    //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).
1545    temp = style.display;
1546    style.display = "block";
1547    parent = target.parentNode;
1548
1549    if (!parent || !target.offsetParent) {
1550      // 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
1551      addedToDOM = 1; //flag
1552
1553      nextSibling = target.nextElementSibling;
1554
1555      _docElement.appendChild(target); //we must add it to the DOM in order to get values properly
1556
1557    }
1558
1559    matrix = _getComputedTransformMatrixAsArray(target);
1560    temp ? style.display = temp : _removeProperty(target, "display");
1561
1562    if (addedToDOM) {
1563      nextSibling ? parent.insertBefore(target, nextSibling) : parent ? parent.appendChild(target) : _docElement.removeChild(target);
1564    }
1565  }
1566
1567  return force2D && matrix.length > 6 ? [matrix[0], matrix[1], matrix[4], matrix[5], matrix[12], matrix[13]] : matrix;
1568},
1569    _applySVGOrigin = function _applySVGOrigin(target, origin, originIsAbsolute, smooth, matrixArray, pluginToAddPropTweensTo) {
1570  var cache = target._gsap,
1571      matrix = matrixArray || _getMatrix(target, true),
1572      xOriginOld = cache.xOrigin || 0,
1573      yOriginOld = cache.yOrigin || 0,
1574      xOffsetOld = cache.xOffset || 0,
1575      yOffsetOld = cache.yOffset || 0,
1576      a = matrix[0],
1577      b = matrix[1],
1578      c = matrix[2],
1579      d = matrix[3],
1580      tx = matrix[4],
1581      ty = matrix[5],
1582      originSplit = origin.split(" "),
1583      xOrigin = parseFloat(originSplit[0]) || 0,
1584      yOrigin = parseFloat(originSplit[1]) || 0,
1585      bounds,
1586      determinant,
1587      x,
1588      y;
1589
1590  if (!originIsAbsolute) {
1591    bounds = _getBBox(target);
1592    xOrigin = bounds.x + (~originSplit[0].indexOf("%") ? xOrigin / 100 * bounds.width : xOrigin);
1593    yOrigin = bounds.y + (~(originSplit[1] || originSplit[0]).indexOf("%") ? yOrigin / 100 * bounds.height : yOrigin);
1594  } else if (matrix !== _identity2DMatrix && (determinant = a * d - b * c)) {
1595    //if it's zero (like if scaleX and scaleY are zero), skip it to avoid errors with dividing by zero.
1596    x = xOrigin * (d / determinant) + yOrigin * (-c / determinant) + (c * ty - d * tx) / determinant;
1597    y = xOrigin * (-b / determinant) + yOrigin * (a / determinant) - (a * ty - b * tx) / determinant;
1598    xOrigin = x;
1599    yOrigin = y;
1600  }
1601
1602  if (smooth || smooth !== false && cache.smooth) {
1603    tx = xOrigin - xOriginOld;
1604    ty = yOrigin - yOriginOld;
1605    cache.xOffset = xOffsetOld + (tx * a + ty * c) - tx;
1606    cache.yOffset = yOffsetOld + (tx * b + ty * d) - ty;
1607  } else {
1608    cache.xOffset = cache.yOffset = 0;
1609  }
1610
1611  cache.xOrigin = xOrigin;
1612  cache.yOrigin = yOrigin;
1613  cache.smooth = !!smooth;
1614  cache.origin = origin;
1615  cache.originIsAbsolute = !!originIsAbsolute;
1616  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).
1617
1618  if (pluginToAddPropTweensTo) {
1619    _addNonTweeningPT(pluginToAddPropTweensTo, cache, "xOrigin", xOriginOld, xOrigin);
1620
1621    _addNonTweeningPT(pluginToAddPropTweensTo, cache, "yOrigin", yOriginOld, yOrigin);
1622
1623    _addNonTweeningPT(pluginToAddPropTweensTo, cache, "xOffset", xOffsetOld, cache.xOffset);
1624
1625    _addNonTweeningPT(pluginToAddPropTweensTo, cache, "yOffset", yOffsetOld, cache.yOffset);
1626  }
1627
1628  target.setAttribute("data-svg-origin", xOrigin + " " + yOrigin);
1629},
1630    _parseTransform = function _parseTransform(target, uncache) {
1631  var cache = target._gsap || new _gsap_core_js__WEBPACK_IMPORTED_MODULE_0__.GSCache(target);
1632
1633  if ("x" in cache && !uncache && !cache.uncache) {
1634    return cache;
1635  }
1636
1637  var style = target.style,
1638      invertedScaleX = cache.scaleX < 0,
1639      px = "px",
1640      deg = "deg",
1641      cs = getComputedStyle(target),
1642      origin = _getComputedProperty(target, _transformOriginProp) || "0",
1643      x,
1644      y,
1645      z,
1646      scaleX,
1647      scaleY,
1648      rotation,
1649      rotationX,
1650      rotationY,
1651      skewX,
1652      skewY,
1653      perspective,
1654      xOrigin,
1655      yOrigin,
1656      matrix,
1657      angle,
1658      cos,
1659      sin,
1660      a,
1661      b,
1662      c,
1663      d,
1664      a12,
1665      a22,
1666      t1,
1667      t2,
1668      t3,
1669      a13,
1670      a23,
1671      a33,
1672      a42,
1673      a43,
1674      a32;
1675  x = y = z = rotation = rotationX = rotationY = skewX = skewY = perspective = 0;
1676  scaleX = scaleY = 1;
1677  cache.svg = !!(target.getCTM && _isSVG(target));
1678
1679  if (cs.translate) {
1680    // accommodate independent transforms by combining them into normal ones.
1681    if (cs.translate !== "none" || cs.scale !== "none" || cs.rotate !== "none") {
1682      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] : "");
1683    }
1684
1685    style.scale = style.rotate = style.translate = "none";
1686  }
1687
1688  matrix = _getMatrix(target, cache.svg);
1689
1690  if (cache.svg) {
1691    if (cache.uncache) {
1692      // 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.
1693      t2 = target.getBBox();
1694      origin = cache.xOrigin - t2.x + "px " + (cache.yOrigin - t2.y) + "px";
1695      t1 = "";
1696    } else {
1697      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.
1698    }
1699
1700    _applySVGOrigin(target, t1 || origin, !!t1 || cache.originIsAbsolute, cache.smooth !== false, matrix);
1701  }
1702
1703  xOrigin = cache.xOrigin || 0;
1704  yOrigin = cache.yOrigin || 0;
1705
1706  if (matrix !== _identity2DMatrix) {
1707    a = matrix[0]; //a11
1708
1709    b = matrix[1]; //a21
1710
1711    c = matrix[2]; //a31
1712
1713    d = matrix[3]; //a41
1714
1715    x = a12 = matrix[4];
1716    y = a22 = matrix[5]; //2D matrix
1717
1718    if (matrix.length === 6) {
1719      scaleX = Math.sqrt(a * a + b * b);
1720      scaleY = Math.sqrt(d * d + c * c);
1721      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).
1722
1723      skewX = c || d ? _atan2(c, d) * _RAD2DEG + rotation : 0;
1724      skewX && (scaleY *= Math.abs(Math.cos(skewX * _DEG2RAD)));
1725
1726      if (cache.svg) {
1727        x -= xOrigin - (xOrigin * a + yOrigin * c);
1728        y -= yOrigin - (xOrigin * b + yOrigin * d);
1729      } //3D matrix
1730
1731    } else {
1732      a32 = matrix[6];
1733      a42 = matrix[7];
1734      a13 = matrix[8];
1735      a23 = matrix[9];
1736      a33 = matrix[10];
1737      a43 = matrix[11];
1738      x = matrix[12];
1739      y = matrix[13];
1740      z = matrix[14];
1741      angle = _atan2(a32, a33);
1742      rotationX = angle * _RAD2DEG; //rotationX
1743
1744      if (angle) {
1745        cos = Math.cos(-angle);
1746        sin = Math.sin(-angle);
1747        t1 = a12 * cos + a13 * sin;
1748        t2 = a22 * cos + a23 * sin;
1749        t3 = a32 * cos + a33 * sin;
1750        a13 = a12 * -sin + a13 * cos;
1751        a23 = a22 * -sin + a23 * cos;
1752        a33 = a32 * -sin + a33 * cos;
1753        a43 = a42 * -sin + a43 * cos;
1754        a12 = t1;
1755        a22 = t2;
1756        a32 = t3;
1757      } //rotationY
1758
1759
1760      angle = _atan2(-c, a33);
1761      rotationY = angle * _RAD2DEG;
1762
1763      if (angle) {
1764        cos = Math.cos(-angle);
1765        sin = Math.sin(-angle);
1766        t1 = a * cos - a13 * sin;
1767        t2 = b * cos - a23 * sin;
1768        t3 = c * cos - a33 * sin;
1769        a43 = d * sin + a43 * cos;
1770        a = t1;
1771        b = t2;
1772        c = t3;
1773      } //rotationZ
1774
1775
1776      angle = _atan2(b, a);
1777      rotation = angle * _RAD2DEG;
1778
1779      if (angle) {
1780        cos = Math.cos(angle);
1781        sin = Math.sin(angle);
1782        t1 = a * cos + b * sin;
1783        t2 = a12 * cos + a22 * sin;
1784        b = b * cos - a * sin;
1785        a22 = a22 * cos - a12 * sin;
1786        a = t1;
1787        a12 = t2;
1788      }
1789
1790      if (rotationX && Math.abs(rotationX) + Math.abs(rotation) > 359.9) {
1791        //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.
1792        rotationX = rotation = 0;
1793        rotationY = 180 - rotationY;
1794      }
1795
1796      scaleX = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._round)(Math.sqrt(a * a + b * b + c * c));
1797      scaleY = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._round)(Math.sqrt(a22 * a22 + a32 * a32));
1798      angle = _atan2(a12, a22);
1799      skewX = Math.abs(angle) > 0.0002 ? angle * _RAD2DEG : 0;
1800      perspective = a43 ? 1 / (a43 < 0 ? -a43 : a43) : 0;
1801    }
1802
1803    if (cache.svg) {
1804      //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).
1805      t1 = target.getAttribute("transform");
1806      cache.forceCSS = target.setAttribute("transform", "") || !_isNullTransform(_getComputedProperty(target, _transformProp));
1807      t1 && target.setAttribute("transform", t1);
1808    }
1809  }
1810
1811  if (Math.abs(skewX) > 90 && Math.abs(skewX) < 270) {
1812    if (invertedScaleX) {
1813      scaleX *= -1;
1814      skewX += rotation <= 0 ? 180 : -180;
1815      rotation += rotation <= 0 ? 180 : -180;
1816    } else {
1817      scaleY *= -1;
1818      skewX += skewX <= 0 ? 180 : -180;
1819    }
1820  }
1821
1822  uncache = uncache || cache.uncache;
1823  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;
1824  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;
1825  cache.z = z + px;
1826  cache.scaleX = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._round)(scaleX);
1827  cache.scaleY = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._round)(scaleY);
1828  cache.rotation = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._round)(rotation) + deg;
1829  cache.rotationX = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._round)(rotationX) + deg;
1830  cache.rotationY = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._round)(rotationY) + deg;
1831  cache.skewX = skewX + deg;
1832  cache.skewY = skewY + deg;
1833  cache.transformPerspective = perspective + px;
1834
1835  if (cache.zOrigin = parseFloat(origin.split(" ")[2]) || 0) {
1836    style[_transformOriginProp] = _firstTwoOnly(origin);
1837  }
1838
1839  cache.xOffset = cache.yOffset = 0;
1840  cache.force3D = _gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._config.force3D;
1841  cache.renderTransform = cache.svg ? _renderSVGTransforms : _supports3D ? _renderCSSTransforms : _renderNon3DTransforms;
1842  cache.uncache = 0;
1843  return cache;
1844},
1845    _firstTwoOnly = function _firstTwoOnly(value) {
1846  return (value = value.split(" "))[0] + " " + value[1];
1847},
1848    //for handling transformOrigin values, stripping out the 3rd dimension
1849_addPxTranslate = function _addPxTranslate(target, start, value) {
1850  var unit = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__.getUnit)(start);
1851  return (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._round)(parseFloat(start) + parseFloat(_convertToUnit(target, "x", value + "px", unit))) + unit;
1852},
1853    _renderNon3DTransforms = function _renderNon3DTransforms(ratio, cache) {
1854  cache.z = "0px";
1855  cache.rotationY = cache.rotationX = "0deg";
1856  cache.force3D = 0;
1857
1858  _renderCSSTransforms(ratio, cache);
1859},
1860    _zeroDeg = "0deg",
1861    _zeroPx = "0px",
1862    _endParenthesis = ") ",
1863    _renderCSSTransforms = function _renderCSSTransforms(ratio, cache) {
1864  var _ref = cache || this,
1865      xPercent = _ref.xPercent,
1866      yPercent = _ref.yPercent,
1867      x = _ref.x,
1868      y = _ref.y,
1869      z = _ref.z,
1870      rotation = _ref.rotation,
1871      rotationY = _ref.rotationY,
1872      rotationX = _ref.rotationX,
1873      skewX = _ref.skewX,
1874      skewY = _ref.skewY,
1875      scaleX = _ref.scaleX,
1876      scaleY = _ref.scaleY,
1877      transformPerspective = _ref.transformPerspective,
1878      force3D = _ref.force3D,
1879      target = _ref.target,
1880      zOrigin = _ref.zOrigin,
1881      transforms = "",
1882      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)
1883
1884
1885  if (zOrigin && (rotationX !== _zeroDeg || rotationY !== _zeroDeg)) {
1886    var angle = parseFloat(rotationY) * _DEG2RAD,
1887        a13 = Math.sin(angle),
1888        a33 = Math.cos(angle),
1889        cos;
1890
1891    angle = parseFloat(rotationX) * _DEG2RAD;
1892    cos = Math.cos(angle);
1893    x = _addPxTranslate(target, x, a13 * cos * -zOrigin);
1894    y = _addPxTranslate(target, y, -Math.sin(angle) * -zOrigin);
1895    z = _addPxTranslate(target, z, a33 * cos * -zOrigin + zOrigin);
1896  }
1897
1898  if (transformPerspective !== _zeroPx) {
1899    transforms += "perspective(" + transformPerspective + _endParenthesis;
1900  }
1901
1902  if (xPercent || yPercent) {
1903    transforms += "translate(" + xPercent + "%, " + yPercent + "%) ";
1904  }
1905
1906  if (use3D || x !== _zeroPx || y !== _zeroPx || z !== _zeroPx) {
1907    transforms += z !== _zeroPx || use3D ? "translate3d(" + x + ", " + y + ", " + z + ") " : "translate(" + x + ", " + y + _endParenthesis;
1908  }
1909
1910  if (rotation !== _zeroDeg) {
1911    transforms += "rotate(" + rotation + _endParenthesis;
1912  }
1913
1914  if (rotationY !== _zeroDeg) {
1915    transforms += "rotateY(" + rotationY + _endParenthesis;
1916  }
1917
1918  if (rotationX !== _zeroDeg) {
1919    transforms += "rotateX(" + rotationX + _endParenthesis;
1920  }
1921
1922  if (skewX !== _zeroDeg || skewY !== _zeroDeg) {
1923    transforms += "skew(" + skewX + ", " + skewY + _endParenthesis;
1924  }
1925
1926  if (scaleX !== 1 || scaleY !== 1) {
1927    transforms += "scale(" + scaleX + ", " + scaleY + _endParenthesis;
1928  }
1929
1930  target.style[_transformProp] = transforms || "translate(0, 0)";
1931},
1932    _renderSVGTransforms = function _renderSVGTransforms(ratio, cache) {
1933  var _ref2 = cache || this,
1934      xPercent = _ref2.xPercent,
1935      yPercent = _ref2.yPercent,
1936      x = _ref2.x,
1937      y = _ref2.y,
1938      rotation = _ref2.rotation,
1939      skewX = _ref2.skewX,
1940      skewY = _ref2.skewY,
1941      scaleX = _ref2.scaleX,
1942      scaleY = _ref2.scaleY,
1943      target = _ref2.target,
1944      xOrigin = _ref2.xOrigin,
1945      yOrigin = _ref2.yOrigin,
1946      xOffset = _ref2.xOffset,
1947      yOffset = _ref2.yOffset,
1948      forceCSS = _ref2.forceCSS,
1949      tx = parseFloat(x),
1950      ty = parseFloat(y),
1951      a11,
1952      a21,
1953      a12,
1954      a22,
1955      temp;
1956
1957  rotation = parseFloat(rotation);
1958  skewX = parseFloat(skewX);
1959  skewY = parseFloat(skewY);
1960
1961  if (skewY) {
1962    //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.
1963    skewY = parseFloat(skewY);
1964    skewX += skewY;
1965    rotation += skewY;
1966  }
1967
1968  if (rotation || skewX) {
1969    rotation *= _DEG2RAD;
1970    skewX *= _DEG2RAD;
1971    a11 = Math.cos(rotation) * scaleX;
1972    a21 = Math.sin(rotation) * scaleX;
1973    a12 = Math.sin(rotation - skewX) * -scaleY;
1974    a22 = Math.cos(rotation - skewX) * scaleY;
1975
1976    if (skewX) {
1977      skewY *= _DEG2RAD;
1978      temp = Math.tan(skewX - skewY);
1979      temp = Math.sqrt(1 + temp * temp);
1980      a12 *= temp;
1981      a22 *= temp;
1982
1983      if (skewY) {
1984        temp = Math.tan(skewY);
1985        temp = Math.sqrt(1 + temp * temp);
1986        a11 *= temp;
1987        a21 *= temp;
1988      }
1989    }
1990
1991    a11 = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._round)(a11);
1992    a21 = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._round)(a21);
1993    a12 = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._round)(a12);
1994    a22 = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._round)(a22);
1995  } else {
1996    a11 = scaleX;
1997    a22 = scaleY;
1998    a21 = a12 = 0;
1999  }
2000
2001  if (tx && !~(x + "").indexOf("px") || ty && !~(y + "").indexOf("px")) {
2002    tx = _convertToUnit(target, "x", x, "px");
2003    ty = _convertToUnit(target, "y", y, "px");
2004  }
2005
2006  if (xOrigin || yOrigin || xOffset || yOffset) {
2007    tx = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._round)(tx + xOrigin - (xOrigin * a11 + yOrigin * a12) + xOffset);
2008    ty = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._round)(ty + yOrigin - (xOrigin * a21 + yOrigin * a22) + yOffset);
2009  }
2010
2011  if (xPercent || yPercent) {
2012    //The SVG spec doesn't support percentage-based translation in the "transform" attribute, so we merge it into the translation to simulate it.
2013    temp = target.getBBox();
2014    tx = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._round)(tx + xPercent / 100 * temp.width);
2015    ty = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._round)(ty + yPercent / 100 * temp.height);
2016  }
2017
2018  temp = "matrix(" + a11 + "," + a21 + "," + a12 + "," + a22 + "," + tx + "," + ty + ")";
2019  target.setAttribute("transform", temp);
2020  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!)
2021},
2022    _addRotationalPropTween = function _addRotationalPropTween(plugin, target, property, startNum, endValue) {
2023  var cap = 360,
2024      isString = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._isString)(endValue),
2025      endNum = parseFloat(endValue) * (isString && ~endValue.indexOf("rad") ? _RAD2DEG : 1),
2026      change = endNum - startNum,
2027      finalValue = startNum + change + "deg",
2028      direction,
2029      pt;
2030
2031  if (isString) {
2032    direction = endValue.split("_")[1];
2033
2034    if (direction === "short") {
2035      change %= cap;
2036
2037      if (change !== change % (cap / 2)) {
2038        change += change < 0 ? cap : -cap;
2039      }
2040    }
2041
2042    if (direction === "cw" && change < 0) {
2043      change = (change + cap * _bigNum) % cap - ~~(change / cap) * cap;
2044    } else if (direction === "ccw" && change > 0) {
2045      change = (change - cap * _bigNum) % cap - ~~(change / cap) * cap;
2046    }
2047  }
2048
2049  plugin._pt = pt = new _gsap_core_js__WEBPACK_IMPORTED_MODULE_0__.PropTween(plugin._pt, target, property, startNum, change, _renderPropWithEnd);
2050  pt.e = finalValue;
2051  pt.u = "deg";
2052
2053  plugin._props.push(property);
2054
2055  return pt;
2056},
2057    _assign = function _assign(target, source) {
2058  // Internet Explorer doesn't have Object.assign(), so we recreate it here.
2059  for (var p in source) {
2060    target[p] = source[p];
2061  }
2062
2063  return target;
2064},
2065    _addRawTransformPTs = function _addRawTransformPTs(plugin, transforms, target) {
2066  //for handling cases where someone passes in a whole transform string, like transform: "scale(2, 3) rotate(20deg) translateY(30em)"
2067  var startCache = _assign({}, target._gsap),
2068      exclude = "perspective,force3D,transformOrigin,svgOrigin",
2069      style = target.style,
2070      endCache,
2071      p,
2072      startValue,
2073      endValue,
2074      startNum,
2075      endNum,
2076      startUnit,
2077      endUnit;
2078
2079  if (startCache.svg) {
2080    startValue = target.getAttribute("transform");
2081    target.setAttribute("transform", "");
2082    style[_transformProp] = transforms;
2083    endCache = _parseTransform(target, 1);
2084
2085    _removeProperty(target, _transformProp);
2086
2087    target.setAttribute("transform", startValue);
2088  } else {
2089    startValue = getComputedStyle(target)[_transformProp];
2090    style[_transformProp] = transforms;
2091    endCache = _parseTransform(target, 1);
2092    style[_transformProp] = startValue;
2093  }
2094
2095  for (p in _transformProps) {
2096    startValue = startCache[p];
2097    endValue = endCache[p];
2098
2099    if (startValue !== endValue && exclude.indexOf(p) < 0) {
2100      //tweening to no perspective gives very unintuitive results - just keep the same perspective in that case.
2101      startUnit = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__.getUnit)(startValue);
2102      endUnit = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__.getUnit)(endValue);
2103      startNum = startUnit !== endUnit ? _convertToUnit(target, p, startValue, endUnit) : parseFloat(startValue);
2104      endNum = parseFloat(endValue);
2105      plugin._pt = new _gsap_core_js__WEBPACK_IMPORTED_MODULE_0__.PropTween(plugin._pt, endCache, p, startNum, endNum - startNum, _renderCSSProp);
2106      plugin._pt.u = endUnit || 0;
2107
2108      plugin._props.push(p);
2109    }
2110  }
2111
2112  _assign(endCache, startCache);
2113}; // 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.
2114
2115
2116(0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._forEachName)("padding,margin,Width,Radius", function (name, index) {
2117  var t = "Top",
2118      r = "Right",
2119      b = "Bottom",
2120      l = "Left",
2121      props = (index < 3 ? [t, r, b, l] : [t + l, t + r, b + r, b + l]).map(function (side) {
2122    return index < 2 ? name + side : "border" + side + name;
2123  });
2124
2125  _specialProps[index > 1 ? "border" + name : name] = function (plugin, target, property, endValue, tween) {
2126    var a, vars;
2127
2128    if (arguments.length < 4) {
2129      // getter, passed target, property, and unit (from _get())
2130      a = props.map(function (prop) {
2131        return _get(plugin, prop, property);
2132      });
2133      vars = a.join(" ");
2134      return vars.split(a[0]).length === 5 ? a[0] : vars;
2135    }
2136
2137    a = (endValue + "").split(" ");
2138    vars = {};
2139    props.forEach(function (prop, i) {
2140      return vars[prop] = a[i] = a[i] || a[(i - 1) / 2 | 0];
2141    });
2142    plugin.init(target, vars, tween);
2143  };
2144});
2145
2146var CSSPlugin = {
2147  name: "css",
2148  register: _initCore,
2149  targetTest: function targetTest(target) {
2150    return target.style && target.nodeType;
2151  },
2152  init: function init(target, vars, tween, index, targets) {
2153    var props = this._props,
2154        style = target.style,
2155        startAt = tween.vars.startAt,
2156        startValue,
2157        endValue,
2158        endNum,
2159        startNum,
2160        type,
2161        specialProp,
2162        p,
2163        startUnit,
2164        endUnit,
2165        relative,
2166        isTransformRelated,
2167        transformPropTween,
2168        cache,
2169        smooth,
2170        hasPriority,
2171        inlineProps;
2172    _pluginInitted || _initCore(); // we may call init() multiple times on the same plugin instance, like when adding special properties, so make sure we don't overwrite the revert data or inlineProps
2173
2174    this.styles = this.styles || _getStyleSaver(target);
2175    inlineProps = this.styles.props;
2176    this.tween = tween;
2177
2178    for (p in vars) {
2179      if (p === "autoRound") {
2180        continue;
2181      }
2182
2183      endValue = vars[p];
2184
2185      if (_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._plugins[p] && (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._checkPlugin)(p, vars, tween, index, target, targets)) {
2186        // plugins
2187        continue;
2188      }
2189
2190      type = typeof endValue;
2191      specialProp = _specialProps[p];
2192
2193      if (type === "function") {
2194        endValue = endValue.call(tween, index, target, targets);
2195        type = typeof endValue;
2196      }
2197
2198      if (type === "string" && ~endValue.indexOf("random(")) {
2199        endValue = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._replaceRandom)(endValue);
2200      }
2201
2202      if (specialProp) {
2203        specialProp(this, target, p, endValue, tween) && (hasPriority = 1);
2204      } else if (p.substr(0, 2) === "--") {
2205        //CSS variable
2206        startValue = (getComputedStyle(target).getPropertyValue(p) + "").trim();
2207        endValue += "";
2208        _gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._colorExp.lastIndex = 0;
2209
2210        if (!_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._colorExp.test(startValue)) {
2211          // colors don't have units
2212          startUnit = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__.getUnit)(startValue);
2213          endUnit = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__.getUnit)(endValue);
2214        }
2215
2216        endUnit ? startUnit !== endUnit && (startValue = _convertToUnit(target, p, startValue, endUnit) + endUnit) : startUnit && (endValue += startUnit);
2217        this.add(style, "setProperty", startValue, endValue, index, targets, 0, 0, p);
2218        props.push(p);
2219        inlineProps.push(p, 0, style[p]);
2220      } else if (type !== "undefined") {
2221        if (startAt && p in startAt) {
2222          // in case someone hard-codes a complex value as the start, like top: "calc(2vh / 2)". Without this, it'd use the computed value (always in px)
2223          startValue = typeof startAt[p] === "function" ? startAt[p].call(tween, index, target, targets) : startAt[p];
2224          (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._isString)(startValue) && ~startValue.indexOf("random(") && (startValue = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._replaceRandom)(startValue));
2225          (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__.getUnit)(startValue + "") || (startValue += _gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._config.units[p] || (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__.getUnit)(_get(target, p)) || ""); // for cases when someone passes in a unitless value like {x: 100}; if we try setting translate(100, 0px) it won't work.
2226
2227          (startValue + "").charAt(1) === "=" && (startValue = _get(target, p)); // can't work with relative values
2228        } else {
2229          startValue = _get(target, p);
2230        }
2231
2232        startNum = parseFloat(startValue);
2233        relative = type === "string" && endValue.charAt(1) === "=" && endValue.substr(0, 2);
2234        relative && (endValue = endValue.substr(2));
2235        endNum = parseFloat(endValue);
2236
2237        if (p in _propertyAliases) {
2238          if (p === "autoAlpha") {
2239            //special case where we control the visibility along with opacity. We still allow the opacity value to pass through and get tweened.
2240            if (startNum === 1 && _get(target, "visibility") === "hidden" && endNum) {
2241              //if visibility is initially set to "hidden", we should interpret that as intent to make opacity 0 (a convenience)
2242              startNum = 0;
2243            }
2244
2245            inlineProps.push("visibility", 0, style.visibility);
2246
2247            _addNonTweeningPT(this, style, "visibility", startNum ? "inherit" : "hidden", endNum ? "inherit" : "hidden", !endNum);
2248          }
2249
2250          if (p !== "scale" && p !== "transform") {
2251            p = _propertyAliases[p];
2252            ~p.indexOf(",") && (p = p.split(",")[0]);
2253          }
2254        }
2255
2256        isTransformRelated = p in _transformProps; //--- TRANSFORM-RELATED ---
2257
2258        if (isTransformRelated) {
2259          this.styles.save(p);
2260
2261          if (!transformPropTween) {
2262            cache = target._gsap;
2263            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.
2264
2265            smooth = vars.smoothOrigin !== false && cache.smooth;
2266            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)
2267
2268            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.
2269          }
2270
2271          if (p === "scale") {
2272            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);
2273            this._pt.u = 0;
2274            props.push("scaleY", p);
2275            p += "X";
2276          } else if (p === "transformOrigin") {
2277            inlineProps.push(_transformOriginProp, 0, style[_transformOriginProp]);
2278            endValue = _convertKeywordsToPercentages(endValue); //in case something like "left top" or "bottom right" is passed in. Convert to percentages.
2279
2280            if (cache.svg) {
2281              _applySVGOrigin(target, endValue, 0, smooth, 0, this);
2282            } else {
2283              endUnit = parseFloat(endValue.split(" ")[2]) || 0; //handle the zOrigin separately!
2284
2285              endUnit !== cache.zOrigin && _addNonTweeningPT(this, cache, "zOrigin", cache.zOrigin, endUnit);
2286
2287              _addNonTweeningPT(this, style, p, _firstTwoOnly(startValue), _firstTwoOnly(endValue));
2288            }
2289
2290            continue;
2291          } else if (p === "svgOrigin") {
2292            _applySVGOrigin(target, endValue, 1, smooth, 0, this);
2293
2294            continue;
2295          } else if (p in _rotationalProperties) {
2296            _addRotationalPropTween(this, cache, p, startNum, relative ? (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._parseRelative)(startNum, relative + endValue) : endValue);
2297
2298            continue;
2299          } else if (p === "smoothOrigin") {
2300            _addNonTweeningPT(this, cache, "smooth", cache.smooth, endValue);
2301
2302            continue;
2303          } else if (p === "force3D") {
2304            cache[p] = endValue;
2305            continue;
2306          } else if (p === "transform") {
2307            _addRawTransformPTs(this, endValue, target);
2308
2309            continue;
2310          }
2311        } else if (!(p in style)) {
2312          p = _checkPropPrefix(p) || p;
2313        }
2314
2315        if (isTransformRelated || (endNum || endNum === 0) && (startNum || startNum === 0) && !_complexExp.test(endValue) && p in style) {
2316          startUnit = (startValue + "").substr((startNum + "").length);
2317          endNum || (endNum = 0); // protect against NaN
2318
2319          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);
2320          startUnit !== endUnit && (startNum = _convertToUnit(target, p, startValue, endUnit));
2321          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, !isTransformRelated && (endUnit === "px" || p === "zIndex") && vars.autoRound !== false ? _renderRoundedCSSProp : _renderCSSProp);
2322          this._pt.u = endUnit || 0;
2323
2324          if (startUnit !== endUnit && endUnit !== "%") {
2325            //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)
2326            this._pt.b = startValue;
2327            this._pt.r = _renderCSSPropWithBeginning;
2328          }
2329        } else if (!(p in style)) {
2330          if (p in target) {
2331            //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.
2332            this.add(target, p, startValue || target[p], relative ? relative + endValue : endValue, index, targets);
2333          } else if (p !== "parseTransform") {
2334            (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._missingPlugin)(p, endValue);
2335
2336            continue;
2337          }
2338        } else {
2339          _tweenComplexCSSString.call(this, target, p, startValue, relative ? relative + endValue : endValue);
2340        }
2341
2342        isTransformRelated || (p in style ? inlineProps.push(p, 0, style[p]) : inlineProps.push(p, 1, startValue || target[p]));
2343        props.push(p);
2344      }
2345    }
2346
2347    hasPriority && (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._sortPropTweensByPriority)(this);
2348  },
2349  render: function render(ratio, data) {
2350    if (data.tween._time || !_reverting()) {
2351      var pt = data._pt;
2352
2353      while (pt) {
2354        pt.r(ratio, pt.d);
2355        pt = pt._next;
2356      }
2357    } else {
2358      data.styles.revert();
2359    }
2360  },
2361  get: _get,
2362  aliases: _propertyAliases,
2363  getSetter: function getSetter(target, property, plugin) {
2364    //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.
2365    var p = _propertyAliases[property];
2366    p && p.indexOf(",") < 0 && (property = p);
2367    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);
2368  },
2369  core: {
2370    _removeProperty: _removeProperty,
2371    _getMatrix: _getMatrix
2372  }
2373};
2374_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__.gsap.utils.checkPrefix = _checkPropPrefix;
2375_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__.gsap.core.getStyleSaver = _getStyleSaver;
2376
2377(function (positionAndScale, rotation, others, aliases) {
2378  var all = (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._forEachName)(positionAndScale + "," + rotation + "," + others, function (name) {
2379    _transformProps[name] = 1;
2380  });
2381
2382  (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._forEachName)(rotation, function (name) {
2383    _gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._config.units[name] = "deg";
2384    _rotationalProperties[name] = 1;
2385  });
2386
2387  _propertyAliases[all[13]] = positionAndScale + "," + rotation;
2388
2389  (0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._forEachName)(aliases, function (name) {
2390    var split = name.split(":");
2391    _propertyAliases[split[1]] = all[split[0]];
2392  });
2393})("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");
2394
2395(0,_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._forEachName)("x,y,z,top,right,bottom,left,width,height,fontSize,padding,margin,perspective", function (name) {
2396  _gsap_core_js__WEBPACK_IMPORTED_MODULE_0__._config.units[name] = "px";
2397});
2398
2399_gsap_core_js__WEBPACK_IMPORTED_MODULE_0__.gsap.registerPlugin(CSSPlugin);
2400
2401
2402/***/ }),
2403

2404/***/ "./node_modules/gsap/Observer.js":
2405/*!***************************************!*\
2406  !*** ./node_modules/gsap/Observer.js ***!
2407  \***************************************/
2408/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
2409
2410__webpack_require__.r(__webpack_exports__);
2411/* harmony export */ __webpack_require__.d(__webpack_exports__, {
2412/* harmony export */   Observer: function() { return /* binding */ Observer; },
2413/* harmony export */   _getProxyProp: function() { return /* binding */ _getProxyProp; },
2414/* harmony export */   _getScrollFunc: function() { return /* binding */ _getScrollFunc; },
2415/* harmony export */   _getTarget: function() { return /* binding */ _getTarget; },
2416/* harmony export */   _getVelocityProp: function() { return /* binding */ _getVelocityProp; },
2417/* harmony export */   _horizontal: function() { return /* binding */ _horizontal; },
2418/* harmony export */   _isViewport: function() { return /* binding */ _isViewport; },
2419/* harmony export */   _proxies: function() { return /* binding */ _proxies; },
2420/* harmony export */   _scrollers: function() { return /* binding */ _scrollers; },
2421/* harmony export */   _vertical: function() { return /* binding */ _vertical; },
2422/* harmony export */   "default": function() { return /* binding */ Observer; }
2423/* harmony export */ });
2424function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
2425
2426function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
2427
2428/*!
2429 * Observer 3.12.2
2430 * https://greensock.com
2431 *
2432 * @license Copyright 2008-2023, GreenSock. All rights reserved.
2433 * Subject to the terms at https://greensock.com/standard-license or for
2434 * Club GreenSock members, the agreement issued with that membership.
2435 * @author: Jack Doyle, [email protected]
2436*/
2437
2438/* eslint-disable */
2439var gsap,
2440    _coreInitted,
2441    _clamp,
2442    _win,
2443    _doc,
2444    _docEl,
2445    _body,
2446    _isTouch,
2447    _pointerType,
2448    ScrollTrigger,
2449    _root,
2450    _normalizer,
2451    _eventTypes,
2452    _context,
2453    _getGSAP = function _getGSAP() {
2454  return gsap || typeof window !== "undefined" && (gsap = window.gsap) && gsap.registerPlugin && gsap;
2455},
2456    _startup = 1,
2457    _observers = [],
2458    _scrollers = [],
2459    _proxies = [],
2460    _getTime = Date.now,
2461    _bridge = function _bridge(name, value) {
2462  return value;
2463},
2464    _integrate = function _integrate() {
2465  var core = ScrollTrigger.core,
2466      data = core.bridge || {},
2467      scrollers = core._scrollers,
2468      proxies = core._proxies;
2469  scrollers.push.apply(scrollers, _scrollers);
2470  proxies.push.apply(proxies, _proxies);
2471  _scrollers = scrollers;
2472  _proxies = proxies;
2473
2474  _bridge = function _bridge(name, value) {
2475    return data[name](value);
2476  };
2477},
2478    _getProxyProp = function _getProxyProp(element, property) {
2479  return ~_proxies.indexOf(element) && _proxies[_proxies.indexOf(element) + 1][property];
2480},
2481    _isViewport = function _isViewport(el) {
2482  return !!~_root.indexOf(el);
2483},
2484    _addListener = function _addListener(element, type, func, nonPassive, capture) {
2485  return element.addEventListener(type, func, {
2486    passive: !nonPassive,
2487    capture: !!capture
2488  });
2489},
2490    _removeListener = function _removeListener(element, type, func, capture) {
2491  return element.removeEventListener(type, func, !!capture);
2492},
2493    _scrollLeft = "scrollLeft",
2494    _scrollTop = "scrollTop",
2495    _onScroll = function _onScroll() {
2496  return _normalizer && _normalizer.isPressed || _scrollers.cache++;
2497},
2498    _scrollCacheFunc = function _scrollCacheFunc(f, doNotCache) {
2499  var cachingFunc = function cachingFunc(value) {
2500    // since reading the scrollTop/scrollLeft/pageOffsetY/pageOffsetX can trigger a layout, this function allows us to cache the value so it only gets read fresh after a "scroll" event fires (or while we're refreshing because that can lengthen the page and alter the scroll position). when "soft" is true, that means don't actually set the scroll, but cache the new value instead (useful in ScrollSmoother)
2501    if (value || value === 0) {
2502      _startup && (_win.history.scrollRestoration = "manual"); // otherwise the new position will get overwritten by the browser onload.
2503
2504      var isNormalizing = _normalizer && _normalizer.isPressed;
2505      value = cachingFunc.v = Math.round(value) || (_normalizer && _normalizer.iOS ? 1 : 0); //TODO: iOS Bug: if you allow it to go to 0, Safari can start to report super strange (wildly inaccurate) touch positions!
2506
2507      f(value);
2508      cachingFunc.cacheID = _scrollers.cache;
2509      isNormalizing && _bridge("ss", value); // set scroll (notify ScrollTrigger so it can dispatch a "scrollStart" event if necessary
2510    } else if (doNotCache || _scrollers.cache !== cachingFunc.cacheID || _bridge("ref")) {
2511      cachingFunc.cacheID = _scrollers.cache;
2512      cachingFunc.v = f();
2513    }
2514
2515    return cachingFunc.v + cachingFunc.offset;
2516  };
2517
2518  cachingFunc.offset = 0;
2519  return f && cachingFunc;
2520},
2521    _horizontal = {
2522  s: _scrollLeft,
2523  p: "left",
2524  p2: "Left",
2525  os: "right",
2526  os2: "Right",
2527  d: "width",
2528  d2: "Width",
2529  a: "x",
2530  sc: _scrollCacheFunc(function (value) {
2531    return arguments.length ? _win.scrollTo(value, _vertical.sc()) : _win.pageXOffset || _doc[_scrollLeft] || _docEl[_scrollLeft] || _body[_scrollLeft] || 0;
2532  })
2533},
2534    _vertical = {
2535  s: _scrollTop,
2536  p: "top",
2537  p2: "Top",
2538  os: "bottom",
2539  os2: "Bottom",
2540  d: "height",
2541  d2: "Height",
2542  a: "y",
2543  op: _horizontal,
2544  sc: _scrollCacheFunc(function (value) {
2545    return arguments.length ? _win.scrollTo(_horizontal.sc(), value) : _win.pageYOffset || _doc[_scrollTop] || _docEl[_scrollTop] || _body[_scrollTop] || 0;
2546  })
2547},
2548    _getTarget = function _getTarget(t, self) {
2549  return (self && self._ctx && self._ctx.selector || gsap.utils.toArray)(t)[0] || (typeof t === "string" && gsap.config().nullTargetWarn !== false ? console.warn("Element not found:", t) : null);
2550},
2551    _getScrollFunc = function _getScrollFunc(element, _ref) {
2552  var s = _ref.s,
2553      sc = _ref.sc;
2554  // we store the scroller functions in an alternating sequenced Array like [element, verticalScrollFunc, horizontalScrollFunc, ...] so that we can minimize memory, maximize performance, and we also record the last position as a ".rec" property in order to revert to that after refreshing to ensure things don't shift around.
2555  _isViewport(element) && (element = _doc.scrollingElement || _docEl);
2556
2557  var i = _scrollers.indexOf(element),
2558      offset = sc === _vertical.sc ? 1 : 2;
2559
2560  !~i && (i = _scrollers.push(element) - 1);
2561  _scrollers[i + offset] || _addListener(element, "scroll", _onScroll); // clear the cache when a scroll occurs
2562
2563  var prev = _scrollers[i + offset],
2564      func = prev || (_scrollers[i + offset] = _scrollCacheFunc(_getProxyProp(element, s), true) || (_isViewport(element) ? sc : _scrollCacheFunc(function (value) {
2565    return arguments.length ? element[s] = value : element[s];
2566  })));
2567  func.target = element;
2568  prev || (func.smooth = gsap.getProperty(element, "scrollBehavior") === "smooth"); // only set it the first time (don't reset every time a scrollFunc is requested because perhaps it happens during a refresh() when it's disabled in ScrollTrigger.
2569
2570  return func;
2571},
2572    _getVelocityProp = function _getVelocityProp(value, minTimeRefresh, useDelta) {
2573  var v1 = value,
2574      v2 = value,
2575      t1 = _getTime(),
2576      t2 = t1,
2577      min = minTimeRefresh || 50,
2578      dropToZeroTime = Math.max(500, min * 3),
2579      update = function update(value, force) {
2580    var t = _getTime();
2581
2582    if (force || t - t1 > min) {
2583      v2 = v1;
2584      v1 = value;
2585      t2 = t1;
2586      t1 = t;
2587    } else if (useDelta) {
2588      v1 += value;
2589    } else {
2590      // not totally necessary, but makes it a bit more accurate by adjusting the v1 value according to the new slope. This way we're not just ignoring the incoming data. Removing for now because it doesn't seem to make much practical difference and it's probably not worth the kb.
2591      v1 = v2 + (value - v2) / (t - t2) * (t1 - t2);
2592    }
2593  },
2594      reset = function reset() {
2595    v2 = v1 = useDelta ? 0 : v1;
2596    t2 = t1 = 0;
2597  },
2598      getVelocity = function getVelocity(latestValue) {
2599    var tOld = t2,
2600        vOld = v2,
2601        t = _getTime();
2602
2603    (latestValue || latestValue === 0) && latestValue !== v1 && update(latestValue);
2604    return t1 === t2 || t - t2 > dropToZeroTime ? 0 : (v1 + (useDelta ? vOld : -vOld)) / ((useDelta ? t : t1) - tOld) * 1000;
2605  };
2606
2607  return {
2608    update: update,
2609    reset: reset,
2610    getVelocity: getVelocity
2611  };
2612},
2613    _getEvent = function _getEvent(e, preventDefault) {
2614  preventDefault && !e._gsapAllow && e.preventDefault();
2615  return e.changedTouches ? e.changedTouches[0] : e;
2616},
2617    _getAbsoluteMax = function _getAbsoluteMax(a) {
2618  var max = Math.max.apply(Math, a),
2619      min = Math.min.apply(Math, a);
2620  return Math.abs(max) >= Math.abs(min) ? max : min;
2621},
2622    _setScrollTrigger = function _setScrollTrigger() {
2623  ScrollTrigger = gsap.core.globals().ScrollTrigger;
2624  ScrollTrigger && ScrollTrigger.core && _integrate();
2625},
2626    _initCore = function _initCore(core) {
2627  gsap = core || _getGSAP();
2628
2629  if (gsap && typeof document !== "undefined" && document.body) {
2630    _win = window;
2631    _doc = document;
2632    _docEl = _doc.documentElement;
2633    _body = _doc.body;
2634    _root = [_win, _doc, _docEl, _body];
2635    _clamp = gsap.utils.clamp;
2636
2637    _context = gsap.core.context || function () {};
2638
2639    _pointerType = "onpointerenter" in _body ? "pointer" : "mouse"; // isTouch is 0 if no touch, 1 if ONLY touch, and 2 if it can accommodate touch but also other types like mouse/pointer.
2640
2641    _isTouch = Observer.isTouch = _win.matchMedia && _win.matchMedia("(hover: none), (pointer: coarse)").matches ? 1 : "ontouchstart" in _win || navigator.maxTouchPoints > 0 || navigator.msMaxTouchPoints > 0 ? 2 : 0;
2642    _eventTypes = Observer.eventTypes = ("ontouchstart" in _docEl ? "touchstart,touchmove,touchcancel,touchend" : !("onpointerdown" in _docEl) ? "mousedown,mousemove,mouseup,mouseup" : "pointerdown,pointermove,pointercancel,pointerup").split(",");
2643    setTimeout(function () {
2644      return _startup = 0;
2645    }, 500);
2646
2647    _setScrollTrigger();
2648
2649    _coreInitted = 1;
2650  }
2651
2652  return _coreInitted;
2653};
2654
2655_horizontal.op = _vertical;
2656_scrollers.cache = 0;
2657var Observer = /*#__PURE__*/function () {
2658  function Observer(vars) {
2659    this.init(vars);
2660  }
2661
2662  var _proto = Observer.prototype;
2663
2664  _proto.init = function init(vars) {
2665    _coreInitted || _initCore(gsap) || console.warn("Please gsap.registerPlugin(Observer)");
2666    ScrollTrigger || _setScrollTrigger();
2667    var tolerance = vars.tolerance,
2668        dragMinimum = vars.dragMinimum,
2669        type = vars.type,
2670        target = vars.target,
2671        lineHeight = vars.lineHeight,
2672        debounce = vars.debounce,
2673        preventDefault = vars.preventDefault,
2674        onStop = vars.onStop,
2675        onStopDelay = vars.onStopDelay,
2676        ignore = vars.ignore,
2677        wheelSpeed = vars.wheelSpeed,
2678        event = vars.event,
2679        onDragStart = vars.onDragStart,
2680        onDragEnd = vars.onDragEnd,
2681        onDrag = vars.onDrag,
2682        onPress = vars.onPress,
2683        onRelease = vars.onRelease,
2684        onRight = vars.onRight,
2685        onLeft = vars.onLeft,
2686        onUp = vars.onUp,
2687        onDown = vars.onDown,
2688        onChangeX = vars.onChangeX,
2689        onChangeY = vars.onChangeY,
2690        onChange = vars.onChange,
2691        onToggleX = vars.onToggleX,
2692        onToggleY = vars.onToggleY,
2693        onHover = vars.onHover,
2694        onHoverEnd = vars.onHoverEnd,
2695        onMove = vars.onMove,
2696        ignoreCheck = vars.ignoreCheck,
2697        isNormalizer = vars.isNormalizer,
2698        onGestureStart = vars.onGestureStart,
2699        onGestureEnd = vars.onGestureEnd,
2700        onWheel = vars.onWheel,
2701        onEnable = vars.onEnable,
2702        onDisable = vars.onDisable,
2703        onClick = vars.onClick,
2704        scrollSpeed = vars.scrollSpeed,
2705        capture = vars.capture,
2706        allowClicks = vars.allowClicks,
2707        lockAxis = vars.lockAxis,
2708        onLockAxis = vars.onLockAxis;
2709    this.target = target = _getTarget(target) || _docEl;
2710    this.vars = vars;
2711    ignore && (ignore = gsap.utils.toArray(ignore));
2712    tolerance = tolerance || 1e-9;
2713    dragMinimum = dragMinimum || 0;
2714    wheelSpeed = wheelSpeed || 1;
2715    scrollSpeed = scrollSpeed || 1;
2716    type = type || "wheel,touch,pointer";
2717    debounce = debounce !== false;
2718    lineHeight || (lineHeight = parseFloat(_win.getComputedStyle(_body).lineHeight) || 22); // note: browser may report "normal", so default to 22.
2719
2720    var id,
2721        onStopDelayedCall,
2722        dragged,
2723        moved,
2724        wheeled,
2725        locked,
2726        axis,
2727        self = this,
2728        prevDeltaX = 0,
2729        prevDeltaY = 0,
2730        scrollFuncX = _getScrollFunc(target, _horizontal),
2731        scrollFuncY = _getScrollFunc(target, _vertical),
2732        scrollX = scrollFuncX(),
2733        scrollY = scrollFuncY(),
2734        limitToTouch = ~type.indexOf("touch") && !~type.indexOf("pointer") && _eventTypes[0] === "pointerdown",
2735        // for devices that accommodate mouse events and touch events, we need to distinguish.
2736    isViewport = _isViewport(target),
2737        ownerDoc = target.ownerDocument || _doc,
2738        deltaX = [0, 0, 0],
2739        // wheel, scroll, pointer/touch
2740    deltaY = [0, 0, 0],
2741        onClickTime = 0,
2742        clickCapture = function clickCapture() {
2743      return onClickTime = _getTime();
2744    },
2745        _ignoreCheck = function _ignoreCheck(e, isPointerOrTouch) {
2746      return (self.event = e) && ignore && ~ignore.indexOf(e.target) || isPointerOrTouch && limitToTouch && e.pointerType !== "touch" || ignoreCheck && ignoreCheck(e, isPointerOrTouch);
2747    },
2748        onStopFunc = function onStopFunc() {
2749      self._vx.reset();
2750
2751      self._vy.reset();
2752
2753      onStopDelayedCall.pause();
2754      onStop && onStop(self);
2755    },
2756        update = function update() {
2757      var dx = self.deltaX = _getAbsoluteMax(deltaX),
2758          dy = self.deltaY = _getAbsoluteMax(deltaY),
2759          changedX = Math.abs(dx) >= tolerance,
2760          changedY = Math.abs(dy) >= tolerance;
2761
2762      onChange && (changedX || changedY) && onChange(self, dx, dy, deltaX, deltaY); // in ScrollTrigger.normalizeScroll(), we need to know if it was touch/pointer so we need access to the deltaX/deltaY Arrays before we clear them out.
2763
2764      if (changedX) {
2765        onRight && self.deltaX > 0 && onRight(self);
2766        onLeft && self.deltaX < 0 && onLeft(self);
2767        onChangeX && onChangeX(self);
2768        onToggleX && self.deltaX < 0 !== prevDeltaX < 0 && onToggleX(self);
2769        prevDeltaX = self.deltaX;
2770        deltaX[0] = deltaX[1] = deltaX[2] = 0;
2771      }
2772
2773      if (changedY) {
2774        onDown && self.deltaY > 0 && onDown(self);
2775        onUp && self.deltaY < 0 && onUp(self);
2776        onChangeY && onChangeY(self);
2777        onToggleY && self.deltaY < 0 !== prevDeltaY < 0 && onToggleY(self);
2778        prevDeltaY = self.deltaY;
2779        deltaY[0] = deltaY[1] = deltaY[2] = 0;
2780      }
2781
2782      if (moved || dragged) {
2783        onMove && onMove(self);
2784
2785        if (dragged) {
2786          onDrag(self);
2787          dragged = false;
2788        }
2789
2790        moved = false;
2791      }
2792
2793      locked && !(locked = false) && onLockAxis && onLockAxis(self);
2794
2795      if (wheeled) {
2796        onWheel(self);
2797        wheeled = false;
2798      }
2799
2800      id = 0;
2801    },
2802        onDelta = function onDelta(x, y, index) {
2803      deltaX[index] += x;
2804      deltaY[index] += y;
2805
2806      self._vx.update(x);
2807
2808      self._vy.update(y);
2809
2810      debounce ? id || (id = requestAnimationFrame(update)) : update();
2811    },
2812        onTouchOrPointerDelta = function onTouchOrPointerDelta(x, y) {
2813      if (lockAxis && !axis) {
2814        self.axis = axis = Math.abs(x) > Math.abs(y) ? "x" : "y";
2815        locked = true;
2816      }
2817
2818      if (axis !== "y") {
2819        deltaX[2] += x;
2820
2821        self._vx.update(x, true); // update the velocity as frequently as possible instead of in the debounced function so that very quick touch-scrolls (flicks) feel natural. If it's the mouse/touch/pointer, force it so that we get snappy/accurate momentum scroll.
2822
2823      }
2824
2825      if (axis !== "x") {
2826        deltaY[2] += y;
2827
2828        self._vy.update(y, true);
2829      }
2830
2831      debounce ? id || (id = requestAnimationFrame(update)) : update();
2832    },
2833        _onDrag = function _onDrag(e) {
2834      if (_ignoreCheck(e, 1)) {
2835        return;
2836      }
2837
2838      e = _getEvent(e, preventDefault);
2839      var x = e.clientX,
2840          y = e.clientY,
2841          dx = x - self.x,
2842          dy = y - self.y,
2843          isDragging = self.isDragging;
2844      self.x = x;
2845      self.y = y;
2846
2847      if (isDragging || Math.abs(self.startX - x) >= dragMinimum || Math.abs(self.startY - y) >= dragMinimum) {
2848        onDrag && (dragged = true);
2849        isDragging || (self.isDragging = true);
2850        onTouchOrPointerDelta(dx, dy);
2851        isDragging || onDragStart && onDragStart(self);
2852      }
2853    },
2854        _onPress = self.onPress = function (e) {
2855      if (_ignoreCheck(e, 1) || e && e.button) {
2856        return;
2857      }
2858
2859      self.axis = axis = null;
2860      onStopDelayedCall.pause();
2861      self.isPressed = true;
2862      e = _getEvent(e); // note: may need to preventDefault(?) Won't side-scroll on iOS Safari if we do, though.
2863
2864      prevDeltaX = prevDeltaY = 0;
2865      self.startX = self.x = e.clientX;
2866      self.startY = self.y = e.clientY;
2867
2868      self._vx.reset(); // otherwise the t2 may be stale if the user touches and flicks super fast and releases in less than 2 requestAnimationFrame ticks, causing velocity to be 0.
2869
2870
2871      self._vy.reset();
2872
2873      _addListener(isNormalizer ? target : ownerDoc, _eventTypes[1], _onDrag, preventDefault, true);
2874
2875      self.deltaX = self.deltaY = 0;
2876      onPress && onPress(self);
2877    },
2878        _onRelease = self.onRelease = function (e) {
2879      if (_ignoreCheck(e, 1)) {
2880        return;
2881      }
2882
2883      _removeListener(isNormalizer ? target : ownerDoc, _eventTypes[1], _onDrag, true);
2884
2885      var isTrackingDrag = !isNaN(self.y - self.startY),
2886          wasDragging = self.isDragging && (Math.abs(self.x - self.startX) > 3 || Math.abs(self.y - self.startY) > 3),
2887          // some touch devices need some wiggle room in terms of sensing clicks - the finger may move a few pixels.
2888      eventData = _getEvent(e);
2889
2890      if (!wasDragging && isTrackingDrag) {
2891        self._vx.reset();
2892
2893        self._vy.reset();
2894
2895        if (preventDefault && allowClicks) {
2896          gsap.delayedCall(0.08, function () {
2897            // some browsers (like Firefox) won't trust script-generated clicks, so if the user tries to click on a video to play it, for example, it simply won't work. Since a regular "click" event will most likely be generated anyway (one that has its isTrusted flag set to true), we must slightly delay our script-generated click so that the "real"/trusted one is prioritized. Remember, when there are duplicate events in quick succession, we suppress all but the first one. Some browsers don't even trigger the "real" one at all, so our synthetic one is a safety valve that ensures that no matter what, a click event does get dispatched.
2898            if (_getTime() - onClickTime > 300 && !e.defaultPrevented) {
2899              if (e.target.click) {
2900                //some browsers (like mobile Safari) don't properly trigger the click event
2901                e.target.click();
2902              } else if (ownerDoc.createEvent) {
2903                var syntheticEvent = ownerDoc.createEvent("MouseEvents");
2904                syntheticEvent.initMouseEvent("click", true, true, _win, 1, eventData.screenX, eventData.screenY, eventData.clientX, eventData.clientY, false, false, false, false, 0, null);
2905                e.target.dispatchEvent(syntheticEvent);
2906              }
2907            }
2908          });
2909        }
2910      }
2911
2912      self.isDragging = self.isGesturing = self.isPressed = false;
2913      onStop && !isNormalizer && onStopDelayedCall.restart(true);
2914      onDragEnd && wasDragging && onDragEnd(self);
2915      onRelease && onRelease(self, wasDragging);
2916    },
2917        _onGestureStart = function _onGestureStart(e) {
2918      return e.touches && e.touches.length > 1 && (self.isGesturing = true) && onGestureStart(e, self.isDragging);
2919    },
2920        _onGestureEnd = function _onGestureEnd() {
2921      return (self.isGesturing = false) || onGestureEnd(self);
2922    },
2923        onScroll = function onScroll(e) {
2924      if (_ignoreCheck(e)) {
2925        return;
2926      }
2927
2928      var x = scrollFuncX(),
2929          y = scrollFuncY();
2930      onDelta((x - scrollX) * scrollSpeed, (y - scrollY) * scrollSpeed, 1);
2931      scrollX = x;
2932      scrollY = y;
2933      onStop && onStopDelayedCall.restart(true);
2934    },
2935        _onWheel = function _onWheel(e) {
2936      if (_ignoreCheck(e)) {
2937        return;
2938      }
2939
2940      e = _getEvent(e, preventDefault);
2941      onWheel && (wheeled = true);
2942      var multiplier = (e.deltaMode === 1 ? lineHeight : e.deltaMode === 2 ? _win.innerHeight : 1) * wheelSpeed;
2943      onDelta(e.deltaX * multiplier, e.deltaY * multiplier, 0);
2944      onStop && !isNormalizer && onStopDelayedCall.restart(true);
2945    },
2946        _onMove = function _onMove(e) {
2947      if (_ignoreCheck(e)) {
2948        return;
2949      }
2950
2951      var x = e.clientX,
2952          y = e.clientY,
2953          dx = x - self.x,
2954          dy = y - self.y;
2955      self.x = x;
2956      self.y = y;
2957      moved = true;
2958      (dx || dy) && onTouchOrPointerDelta(dx, dy);
2959    },
2960        _onHover = function _onHover(e) {
2961      self.event = e;
2962      onHover(self);
2963    },
2964        _onHoverEnd = function _onHoverEnd(e) {
2965      self.event = e;
2966      onHoverEnd(self);
2967    },
2968        _onClick = function _onClick(e) {
2969      return _ignoreCheck(e) || _getEvent(e, preventDefault) && onClick(self);
2970    };
2971
2972    onStopDelayedCall = self._dc = gsap.delayedCall(onStopDelay || 0.25, onStopFunc).pause();
2973    self.deltaX = self.deltaY = 0;
2974    self._vx = _getVelocityProp(0, 50, true);
2975    self._vy = _getVelocityProp(0, 50, true);
2976    self.scrollX = scrollFuncX;
2977    self.scrollY = scrollFuncY;
2978    self.isDragging = self.isGesturing = self.isPressed = false;
2979
2980    _context(this);
2981
2982    self.enable = function (e) {
2983      if (!self.isEnabled) {
2984        _addListener(isViewport ? ownerDoc : target, "scroll", _onScroll);
2985
2986        type.indexOf("scroll") >= 0 && _addListener(isViewport ? ownerDoc : target, "scroll", onScroll, preventDefault, capture);
2987        type.indexOf("wheel") >= 0 && _addListener(target, "wheel", _onWheel, preventDefault, capture);
2988
2989        if (type.indexOf("touch") >= 0 && _isTouch || type.indexOf("pointer") >= 0) {
2990          _addListener(target, _eventTypes[0], _onPress, preventDefault, capture);
2991
2992          _addListener(ownerDoc, _eventTypes[2], _onRelease);
2993
2994          _addListener(ownerDoc, _eventTypes[3], _onRelease);
2995
2996          allowClicks && _addListener(target, "click", clickCapture, false, true);
2997          onClick && _addListener(target, "click", _onClick);
2998          onGestureStart && _addListener(ownerDoc, "gesturestart", _onGestureStart);
2999          onGestureEnd && _addListener(ownerDoc, "gestureend", _onGestureEnd);
3000          onHover && _addListener(target, _pointerType + "enter", _onHover);
3001          onHoverEnd && _addListener(target, _pointerType + "leave", _onHoverEnd);
3002          onMove && _addListener(target, _pointerType + "move", _onMove);
3003        }
3004
3005        self.isEnabled = true;
3006        e && e.type && _onPress(e);
3007        onEnable && onEnable(self);
3008      }
3009
3010      return self;
3011    };
3012
3013    self.disable = function () {
3014      if (self.isEnabled) {
3015        // only remove the _onScroll listener if there aren't any others that rely on the functionality.
3016        _observers.filter(function (o) {
3017          return o !== self && _isViewport(o.target);
3018        }).length || _removeListener(isViewport ? ownerDoc : target, "scroll", _onScroll);
3019
3020        if (self.isPressed) {
3021          self._vx.reset();
3022
3023          self._vy.reset();
3024
3025          _removeListener(isNormalizer ? target : ownerDoc, _eventTypes[1], _onDrag, true);
3026        }
3027
3028        _removeListener(isViewport ? ownerDoc : target, "scroll", onScroll, capture);
3029
3030        _removeListener(target, "wheel", _onWheel, capture);
3031
3032        _removeListener(target, _eventTypes[0], _onPress, capture);
3033
3034        _removeListener(ownerDoc, _eventTypes[2], _onRelease);
3035
3036        _removeListener(ownerDoc, _eventTypes[3], _onRelease);
3037
3038        _removeListener(target, "click", clickCapture, true);
3039
3040        _removeListener(target, "click", _onClick);
3041
3042        _removeListener(ownerDoc, "gesturestart", _onGestureStart);
3043
3044        _removeListener(ownerDoc, "gestureend", _onGestureEnd);
3045
3046        _removeListener(target, _pointerType + "enter", _onHover);
3047
3048        _removeListener(target, _pointerType + "leave", _onHoverEnd);
3049
3050        _removeListener(target, _pointerType + "move", _onMove);
3051
3052        self.isEnabled = self.isPressed = self.isDragging = false;
3053        onDisable && onDisable(self);
3054      }
3055    };
3056
3057    self.kill = self.revert = function () {
3058      self.disable();
3059
3060      var i = _observers.indexOf(self);
3061
3062      i >= 0 && _observers.splice(i, 1);
3063      _normalizer === self && (_normalizer = 0);
3064    };
3065
3066    _observers.push(self);
3067
3068    isNormalizer && _isViewport(target) && (_normalizer = self);
3069    self.enable(event);
3070  };
3071
3072  _createClass(Observer, [{
3073    key: "velocityX",
3074    get: function get() {
3075      return this._vx.getVelocity();
3076    }
3077  }, {
3078    key: "velocityY",
3079    get: function get() {
3080      return this._vy.getVelocity();
3081    }
3082  }]);
3083
3084  return Observer;
3085}();
3086Observer.version = "3.12.2";
3087
3088Observer.create = function (vars) {
3089  return new Observer(vars);
3090};
3091
3092Observer.register = _initCore;
3093
3094Observer.getAll = function () {
3095  return _observers.slice();
3096};
3097
3098Observer.getById = function (id) {
3099  return _observers.filter(function (o) {
3100    return o.vars.id === id;
3101  })[0];
3102};
3103
3104_getGSAP() && gsap.registerPlugin(Observer);
3105
3106
3107/***/ }),
3108