@yoobic/yobi 8.5.0-53 → 8.5.0-54

package/dist/cjs/{overlays-8f4f8873.js → overlays-c16ad273.js}

@@ -1774,7 +1774,7 @@ function _assertThisInitialized$1(self) { if (self === void 0) { throw new Refer
 function _inheritsLoose$1(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }
 
 /*!
- * GSAP 3.11.1
+ * GSAP 3.11.3
  * https://greensock.com
  *
  * @license Copyright 2008-2022, GreenSock. All rights reserved.
@@ -1870,7 +1870,12 @@ _unitExp = /^[+\-=e\s\d]*\d+[.\d]*([a-z]*|%)\s*$/i,
 },
     _startAtRevertConfig = {
   suppressEvents: true,
-  isStart: true
+  isStart: true,
+  kill: false
+},
+    _revertConfigNoKill = {
+  suppressEvents: true,
+  kill: false
 },
     _revertConfig = {
   suppressEvents: true
@@ -1955,7 +1960,7 @@ _parseRelative = function _parseRelative(start, value) {
 },
     _lazySafeRender = function _lazySafeRender(animation, time, suppressEvents, force) {
   _lazyTweens.length && _lazyRender();
-  animation.render(time, suppressEvents, force || _reverting$2);
+  animation.render(time, suppressEvents, force || _reverting$2 && time < 0 && (animation._initted || animation._startAt));
   _lazyTweens.length && _lazyRender(); //in case rendering caused any tweens to lazy-init, we should render them because typically when someone calls seek() or time() or progress(), they expect an immediate render.
 },
     _numericIfPossible = function _numericIfPossible(value) {
@@ -2118,7 +2123,7 @@ _parseRelative = function _parseRelative(start, value) {
   return animation;
 },
     _rewindStartAt = function _rewindStartAt(tween, totalTime, suppressEvents, force) {
-  return tween._startAt && (_reverting$2 ? tween._startAt.revert(_revertConfig) : tween.vars.immediateRender && !tween.vars.autoRevert || tween._startAt.render(totalTime, true, force));
+  return tween._startAt && (_reverting$2 ? tween._startAt.revert(_revertConfigNoKill) : tween.vars.immediateRender && !tween.vars.autoRevert || tween._startAt.render(totalTime, true, force));
 },
     _hasNoPausedAncestors = function _hasNoPausedAncestors(animation) {
   return !animation || animation._ts && _hasNoPausedAncestors(animation.parent);
@@ -2206,17 +2211,17 @@ _postAddChecks = function _postAddChecks(timeline, child) {
     _scrollTrigger = function _scrollTrigger(animation, trigger) {
   return (_globals.ScrollTrigger || _missingPlugin("scrollTrigger", trigger)) && _globals.ScrollTrigger.create(trigger, animation);
 },
-    _attemptInitTween = function _attemptInitTween(tween, totalTime, force, suppressEvents) {
-  _initTween(tween, totalTime);
+    _attemptInitTween = function _attemptInitTween(tween, time, force, suppressEvents, tTime) {
+  _initTween(tween, time, tTime);
 
   if (!tween._initted) {
     return 1;
   }
 
-  if (!force && tween._pt && (tween._dur && tween.vars.lazy !== false || !tween._dur && tween.vars.lazy) && _lastRenderedFrame !== _ticker$1.frame) {
+  if (!force && tween._pt && !_reverting$2 && (tween._dur && tween.vars.lazy !== false || !tween._dur && tween.vars.lazy) && _lastRenderedFrame !== _ticker$1.frame) {
     _lazyTweens.push(tween);
 
-    tween._lazy = [totalTime, suppressEvents];
+    tween._lazy = [tTime, suppressEvents];
     return 1;
   }
 },
@@ -2253,7 +2258,7 @@ _isFromOrFromStart = function _isFromOrFromStart(_ref2) {
   }
 
   if (ratio !== prevRatio || _reverting$2 || force || tween._zTime === _tinyNum$1 || !totalTime && tween._zTime) {
-    if (!tween._initted && _attemptInitTween(tween, totalTime, force, suppressEvents)) {
+    if (!tween._initted && _attemptInitTween(tween, totalTime, force, suppressEvents, tTime)) {
       // if we render the very beginning (time == 0) of a fromTo(), we must force the render (normal tweens wouldn't need to render at a time of 0 when the prevTime was also 0). This is also mandatory to make sure overwriting kicks in immediately.
       return;
     }
@@ -2323,7 +2328,8 @@ _isFromOrFromStart = function _isFromOrFromStart(_ref2) {
   totalProgress && !leavePlayhead && (animation._time *= dur / animation._dur);
   animation._dur = dur;
   animation._tDur = !repeat ? dur : repeat < 0 ? 1e10 : _roundPrecise$1(dur * (repeat + 1) + animation._rDelay * repeat);
-  totalProgress > 0 && !leavePlayhead ? _alignPlayhead(animation, animation._tTime = animation._tDur * totalProgress) : animation.parent && _setEnd(animation);
+  totalProgress > 0 && !leavePlayhead && _alignPlayhead(animation, animation._tTime = animation._tDur * totalProgress);
+  animation.parent && _setEnd(animation);
   skipUncache || _uncache(animation.parent, animation);
   return animation;
 },
@@ -2759,7 +2765,7 @@ distribute = function distribute(v) {
     _interrupt$1 = function _interrupt(animation) {
   _removeFromParent(animation);
 
-  animation.scrollTrigger && animation.scrollTrigger.kill(false);
+  animation.scrollTrigger && animation.scrollTrigger.kill(!!_reverting$2);
   animation.progress() < 1 && _callback$1(animation, "onInterrupt");
   return animation;
 },
@@ -3594,9 +3600,13 @@ var Animation$1 = /*#__PURE__*/function () {
 
     var prevIsReverting = _reverting$2;
     _reverting$2 = config;
-    this.timeline && this.timeline.revert(config);
-    this.totalTime(-0.01, config.suppressEvents);
-    this.data !== "nested" && _removeFromParent(this);
+
+    if (this._initted || this._startAt) {
+      this.timeline && this.timeline.revert(config);
+      this.totalTime(-0.01, config.suppressEvents);
+    }
+
+    this.data !== "nested" && config.kill !== false && this.kill();
     _reverting$2 = prevIsReverting;
     return this;
   };
@@ -4020,8 +4030,6 @@ var Timeline = /*#__PURE__*/function (_Animation) {
           child = next;
         }
       } else {
-        force = force || _reverting$2; // if reverting, we should always force renders. If, for example, a .fromTo() tween with a stagger (which creates an internal timeline) gets reverted BEFORE some of its child tweens render for the first time, it may not properly trigger them to revert.
-
         child = this._last;
         var adjustedTime = totalTime < 0 ? totalTime : time; //when the playhead goes backward beyond the start of this timeline, we must pass that information down to the child animations so that zero-duration tweens know whether to render their starting or ending values.
 
@@ -4034,7 +4042,7 @@ var Timeline = /*#__PURE__*/function (_Animation) {
               return this.render(totalTime, suppressEvents, force);
             }
 
-            child.render(child._ts > 0 ? (adjustedTime - child._start) * child._ts : (child._dirty ? child.totalDuration() : child._tDur) + (adjustedTime - child._start) * child._ts, suppressEvents, force);
+            child.render(child._ts > 0 ? (adjustedTime - child._start) * child._ts : (child._dirty ? child.totalDuration() : child._tDur) + (adjustedTime - child._start) * child._ts, suppressEvents, force || _reverting$2 && (child._initted || child._startAt)); // if reverting, we should always force renders of initted tweens (but remember that .fromTo() or .from() may have a _startAt but not _initted yet). If, for example, a .fromTo() tween with a stagger (which creates an internal timeline) gets reverted BEFORE some of its child tweens render for the first time, it may not properly trigger them to revert.
 
             if (time !== this._time || !this._ts && !prevPaused) {
               //in case a tween pauses or seeks the timeline when rendering, like inside of an onUpdate/onComplete
@@ -4355,16 +4363,16 @@ var Timeline = /*#__PURE__*/function (_Animation) {
     return _uncache(this);
   };
 
-  _proto2.invalidate = function invalidate() {
+  _proto2.invalidate = function invalidate(soft) {
     var child = this._first;
     this._lock = 0;
 
     while (child) {
-      child.invalidate();
+      child.invalidate(soft);
       child = child._next;
     }
 
-    return _Animation.prototype.invalidate.call(this);
+    return _Animation.prototype.invalidate.call(this, soft);
   };
 
   _proto2.clear = function clear(includeLabels) {
@@ -4617,7 +4625,7 @@ _processVars = function _processVars(vars, index, target, targets, tween) {
     _overwritingTween,
     //store a reference temporarily so we can avoid overwriting itself.
 _forceAllPropTweens,
-    _initTween = function _initTween(tween, time) {
+    _initTween = function _initTween(tween, time, tTime) {
   var vars = tween.vars,
       ease = vars.ease,
       startAt = vars.startAt,
@@ -4671,7 +4679,9 @@ _forceAllPropTweens,
     cleanVars = _copyExcluding(vars, _reservedProps$1);
 
     if (prevStartAt) {
-      time < 0 && runBackwards && immediateRender && !autoRevert ? prevStartAt.render(-1, true) : prevStartAt.revert(runBackwards && dur ? _revertConfig : _startAtRevertConfig); // if it's a "startAt" (not "from()" or runBackwards: true), we only need to do a shallow revert (keep transforms cached in CSSPlugin)
+      prevStartAt._zTime < 0 && prevStartAt.progress(1); // in case it's a lazy startAt that hasn't rendered yet.
+
+      time < 0 && runBackwards && immediateRender && !autoRevert ? prevStartAt.render(-1, true) : prevStartAt.revert(runBackwards && dur ? _revertConfigNoKill : _startAtRevertConfig); // if it's a "startAt" (not "from()" or runBackwards: true), we only need to do a shallow revert (keep transforms cached in CSSPlugin)
       // don't just _removeFromParent(prevStartAt.render(-1, true)) because that'll leave inline styles. We're creating a new _startAt for "startAt" tweens that re-capture things to ensure that if the pre-tween values changed since the tween was created, they're recorded.
 
       prevStartAt._lazy = 0;
@@ -4693,10 +4703,13 @@ _forceAllPropTweens,
       }, startAt))); //copy the properties/values into a new object to avoid collisions, like var to = {x:0}, from = {x:500}; timeline.fromTo(e, from, to).fromTo(e, to, from);
 
 
-      time < 0 && (_reverting$2 || !immediateRender && !autoRevert) && tween._startAt.revert(_revertConfig); // rare edge case, like if a render is forced in the negative direction of a non-initted tween.
+      tween._startAt._dp = 0; // don't allow it to get put back into root timeline! Like when revert() is called and totalTime() gets set.
+
+      time < 0 && (_reverting$2 || !immediateRender && !autoRevert) && tween._startAt.revert(_revertConfigNoKill); // rare edge case, like if a render is forced in the negative direction of a non-initted tween.
 
       if (immediateRender) {
-        if (dur && time <= 0) {
+        if (dur && time <= 0 && tTime <= 0) {
+          // check tTime here because in the case of a yoyo tween whose playhead gets pushed to the end like tween.progress(1), we should allow it through so that the onComplete gets fired properly.
           time && (tween._zTime = time);
           return; //we skip initialization here so that overwriting doesn't occur until the tween actually begins. Otherwise, if you create several immediateRender:true tweens of the same target/properties to drop into a Timeline, the last one created would overwrite the first ones because they didn't get placed into the timeline yet before the first render occurs and kicks in overwriting.
         }
@@ -4721,11 +4734,13 @@ _forceAllPropTweens,
 
         _removeFromParent(tween._startAt = Tween.set(targets, p));
 
-        time < 0 && (_reverting$2 ? tween._startAt.revert(_revertConfig) : tween._startAt.render(-1, true));
+        tween._startAt._dp = 0; // don't allow it to get put back into root timeline!
+
+        time < 0 && (_reverting$2 ? tween._startAt.revert(_revertConfigNoKill) : tween._startAt.render(-1, true));
         tween._zTime = time;
 
         if (!immediateRender) {
-          _initTween(tween._startAt, _tinyNum$1); //ensures that the initial values are recorded
+          _initTween(tween._startAt, _tinyNum$1, _tinyNum$1); //ensures that the initial values are recorded
 
         } else if (!time) {
           return;
@@ -5067,7 +5082,7 @@ var Tween = /*#__PURE__*/function (_Animation2) {
     if (immediateRender || !duration && !keyframes && _this3._start === _roundPrecise$1(parent._time) && _isNotFalse(immediateRender) && _hasNoPausedAncestors(_assertThisInitialized$1(_this3)) && parent.data !== "nested") {
       _this3._tTime = -_tinyNum$1; //forces a render without having to set the render() "force" parameter to true because we want to allow lazying by default (using the "force" parameter always forces an immediate full render)
 
-      _this3.render(Math.max(0, -delay)); //in case delay is negative
+      _this3.render(Math.max(0, -delay) || 0); //in case delay is negative
 
     }
 
@@ -5152,7 +5167,7 @@ var Tween = /*#__PURE__*/function (_Animation2) {
       }
 
       if (!this._initted) {
-        if (_attemptInitTween(this, isNegative ? totalTime : time, force, suppressEvents)) {
+        if (_attemptInitTween(this, isNegative ? totalTime : time, force, suppressEvents, tTime)) {
           this._tTime = 0; // in constructor if immediateRender is true, we set _tTime to -_tinyNum to have the playhead cross the starting point but we can't leave _tTime as a negative number.
 
           return this;
@@ -5214,7 +5229,7 @@ var Tween = /*#__PURE__*/function (_Animation2) {
         isNegative && !this._onUpdate && _rewindStartAt(this, totalTime, true, true);
         (totalTime || !dur) && (tTime === this._tDur && this._ts > 0 || !tTime && this._ts < 0) && _removeFromParent(this, 1); // don't remove if we're rendering at exactly a time of 0, as there could be autoRevert values that should get set on the next tick (if the playhead goes backward beyond the startTime, negative totalTime). Don't remove if the timeline is reversed and the playhead isn't at 0, otherwise tl.progress(1).reverse() won't work. Only remove if the playhead is at the end and timeScale is positive, or if the playhead is at 0 and the timeScale is negative.
 
-        if (!suppressEvents && !(isNegative && !prevTime) && (tTime || prevTime)) {
+        if (!suppressEvents && !(isNegative && !prevTime) && (tTime || prevTime || isYoyo)) {
           // if prevTime and tTime are zero, we shouldn't fire the onReverseComplete. This could happen if you gsap.to(... {paused:true}).play();
           _callback$1(this, tTime === tDur ? "onComplete" : "onReverseComplete", true);
 
@@ -5230,11 +5245,13 @@ var Tween = /*#__PURE__*/function (_Animation2) {
     return this._targets;
   };
 
-  _proto3.invalidate = function invalidate() {
-    this._pt = this._op = this._startAt = this._onUpdate = this._lazy = this.ratio = 0;
+  _proto3.invalidate = function invalidate(soft) {
+    // "soft" gives us a way to clear out everything EXCEPT the recorded pre-"from" portion of from() tweens. Otherwise, for example, if you tween.progress(1).render(0, true true).invalidate(), the "from" values would persist and then on the next render, the from() tweens would initialize and the current value would match the "from" values, thus animate from the same value to the same value (no animation). We tap into this in ScrollTrigger's refresh() where we must push a tween to completion and then back again but honor its init state in case the tween is dependent on another tween further up on the page.
+    (!soft || !this.vars.runBackwards) && (this._startAt = 0);
+    this._pt = this._op = this._onUpdate = this._lazy = this.ratio = 0;
     this._ptLookup = [];
-    this.timeline && this.timeline.invalidate();
-    return _Animation2.prototype.invalidate.call(this);
+    this.timeline && this.timeline.invalidate(soft);
+    return _Animation2.prototype.invalidate.call(this, soft);
   };
 
   _proto3.resetTo = function resetTo(property, value, start, startIsRelative) {
@@ -5691,7 +5708,7 @@ var Context = /*#__PURE__*/function () {
   _proto5.getTweens = function getTweens() {
     var a = [];
     this.data.forEach(function (e) {
-      return e instanceof Context ? a.push.apply(a, e.getTweens()) : e instanceof Tween && a.push(e);
+      return e instanceof Context ? a.push.apply(a, e.getTweens()) : e instanceof Tween && !(e.parent && e.parent.data === "nested") && a.push(e);
     });
     return a;
   };
@@ -5704,8 +5721,18 @@ var Context = /*#__PURE__*/function () {
     var _this4 = this;
 
     if (revert) {
-      // save as an object so that we can cache the globalTime for each tween to optimize performance during the sort
-      this.getTweens().map(function (t) {
+      var tweens = this.getTweens();
+      this.data.forEach(function (t) {
+        // Flip plugin tweens are very different in that they should actually be pushed to their end. The plugin replaces the timeline's .revert() method to do exactly that. But we also need to remove any of those nested tweens inside the flip timeline so that they don't get individually reverted.
+        if (t.data === "isFlip") {
+          t.revert();
+          t.getChildren(true, true, false).forEach(function (tween) {
+            return tweens.splice(tweens.indexOf(tween), 1);
+          });
+        }
+      }); // save as an object so that we can cache the globalTime for each tween to optimize performance during the sort
+
+      tweens.map(function (t) {
         return {
           g: t.globalTime(0),
           t: t
@@ -6152,7 +6179,7 @@ var gsap$f = _gsap.registerPlugin({
   }
 }, _buildModifierPlugin("roundProps", _roundModifier), _buildModifierPlugin("modifiers"), _buildModifierPlugin("snap", snap)) || _gsap; //to prevent the core plugins from being dropped via aggressive tree shaking, we must include them in the variable declaration in this way.
 
-Tween.version = Timeline.version = gsap$f.version = "3.11.1";
+Tween.version = Timeline.version = gsap$f.version = "3.11.3";
 _coreReady = 1;
 _windowExists$8() && _wake();
 var Power0 = _easeMap.Power0,
@@ -6175,7 +6202,7 @@ var Power0 = _easeMap.Power0,
     Circ = _easeMap.Circ;
 
 /*!
- * CSSPlugin 3.11.1
+ * CSSPlugin 3.11.3
  * https://greensock.com
  *
  * Copyright 2008-2022, GreenSock. All rights reserved.
@@ -6252,7 +6279,7 @@ _renderRoundedCSSProp = function _renderRoundedCSSProp(ratio, data) {
 },
     _transformProp$3 = "transform",
     _transformOriginProp$2 = _transformProp$3 + "Origin",
-    _saveStyle = function _saveStyle(property) {
+    _saveStyle = function _saveStyle(property, isNotCSS) {
   var _this = this;
 
   var target = this.target,
@@ -6274,13 +6301,13 @@ _renderRoundedCSSProp = function _renderRoundedCSSProp(ratio, data) {
 
     if (target._gsap.svg) {
       this.svgo = target.getAttribute("data-svg-origin");
-      this.props.push(_transformOriginProp$2, "");
+      this.props.push(_transformOriginProp$2, isNotCSS, "");
     }
 
     property = _transformProp$3;
   }
 
-  style && this.props.push(property, style[property]);
+  (style || isNotCSS) && this.props.push(property, isNotCSS, style[property]);
 },
     _removeIndependentTransforms = function _removeIndependentTransforms(style) {
   if (style.translate) {
@@ -6297,8 +6324,9 @@ _renderRoundedCSSProp = function _renderRoundedCSSProp(ratio, data) {
       i,
       p;
 
-  for (i = 0; i < props.length; i += 2) {
-    props[i + 1] ? style[props[i]] = props[i + 1] : style.removeProperty(props[i].replace(_capsExp$1, "-$1").toLowerCase());
+  for (i = 0; i < props.length; i += 3) {
+    // stored like this: property, isNotCSS, value
+    props[i + 1] ? target[props[i]] = props[i + 2] : props[i + 2] ? style[props[i]] = props[i + 2] : style.removeProperty(props[i].replace(_capsExp$1, "-$1").toLowerCase());
   }
 
   if (this.tfm) {
@@ -6996,7 +7024,7 @@ _identity2DMatrix = [1, 0, 0, 1, 0, 0],
   if (cs.translate) {
     // accommodate independent transforms by combining them into normal ones.
     if (cs.translate !== "none" || cs.scale !== "none" || cs.rotate !== "none") {
-      style[_transformProp$3] = (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$3];
+      style[_transformProp$3] = (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$3] !== "none" ? cs[_transformProp$3] : "");
     }
 
     style.scale = style.rotate = style.translate = "none";
@@ -7533,7 +7561,7 @@ var CSSPlugin$1 = {
         endUnit ? startUnit !== endUnit && (startValue = _convertToUnit(target, p, startValue, endUnit) + endUnit) : startUnit && (endValue += startUnit);
         this.add(style, "setProperty", startValue, endValue, index, targets, 0, 0, p);
         props.push(p);
-        inlineProps.push(p, style[p]);
+        inlineProps.push(p, 0, style[p]);
       } else if (type !== "undefined") {
         if (startAt && p in startAt) {
           // 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)
@@ -7559,7 +7587,7 @@ var CSSPlugin$1 = {
               startNum = 0;
             }
 
-            inlineProps.push("visibility", style.visibility);
+            inlineProps.push("visibility", 0, style.visibility);
 
             _addNonTweeningPT(this, style, "visibility", startNum ? "inherit" : "hidden", endNum ? "inherit" : "hidden", !endNum);
           }
@@ -7586,12 +7614,12 @@ var CSSPlugin$1 = {
           }
 
           if (p === "scale") {
-            this._pt = new PropTween$3(this._pt, cache, "scaleY", cache.scaleY, (relative ? _parseRelative(cache.scaleY, relative + endNum) : endNum) - cache.scaleY || 0, _renderCSSProp);
+            this._pt = new PropTween$3(this._pt, cache, "scaleY", startNum, (relative ? _parseRelative(startNum, relative + endNum) : endNum) - startNum || 0, _renderCSSProp);
             this._pt.u = 0;
             props.push("scaleY", p);
             p += "X";
           } else if (p === "transformOrigin") {
-            inlineProps.push(_transformOriginProp$2, style[_transformOriginProp$2]);
+            inlineProps.push(_transformOriginProp$2, 0, style[_transformOriginProp$2]);
             endValue = _convertKeywordsToPercentages(endValue); //in case something like "left top" or "bottom right" is passed in. Convert to percentages.
 
             if (cache.svg) {
@@ -7656,7 +7684,7 @@ var CSSPlugin$1 = {
           _tweenComplexCSSString.call(this, target, p, startValue, relative ? relative + endValue : endValue);
         }
 
-        isTransformRelated || inlineProps.push(p, style[p]);
+        isTransformRelated || (p in style ? inlineProps.push(p, 0, style[p]) : inlineProps.push(p, 1, startValue || target[p]));
         props.push(p);
       }
     }
@@ -7716,7 +7744,7 @@ _forEachName("x,y,z,top,right,bottom,left,width,height,fontSize,padding,margin,p
 gsap$f.registerPlugin(CSSPlugin$1);
 
 /*!
- * paths 3.11.1
+ * paths 3.11.3
  * https://greensock.com
  *
  * Copyright 2008-2022, GreenSock. All rights reserved.
@@ -9202,7 +9230,7 @@ export function pointToScreen(svgElement, point) {
 */
 
 /*!
- * CustomEase 3.11.1
+ * CustomEase 3.11.3
  * https://greensock.com
  *
  * @license Copyright 2008-2022, GreenSock. All rights reserved.
@@ -9567,10 +9595,10 @@ var CustomEase = /*#__PURE__*/function () {
   return CustomEase;
 }();
 _getGSAP$d() && gsap$e.registerPlugin(CustomEase);
-CustomEase.version = "3.11.1";
+CustomEase.version = "3.11.3";
 
 /*!
- * matrix 3.11.1
+ * matrix 3.11.3
  * https://greensock.com
  *
  * Copyright 2008-2022, GreenSock. All rights reserved.
@@ -12429,15 +12457,15 @@ var Draggable = /*#__PURE__*/function (_EventDispatcher) {
 
           _addListener$2(trigger, "touchstart", onPress);
 
-          _addListener$2(trigger, "click", onClick, true); //note: used to pass true for capture but it prevented click-to-play-video functionality in Firefox.
+          _addListener$2(trigger, "click", onClick, true); // note: used to pass true for capture but it prevented click-to-play-video functionality in Firefox.
 
 
           gsap$d.set(trigger, setVars);
 
-          if (trigger.getBBox && trigger.ownerSVGElement) {
+          if (trigger.getBBox && trigger.ownerSVGElement && allowX !== allowY) {
             // a bug in chrome doesn't respect touch-action on SVG elements - it only works if we set it on the parent SVG.
             gsap$d.set(trigger.ownerSVGElement, {
-              touchAction: allowX === allowY ? "none" : vars.allowNativeTouchScrolling || vars.allowEventDefault ? "manipulation" : allowX ? "pan-y" : "pan-x"
+              touchAction: vars.allowNativeTouchScrolling || vars.allowEventDefault ? "manipulation" : allowX ? "pan-y" : "pan-x"
             });
           }
 
@@ -12651,11 +12679,11 @@ _setDefaults$1(Draggable.prototype, {
 });
 
 Draggable.zIndex = 1000;
-Draggable.version = "3.11.1";
+Draggable.version = "3.11.3";
 _getGSAP$c() && gsap$d.registerPlugin(Draggable);
 
 /*!
- * CSSRulePlugin 3.11.1
+ * CSSRulePlugin 3.11.3
  * https://greensock.com
  *
  * @license Copyright 2008-2022, GreenSock. All rights reserved.
@@ -12705,7 +12733,7 @@ var gsap$c,
 };
 
 var CSSRulePlugin = {
-  version: "3.11.1",
+  version: "3.11.3",
   name: "cssRule",
   init: function init(target, value, tween, index, targets) {
     if (!_checkRegister() || typeof target.cssText === "undefined") {
@@ -12789,7 +12817,7 @@ var CSSRulePlugin = {
 _getGSAP$b() && gsap$c.registerPlugin(CSSRulePlugin);
 
 /*!
- * EaselPlugin 3.11.1
+ * EaselPlugin 3.11.3
  * https://greensock.com
  *
  * @license Copyright 2008-2022, GreenSock. All rights reserved.
@@ -13060,7 +13088,7 @@ var gsap$b,
 };
 
 var EaselPlugin = {
-  version: "3.11.1",
+  version: "3.11.3",
   name: "easel",
   init: function init(target, value, tween, index, targets) {
     if (!_coreInitted$8) {
@@ -13130,7 +13158,7 @@ EaselPlugin.registerCreateJS = function (createjs) {
 _getGSAP$a() && gsap$b.registerPlugin(EaselPlugin);
 
 /*!
- * EasePack 3.11.1
+ * EasePack 3.11.3
  * https://greensock.com
  *
  * @license Copyright 2008-2022, GreenSock. All rights reserved.
@@ -13336,13 +13364,13 @@ var EasePack = {
 
 for (var p$1 in EasePack) {
   EasePack[p$1].register = _initCore$6;
-  EasePack[p$1].version = "3.11.1";
+  EasePack[p$1].version = "3.11.3";
 }
 
 _getGSAP$9() && gsap$a.registerPlugin(SlowMo);
 
 /*!
- * Flip 3.11.1
+ * Flip 3.11.3
  * https://greensock.com
  *
  * @license Copyright 2008-2022, GreenSock. All rights reserved.
@@ -13865,7 +13893,8 @@ _makeAbsolute = function _makeAbsolute(elState, fallbackNode, ignoreBatch) {
     paused: paused,
     repeat: repeat,
     repeatDelay: repeatDelay,
-    yoyo: yoyo
+    yoyo: yoyo,
+    data: "isFlip"
   }),
       remainingProps = tweenVars,
       entering = [],
@@ -14167,7 +14196,14 @@ _makeAbsolute = function _makeAbsolute(elState, fallbackNode, ignoreBatch) {
     run();
   }
 
-  return _batch ? _batch.timeline : animation;
+  var anim = _batch ? _batch.timeline : animation;
+
+  anim.revert = function () {
+    return _killFlip(anim, 1);
+  }; // a Flip timeline should behave very different when reverting - it should actually jump to the end so that styles get cleared out.
+
+
+  return anim;
 },
     _interrupt = function _interrupt(tl) {
   tl.vars.onInterrupt && tl.vars.onInterrupt.apply(tl, tl.vars.onInterruptParams || []);
@@ -14823,7 +14859,7 @@ var Flip = /*#__PURE__*/function () {
 
   return Flip;
 }();
-Flip.version = "3.11.1"; // function whenImagesLoad(el, func) {
+Flip.version = "3.11.3"; // function whenImagesLoad(el, func) {
 // 	let pending = [],
 // 		onLoad = e => {
 // 			pending.splice(pending.indexOf(e.target), 1);
@@ -14837,7 +14873,7 @@ Flip.version = "3.11.1"; // function whenImagesLoad(el, func) {
 typeof window !== "undefined" && window.gsap && window.gsap.registerPlugin(Flip);
 
 /*!
- * MotionPathPlugin 3.11.1
+ * MotionPathPlugin 3.11.3
  * https://greensock.com
  *
  * @license Copyright 2008-2022, GreenSock. All rights reserved.
@@ -15051,7 +15087,7 @@ _segmentToRawPath = function _segmentToRawPath(plugin, segment, target, x, y, sl
 };
 
 var MotionPathPlugin = {
-  version: "3.11.1",
+  version: "3.11.3",
   name: "motionPath",
   register: function register(core, Plugin, propTween) {
     gsap$8 = core;
@@ -15205,7 +15241,7 @@ function _defineProperties(target, props) { for (var i = 0; i < props.length; i+
 function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
 
 /*!
- * Observer 3.11.1
+ * Observer 3.11.3
  * https://greensock.com
  *
  * @license Copyright 2008-2022, GreenSock. All rights reserved.
@@ -15332,15 +15368,23 @@ var gsap$7,
     _getScrollFunc = function _getScrollFunc(element, _ref) {
   var s = _ref.s,
       sc = _ref.sc;
+  // 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.
+  _isViewport$1(element) && (element = _doc$1.scrollingElement || _docEl$3);
 
-  // we store the scroller functions in a 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.
   var i = _scrollers.indexOf(element),
       offset = sc === _vertical.sc ? 1 : 2;
 
   !~i && (i = _scrollers.push(element) - 1);
-  return _scrollers[i + offset] || (_scrollers[i + offset] = _scrollCacheFunc(_getProxyProp(element, s), true) || (_isViewport$1(element) ? sc : _scrollCacheFunc(function (value) {
+  _scrollers[i + offset] || element.addEventListener("scroll", _onScroll$1); // clear the cache when a scroll occurs
+
+  var prev = _scrollers[i + offset],
+      func = prev || (_scrollers[i + offset] = _scrollCacheFunc(_getProxyProp(element, s), true) || (_isViewport$1(element) ? sc : _scrollCacheFunc(function (value) {
     return arguments.length ? element[s] = value : element[s];
   })));
+  func.target = element;
+  prev || (func.smooth = gsap$7.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.
+
+  return func;
 },
     _getVelocityProp = function _getVelocityProp(value, minTimeRefresh, useDelta) {
   var v1 = value,
@@ -15850,7 +15894,7 @@ var Observer = /*#__PURE__*/function () {
 
   return Observer;
 }();
-Observer.version = "3.11.1";
+Observer.version = "3.11.3";
 
 Observer.create = function (vars) {
   return new Observer(vars);
@@ -15871,7 +15915,7 @@ Observer.getById = function (id) {
 _getGSAP$7() && gsap$7.registerPlugin(Observer);
 
 /*!
- * PixiPlugin 3.11.1
+ * PixiPlugin 3.11.3
  * https://greensock.com
  *
  * @license Copyright 2008-2022, GreenSock. All rights reserved.
@@ -16240,7 +16284,7 @@ for (i$1 = 0; i$1 < _xyContexts.length; i$1++) {
 }
 
 var PixiPlugin = {
-  version: "3.11.1",
+  version: "3.11.3",
   name: "pixi",
   register: function register(core, Plugin, propTween) {
     gsap$6 = core;
@@ -16324,7 +16368,7 @@ var PixiPlugin = {
 _getGSAP$6() && gsap$6.registerPlugin(PixiPlugin);
 
 /*!
- * ScrollToPlugin 3.11.1
+ * ScrollToPlugin 3.11.3
  * https://greensock.com
  *
  * @license Copyright 2008-2022, GreenSock. All rights reserved.
@@ -16450,7 +16494,7 @@ var gsap$5,
 };
 
 var ScrollToPlugin$1 = {
-  version: "3.11.1",
+  version: "3.11.3",
   name: "scrollTo",
   rawVars: 1,
   register: function register(core) {
@@ -16590,7 +16634,7 @@ ScrollToPlugin$1.buildGetter = _buildGetter$1;
 _getGSAP$5() && gsap$5.registerPlugin(ScrollToPlugin$1);
 
 /*!
- * ScrollTrigger 3.11.1
+ * ScrollTrigger 3.11.3
  * https://greensock.com
  *
  * @license Copyright 2008-2022, GreenSock. All rights reserved.
@@ -16627,6 +16671,7 @@ var gsap$4,
     _baseScreenWidth,
     _fixIOSBug,
     _context,
+    _scrollRestoration,
     _limitCallbacks,
     // if true, we'll only trigger callbacks if the active state toggles, so if you scroll immediately past both the start and end positions of a ScrollTrigger (thus inactive to inactive), neither its onEnter nor onLeave will be called. This is useful during startup.
 _startup = 1,
@@ -16948,14 +16993,21 @@ _startup = 1,
     _ids = {},
     _rafID,
     _sync = function _sync() {
-  return _getTime() - _lastScrollTime > 34 && _updateAll();
+  return _getTime() - _lastScrollTime > 34 && (_rafID || (_rafID = requestAnimationFrame(_updateAll)));
 },
     _onScroll = function _onScroll() {
   // previously, we tried to optimize performance by batching/deferring to the next requestAnimationFrame(), but discovered that Safari has a few bugs that make this unworkable (especially on iOS). See https://codepen.io/GreenSock/pen/16c435b12ef09c38125204818e7b45fc?editors=0010 and https://codepen.io/GreenSock/pen/JjOxYpQ/3dd65ccec5a60f1d862c355d84d14562?editors=0010 and https://codepen.io/GreenSock/pen/ExbrPNa/087cef197dc35445a0951e8935c41503?editors=0010
   if (!_normalizer || !_normalizer.isPressed || _normalizer.startX > _body$1.clientWidth) {
     // if the user is dragging the scrollbar, allow it.
     _scrollers.cache++;
-    _rafID || (_rafID = requestAnimationFrame(_updateAll));
+
+    if (_normalizer) {
+      _rafID || (_rafID = requestAnimationFrame(_updateAll));
+    } else {
+      _updateAll(); // Safari in particular (on desktop) NEEDS the immediate update rather than waiting for a requestAnimationFrame() whereas iOS seems to benefit from waiting for the requestAnimationFrame() tick, at least when normalizing. See https://codepen.io/GreenSock/pen/qBYozqO?editors=0110
+
+    }
+
     _lastScrollTime || _dispatch("scrollStart");
     _lastScrollTime = _getTime();
   }
@@ -17008,14 +17060,26 @@ _revertRecorded = function _revertRecorded(media) {
   media && _revertRecorded(media);
   media || _dispatch("revert");
 },
-    _clearScrollMemory = function _clearScrollMemory() {
-  return _scrollers.cache++ && _scrollers.forEach(function (obj) {
-    return typeof obj === "function" && (obj.rec = 0);
+    _clearScrollMemory = function _clearScrollMemory(scrollRestoration, force) {
+  // zero-out all the recorded scroll positions. Don't use _triggers because if, for example, .matchMedia() is used to create some ScrollTriggers and then the user resizes and it removes ALL ScrollTriggers, and then go back to a size where there are ScrollTriggers, it would have kept the position(s) saved from the initial state.
+  _scrollers.cache++;
+  (force || !_refreshingAll) && _scrollers.forEach(function (obj) {
+    return _isFunction$1(obj) && obj.cacheID++ && (obj.rec = 0);
   });
+  _isString$2(scrollRestoration) && (_win.history.scrollRestoration = _scrollRestoration = scrollRestoration);
 },
-    // zero-out all the recorded scroll positions. Don't use _triggers because if, for example, .matchMedia() is used to create some ScrollTriggers and then the user resizes and it removes ALL ScrollTriggers, and then go back to a size where there are ScrollTriggers, it would have kept the position(s) saved from the initial state.
-_refreshingAll,
+    _refreshingAll,
     _refreshID = 0,
+    _queueRefreshID,
+    _queueRefreshAll = function _queueRefreshAll() {
+  // we don't want to call _refreshAll() every time we create a new ScrollTrigger (for performance reasons) - it's better to batch them. Some frameworks dynamically load content and we can't rely on the window's "load" or "DOMContentLoaded" events to trigger it.
+  if (_queueRefreshID !== _refreshID) {
+    var id = _queueRefreshID = _refreshID;
+    requestAnimationFrame(function () {
+      return id === _refreshID && _refreshAll(true);
+    });
+  }
+},
     _refreshAll = function _refreshAll(force, skipRevert) {
   if (_lastScrollTime && !force) {
     _addListener(ScrollTrigger, "scrollEnd", _softRefresh);
@@ -17023,18 +17087,42 @@ _refreshingAll,
     return;
   }
 
-  _refreshingAll = true;
+  _refreshingAll = ScrollTrigger.isRefreshing = true;
+
+  _scrollers.forEach(function (obj) {
+    return _isFunction$1(obj) && obj.cacheID++ && (obj.rec = obj());
+  }); // force the clearing of the cache because some browsers take a little while to dispatch the "scroll" event and the user may have changed the scroll position and then called ScrollTrigger.refresh() right away
+
 
   var refreshInits = _dispatch("refreshInit");
 
   _sort && ScrollTrigger.sort();
   skipRevert || _revertAll();
 
+  _scrollers.forEach(function (obj) {
+    if (_isFunction$1(obj)) {
+      obj.smooth && (obj.target.style.scrollBehavior = "auto"); // smooth scrolling interferes
+
+      obj(0);
+    }
+  });
+
   _triggers.slice(0).forEach(function (t) {
     return t.refresh();
   }); // don't loop with _i because during a refresh() someone could call ScrollTrigger.update() which would iterate through _i resulting in a skip.
 
 
+  _triggers.forEach(function (t, i) {
+    // nested pins (pinnedContainer) with pinSpacing may expand the container, so we must accommodate that here.
+    if (t._subPinOffset && t.pin) {
+      var prop = t.vars.horizontal ? "offsetWidth" : "offsetHeight",
+          original = t.pin[prop];
+      t.revert(true, 1);
+      t.adjustPinSpacing(t.pin[prop] - original);
+      t.revert(false, 1);
+    }
+  });
+
   _triggers.forEach(function (t) {
     return t.vars.end === "max" && t.setPositions(t.start, Math.max(t.start + 1, _maxScroll(t.scroller, t._dir)));
   }); // the scroller's max scroll position may change after all the ScrollTriggers refreshed (like pinning could push it down), so we need to loop back and correct any with end: "max".
@@ -17045,25 +17133,37 @@ _refreshingAll,
   }); // if the onRefreshInit() returns an animation (typically a gsap.set()), revert it. This makes it easy to put things in a certain spot before refreshing for measurement purposes, and then put things back.
 
   _scrollers.forEach(function (obj) {
-    return typeof obj === "function" && obj(obj.rec);
+    if (_isFunction$1(obj)) {
+      obj.smooth && requestAnimationFrame(function () {
+        return obj.target.style.scrollBehavior = "smooth";
+      });
+      obj.rec && obj(obj.rec);
+    }
   });
 
-  _clearScrollMemory();
+  _clearScrollMemory(_scrollRestoration, 1);
 
   _resizeDelay.pause();
 
   _refreshID++;
-  _refreshingAll = false;
+
+  _updateAll(2);
+
+  _triggers.forEach(function (t) {
+    return _isFunction$1(t.vars.onRefresh) && t.vars.onRefresh(t);
+  });
+
+  _refreshingAll = ScrollTrigger.isRefreshing = false;
 
   _dispatch("refresh");
 },
     _lastScroll = 0,
     _direction = 1,
     _primary,
-    _updateAll = function _updateAll() {
-  if (!_refreshingAll) {
+    _updateAll = function _updateAll(force) {
+  if (!_refreshingAll || force === 2) {
     ScrollTrigger.isUpdating = true;
-    _primary && _primary.update(0); // ScrollSmoother users refreshPriority -9999 to become the primary that gets updated before all others because it affects the scroll position.
+    _primary && _primary.update(0); // ScrollSmoother uses refreshPriority -9999 to become the primary that gets updated before all others because it affects the scroll position.
 
     var l = _triggers.length,
         time = _getTime(),
@@ -17519,7 +17619,7 @@ var ScrollTrigger = /*#__PURE__*/function () {
 
     if (animation) {
       animation.vars.lazy = false;
-      animation._initted || animation.vars.immediateRender !== false && vars.immediateRender !== false && animation.render(0, true, true);
+      animation._initted || animation.vars.immediateRender !== false && vars.immediateRender !== false && animation.duration() && animation.render(0, true, true);
       self.animation = animation.pause();
       animation.scrollTrigger = self;
       self.scrubDuration(scrub);
@@ -17541,6 +17641,11 @@ var ScrollTrigger = /*#__PURE__*/function () {
         scrollBehavior: "auto"
       }); // smooth scrolling doesn't work with snap.
 
+      _scrollers.forEach(function (o) {
+        return _isFunction$1(o) && o.target === (isViewport ? _doc.scrollingElement || _docEl$1 : scroller) && (o.smooth = false);
+      }); // note: set smooth to false on both the vertical and horizontal scroll getters/setters
+
+
       snapFunc = _isFunction$1(snap.snapTo) ? snap.snapTo : snap.snapTo === "labels" ? _getClosestLabel(animation) : snap.snapTo === "labelsDirectional" ? _getLabelAtDirection(animation) : snap.directional !== false ? function (value, st) {
         return _snapDirectional(snap.snapTo)(value, _getTime() - lastRefresh < 500 ? 0 : st.direction);
       } : gsap$4.utils.snap(snap.snapTo);
@@ -17613,12 +17718,9 @@ var ScrollTrigger = /*#__PURE__*/function () {
     });
 
     if (pin) {
-      pinSpacing === false || pinSpacing === _margin || (pinSpacing = !pinSpacing && _getComputedStyle(pin.parentNode).display === "flex" ? false : _padding); // if the parent is display: flex, don't apply pinSpacing by default.
+      pinSpacing === false || pinSpacing === _margin || (pinSpacing = !pinSpacing && pin.parentNode && pin.parentNode.style && _getComputedStyle(pin.parentNode).display === "flex" ? false : _padding); // if the parent is display: flex, don't apply pinSpacing by default. We should check that pin.parentNode is an element (not shadow dom window)
 
       self.pin = pin;
-      vars.force3D !== false && gsap$4.set(pin, {
-        force3D: true
-      });
       pinCache = gsap$4.core.getCache(pin);
 
       if (!pinCache.spacer) {
@@ -17639,6 +17741,9 @@ var ScrollTrigger = /*#__PURE__*/function () {
         pinOriginalState = pinCache.pinState;
       }
 
+      vars.force3D !== false && gsap$4.set(pin, {
+        force3D: true
+      });
       self.spacer = spacer = pinCache.spacer;
       cs = _getComputedStyle(pin);
       spacingStart = cs[pinSpacing + direction.os2];
@@ -17701,11 +17806,10 @@ var ScrollTrigger = /*#__PURE__*/function () {
 
       if (r !== self.isReverted) {
         if (r) {
-          if (!self.scroll.rec && (_refreshing || _refreshingAll)) {
-            self.scroll.rec = scrollFunc();
-            _refreshingAll && scrollFunc(0);
-          }
-
+          // if (!self.scroll.rec && (_refreshing || _refreshingAll)) {
+          // 	self.scroll.rec = scrollFunc();
+          // 	_refreshingAll && scrollFunc(0);
+          // }
           prevScroll = Math.max(scrollFunc(), self.scroll.rec || 0); // record the scroll so we can revert later (repositioning/pinning things can affect scroll position). In the static refresh() method, we first record all the scroll positions as a reference.
 
           prevProgress = self.progress;
@@ -17715,11 +17819,24 @@ var ScrollTrigger = /*#__PURE__*/function () {
         markerStart && [markerStart, markerEnd, markerStartTrigger, markerEndTrigger].forEach(function (m) {
           return m.style.display = r ? "none" : "block";
         });
-        r && (_refreshing = 1);
-        self.update(r); // make sure the pin is back in its original position so that all the measurements are correct.
 
-        _refreshing = prevRefreshing;
-        pin && (r ? _swapPinOut(pin, spacer, pinOriginalState) : (!pinReparent || !self.isActive) && _swapPinIn(pin, spacer, _getComputedStyle(pin), spacerState));
+        if (r) {
+          _refreshing = 1;
+          self.update(r); // make sure the pin is back in its original position so that all the measurements are correct. do this BEFORE swapping the pin out
+        }
+
+        if (pin) {
+          if (r) {
+            _swapPinOut(pin, spacer, pinOriginalState);
+          } else {
+            (!pinReparent || !self.isActive) && _swapPinIn(pin, spacer, _getComputedStyle(pin), spacerState);
+          }
+        }
+
+        r || self.update(r); // when we're restoring, the update should run AFTER swapping the pin into its pin-spacer.
+
+        _refreshing = prevRefreshing; // restore. We set it to true during the update() so that things fire properly in there.
+
         self.isReverted = r;
       }
     };
@@ -17745,8 +17862,11 @@ var ScrollTrigger = /*#__PURE__*/function () {
       }
 
       scrubTween && scrubTween.pause();
-      invalidateOnRefresh && animation && animation.revert().invalidate();
+      invalidateOnRefresh && animation && animation.revert({
+        kill: false
+      }).invalidate();
       self.isReverted || self.revert(true, true);
+      self._subPinOffset = false; // we'll set this to true in the sub-pins if we find any
 
       var size = getScrollerSize(),
           scrollerBounds = getScrollerOffsets(),
@@ -17815,10 +17935,10 @@ var ScrollTrigger = /*#__PURE__*/function () {
         curTrigger = _triggers[i];
         curPin = curTrigger.pin;
 
-        if (curPin && curTrigger.start - curTrigger._pinPush < start && !containerAnimation && curTrigger.end > 0) {
+        if (curPin && curTrigger.start - curTrigger._pinPush <= start && !containerAnimation && curTrigger.end > 0) {
           cs = curTrigger.end - curTrigger.start;
 
-          if ((curPin === trigger || curPin === pinnedContainer) && !_isNumber$1(parsedStart)) {
+          if ((curPin === trigger && curTrigger.start - curTrigger._pinPush < start || curPin === pinnedContainer) && !_isNumber$1(parsedStart)) {
             // numeric start values shouldn't be offset at all - treat them as absolute
             offset += cs * (1 - curTrigger.progress);
           }
@@ -17862,6 +17982,15 @@ var ScrollTrigger = /*#__PURE__*/function () {
 
           _setState(spacerState);
 
+          if (pinnedContainer) {
+            // in ScrollTrigger.refresh(), we need to re-evaluate the pinContainer's size because this pinSpacing may stretch it out, but we can't just add the exact distance because depending on layout, it may not push things down or it may only do so partially.
+            _triggers.forEach(function (t) {
+              if (t.pin === pinnedContainer && t.vars.pinSpacing !== false) {
+                t._subPinOffset = true;
+              }
+            });
+          }
+
           useFixedPosition && scrollFunc(prevScroll);
         }
 
@@ -17895,7 +18024,8 @@ var ScrollTrigger = /*#__PURE__*/function () {
           change !== pinChange && useFixedPosition && pinActiveState.splice(pinActiveState.length - 2, 2); // transform is the last property/value set in the state Array. Since the animation is controlling that, we should omit it.
 
           animation.render(0, true, true);
-          initted || animation.invalidate();
+          initted || animation.invalidate(true);
+          animation.parent || animation.totalTime(animation.totalTime()); // if, for example, a toggleAction called play() and then refresh() happens and when we render(1) above, it would cause the animation to complete and get removed from its parent, so this makes sure it gets put back in.
 
           _suppressOverwrites(0);
         } else {
@@ -17920,7 +18050,7 @@ var ScrollTrigger = /*#__PURE__*/function () {
       });
       self.start = start;
       self.end = end;
-      scroll1 = scroll2 = scrollFunc(); // reset velocity
+      scroll1 = scroll2 = _refreshingAll ? prevScroll : scrollFunc(); // reset velocity
 
       if (!containerAnimation && !_refreshingAll) {
         scroll1 < prevScroll && scrollFunc(prevScroll);
@@ -17944,12 +18074,11 @@ var ScrollTrigger = /*#__PURE__*/function () {
         animation && !isToggle && animation.totalProgress(prevProgress, true); // to avoid issues where animation callbacks like onStart aren't triggered.
 
         self.progress = (scroll1 - start) / change === prevProgress ? 0 : prevProgress;
-        self.update(0, 0, 1);
       }
 
       pin && pinSpacing && (spacer._pinOffset = Math.round(self.progress * pinChange)); //			scrubTween && scrubTween.invalidate();
 
-      onRefresh && onRefresh(self);
+      onRefresh && !_refreshingAll && onRefresh(self); // when refreshing all, we do extra work to correct pinnedContainer sizes and ensure things don't exceed the maxScroll, so we should do all the refreshes at the end after all that work so that the start/end values are corrected.
     };
 
     self.getVelocity = function () {
@@ -17984,7 +18113,7 @@ var ScrollTrigger = /*#__PURE__*/function () {
         return;
       }
 
-      var scroll = self.scroll(),
+      var scroll = _refreshingAll ? prevScroll : self.scroll(),
           p = reset ? 0 : (scroll - start) / change,
           clipped = p < 0 ? 0 : p > 1 ? 1 : p || 0,
           prevProgress = self.progress,
@@ -18159,6 +18288,7 @@ var ScrollTrigger = /*#__PURE__*/function () {
       if (pin) {
         pinStart += newStart - start;
         pinChange += newEnd - newStart - change;
+        pinSpacing === _padding && self.adjustPinSpacing(newEnd - newStart - change);
       }
 
       self.start = start = newStart;
@@ -18167,6 +18297,16 @@ var ScrollTrigger = /*#__PURE__*/function () {
       self.update();
     };
 
+    self.adjustPinSpacing = function (amount) {
+      if (spacerState) {
+        var i = spacerState.indexOf(direction.d) + 1;
+        spacerState[i] = parseFloat(spacerState[i]) + amount + _px;
+        spacerState[1] = parseFloat(spacerState[1]) + amount + _px;
+
+        _setState(spacerState);
+      }
+    };
+
     self.disable = function (reset, allowAnimation) {
       if (self.enabled) {
         reset !== false && self.revert(true, true);
@@ -18218,7 +18358,9 @@ var ScrollTrigger = /*#__PURE__*/function () {
 
       if (animation) {
         animation.scrollTrigger = null;
-        revert && animation.render(-1);
+        revert && animation.revert({
+          kill: false
+        });
         allowAnimation || animation.kill();
       }
 
@@ -18246,6 +18388,8 @@ var ScrollTrigger = /*#__PURE__*/function () {
     !animation || !animation.add || change ? self.refresh() : gsap$4.delayedCall(0.01, function () {
       return start || end || self.refresh();
     }) && (change = 0.01) && (start = end = 0); // if the animation is a timeline, it may not have been populated yet, so it wouldn't render at the proper place on the first refresh(), thus we should schedule one for the next tick. If "change" is defined, we know it must be re-enabling, thus we can refresh() right away.
+
+    pin && _queueRefreshAll(); // pinning could affect the positions of other things, so make sure we queue a full refresh()
   };
 
   ScrollTrigger.register = function register(core) {
@@ -18311,6 +18455,7 @@ var ScrollTrigger = /*#__PURE__*/function () {
       _clamp = gsap$4.utils.clamp;
       _context = gsap$4.core.context || _passThrough;
       _suppressOverwrites = gsap$4.core.suppressOverwrites || _passThrough;
+      _scrollRestoration = _win.history.scrollRestoration || "auto";
       gsap$4.core.globals("ScrollTrigger", ScrollTrigger); // must register the global manually because in Internet Explorer, functions (classes) don't have a "name" property.
 
       if (_body$1) {
@@ -18358,6 +18503,8 @@ var ScrollTrigger = /*#__PURE__*/function () {
           console.warn("Requires GSAP 3.11.0 or later");
         }
 
+        _setBaseDimensions();
+
         _addListener(_doc, "scroll", _onScroll); // some browsers (like Chrome), the window stops dispatching scroll events on the window if you scroll really fast, but it's consistent on the document!
 
 
@@ -18490,7 +18637,7 @@ var ScrollTrigger = /*#__PURE__*/function () {
 
   return ScrollTrigger;
 }();
-ScrollTrigger.version = "3.11.1";
+ScrollTrigger.version = "3.11.3";
 
 ScrollTrigger.saveStyles = function (targets) {
   return targets ? _toArray$3(targets).forEach(function (target) {
@@ -18847,8 +18994,15 @@ _inputObserver = function _inputObserver(target, type, inputs, nested) {
   vars.onEnable = function () {
     _allowNativePanning(target, normalizeScrollX ? false : "x");
 
+    ScrollTrigger.addEventListener("refresh", onResize);
+
     _addListener(_win, "resize", onResize);
 
+    if (scrollFuncY.smooth) {
+      scrollFuncY.target.style.scrollBehavior = "auto";
+      scrollFuncY.smooth = scrollFuncX.smooth = false;
+    }
+
     inputObserver.enable();
   };
 
@@ -18857,6 +19011,7 @@ _inputObserver = function _inputObserver(target, type, inputs, nested) {
 
     _removeListener(_win, "resize", onResize);
 
+    ScrollTrigger.removeEventListener("refresh", onResize);
     inputObserver.kill();
   };
 
@@ -18929,7 +19084,7 @@ ScrollTrigger.core = {
 _getGSAP$4() && gsap$4.registerPlugin(ScrollTrigger);
 
 /*!
- * strings: 3.11.1
+ * strings: 3.11.3
  * https://greensock.com
  *
  * Copyright 2008-2022, GreenSock. All rights reserved.
@@ -19037,7 +19192,7 @@ function emojiSafeSplit(text, delimiter, trim, preserveSpaces) {
 }
 
 /*!
- * TextPlugin 3.11.1
+ * TextPlugin 3.11.3
  * https://greensock.com
  *
  * @license Copyright 2008-2022, GreenSock. All rights reserved.
@@ -19053,7 +19208,7 @@ var gsap$3,
 };
 
 var TextPlugin = {
-  version: "3.11.1",
+  version: "3.11.3",
   name: "text",
   init: function init(target, value, tween) {
     typeof value !== "object" && (value = {
@@ -25074,7 +25229,7 @@ const HapticsNotificationType = exports.NotificationType;
 const HapticsImpactStyle = exports.ImpactStyle;
 
 const Haptics = registerPlugin('Haptics', {
-    web: () => Promise.resolve().then(function () { return require('./web-c4e788b7.js'); }).then(m => new m.HapticsWeb()),
+    web: () => Promise.resolve().then(function () { return require('./web-9a809681.js'); }).then(m => new m.HapticsWeb()),
 });
 
 /// <reference types="@capacitor/cli" />
@@ -25138,7 +25293,7 @@ const Keyboard = registerPlugin('Keyboard');
 /// <reference types="@capacitor/cli" />
 
 const SplashScreen = registerPlugin('SplashScreen', {
-    web: () => Promise.resolve().then(function () { return require('./web-34296086.js'); }).then(m => new m.SplashScreenWeb()),
+    web: () => Promise.resolve().then(function () { return require('./web-d7fd2021.js'); }).then(m => new m.SplashScreenWeb()),
 });
 
 var Style;