2399 lines
103 KiB
JavaScript
2399 lines
103 KiB
JavaScript
import "./chunk-G3PMV62Z.js";
|
|
|
|
// node_modules/gsap/Observer.js
|
|
function _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);
|
|
}
|
|
}
|
|
function _createClass(Constructor, protoProps, staticProps) {
|
|
if (protoProps) _defineProperties(Constructor.prototype, protoProps);
|
|
if (staticProps) _defineProperties(Constructor, staticProps);
|
|
return Constructor;
|
|
}
|
|
var gsap;
|
|
var _coreInitted;
|
|
var _clamp;
|
|
var _win;
|
|
var _doc;
|
|
var _docEl;
|
|
var _body;
|
|
var _isTouch;
|
|
var _pointerType;
|
|
var ScrollTrigger;
|
|
var _root;
|
|
var _normalizer;
|
|
var _eventTypes;
|
|
var _context;
|
|
var _getGSAP = function _getGSAP2() {
|
|
return gsap || typeof window !== "undefined" && (gsap = window.gsap) && gsap.registerPlugin && gsap;
|
|
};
|
|
var _startup = 1;
|
|
var _observers = [];
|
|
var _scrollers = [];
|
|
var _proxies = [];
|
|
var _getTime = Date.now;
|
|
var _bridge = function _bridge2(name, value) {
|
|
return value;
|
|
};
|
|
var _integrate = function _integrate2() {
|
|
var core = ScrollTrigger.core, data = core.bridge || {}, scrollers = core._scrollers, proxies = core._proxies;
|
|
scrollers.push.apply(scrollers, _scrollers);
|
|
proxies.push.apply(proxies, _proxies);
|
|
_scrollers = scrollers;
|
|
_proxies = proxies;
|
|
_bridge = function _bridge3(name, value) {
|
|
return data[name](value);
|
|
};
|
|
};
|
|
var _getProxyProp = function _getProxyProp2(element, property) {
|
|
return ~_proxies.indexOf(element) && _proxies[_proxies.indexOf(element) + 1][property];
|
|
};
|
|
var _isViewport = function _isViewport2(el) {
|
|
return !!~_root.indexOf(el);
|
|
};
|
|
var _addListener = function _addListener2(element, type, func, passive, capture) {
|
|
return element.addEventListener(type, func, {
|
|
passive: passive !== false,
|
|
capture: !!capture
|
|
});
|
|
};
|
|
var _removeListener = function _removeListener2(element, type, func, capture) {
|
|
return element.removeEventListener(type, func, !!capture);
|
|
};
|
|
var _scrollLeft = "scrollLeft";
|
|
var _scrollTop = "scrollTop";
|
|
var _onScroll = function _onScroll2() {
|
|
return _normalizer && _normalizer.isPressed || _scrollers.cache++;
|
|
};
|
|
var _scrollCacheFunc = function _scrollCacheFunc2(f, doNotCache) {
|
|
var cachingFunc = function cachingFunc2(value) {
|
|
if (value || value === 0) {
|
|
_startup && (_win.history.scrollRestoration = "manual");
|
|
var isNormalizing = _normalizer && _normalizer.isPressed;
|
|
value = cachingFunc2.v = Math.round(value) || (_normalizer && _normalizer.iOS ? 1 : 0);
|
|
f(value);
|
|
cachingFunc2.cacheID = _scrollers.cache;
|
|
isNormalizing && _bridge("ss", value);
|
|
} else if (doNotCache || _scrollers.cache !== cachingFunc2.cacheID || _bridge("ref")) {
|
|
cachingFunc2.cacheID = _scrollers.cache;
|
|
cachingFunc2.v = f();
|
|
}
|
|
return cachingFunc2.v + cachingFunc2.offset;
|
|
};
|
|
cachingFunc.offset = 0;
|
|
return f && cachingFunc;
|
|
};
|
|
var _horizontal = {
|
|
s: _scrollLeft,
|
|
p: "left",
|
|
p2: "Left",
|
|
os: "right",
|
|
os2: "Right",
|
|
d: "width",
|
|
d2: "Width",
|
|
a: "x",
|
|
sc: _scrollCacheFunc(function(value) {
|
|
return arguments.length ? _win.scrollTo(value, _vertical.sc()) : _win.pageXOffset || _doc[_scrollLeft] || _docEl[_scrollLeft] || _body[_scrollLeft] || 0;
|
|
})
|
|
};
|
|
var _vertical = {
|
|
s: _scrollTop,
|
|
p: "top",
|
|
p2: "Top",
|
|
os: "bottom",
|
|
os2: "Bottom",
|
|
d: "height",
|
|
d2: "Height",
|
|
a: "y",
|
|
op: _horizontal,
|
|
sc: _scrollCacheFunc(function(value) {
|
|
return arguments.length ? _win.scrollTo(_horizontal.sc(), value) : _win.pageYOffset || _doc[_scrollTop] || _docEl[_scrollTop] || _body[_scrollTop] || 0;
|
|
})
|
|
};
|
|
var _getTarget = function _getTarget2(t, self) {
|
|
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);
|
|
};
|
|
var _isWithin = function _isWithin2(element, list) {
|
|
var i = list.length;
|
|
while (i--) {
|
|
if (list[i] === element || list[i].contains(element)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
var _getScrollFunc = function _getScrollFunc2(element, _ref) {
|
|
var s = _ref.s, sc = _ref.sc;
|
|
_isViewport(element) && (element = _doc.scrollingElement || _docEl);
|
|
var i = _scrollers.indexOf(element), offset = sc === _vertical.sc ? 1 : 2;
|
|
!~i && (i = _scrollers.push(element) - 1);
|
|
_scrollers[i + offset] || _addListener(element, "scroll", _onScroll);
|
|
var prev = _scrollers[i + offset], func = prev || (_scrollers[i + offset] = _scrollCacheFunc(_getProxyProp(element, s), true) || (_isViewport(element) ? sc : _scrollCacheFunc(function(value) {
|
|
return arguments.length ? element[s] = value : element[s];
|
|
})));
|
|
func.target = element;
|
|
prev || (func.smooth = gsap.getProperty(element, "scrollBehavior") === "smooth");
|
|
return func;
|
|
};
|
|
var _getVelocityProp = function _getVelocityProp2(value, minTimeRefresh, useDelta) {
|
|
var v1 = value, v2 = value, t1 = _getTime(), t2 = t1, min = minTimeRefresh || 50, dropToZeroTime = Math.max(500, min * 3), update = function update2(value2, force) {
|
|
var t = _getTime();
|
|
if (force || t - t1 > min) {
|
|
v2 = v1;
|
|
v1 = value2;
|
|
t2 = t1;
|
|
t1 = t;
|
|
} else if (useDelta) {
|
|
v1 += value2;
|
|
} else {
|
|
v1 = v2 + (value2 - v2) / (t - t2) * (t1 - t2);
|
|
}
|
|
}, reset = function reset2() {
|
|
v2 = v1 = useDelta ? 0 : v1;
|
|
t2 = t1 = 0;
|
|
}, getVelocity = function getVelocity2(latestValue) {
|
|
var tOld = t2, vOld = v2, t = _getTime();
|
|
(latestValue || latestValue === 0) && latestValue !== v1 && update(latestValue);
|
|
return t1 === t2 || t - t2 > dropToZeroTime ? 0 : (v1 + (useDelta ? vOld : -vOld)) / ((useDelta ? t : t1) - tOld) * 1e3;
|
|
};
|
|
return {
|
|
update,
|
|
reset,
|
|
getVelocity
|
|
};
|
|
};
|
|
var _getEvent = function _getEvent2(e, preventDefault) {
|
|
preventDefault && !e._gsapAllow && e.cancelable !== false && e.preventDefault();
|
|
return e.changedTouches ? e.changedTouches[0] : e;
|
|
};
|
|
var _getAbsoluteMax = function _getAbsoluteMax2(a) {
|
|
var max = Math.max.apply(Math, a), min = Math.min.apply(Math, a);
|
|
return Math.abs(max) >= Math.abs(min) ? max : min;
|
|
};
|
|
var _setScrollTrigger = function _setScrollTrigger2() {
|
|
ScrollTrigger = gsap.core.globals().ScrollTrigger;
|
|
ScrollTrigger && ScrollTrigger.core && _integrate();
|
|
};
|
|
var _initCore = function _initCore2(core) {
|
|
gsap = core || _getGSAP();
|
|
if (!_coreInitted && gsap && typeof document !== "undefined" && document.body) {
|
|
_win = window;
|
|
_doc = document;
|
|
_docEl = _doc.documentElement;
|
|
_body = _doc.body;
|
|
_root = [_win, _doc, _docEl, _body];
|
|
_clamp = gsap.utils.clamp;
|
|
_context = gsap.core.context || function() {
|
|
};
|
|
_pointerType = "onpointerenter" in _body ? "pointer" : "mouse";
|
|
_isTouch = Observer.isTouch = _win.matchMedia && _win.matchMedia("(hover: none), (pointer: coarse)").matches ? 1 : "ontouchstart" in _win || navigator.maxTouchPoints > 0 || navigator.msMaxTouchPoints > 0 ? 2 : 0;
|
|
_eventTypes = Observer.eventTypes = ("ontouchstart" in _docEl ? "touchstart,touchmove,touchcancel,touchend" : !("onpointerdown" in _docEl) ? "mousedown,mousemove,mouseup,mouseup" : "pointerdown,pointermove,pointercancel,pointerup").split(",");
|
|
setTimeout(function() {
|
|
return _startup = 0;
|
|
}, 500);
|
|
_coreInitted = 1;
|
|
}
|
|
ScrollTrigger || _setScrollTrigger();
|
|
return _coreInitted;
|
|
};
|
|
_horizontal.op = _vertical;
|
|
_scrollers.cache = 0;
|
|
var Observer = (function() {
|
|
function Observer2(vars) {
|
|
this.init(vars);
|
|
}
|
|
var _proto = Observer2.prototype;
|
|
_proto.init = function init(vars) {
|
|
_coreInitted || _initCore(gsap) || console.warn("Please gsap.registerPlugin(Observer)");
|
|
ScrollTrigger || _setScrollTrigger();
|
|
var tolerance = vars.tolerance, dragMinimum = vars.dragMinimum, type = vars.type, target = vars.target, lineHeight = vars.lineHeight, debounce = vars.debounce, preventDefault = vars.preventDefault, onStop = vars.onStop, onStopDelay = vars.onStopDelay, ignore = vars.ignore, wheelSpeed = vars.wheelSpeed, event = vars.event, onDragStart = vars.onDragStart, onDragEnd = vars.onDragEnd, onDrag = vars.onDrag, onPress = vars.onPress, onRelease = vars.onRelease, onRight = vars.onRight, onLeft = vars.onLeft, onUp = vars.onUp, onDown = vars.onDown, onChangeX = vars.onChangeX, onChangeY = vars.onChangeY, onChange = vars.onChange, onToggleX = vars.onToggleX, onToggleY = vars.onToggleY, onHover = vars.onHover, onHoverEnd = vars.onHoverEnd, onMove = vars.onMove, ignoreCheck = vars.ignoreCheck, isNormalizer = vars.isNormalizer, onGestureStart = vars.onGestureStart, onGestureEnd = vars.onGestureEnd, onWheel = vars.onWheel, onEnable = vars.onEnable, onDisable = vars.onDisable, onClick = vars.onClick, scrollSpeed = vars.scrollSpeed, capture = vars.capture, allowClicks = vars.allowClicks, lockAxis = vars.lockAxis, onLockAxis = vars.onLockAxis;
|
|
this.target = target = _getTarget(target) || _docEl;
|
|
this.vars = vars;
|
|
ignore && (ignore = gsap.utils.toArray(ignore));
|
|
tolerance = tolerance || 1e-9;
|
|
dragMinimum = dragMinimum || 0;
|
|
wheelSpeed = wheelSpeed || 1;
|
|
scrollSpeed = scrollSpeed || 1;
|
|
type = type || "wheel,touch,pointer";
|
|
debounce = debounce !== false;
|
|
lineHeight || (lineHeight = parseFloat(_win.getComputedStyle(_body).lineHeight) || 22);
|
|
var id, onStopDelayedCall, dragged, moved, wheeled, locked, axis, self = this, prevDeltaX = 0, prevDeltaY = 0, passive = vars.passive || !preventDefault && vars.passive !== false, scrollFuncX = _getScrollFunc(target, _horizontal), scrollFuncY = _getScrollFunc(target, _vertical), scrollX = scrollFuncX(), scrollY = scrollFuncY(), limitToTouch = ~type.indexOf("touch") && !~type.indexOf("pointer") && _eventTypes[0] === "pointerdown", isViewport = _isViewport(target), ownerDoc = target.ownerDocument || _doc, deltaX = [0, 0, 0], deltaY = [0, 0, 0], onClickTime = 0, clickCapture = function clickCapture2() {
|
|
return onClickTime = _getTime();
|
|
}, _ignoreCheck = function _ignoreCheck2(e, isPointerOrTouch) {
|
|
return (self.event = e) && ignore && _isWithin(e.target, ignore) || isPointerOrTouch && limitToTouch && e.pointerType !== "touch" || ignoreCheck && ignoreCheck(e, isPointerOrTouch);
|
|
}, onStopFunc = function onStopFunc2() {
|
|
self._vx.reset();
|
|
self._vy.reset();
|
|
onStopDelayedCall.pause();
|
|
onStop && onStop(self);
|
|
}, update = function update2() {
|
|
var dx = self.deltaX = _getAbsoluteMax(deltaX), dy = self.deltaY = _getAbsoluteMax(deltaY), changedX = Math.abs(dx) >= tolerance, changedY = Math.abs(dy) >= tolerance;
|
|
onChange && (changedX || changedY) && onChange(self, dx, dy, deltaX, deltaY);
|
|
if (changedX) {
|
|
onRight && self.deltaX > 0 && onRight(self);
|
|
onLeft && self.deltaX < 0 && onLeft(self);
|
|
onChangeX && onChangeX(self);
|
|
onToggleX && self.deltaX < 0 !== prevDeltaX < 0 && onToggleX(self);
|
|
prevDeltaX = self.deltaX;
|
|
deltaX[0] = deltaX[1] = deltaX[2] = 0;
|
|
}
|
|
if (changedY) {
|
|
onDown && self.deltaY > 0 && onDown(self);
|
|
onUp && self.deltaY < 0 && onUp(self);
|
|
onChangeY && onChangeY(self);
|
|
onToggleY && self.deltaY < 0 !== prevDeltaY < 0 && onToggleY(self);
|
|
prevDeltaY = self.deltaY;
|
|
deltaY[0] = deltaY[1] = deltaY[2] = 0;
|
|
}
|
|
if (moved || dragged) {
|
|
onMove && onMove(self);
|
|
if (dragged) {
|
|
onDragStart && dragged === 1 && onDragStart(self);
|
|
onDrag && onDrag(self);
|
|
dragged = 0;
|
|
}
|
|
moved = false;
|
|
}
|
|
locked && !(locked = false) && onLockAxis && onLockAxis(self);
|
|
if (wheeled) {
|
|
onWheel(self);
|
|
wheeled = false;
|
|
}
|
|
id = 0;
|
|
}, onDelta = function onDelta2(x, y, index) {
|
|
deltaX[index] += x;
|
|
deltaY[index] += y;
|
|
self._vx.update(x);
|
|
self._vy.update(y);
|
|
debounce ? id || (id = requestAnimationFrame(update)) : update();
|
|
}, onTouchOrPointerDelta = function onTouchOrPointerDelta2(x, y) {
|
|
if (lockAxis && !axis) {
|
|
self.axis = axis = Math.abs(x) > Math.abs(y) ? "x" : "y";
|
|
locked = true;
|
|
}
|
|
if (axis !== "y") {
|
|
deltaX[2] += x;
|
|
self._vx.update(x, true);
|
|
}
|
|
if (axis !== "x") {
|
|
deltaY[2] += y;
|
|
self._vy.update(y, true);
|
|
}
|
|
debounce ? id || (id = requestAnimationFrame(update)) : update();
|
|
}, _onDrag = function _onDrag2(e) {
|
|
if (_ignoreCheck(e, 1)) {
|
|
return;
|
|
}
|
|
e = _getEvent(e, preventDefault);
|
|
var x = e.clientX, y = e.clientY, dx = x - self.x, dy = y - self.y, isDragging = self.isDragging;
|
|
self.x = x;
|
|
self.y = y;
|
|
if (isDragging || (dx || dy) && (Math.abs(self.startX - x) >= dragMinimum || Math.abs(self.startY - y) >= dragMinimum)) {
|
|
dragged || (dragged = isDragging ? 2 : 1);
|
|
isDragging || (self.isDragging = true);
|
|
onTouchOrPointerDelta(dx, dy);
|
|
}
|
|
}, _onPress = self.onPress = function(e) {
|
|
if (_ignoreCheck(e, 1) || e && e.button) {
|
|
return;
|
|
}
|
|
self.axis = axis = null;
|
|
onStopDelayedCall.pause();
|
|
self.isPressed = true;
|
|
e = _getEvent(e);
|
|
prevDeltaX = prevDeltaY = 0;
|
|
self.startX = self.x = e.clientX;
|
|
self.startY = self.y = e.clientY;
|
|
self._vx.reset();
|
|
self._vy.reset();
|
|
_addListener(isNormalizer ? target : ownerDoc, _eventTypes[1], _onDrag, passive, true);
|
|
self.deltaX = self.deltaY = 0;
|
|
onPress && onPress(self);
|
|
}, _onRelease = self.onRelease = function(e) {
|
|
if (_ignoreCheck(e, 1)) {
|
|
return;
|
|
}
|
|
_removeListener(isNormalizer ? target : ownerDoc, _eventTypes[1], _onDrag, true);
|
|
var isTrackingDrag = !isNaN(self.y - self.startY), wasDragging = self.isDragging, isDragNotClick = wasDragging && (Math.abs(self.x - self.startX) > 3 || Math.abs(self.y - self.startY) > 3), eventData = _getEvent(e);
|
|
if (!isDragNotClick && isTrackingDrag) {
|
|
self._vx.reset();
|
|
self._vy.reset();
|
|
if (preventDefault && allowClicks) {
|
|
gsap.delayedCall(0.08, function() {
|
|
if (_getTime() - onClickTime > 300 && !e.defaultPrevented) {
|
|
if (e.target.click) {
|
|
e.target.click();
|
|
} else if (ownerDoc.createEvent) {
|
|
var syntheticEvent = ownerDoc.createEvent("MouseEvents");
|
|
syntheticEvent.initMouseEvent("click", true, true, _win, 1, eventData.screenX, eventData.screenY, eventData.clientX, eventData.clientY, false, false, false, false, 0, null);
|
|
e.target.dispatchEvent(syntheticEvent);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
self.isDragging = self.isGesturing = self.isPressed = false;
|
|
onStop && wasDragging && !isNormalizer && onStopDelayedCall.restart(true);
|
|
dragged && update();
|
|
onDragEnd && wasDragging && onDragEnd(self);
|
|
onRelease && onRelease(self, isDragNotClick);
|
|
}, _onGestureStart = function _onGestureStart2(e) {
|
|
return e.touches && e.touches.length > 1 && (self.isGesturing = true) && onGestureStart(e, self.isDragging);
|
|
}, _onGestureEnd = function _onGestureEnd2() {
|
|
return (self.isGesturing = false) || onGestureEnd(self);
|
|
}, onScroll = function onScroll2(e) {
|
|
if (_ignoreCheck(e)) {
|
|
return;
|
|
}
|
|
var x = scrollFuncX(), y = scrollFuncY();
|
|
onDelta((x - scrollX) * scrollSpeed, (y - scrollY) * scrollSpeed, 1);
|
|
scrollX = x;
|
|
scrollY = y;
|
|
onStop && onStopDelayedCall.restart(true);
|
|
}, _onWheel = function _onWheel2(e) {
|
|
if (_ignoreCheck(e)) {
|
|
return;
|
|
}
|
|
e = _getEvent(e, preventDefault);
|
|
onWheel && (wheeled = true);
|
|
var multiplier = (e.deltaMode === 1 ? lineHeight : e.deltaMode === 2 ? _win.innerHeight : 1) * wheelSpeed;
|
|
onDelta(e.deltaX * multiplier, e.deltaY * multiplier, 0);
|
|
onStop && !isNormalizer && onStopDelayedCall.restart(true);
|
|
}, _onMove = function _onMove2(e) {
|
|
if (_ignoreCheck(e)) {
|
|
return;
|
|
}
|
|
var x = e.clientX, y = e.clientY, dx = x - self.x, dy = y - self.y;
|
|
self.x = x;
|
|
self.y = y;
|
|
moved = true;
|
|
onStop && onStopDelayedCall.restart(true);
|
|
(dx || dy) && onTouchOrPointerDelta(dx, dy);
|
|
}, _onHover = function _onHover2(e) {
|
|
self.event = e;
|
|
onHover(self);
|
|
}, _onHoverEnd = function _onHoverEnd2(e) {
|
|
self.event = e;
|
|
onHoverEnd(self);
|
|
}, _onClick = function _onClick2(e) {
|
|
return _ignoreCheck(e) || _getEvent(e, preventDefault) && onClick(self);
|
|
};
|
|
onStopDelayedCall = self._dc = gsap.delayedCall(onStopDelay || 0.25, onStopFunc).pause();
|
|
self.deltaX = self.deltaY = 0;
|
|
self._vx = _getVelocityProp(0, 50, true);
|
|
self._vy = _getVelocityProp(0, 50, true);
|
|
self.scrollX = scrollFuncX;
|
|
self.scrollY = scrollFuncY;
|
|
self.isDragging = self.isGesturing = self.isPressed = false;
|
|
_context(this);
|
|
self.enable = function(e) {
|
|
if (!self.isEnabled) {
|
|
_addListener(isViewport ? ownerDoc : target, "scroll", _onScroll);
|
|
type.indexOf("scroll") >= 0 && _addListener(isViewport ? ownerDoc : target, "scroll", onScroll, passive, capture);
|
|
type.indexOf("wheel") >= 0 && _addListener(target, "wheel", _onWheel, passive, capture);
|
|
if (type.indexOf("touch") >= 0 && _isTouch || type.indexOf("pointer") >= 0) {
|
|
_addListener(target, _eventTypes[0], _onPress, passive, capture);
|
|
_addListener(ownerDoc, _eventTypes[2], _onRelease);
|
|
_addListener(ownerDoc, _eventTypes[3], _onRelease);
|
|
allowClicks && _addListener(target, "click", clickCapture, true, true);
|
|
onClick && _addListener(target, "click", _onClick);
|
|
onGestureStart && _addListener(ownerDoc, "gesturestart", _onGestureStart);
|
|
onGestureEnd && _addListener(ownerDoc, "gestureend", _onGestureEnd);
|
|
onHover && _addListener(target, _pointerType + "enter", _onHover);
|
|
onHoverEnd && _addListener(target, _pointerType + "leave", _onHoverEnd);
|
|
onMove && _addListener(target, _pointerType + "move", _onMove);
|
|
}
|
|
self.isEnabled = true;
|
|
self.isDragging = self.isGesturing = self.isPressed = moved = dragged = false;
|
|
self._vx.reset();
|
|
self._vy.reset();
|
|
scrollX = scrollFuncX();
|
|
scrollY = scrollFuncY();
|
|
e && e.type && _onPress(e);
|
|
onEnable && onEnable(self);
|
|
}
|
|
return self;
|
|
};
|
|
self.disable = function() {
|
|
if (self.isEnabled) {
|
|
_observers.filter(function(o) {
|
|
return o !== self && _isViewport(o.target);
|
|
}).length || _removeListener(isViewport ? ownerDoc : target, "scroll", _onScroll);
|
|
if (self.isPressed) {
|
|
self._vx.reset();
|
|
self._vy.reset();
|
|
_removeListener(isNormalizer ? target : ownerDoc, _eventTypes[1], _onDrag, true);
|
|
}
|
|
_removeListener(isViewport ? ownerDoc : target, "scroll", onScroll, capture);
|
|
_removeListener(target, "wheel", _onWheel, capture);
|
|
_removeListener(target, _eventTypes[0], _onPress, capture);
|
|
_removeListener(ownerDoc, _eventTypes[2], _onRelease);
|
|
_removeListener(ownerDoc, _eventTypes[3], _onRelease);
|
|
_removeListener(target, "click", clickCapture, true);
|
|
_removeListener(target, "click", _onClick);
|
|
_removeListener(ownerDoc, "gesturestart", _onGestureStart);
|
|
_removeListener(ownerDoc, "gestureend", _onGestureEnd);
|
|
_removeListener(target, _pointerType + "enter", _onHover);
|
|
_removeListener(target, _pointerType + "leave", _onHoverEnd);
|
|
_removeListener(target, _pointerType + "move", _onMove);
|
|
self.isEnabled = self.isPressed = self.isDragging = false;
|
|
onDisable && onDisable(self);
|
|
}
|
|
};
|
|
self.kill = self.revert = function() {
|
|
self.disable();
|
|
var i = _observers.indexOf(self);
|
|
i >= 0 && _observers.splice(i, 1);
|
|
_normalizer === self && (_normalizer = 0);
|
|
};
|
|
_observers.push(self);
|
|
isNormalizer && _isViewport(target) && (_normalizer = self);
|
|
self.enable(event);
|
|
};
|
|
_createClass(Observer2, [{
|
|
key: "velocityX",
|
|
get: function get() {
|
|
return this._vx.getVelocity();
|
|
}
|
|
}, {
|
|
key: "velocityY",
|
|
get: function get() {
|
|
return this._vy.getVelocity();
|
|
}
|
|
}]);
|
|
return Observer2;
|
|
})();
|
|
Observer.version = "3.15.0";
|
|
Observer.create = function(vars) {
|
|
return new Observer(vars);
|
|
};
|
|
Observer.register = _initCore;
|
|
Observer.getAll = function() {
|
|
return _observers.slice();
|
|
};
|
|
Observer.getById = function(id) {
|
|
return _observers.filter(function(o) {
|
|
return o.vars.id === id;
|
|
})[0];
|
|
};
|
|
_getGSAP() && gsap.registerPlugin(Observer);
|
|
|
|
// node_modules/gsap/ScrollTrigger.js
|
|
var gsap2;
|
|
var _coreInitted2;
|
|
var _win2;
|
|
var _doc2;
|
|
var _docEl2;
|
|
var _body2;
|
|
var _root2;
|
|
var _resizeDelay;
|
|
var _toArray;
|
|
var _clamp2;
|
|
var _time2;
|
|
var _syncInterval;
|
|
var _refreshing;
|
|
var _pointerIsDown;
|
|
var _transformProp;
|
|
var _i;
|
|
var _prevWidth;
|
|
var _prevHeight;
|
|
var _autoRefresh;
|
|
var _sort;
|
|
var _suppressOverwrites;
|
|
var _ignoreResize;
|
|
var _normalizer2;
|
|
var _ignoreMobileResize;
|
|
var _baseScreenHeight;
|
|
var _baseScreenWidth;
|
|
var _fixIOSBug;
|
|
var _context2;
|
|
var _scrollRestoration;
|
|
var _div100vh;
|
|
var _100vh;
|
|
var _isReverted;
|
|
var _clampingMax;
|
|
var _limitCallbacks;
|
|
var _startup2 = 1;
|
|
var _getTime2 = Date.now;
|
|
var _time1 = _getTime2();
|
|
var _lastScrollTime = 0;
|
|
var _enabled = 0;
|
|
var _parseClamp = function _parseClamp2(value, type, self) {
|
|
var clamp = _isString(value) && (value.substr(0, 6) === "clamp(" || value.indexOf("max") > -1);
|
|
self["_" + type + "Clamp"] = clamp;
|
|
return clamp ? value.substr(6, value.length - 7) : value;
|
|
};
|
|
var _keepClamp = function _keepClamp2(value, clamp) {
|
|
return clamp && (!_isString(value) || value.substr(0, 6) !== "clamp(") ? "clamp(" + value + ")" : value;
|
|
};
|
|
var _rafBugFix = function _rafBugFix2() {
|
|
return _enabled && requestAnimationFrame(_rafBugFix2);
|
|
};
|
|
var _pointerDownHandler = function _pointerDownHandler2() {
|
|
return _pointerIsDown = 1;
|
|
};
|
|
var _pointerUpHandler = function _pointerUpHandler2() {
|
|
return _pointerIsDown = 0;
|
|
};
|
|
var _passThrough = function _passThrough2(v) {
|
|
return v;
|
|
};
|
|
var _round = function _round2(value) {
|
|
return Math.round(value * 1e5) / 1e5 || 0;
|
|
};
|
|
var _windowExists = function _windowExists2() {
|
|
return typeof window !== "undefined";
|
|
};
|
|
var _getGSAP3 = function _getGSAP4() {
|
|
return gsap2 || _windowExists() && (gsap2 = window.gsap) && gsap2.registerPlugin && gsap2;
|
|
};
|
|
var _isViewport3 = function _isViewport4(e) {
|
|
return !!~_root2.indexOf(e);
|
|
};
|
|
var _getViewportDimension = function _getViewportDimension2(dimensionProperty) {
|
|
return (dimensionProperty === "Height" ? _100vh : _win2["inner" + dimensionProperty]) || _docEl2["client" + dimensionProperty] || _body2["client" + dimensionProperty];
|
|
};
|
|
var _getBoundsFunc = function _getBoundsFunc2(element) {
|
|
return _getProxyProp(element, "getBoundingClientRect") || (_isViewport3(element) ? function() {
|
|
_winOffsets.width = _win2.innerWidth;
|
|
_winOffsets.height = _100vh;
|
|
return _winOffsets;
|
|
} : function() {
|
|
return _getBounds(element);
|
|
});
|
|
};
|
|
var _getSizeFunc = function _getSizeFunc2(scroller, isViewport, _ref) {
|
|
var d = _ref.d, d2 = _ref.d2, a = _ref.a;
|
|
return (a = _getProxyProp(scroller, "getBoundingClientRect")) ? function() {
|
|
return a()[d];
|
|
} : function() {
|
|
return (isViewport ? _getViewportDimension(d2) : scroller["client" + d2]) || 0;
|
|
};
|
|
};
|
|
var _getOffsetsFunc = function _getOffsetsFunc2(element, isViewport) {
|
|
return !isViewport || ~_proxies.indexOf(element) ? _getBoundsFunc(element) : function() {
|
|
return _winOffsets;
|
|
};
|
|
};
|
|
var _maxScroll = function _maxScroll2(element, _ref2) {
|
|
var s = _ref2.s, d2 = _ref2.d2, d = _ref2.d, a = _ref2.a;
|
|
return Math.max(0, (s = "scroll" + d2) && (a = _getProxyProp(element, s)) ? a() - _getBoundsFunc(element)()[d] : _isViewport3(element) ? (_docEl2[s] || _body2[s]) - _getViewportDimension(d2) : element[s] - element["offset" + d2]);
|
|
};
|
|
var _iterateAutoRefresh = function _iterateAutoRefresh2(func, events) {
|
|
for (var i = 0; i < _autoRefresh.length; i += 3) {
|
|
(!events || ~events.indexOf(_autoRefresh[i + 1])) && func(_autoRefresh[i], _autoRefresh[i + 1], _autoRefresh[i + 2]);
|
|
}
|
|
};
|
|
var _isString = function _isString2(value) {
|
|
return typeof value === "string";
|
|
};
|
|
var _isFunction = function _isFunction2(value) {
|
|
return typeof value === "function";
|
|
};
|
|
var _isNumber = function _isNumber2(value) {
|
|
return typeof value === "number";
|
|
};
|
|
var _isObject = function _isObject2(value) {
|
|
return typeof value === "object";
|
|
};
|
|
var _endAnimation = function _endAnimation2(animation, reversed, pause) {
|
|
return animation && animation.progress(reversed ? 0 : 1) && pause && animation.pause();
|
|
};
|
|
var _callback = function _callback2(self, func, extraParam) {
|
|
if (self.enabled) {
|
|
var result = self._ctx ? self._ctx.add(function() {
|
|
return func(self, extraParam);
|
|
}) : func(self, extraParam);
|
|
result && result.totalTime && (self.callbackAnimation = result);
|
|
}
|
|
};
|
|
var _abs = Math.abs;
|
|
var _left = "left";
|
|
var _top = "top";
|
|
var _right = "right";
|
|
var _bottom = "bottom";
|
|
var _width = "width";
|
|
var _height = "height";
|
|
var _Right = "Right";
|
|
var _Left = "Left";
|
|
var _Top = "Top";
|
|
var _Bottom = "Bottom";
|
|
var _padding = "padding";
|
|
var _margin = "margin";
|
|
var _Width = "Width";
|
|
var _Height = "Height";
|
|
var _px = "px";
|
|
var _getComputedStyle = function _getComputedStyle2(element) {
|
|
return _win2.getComputedStyle(element.nodeType === Node.DOCUMENT_NODE ? element.scrollingElement : element);
|
|
};
|
|
var _makePositionable = function _makePositionable2(element) {
|
|
var position = _getComputedStyle(element).position;
|
|
element.style.position = position === "absolute" || position === "fixed" ? position : "relative";
|
|
};
|
|
var _setDefaults = function _setDefaults2(obj, defaults) {
|
|
for (var p in defaults) {
|
|
p in obj || (obj[p] = defaults[p]);
|
|
}
|
|
return obj;
|
|
};
|
|
var _getBounds = function _getBounds2(element, withoutTransforms) {
|
|
var tween = withoutTransforms && _getComputedStyle(element)[_transformProp] !== "matrix(1, 0, 0, 1, 0, 0)" && gsap2.to(element, {
|
|
x: 0,
|
|
y: 0,
|
|
xPercent: 0,
|
|
yPercent: 0,
|
|
rotation: 0,
|
|
rotationX: 0,
|
|
rotationY: 0,
|
|
scale: 1,
|
|
skewX: 0,
|
|
skewY: 0
|
|
}).progress(1), bounds = element.getBoundingClientRect ? element.getBoundingClientRect() : element.scrollingElement.getBoundingClientRect();
|
|
tween && tween.progress(0).kill();
|
|
return bounds;
|
|
};
|
|
var _getSize = function _getSize2(element, _ref3) {
|
|
var d2 = _ref3.d2;
|
|
return element["offset" + d2] || element["client" + d2] || 0;
|
|
};
|
|
var _getLabelRatioArray = function _getLabelRatioArray2(timeline) {
|
|
var a = [], labels = timeline.labels, duration = timeline.duration(), p;
|
|
for (p in labels) {
|
|
a.push(labels[p] / duration);
|
|
}
|
|
return a;
|
|
};
|
|
var _getClosestLabel = function _getClosestLabel2(animation) {
|
|
return function(value) {
|
|
return gsap2.utils.snap(_getLabelRatioArray(animation), value);
|
|
};
|
|
};
|
|
var _snapDirectional = function _snapDirectional2(snapIncrementOrArray) {
|
|
var snap = gsap2.utils.snap(snapIncrementOrArray), a = Array.isArray(snapIncrementOrArray) && snapIncrementOrArray.slice(0).sort(function(a2, b) {
|
|
return a2 - b;
|
|
});
|
|
return a ? function(value, direction, threshold) {
|
|
if (threshold === void 0) {
|
|
threshold = 1e-3;
|
|
}
|
|
var i;
|
|
if (!direction) {
|
|
return snap(value);
|
|
}
|
|
if (direction > 0) {
|
|
value -= threshold;
|
|
for (i = 0; i < a.length; i++) {
|
|
if (a[i] >= value) {
|
|
return a[i];
|
|
}
|
|
}
|
|
return a[i - 1];
|
|
} else {
|
|
i = a.length;
|
|
value += threshold;
|
|
while (i--) {
|
|
if (a[i] <= value) {
|
|
return a[i];
|
|
}
|
|
}
|
|
}
|
|
return a[0];
|
|
} : function(value, direction, threshold) {
|
|
if (threshold === void 0) {
|
|
threshold = 1e-3;
|
|
}
|
|
var snapped = snap(value);
|
|
return !direction || Math.abs(snapped - value) < threshold || snapped - value < 0 === direction < 0 ? snapped : snap(direction < 0 ? value - snapIncrementOrArray : value + snapIncrementOrArray);
|
|
};
|
|
};
|
|
var _getLabelAtDirection = function _getLabelAtDirection2(timeline) {
|
|
return function(value, st) {
|
|
return _snapDirectional(_getLabelRatioArray(timeline))(value, st.direction);
|
|
};
|
|
};
|
|
var _multiListener = function _multiListener2(func, element, types, callback) {
|
|
return types.split(",").forEach(function(type) {
|
|
return func(element, type, callback);
|
|
});
|
|
};
|
|
var _addListener3 = function _addListener4(element, type, func, nonPassive, capture) {
|
|
return element.addEventListener(type, func, {
|
|
passive: !nonPassive,
|
|
capture: !!capture
|
|
});
|
|
};
|
|
var _removeListener3 = function _removeListener4(element, type, func, capture) {
|
|
return element.removeEventListener(type, func, !!capture);
|
|
};
|
|
var _wheelListener = function _wheelListener2(func, el, scrollFunc) {
|
|
scrollFunc = scrollFunc && scrollFunc.wheelHandler;
|
|
if (scrollFunc) {
|
|
func(el, "wheel", scrollFunc);
|
|
func(el, "touchmove", scrollFunc);
|
|
}
|
|
};
|
|
var _markerDefaults = {
|
|
startColor: "green",
|
|
endColor: "red",
|
|
indent: 0,
|
|
fontSize: "16px",
|
|
fontWeight: "normal"
|
|
};
|
|
var _defaults = {
|
|
toggleActions: "play",
|
|
anticipatePin: 0
|
|
};
|
|
var _keywords = {
|
|
top: 0,
|
|
left: 0,
|
|
center: 0.5,
|
|
bottom: 1,
|
|
right: 1
|
|
};
|
|
var _offsetToPx = function _offsetToPx2(value, size) {
|
|
if (_isString(value)) {
|
|
var eqIndex = value.indexOf("="), relative = ~eqIndex ? +(value.charAt(eqIndex - 1) + 1) * parseFloat(value.substr(eqIndex + 1)) : 0;
|
|
if (~eqIndex) {
|
|
value.indexOf("%") > eqIndex && (relative *= size / 100);
|
|
value = value.substr(0, eqIndex - 1);
|
|
}
|
|
value = relative + (value in _keywords ? _keywords[value] * size : ~value.indexOf("%") ? parseFloat(value) * size / 100 : parseFloat(value) || 0);
|
|
}
|
|
return value;
|
|
};
|
|
var _createMarker = function _createMarker2(type, name, container, direction, _ref4, offset, matchWidthEl, containerAnimation) {
|
|
var startColor = _ref4.startColor, endColor = _ref4.endColor, fontSize = _ref4.fontSize, indent = _ref4.indent, fontWeight = _ref4.fontWeight;
|
|
var e = _doc2.createElement("div"), useFixedPosition = _isViewport3(container) || _getProxyProp(container, "pinType") === "fixed", isScroller = type.indexOf("scroller") !== -1, parent = useFixedPosition ? _body2 : container.tagName === "IFRAME" ? container.contentDocument.body : container, isStart = type.indexOf("start") !== -1, color = isStart ? startColor : endColor, css = "border-color:" + color + ";font-size:" + fontSize + ";color:" + color + ";font-weight:" + fontWeight + ";pointer-events:none;white-space:nowrap;font-family:sans-serif,Arial;z-index:1000;padding:4px 8px;border-width:0;border-style:solid;";
|
|
css += "position:" + ((isScroller || containerAnimation) && useFixedPosition ? "fixed;" : "absolute;");
|
|
(isScroller || containerAnimation || !useFixedPosition) && (css += (direction === _vertical ? _right : _bottom) + ":" + (offset + parseFloat(indent)) + "px;");
|
|
matchWidthEl && (css += "box-sizing:border-box;text-align:left;width:" + matchWidthEl.offsetWidth + "px;");
|
|
e._isStart = isStart;
|
|
e.setAttribute("class", "gsap-marker-" + type + (name ? " marker-" + name : ""));
|
|
e.style.cssText = css;
|
|
e.innerText = name || name === 0 ? type + "-" + name : type;
|
|
parent.children[0] ? parent.insertBefore(e, parent.children[0]) : parent.appendChild(e);
|
|
e._offset = e["offset" + direction.op.d2];
|
|
_positionMarker(e, 0, direction, isStart);
|
|
return e;
|
|
};
|
|
var _positionMarker = function _positionMarker2(marker, start, direction, flipped) {
|
|
var vars = {
|
|
display: "block"
|
|
}, side = direction[flipped ? "os2" : "p2"], oppositeSide = direction[flipped ? "p2" : "os2"];
|
|
marker._isFlipped = flipped;
|
|
vars[direction.a + "Percent"] = flipped ? -100 : 0;
|
|
vars[direction.a] = flipped ? "1px" : 0;
|
|
vars["border" + side + _Width] = 1;
|
|
vars["border" + oppositeSide + _Width] = 0;
|
|
vars[direction.p] = start + "px";
|
|
gsap2.set(marker, vars);
|
|
};
|
|
var _triggers = [];
|
|
var _ids = {};
|
|
var _rafID;
|
|
var _sync = function _sync2() {
|
|
return _getTime2() - _lastScrollTime > 34 && (_rafID || (_rafID = requestAnimationFrame(_updateAll)));
|
|
};
|
|
var _onScroll3 = function _onScroll4() {
|
|
if (!_normalizer2 || !_normalizer2.isPressed || _normalizer2.startX > _body2.clientWidth) {
|
|
_scrollers.cache++;
|
|
if (_normalizer2) {
|
|
_rafID || (_rafID = requestAnimationFrame(_updateAll));
|
|
} else {
|
|
_updateAll();
|
|
}
|
|
_lastScrollTime || _dispatch("scrollStart");
|
|
_lastScrollTime = _getTime2();
|
|
}
|
|
};
|
|
var _setBaseDimensions = function _setBaseDimensions2() {
|
|
_baseScreenWidth = _win2.innerWidth;
|
|
_baseScreenHeight = _win2.innerHeight;
|
|
};
|
|
var _onResize = function _onResize2(force) {
|
|
_scrollers.cache++;
|
|
(force === true || !_refreshing && !_ignoreResize && !_doc2.fullscreenElement && !_doc2.webkitFullscreenElement && (!_ignoreMobileResize || _baseScreenWidth !== _win2.innerWidth || Math.abs(_win2.innerHeight - _baseScreenHeight) > _win2.innerHeight * 0.25)) && _resizeDelay.restart(true);
|
|
};
|
|
var _listeners = {};
|
|
var _emptyArray = [];
|
|
var _softRefresh = function _softRefresh2() {
|
|
return _removeListener3(ScrollTrigger2, "scrollEnd", _softRefresh2) || _refreshAll(true);
|
|
};
|
|
var _dispatch = function _dispatch2(type) {
|
|
return _listeners[type] && _listeners[type].map(function(f) {
|
|
return f();
|
|
}) || _emptyArray;
|
|
};
|
|
var _savedStyles = [];
|
|
var _revertRecorded = function _revertRecorded2(media) {
|
|
for (var i = 0; i < _savedStyles.length; i += 5) {
|
|
if (!media || _savedStyles[i + 4] && _savedStyles[i + 4].query === media) {
|
|
_savedStyles[i].style.cssText = _savedStyles[i + 1];
|
|
_savedStyles[i].getBBox && _savedStyles[i].setAttribute("transform", _savedStyles[i + 2] || "");
|
|
_savedStyles[i + 3].uncache = 1;
|
|
}
|
|
}
|
|
};
|
|
var _recordScrollPositions = function _recordScrollPositions2() {
|
|
return _scrollers.forEach(function(obj) {
|
|
return _isFunction(obj) && ++obj.cacheID && (obj.rec = obj());
|
|
});
|
|
};
|
|
var _revertAll = function _revertAll2(kill, media) {
|
|
var trigger;
|
|
for (_i = 0; _i < _triggers.length; _i++) {
|
|
trigger = _triggers[_i];
|
|
if (trigger && (!media || trigger._ctx === media)) {
|
|
if (kill) {
|
|
trigger.kill(1);
|
|
} else {
|
|
trigger.revert(true, true);
|
|
}
|
|
}
|
|
}
|
|
_isReverted = true;
|
|
media && _revertRecorded(media);
|
|
media || _dispatch("revert");
|
|
};
|
|
var _clearScrollMemory = function _clearScrollMemory2(scrollRestoration, force) {
|
|
_scrollers.cache++;
|
|
(force || !_refreshingAll) && _scrollers.forEach(function(obj) {
|
|
return _isFunction(obj) && obj.cacheID++ && (obj.rec = 0);
|
|
});
|
|
_isString(scrollRestoration) && (_win2.history.scrollRestoration = _scrollRestoration = scrollRestoration);
|
|
};
|
|
var _refreshingAll;
|
|
var _refreshID = 0;
|
|
var _queueRefreshID;
|
|
var _queueRefreshAll = function _queueRefreshAll2() {
|
|
if (_queueRefreshID !== _refreshID) {
|
|
var id = _queueRefreshID = _refreshID;
|
|
requestAnimationFrame(function() {
|
|
return id === _refreshID && _refreshAll(true);
|
|
});
|
|
}
|
|
};
|
|
var _refresh100vh = function _refresh100vh2() {
|
|
_body2.appendChild(_div100vh);
|
|
_100vh = !_normalizer2 && _div100vh.offsetHeight || _win2.innerHeight;
|
|
_body2.removeChild(_div100vh);
|
|
};
|
|
var _hideAllMarkers = function _hideAllMarkers2(hide) {
|
|
return _toArray(".gsap-marker-start, .gsap-marker-end, .gsap-marker-scroller-start, .gsap-marker-scroller-end").forEach(function(el) {
|
|
return el.style.display = hide ? "none" : "block";
|
|
});
|
|
};
|
|
var _refreshAll = function _refreshAll2(force, skipRevert) {
|
|
_docEl2 = _doc2.documentElement;
|
|
_body2 = _doc2.body;
|
|
_root2 = [_win2, _doc2, _docEl2, _body2];
|
|
if (_lastScrollTime && !force && !_isReverted) {
|
|
_addListener3(ScrollTrigger2, "scrollEnd", _softRefresh);
|
|
return;
|
|
}
|
|
_refresh100vh();
|
|
_refreshingAll = ScrollTrigger2.isRefreshing = true;
|
|
_isReverted || _recordScrollPositions();
|
|
var refreshInits = _dispatch("refreshInit");
|
|
_sort && ScrollTrigger2.sort();
|
|
skipRevert || _revertAll();
|
|
_scrollers.forEach(function(obj) {
|
|
if (_isFunction(obj)) {
|
|
obj.smooth && (obj.target.style.scrollBehavior = "auto");
|
|
obj(0);
|
|
}
|
|
});
|
|
_triggers.slice(0).forEach(function(t) {
|
|
return t.refresh();
|
|
});
|
|
_isReverted = false;
|
|
_triggers.forEach(function(t) {
|
|
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.refresh();
|
|
}
|
|
});
|
|
_clampingMax = 1;
|
|
_hideAllMarkers(true);
|
|
_triggers.forEach(function(t) {
|
|
var max = _maxScroll(t.scroller, t._dir), endClamp = t.vars.end === "max" || t._endClamp && t.end > max, startClamp = t._startClamp && t.start >= max;
|
|
(endClamp || startClamp) && t.setPositions(startClamp ? max - 1 : t.start, endClamp ? Math.max(startClamp ? max : t.start + 1, max) : t.end, true);
|
|
});
|
|
_hideAllMarkers(false);
|
|
_clampingMax = 0;
|
|
refreshInits.forEach(function(result) {
|
|
return result && result.render && result.render(-1);
|
|
});
|
|
_scrollers.forEach(function(obj) {
|
|
if (_isFunction(obj)) {
|
|
obj.smooth && requestAnimationFrame(function() {
|
|
return obj.target.style.scrollBehavior = "smooth";
|
|
});
|
|
obj.rec && obj(obj.rec);
|
|
}
|
|
});
|
|
_clearScrollMemory(_scrollRestoration, 1);
|
|
_resizeDelay.pause();
|
|
_refreshID++;
|
|
_refreshingAll = 2;
|
|
_updateAll(2);
|
|
_triggers.forEach(function(t) {
|
|
return _isFunction(t.vars.onRefresh) && t.vars.onRefresh(t);
|
|
});
|
|
_refreshingAll = ScrollTrigger2.isRefreshing = false;
|
|
_dispatch("refresh");
|
|
};
|
|
var _lastScroll = 0;
|
|
var _direction = 1;
|
|
var _primary;
|
|
var _updateAll = function _updateAll2(force) {
|
|
if (force === 2 || !_refreshingAll && !_isReverted) {
|
|
ScrollTrigger2.isUpdating = true;
|
|
_primary && _primary.update(0);
|
|
var l = _triggers.length, time = _getTime2(), recordVelocity = time - _time1 >= 50, scroll = l && _triggers[0].scroll();
|
|
_direction = _lastScroll > scroll ? -1 : 1;
|
|
_refreshingAll || (_lastScroll = scroll);
|
|
if (recordVelocity) {
|
|
if (_lastScrollTime && !_pointerIsDown && time - _lastScrollTime > 200) {
|
|
_lastScrollTime = 0;
|
|
_dispatch("scrollEnd");
|
|
}
|
|
_time2 = _time1;
|
|
_time1 = time;
|
|
}
|
|
if (_direction < 0) {
|
|
_i = l;
|
|
while (_i-- > 0) {
|
|
_triggers[_i] && _triggers[_i].update(0, recordVelocity);
|
|
}
|
|
_direction = 1;
|
|
} else {
|
|
for (_i = 0; _i < l; _i++) {
|
|
_triggers[_i] && _triggers[_i].update(0, recordVelocity);
|
|
}
|
|
}
|
|
ScrollTrigger2.isUpdating = false;
|
|
}
|
|
_rafID = 0;
|
|
};
|
|
var _propNamesToCopy = [_left, _top, _bottom, _right, _margin + _Bottom, _margin + _Right, _margin + _Top, _margin + _Left, "display", "flexShrink", "float", "zIndex", "gridColumnStart", "gridColumnEnd", "gridRowStart", "gridRowEnd", "gridArea", "justifySelf", "alignSelf", "placeSelf", "order"];
|
|
var _stateProps = _propNamesToCopy.concat([_width, _height, "boxSizing", "max" + _Width, "max" + _Height, "position", _margin, _padding, _padding + _Top, _padding + _Right, _padding + _Bottom, _padding + _Left]);
|
|
var _swapPinOut = function _swapPinOut2(pin, spacer, state) {
|
|
_setState(state);
|
|
var cache = pin._gsap;
|
|
if (cache.spacerIsNative) {
|
|
_setState(cache.spacerState);
|
|
} else if (pin._gsap.swappedIn) {
|
|
var parent = spacer.parentNode;
|
|
if (parent) {
|
|
parent.insertBefore(pin, spacer);
|
|
parent.removeChild(spacer);
|
|
}
|
|
}
|
|
pin._gsap.swappedIn = false;
|
|
};
|
|
var _swapPinIn = function _swapPinIn2(pin, spacer, cs, spacerState) {
|
|
if (!pin._gsap.swappedIn) {
|
|
var i = _propNamesToCopy.length, spacerStyle = spacer.style, pinStyle = pin.style, p;
|
|
while (i--) {
|
|
p = _propNamesToCopy[i];
|
|
spacerStyle[p] = cs[p];
|
|
}
|
|
spacerStyle.position = cs.position === "absolute" ? "absolute" : "relative";
|
|
cs.display === "inline" && (spacerStyle.display = "inline-block");
|
|
pinStyle[_bottom] = pinStyle[_right] = "auto";
|
|
spacerStyle.flexBasis = cs.flexBasis || "auto";
|
|
spacerStyle.overflow = "visible";
|
|
spacerStyle.boxSizing = "border-box";
|
|
spacerStyle[_width] = _getSize(pin, _horizontal) + _px;
|
|
spacerStyle[_height] = _getSize(pin, _vertical) + _px;
|
|
spacerStyle[_padding] = pinStyle[_margin] = pinStyle[_top] = pinStyle[_left] = "0";
|
|
_setState(spacerState);
|
|
pinStyle[_width] = pinStyle["max" + _Width] = cs[_width];
|
|
pinStyle[_height] = pinStyle["max" + _Height] = cs[_height];
|
|
pinStyle[_padding] = cs[_padding];
|
|
if (pin.parentNode !== spacer) {
|
|
pin.parentNode.insertBefore(spacer, pin);
|
|
spacer.appendChild(pin);
|
|
}
|
|
pin._gsap.swappedIn = true;
|
|
}
|
|
};
|
|
var _capsExp = /([A-Z])/g;
|
|
var _setState = function _setState2(state) {
|
|
if (state) {
|
|
var style = state.t.style, l = state.length, i = 0, p, value;
|
|
(state.t._gsap || gsap2.core.getCache(state.t)).uncache = 1;
|
|
for (; i < l; i += 2) {
|
|
value = state[i + 1];
|
|
p = state[i];
|
|
if (value) {
|
|
style[p] = value;
|
|
} else if (style[p]) {
|
|
style.removeProperty(p.replace(_capsExp, "-$1").toLowerCase());
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var _getState = function _getState2(element) {
|
|
var l = _stateProps.length, style = element.style, state = [], i = 0;
|
|
for (; i < l; i++) {
|
|
state.push(_stateProps[i], style[_stateProps[i]]);
|
|
}
|
|
state.t = element;
|
|
return state;
|
|
};
|
|
var _copyState = function _copyState2(state, override, omitOffsets) {
|
|
var result = [], l = state.length, i = omitOffsets ? 8 : 0, p;
|
|
for (; i < l; i += 2) {
|
|
p = state[i];
|
|
result.push(p, p in override ? override[p] : state[i + 1]);
|
|
}
|
|
result.t = state.t;
|
|
return result;
|
|
};
|
|
var _winOffsets = {
|
|
left: 0,
|
|
top: 0
|
|
};
|
|
var _parsePosition = function _parsePosition2(value, trigger, scrollerSize, direction, scroll, marker, markerScroller, self, scrollerBounds, borderWidth, useFixedPosition, scrollerMax, containerAnimation, clampZeroProp) {
|
|
_isFunction(value) && (value = value(self));
|
|
if (_isString(value) && value.substr(0, 3) === "max") {
|
|
value = scrollerMax + (value.charAt(4) === "=" ? _offsetToPx("0" + value.substr(3), scrollerSize) : 0);
|
|
}
|
|
var time = containerAnimation ? containerAnimation.time() : 0, p1, p2, element;
|
|
containerAnimation && containerAnimation.seek(0);
|
|
isNaN(value) || (value = +value);
|
|
if (!_isNumber(value)) {
|
|
_isFunction(trigger) && (trigger = trigger(self));
|
|
var offsets = (value || "0").split(" "), bounds, localOffset, globalOffset, display;
|
|
element = _getTarget(trigger, self) || _body2;
|
|
bounds = _getBounds(element) || {};
|
|
if ((!bounds || !bounds.left && !bounds.top) && _getComputedStyle(element).display === "none") {
|
|
display = element.style.display;
|
|
element.style.display = "block";
|
|
bounds = _getBounds(element);
|
|
display ? element.style.display = display : element.style.removeProperty("display");
|
|
}
|
|
localOffset = _offsetToPx(offsets[0], bounds[direction.d]);
|
|
globalOffset = _offsetToPx(offsets[1] || "0", scrollerSize);
|
|
value = bounds[direction.p] - scrollerBounds[direction.p] - borderWidth + localOffset + scroll - globalOffset;
|
|
markerScroller && _positionMarker(markerScroller, globalOffset, direction, scrollerSize - globalOffset < 20 || markerScroller._isStart && globalOffset > 20);
|
|
scrollerSize -= scrollerSize - globalOffset;
|
|
} else {
|
|
containerAnimation && (value = gsap2.utils.mapRange(containerAnimation.scrollTrigger.start, containerAnimation.scrollTrigger.end, 0, scrollerMax, value));
|
|
markerScroller && _positionMarker(markerScroller, scrollerSize, direction, true);
|
|
}
|
|
if (clampZeroProp) {
|
|
self[clampZeroProp] = value || -1e-3;
|
|
value < 0 && (value = 0);
|
|
}
|
|
if (marker) {
|
|
var position = value + scrollerSize, isStart = marker._isStart;
|
|
p1 = "scroll" + direction.d2;
|
|
_positionMarker(marker, position, direction, isStart && position > 20 || !isStart && (useFixedPosition ? Math.max(_body2[p1], _docEl2[p1]) : marker.parentNode[p1]) <= position + 1);
|
|
if (useFixedPosition) {
|
|
scrollerBounds = _getBounds(markerScroller);
|
|
useFixedPosition && (marker.style[direction.op.p] = scrollerBounds[direction.op.p] - direction.op.m - marker._offset + _px);
|
|
}
|
|
}
|
|
if (containerAnimation && element) {
|
|
p1 = _getBounds(element);
|
|
containerAnimation.seek(scrollerMax);
|
|
p2 = _getBounds(element);
|
|
containerAnimation._caScrollDist = p1[direction.p] - p2[direction.p];
|
|
value = value / containerAnimation._caScrollDist * scrollerMax;
|
|
}
|
|
containerAnimation && containerAnimation.seek(time);
|
|
return containerAnimation ? value : Math.round(value);
|
|
};
|
|
var _prefixExp = /(webkit|moz|length|cssText|inset)/i;
|
|
var _reparent = function _reparent2(element, parent, top, left) {
|
|
if (element.parentNode !== parent) {
|
|
var style = element.style, p, cs;
|
|
if (parent === _body2) {
|
|
element._stOrig = style.cssText;
|
|
cs = _getComputedStyle(element);
|
|
for (p in cs) {
|
|
if (!+p && !_prefixExp.test(p) && cs[p] && typeof style[p] === "string" && p !== "0") {
|
|
style[p] = cs[p];
|
|
}
|
|
}
|
|
style.top = top;
|
|
style.left = left;
|
|
} else {
|
|
style.cssText = element._stOrig;
|
|
}
|
|
gsap2.core.getCache(element).uncache = 1;
|
|
parent.appendChild(element);
|
|
}
|
|
};
|
|
var _interruptionTracker = function _interruptionTracker2(getValueFunc, initialValue, onInterrupt) {
|
|
var last1 = initialValue, last2 = last1;
|
|
return function(value) {
|
|
var current = Math.round(getValueFunc());
|
|
if (current !== last1 && current !== last2 && Math.abs(current - last1) > 3 && Math.abs(current - last2) > 3) {
|
|
value = current;
|
|
onInterrupt && onInterrupt();
|
|
}
|
|
last2 = last1;
|
|
last1 = Math.round(value);
|
|
return last1;
|
|
};
|
|
};
|
|
var _shiftMarker = function _shiftMarker2(marker, direction, value) {
|
|
var vars = {};
|
|
vars[direction.p] = "+=" + value;
|
|
gsap2.set(marker, vars);
|
|
};
|
|
var _getTweenCreator = function _getTweenCreator2(scroller, direction) {
|
|
var getScroll = _getScrollFunc(scroller, direction), prop = "_scroll" + direction.p2, getTween = function getTween2(scrollTo, vars, initialValue, change1, change2) {
|
|
var tween = getTween2.tween, onComplete = vars.onComplete, modifiers = {};
|
|
initialValue = initialValue || getScroll();
|
|
var checkForInterruption = _interruptionTracker(getScroll, initialValue, function() {
|
|
tween.kill();
|
|
getTween2.tween = 0;
|
|
});
|
|
change2 = change1 && change2 || 0;
|
|
change1 = change1 || scrollTo - initialValue;
|
|
tween && tween.kill();
|
|
vars[prop] = scrollTo;
|
|
vars.inherit = false;
|
|
vars.modifiers = modifiers;
|
|
modifiers[prop] = function() {
|
|
return checkForInterruption(initialValue + change1 * tween.ratio + change2 * tween.ratio * tween.ratio);
|
|
};
|
|
vars.onUpdate = function() {
|
|
_scrollers.cache++;
|
|
getTween2.tween && _updateAll();
|
|
};
|
|
vars.onComplete = function() {
|
|
getTween2.tween = 0;
|
|
onComplete && onComplete.call(tween);
|
|
};
|
|
tween = getTween2.tween = gsap2.to(scroller, vars);
|
|
return tween;
|
|
};
|
|
scroller[prop] = getScroll;
|
|
getScroll.wheelHandler = function() {
|
|
return getTween.tween && getTween.tween.kill() && (getTween.tween = 0);
|
|
};
|
|
_addListener3(scroller, "wheel", getScroll.wheelHandler);
|
|
ScrollTrigger2.isTouch && _addListener3(scroller, "touchmove", getScroll.wheelHandler);
|
|
return getTween;
|
|
};
|
|
var ScrollTrigger2 = (function() {
|
|
function ScrollTrigger3(vars, animation) {
|
|
_coreInitted2 || ScrollTrigger3.register(gsap2) || console.warn("Please gsap.registerPlugin(ScrollTrigger)");
|
|
_context2(this);
|
|
this.init(vars, animation);
|
|
}
|
|
var _proto = ScrollTrigger3.prototype;
|
|
_proto.init = function init(vars, animation) {
|
|
this.progress = this.start = 0;
|
|
this.vars && this.kill(true, true);
|
|
if (!_enabled) {
|
|
this.update = this.refresh = this.kill = _passThrough;
|
|
return;
|
|
}
|
|
vars = _setDefaults(_isString(vars) || _isNumber(vars) || vars.nodeType ? {
|
|
trigger: vars
|
|
} : vars, _defaults);
|
|
var _vars = vars, onUpdate = _vars.onUpdate, toggleClass = _vars.toggleClass, id = _vars.id, onToggle = _vars.onToggle, onRefresh = _vars.onRefresh, scrub = _vars.scrub, trigger = _vars.trigger, pin = _vars.pin, pinSpacing = _vars.pinSpacing, invalidateOnRefresh = _vars.invalidateOnRefresh, anticipatePin = _vars.anticipatePin, onScrubComplete = _vars.onScrubComplete, onSnapComplete = _vars.onSnapComplete, once = _vars.once, snap = _vars.snap, pinReparent = _vars.pinReparent, pinSpacer = _vars.pinSpacer, containerAnimation = _vars.containerAnimation, fastScrollEnd = _vars.fastScrollEnd, preventOverlaps = _vars.preventOverlaps, direction = vars.horizontal || vars.containerAnimation && vars.horizontal !== false ? _horizontal : _vertical, isToggle = !scrub && scrub !== 0, scroller = _getTarget(vars.scroller || _win2), scrollerCache = gsap2.core.getCache(scroller), isViewport = _isViewport3(scroller), useFixedPosition = ("pinType" in vars ? vars.pinType : _getProxyProp(scroller, "pinType") || isViewport && "fixed") === "fixed", callbacks = [vars.onEnter, vars.onLeave, vars.onEnterBack, vars.onLeaveBack], toggleActions = isToggle && vars.toggleActions.split(" "), markers = "markers" in vars ? vars.markers : _defaults.markers, borderWidth = isViewport ? 0 : parseFloat(_getComputedStyle(scroller)["border" + direction.p2 + _Width]) || 0, self = this, onRefreshInit = vars.onRefreshInit && function() {
|
|
return vars.onRefreshInit(self);
|
|
}, getScrollerSize = _getSizeFunc(scroller, isViewport, direction), getScrollerOffsets = _getOffsetsFunc(scroller, isViewport), lastSnap = 0, lastRefresh = 0, prevProgress = 0, scrollFunc = _getScrollFunc(scroller, direction), tweenTo, pinCache, snapFunc, scroll1, scroll2, start, end, markerStart, markerEnd, markerStartTrigger, markerEndTrigger, markerVars, executingOnRefresh, change, pinOriginalState, pinActiveState, pinState, spacer, offset, pinGetter, pinSetter, pinStart, pinChange, spacingStart, spacerState, markerStartSetter, pinMoves, markerEndSetter, cs, snap1, snap2, scrubTween, scrubSmooth, snapDurClamp, snapDelayedCall, prevScroll, prevAnimProgress, caMarkerSetter, customRevertReturn;
|
|
self._startClamp = self._endClamp = false;
|
|
self._dir = direction;
|
|
anticipatePin *= 45;
|
|
self.scroller = scroller;
|
|
self.scroll = containerAnimation ? containerAnimation.time.bind(containerAnimation) : scrollFunc;
|
|
scroll1 = scrollFunc();
|
|
self.vars = vars;
|
|
animation = animation || vars.animation;
|
|
if ("refreshPriority" in vars) {
|
|
_sort = 1;
|
|
vars.refreshPriority === -9999 && (_primary = self);
|
|
}
|
|
scrollerCache.tweenScroll = scrollerCache.tweenScroll || {
|
|
top: _getTweenCreator(scroller, _vertical),
|
|
left: _getTweenCreator(scroller, _horizontal)
|
|
};
|
|
self.tweenTo = tweenTo = scrollerCache.tweenScroll[direction.p];
|
|
self.scrubDuration = function(value) {
|
|
scrubSmooth = _isNumber(value) && value;
|
|
if (!scrubSmooth) {
|
|
scrubTween && scrubTween.progress(1).kill();
|
|
scrubTween = 0;
|
|
} else {
|
|
scrubTween ? scrubTween.duration(value) : scrubTween = gsap2.to(animation, {
|
|
ease: "expo",
|
|
totalProgress: "+=0",
|
|
inherit: false,
|
|
duration: scrubSmooth,
|
|
paused: true,
|
|
onComplete: function onComplete() {
|
|
return onScrubComplete && onScrubComplete(self);
|
|
}
|
|
});
|
|
}
|
|
};
|
|
if (animation) {
|
|
animation.vars.lazy = false;
|
|
animation._initted && !self.isReverted || animation.vars.immediateRender !== false && vars.immediateRender !== false && animation.duration() && animation.render(0, true, true);
|
|
self.animation = animation.pause();
|
|
animation.scrollTrigger = self;
|
|
self.scrubDuration(scrub);
|
|
snap1 = 0;
|
|
id || (id = animation.vars.id);
|
|
}
|
|
if (snap) {
|
|
if (!_isObject(snap) || snap.push) {
|
|
snap = {
|
|
snapTo: snap
|
|
};
|
|
}
|
|
"scrollBehavior" in _body2.style && gsap2.set(isViewport ? [_body2, _docEl2] : scroller, {
|
|
scrollBehavior: "auto"
|
|
});
|
|
_scrollers.forEach(function(o) {
|
|
return _isFunction(o) && o.target === (isViewport ? _doc2.scrollingElement || _docEl2 : scroller) && (o.smooth = false);
|
|
});
|
|
snapFunc = _isFunction(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, _getTime2() - lastRefresh < 500 ? 0 : st.direction);
|
|
} : gsap2.utils.snap(snap.snapTo);
|
|
snapDurClamp = snap.duration || {
|
|
min: 0.1,
|
|
max: 2
|
|
};
|
|
snapDurClamp = _isObject(snapDurClamp) ? _clamp2(snapDurClamp.min, snapDurClamp.max) : _clamp2(snapDurClamp, snapDurClamp);
|
|
snapDelayedCall = gsap2.delayedCall(snap.delay || scrubSmooth / 2 || 0.1, function() {
|
|
var scroll = scrollFunc(), refreshedRecently = _getTime2() - lastRefresh < 500, tween = tweenTo.tween;
|
|
if ((refreshedRecently || Math.abs(self.getVelocity()) < 10) && !tween && !_pointerIsDown && lastSnap !== scroll) {
|
|
var progress = (scroll - start) / change, totalProgress = animation && !isToggle ? animation.totalProgress() : progress, velocity = refreshedRecently ? 0 : (totalProgress - snap2) / (_getTime2() - _time2) * 1e3 || 0, change1 = gsap2.utils.clamp(-progress, 1 - progress, _abs(velocity / 2) * velocity / 0.185), naturalEnd = progress + (snap.inertia === false ? 0 : change1), endValue, endScroll, _snap = snap, onStart = _snap.onStart, _onInterrupt = _snap.onInterrupt, _onComplete = _snap.onComplete;
|
|
endValue = snapFunc(naturalEnd, self);
|
|
_isNumber(endValue) || (endValue = naturalEnd);
|
|
endScroll = Math.max(0, Math.round(start + endValue * change));
|
|
if (scroll <= end && scroll >= start && endScroll !== scroll) {
|
|
if (tween && !tween._initted && tween.data <= _abs(endScroll - scroll)) {
|
|
return;
|
|
}
|
|
if (snap.inertia === false) {
|
|
change1 = endValue - progress;
|
|
}
|
|
tweenTo(endScroll, {
|
|
duration: snapDurClamp(_abs(Math.max(_abs(naturalEnd - totalProgress), _abs(endValue - totalProgress)) * 0.185 / velocity / 0.05 || 0)),
|
|
ease: snap.ease || "power3",
|
|
data: _abs(endScroll - scroll),
|
|
// record the distance so that if another snap tween occurs (conflict) we can prioritize the closest snap.
|
|
onInterrupt: function onInterrupt() {
|
|
return snapDelayedCall.restart(true) && _onInterrupt && _callback(self, _onInterrupt);
|
|
},
|
|
onComplete: function onComplete() {
|
|
self.update();
|
|
lastSnap = scrollFunc();
|
|
if (animation && !isToggle) {
|
|
scrubTween ? scrubTween.resetTo("totalProgress", endValue, animation._tTime / animation._tDur) : animation.progress(endValue);
|
|
}
|
|
snap1 = snap2 = animation && !isToggle ? animation.totalProgress() : self.progress;
|
|
onSnapComplete && onSnapComplete(self);
|
|
_onComplete && _callback(self, _onComplete);
|
|
}
|
|
}, scroll, change1 * change, endScroll - scroll - change1 * change);
|
|
onStart && _callback(self, onStart, tweenTo.tween);
|
|
}
|
|
} else if (self.isActive && lastSnap !== scroll) {
|
|
snapDelayedCall.restart(true);
|
|
}
|
|
}).pause();
|
|
}
|
|
id && (_ids[id] = self);
|
|
trigger = self.trigger = _getTarget(trigger || pin !== true && pin);
|
|
customRevertReturn = trigger && trigger._gsap && trigger._gsap.stRevert;
|
|
customRevertReturn && (customRevertReturn = customRevertReturn(self));
|
|
pin = pin === true ? trigger : _getTarget(pin);
|
|
_isString(toggleClass) && (toggleClass = {
|
|
targets: trigger,
|
|
className: toggleClass
|
|
});
|
|
if (pin) {
|
|
pinSpacing === false || pinSpacing === _margin || (pinSpacing = !pinSpacing && pin.parentNode && pin.parentNode.style && _getComputedStyle(pin.parentNode).display === "flex" ? false : _padding);
|
|
self.pin = pin;
|
|
pinCache = gsap2.core.getCache(pin);
|
|
if (!pinCache.spacer) {
|
|
if (pinSpacer) {
|
|
pinSpacer = _getTarget(pinSpacer);
|
|
pinSpacer && !pinSpacer.nodeType && (pinSpacer = pinSpacer.current || pinSpacer.nativeElement);
|
|
pinCache.spacerIsNative = !!pinSpacer;
|
|
pinSpacer && (pinCache.spacerState = _getState(pinSpacer));
|
|
}
|
|
pinCache.spacer = spacer = pinSpacer || _doc2.createElement("div");
|
|
spacer.classList.add("pin-spacer");
|
|
id && spacer.classList.add("pin-spacer-" + id);
|
|
pinCache.pinState = pinOriginalState = _getState(pin);
|
|
} else {
|
|
pinOriginalState = pinCache.pinState;
|
|
}
|
|
vars.force3D !== false && gsap2.set(pin, {
|
|
force3D: true
|
|
});
|
|
self.spacer = spacer = pinCache.spacer;
|
|
cs = _getComputedStyle(pin);
|
|
spacingStart = cs[pinSpacing + direction.os2];
|
|
pinGetter = gsap2.getProperty(pin);
|
|
pinSetter = gsap2.quickSetter(pin, direction.a, _px);
|
|
_swapPinIn(pin, spacer, cs);
|
|
pinState = _getState(pin);
|
|
}
|
|
if (markers) {
|
|
markerVars = _isObject(markers) ? _setDefaults(markers, _markerDefaults) : _markerDefaults;
|
|
markerStartTrigger = _createMarker("scroller-start", id, scroller, direction, markerVars, 0);
|
|
markerEndTrigger = _createMarker("scroller-end", id, scroller, direction, markerVars, 0, markerStartTrigger);
|
|
offset = markerStartTrigger["offset" + direction.op.d2];
|
|
var content = _getTarget(_getProxyProp(scroller, "content") || scroller);
|
|
markerStart = this.markerStart = _createMarker("start", id, content, direction, markerVars, offset, 0, containerAnimation);
|
|
markerEnd = this.markerEnd = _createMarker("end", id, content, direction, markerVars, offset, 0, containerAnimation);
|
|
containerAnimation && (caMarkerSetter = gsap2.quickSetter([markerStart, markerEnd], direction.a, _px));
|
|
if (!useFixedPosition && !(_proxies.length && _getProxyProp(scroller, "fixedMarkers") === true)) {
|
|
_makePositionable(isViewport ? _body2 : scroller);
|
|
gsap2.set([markerStartTrigger, markerEndTrigger], {
|
|
force3D: true
|
|
});
|
|
markerStartSetter = gsap2.quickSetter(markerStartTrigger, direction.a, _px);
|
|
markerEndSetter = gsap2.quickSetter(markerEndTrigger, direction.a, _px);
|
|
}
|
|
}
|
|
if (containerAnimation) {
|
|
var oldOnUpdate = containerAnimation.vars.onUpdate, oldParams = containerAnimation.vars.onUpdateParams;
|
|
containerAnimation.eventCallback("onUpdate", function() {
|
|
self.update(0, 0, 1);
|
|
oldOnUpdate && oldOnUpdate.apply(containerAnimation, oldParams || []);
|
|
});
|
|
}
|
|
self.previous = function() {
|
|
return _triggers[_triggers.indexOf(self) - 1];
|
|
};
|
|
self.next = function() {
|
|
return _triggers[_triggers.indexOf(self) + 1];
|
|
};
|
|
self.revert = function(revert, temp) {
|
|
if (!temp) {
|
|
return self.kill(true);
|
|
}
|
|
var r = revert !== false || !self.enabled, prevRefreshing = _refreshing;
|
|
if (r !== self.isReverted) {
|
|
if (r) {
|
|
prevScroll = Math.max(scrollFunc(), self.scroll.rec || 0);
|
|
prevProgress = self.progress;
|
|
prevAnimProgress = animation && animation.progress();
|
|
}
|
|
markerStart && [markerStart, markerEnd, markerStartTrigger, markerEndTrigger].forEach(function(m) {
|
|
return m.style.display = r ? "none" : "block";
|
|
});
|
|
if (r) {
|
|
_refreshing = self;
|
|
self.update(r);
|
|
}
|
|
if (pin && (!pinReparent || !self.isActive)) {
|
|
if (r) {
|
|
_swapPinOut(pin, spacer, pinOriginalState);
|
|
} else {
|
|
_swapPinIn(pin, spacer, _getComputedStyle(pin), spacerState);
|
|
}
|
|
}
|
|
r || self.update(r);
|
|
_refreshing = prevRefreshing;
|
|
self.isReverted = r;
|
|
}
|
|
};
|
|
self.refresh = function(soft, force, position, pinOffset) {
|
|
if ((_refreshing || !self.enabled) && !force) {
|
|
return;
|
|
}
|
|
if (pin && soft && _lastScrollTime) {
|
|
_addListener3(ScrollTrigger3, "scrollEnd", _softRefresh);
|
|
return;
|
|
}
|
|
!_refreshingAll && onRefreshInit && onRefreshInit(self);
|
|
_refreshing = self;
|
|
if (tweenTo.tween && !position) {
|
|
tweenTo.tween.kill();
|
|
tweenTo.tween = 0;
|
|
}
|
|
scrubTween && scrubTween.pause();
|
|
if (invalidateOnRefresh && animation) {
|
|
animation.revert({
|
|
kill: false
|
|
}).invalidate();
|
|
animation.getChildren ? animation.getChildren(true, true, false).forEach(function(t) {
|
|
return t.vars.immediateRender && t.render(0, true, true);
|
|
}) : animation.vars.immediateRender && animation.render(0, true, true);
|
|
}
|
|
self.isReverted || self.revert(true, true);
|
|
self._subPinOffset = false;
|
|
var size = getScrollerSize(), scrollerBounds = getScrollerOffsets(), max = containerAnimation ? containerAnimation.duration() : _maxScroll(scroller, direction), isFirstRefresh = change <= 0.01 || !change, offset2 = 0, otherPinOffset = pinOffset || 0, parsedEnd = _isObject(position) ? position.end : vars.end, parsedEndTrigger = vars.endTrigger || trigger, parsedStart = _isObject(position) ? position.start : vars.start || (vars.start === 0 || !trigger ? 0 : pin ? "0 0" : "0 100%"), pinnedContainer = self.pinnedContainer = vars.pinnedContainer && _getTarget(vars.pinnedContainer, self), triggerIndex = trigger && Math.max(0, _triggers.indexOf(self)) || 0, i = triggerIndex, cs2, bounds, scroll, isVertical, override, curTrigger, curPin, oppositeScroll, initted, revertedPins, forcedOverflow, markerStartOffset, markerEndOffset;
|
|
if (markers && _isObject(position)) {
|
|
markerStartOffset = gsap2.getProperty(markerStartTrigger, direction.p);
|
|
markerEndOffset = gsap2.getProperty(markerEndTrigger, direction.p);
|
|
}
|
|
while (i-- > 0) {
|
|
curTrigger = _triggers[i];
|
|
curTrigger.end || curTrigger.refresh(0, 1) || (_refreshing = self);
|
|
curPin = curTrigger.pin;
|
|
if (curPin && (curPin === trigger || curPin === pin || curPin === pinnedContainer) && !curTrigger.isReverted) {
|
|
revertedPins || (revertedPins = []);
|
|
revertedPins.unshift(curTrigger);
|
|
curTrigger.revert(true, true);
|
|
}
|
|
if (curTrigger !== _triggers[i]) {
|
|
triggerIndex--;
|
|
i--;
|
|
}
|
|
}
|
|
_isFunction(parsedStart) && (parsedStart = parsedStart(self));
|
|
parsedStart = _parseClamp(parsedStart, "start", self);
|
|
start = _parsePosition(parsedStart, trigger, size, direction, scrollFunc(), markerStart, markerStartTrigger, self, scrollerBounds, borderWidth, useFixedPosition, max, containerAnimation, self._startClamp && "_startClamp") || (pin ? -1e-3 : 0);
|
|
_isFunction(parsedEnd) && (parsedEnd = parsedEnd(self));
|
|
if (_isString(parsedEnd) && !parsedEnd.indexOf("+=")) {
|
|
if (~parsedEnd.indexOf(" ")) {
|
|
parsedEnd = (_isString(parsedStart) ? parsedStart.split(" ")[0] : "") + parsedEnd;
|
|
} else {
|
|
offset2 = _offsetToPx(parsedEnd.substr(2), size);
|
|
parsedEnd = _isString(parsedStart) ? parsedStart : (containerAnimation ? gsap2.utils.mapRange(0, containerAnimation.duration(), containerAnimation.scrollTrigger.start, containerAnimation.scrollTrigger.end, start) : start) + offset2;
|
|
parsedEndTrigger = trigger;
|
|
}
|
|
}
|
|
parsedEnd = _parseClamp(parsedEnd, "end", self);
|
|
end = Math.max(start, _parsePosition(parsedEnd || (parsedEndTrigger ? "100% 0" : max), parsedEndTrigger, size, direction, scrollFunc() + offset2, markerEnd, markerEndTrigger, self, scrollerBounds, borderWidth, useFixedPosition, max, containerAnimation, self._endClamp && "_endClamp")) || -1e-3;
|
|
offset2 = 0;
|
|
i = triggerIndex;
|
|
while (i--) {
|
|
curTrigger = _triggers[i] || {};
|
|
curPin = curTrigger.pin;
|
|
if (curPin && curTrigger.start - curTrigger._pinPush <= start && !containerAnimation && curTrigger.end > 0) {
|
|
cs2 = curTrigger.end - (self._startClamp ? Math.max(0, curTrigger.start) : curTrigger.start);
|
|
if ((curPin === trigger && curTrigger.start - curTrigger._pinPush < start || curPin === pinnedContainer) && isNaN(parsedStart)) {
|
|
offset2 += cs2 * (1 - curTrigger.progress);
|
|
}
|
|
curPin === pin && (otherPinOffset += cs2);
|
|
}
|
|
}
|
|
start += offset2;
|
|
end += offset2;
|
|
self._startClamp && (self._startClamp += offset2);
|
|
if (self._endClamp && !_refreshingAll) {
|
|
self._endClamp = end || -1e-3;
|
|
end = Math.min(end, _maxScroll(scroller, direction));
|
|
}
|
|
change = end - start || (start -= 0.01) && 1e-3;
|
|
if (isFirstRefresh) {
|
|
prevProgress = gsap2.utils.clamp(0, 1, gsap2.utils.normalize(start, end, prevScroll));
|
|
}
|
|
self._pinPush = otherPinOffset;
|
|
if (markerStart && offset2) {
|
|
cs2 = {};
|
|
cs2[direction.a] = "+=" + offset2;
|
|
pinnedContainer && (cs2[direction.p] = "-=" + scrollFunc());
|
|
gsap2.set([markerStart, markerEnd], cs2);
|
|
}
|
|
if (pin && !(_clampingMax && self.end >= _maxScroll(scroller, direction))) {
|
|
cs2 = _getComputedStyle(pin);
|
|
isVertical = direction === _vertical;
|
|
scroll = scrollFunc();
|
|
pinStart = parseFloat(pinGetter(direction.a)) + otherPinOffset;
|
|
if (!max && end > 1) {
|
|
forcedOverflow = (isViewport ? _doc2.scrollingElement || _docEl2 : scroller).style;
|
|
forcedOverflow = {
|
|
style: forcedOverflow,
|
|
value: forcedOverflow["overflow" + direction.a.toUpperCase()]
|
|
};
|
|
if (isViewport && _getComputedStyle(_body2)["overflow" + direction.a.toUpperCase()] !== "scroll") {
|
|
forcedOverflow.style["overflow" + direction.a.toUpperCase()] = "scroll";
|
|
}
|
|
}
|
|
_swapPinIn(pin, spacer, cs2);
|
|
pinState = _getState(pin);
|
|
bounds = _getBounds(pin, true);
|
|
oppositeScroll = useFixedPosition && _getScrollFunc(scroller, isVertical ? _horizontal : _vertical)();
|
|
if (pinSpacing) {
|
|
spacerState = [pinSpacing + direction.os2, change + otherPinOffset + _px];
|
|
spacerState.t = spacer;
|
|
i = pinSpacing === _padding ? _getSize(pin, direction) + change + otherPinOffset : 0;
|
|
if (i) {
|
|
spacerState.push(direction.d, i + _px);
|
|
spacer.style.flexBasis !== "auto" && (spacer.style.flexBasis = i + _px);
|
|
}
|
|
_setState(spacerState);
|
|
if (pinnedContainer) {
|
|
_triggers.forEach(function(t) {
|
|
if (t.pin === pinnedContainer && t.vars.pinSpacing !== false) {
|
|
t._subPinOffset = true;
|
|
}
|
|
});
|
|
}
|
|
useFixedPosition && scrollFunc(prevScroll);
|
|
} else {
|
|
i = _getSize(pin, direction);
|
|
i && spacer.style.flexBasis !== "auto" && (spacer.style.flexBasis = i + _px);
|
|
}
|
|
if (useFixedPosition) {
|
|
override = {
|
|
top: bounds.top + (isVertical ? scroll - start : oppositeScroll) + _px,
|
|
left: bounds.left + (isVertical ? oppositeScroll : scroll - start) + _px,
|
|
boxSizing: "border-box",
|
|
position: "fixed"
|
|
};
|
|
override[_width] = override["max" + _Width] = Math.ceil(bounds.width) + _px;
|
|
override[_height] = override["max" + _Height] = Math.ceil(bounds.height) + _px;
|
|
override[_margin] = override[_margin + _Top] = override[_margin + _Right] = override[_margin + _Bottom] = override[_margin + _Left] = "0";
|
|
override[_padding] = cs2[_padding];
|
|
override[_padding + _Top] = cs2[_padding + _Top];
|
|
override[_padding + _Right] = cs2[_padding + _Right];
|
|
override[_padding + _Bottom] = cs2[_padding + _Bottom];
|
|
override[_padding + _Left] = cs2[_padding + _Left];
|
|
pinActiveState = _copyState(pinOriginalState, override, pinReparent);
|
|
_refreshingAll && scrollFunc(0);
|
|
}
|
|
if (animation) {
|
|
initted = animation._initted;
|
|
_suppressOverwrites(1);
|
|
animation.render(animation.duration(), true, true);
|
|
pinChange = pinGetter(direction.a) - pinStart + change + otherPinOffset;
|
|
pinMoves = Math.abs(change - pinChange) > 1;
|
|
useFixedPosition && pinMoves && pinActiveState.splice(pinActiveState.length - 2, 2);
|
|
animation.render(0, true, true);
|
|
initted || animation.invalidate(true);
|
|
animation.parent || animation.totalTime(animation.totalTime());
|
|
_suppressOverwrites(0);
|
|
} else {
|
|
pinChange = change;
|
|
}
|
|
forcedOverflow && (forcedOverflow.value ? forcedOverflow.style["overflow" + direction.a.toUpperCase()] = forcedOverflow.value : forcedOverflow.style.removeProperty("overflow-" + direction.a));
|
|
} else if (trigger && scrollFunc() && !containerAnimation) {
|
|
bounds = trigger.parentNode;
|
|
while (bounds && bounds !== _body2) {
|
|
if (bounds._pinOffset) {
|
|
start -= bounds._pinOffset;
|
|
end -= bounds._pinOffset;
|
|
}
|
|
bounds = bounds.parentNode;
|
|
}
|
|
}
|
|
revertedPins && revertedPins.forEach(function(t) {
|
|
return t.revert(false, true);
|
|
});
|
|
self.start = start;
|
|
self.end = end;
|
|
scroll1 = scroll2 = _refreshingAll ? prevScroll : scrollFunc();
|
|
if (!containerAnimation && !_refreshingAll) {
|
|
scroll1 < prevScroll && scrollFunc(prevScroll);
|
|
self.scroll.rec = 0;
|
|
}
|
|
self.revert(false, true);
|
|
lastRefresh = _getTime2();
|
|
if (snapDelayedCall) {
|
|
lastSnap = -1;
|
|
snapDelayedCall.restart(true);
|
|
}
|
|
_refreshing = 0;
|
|
animation && isToggle && (animation._initted || prevAnimProgress) && animation.progress() !== prevAnimProgress && animation.progress(prevAnimProgress || 0, true).render(animation.time(), true, true);
|
|
if (isFirstRefresh || prevProgress !== self.progress || containerAnimation || invalidateOnRefresh || animation && !animation._initted) {
|
|
animation && !isToggle && (animation._initted || prevProgress || animation.vars.immediateRender !== false) && animation.totalProgress(containerAnimation && start < -1e-3 && !prevProgress ? gsap2.utils.normalize(start, end, 0) : prevProgress, true);
|
|
self.progress = isFirstRefresh || (scroll1 - start) / change === prevProgress ? 0 : prevProgress;
|
|
}
|
|
pin && pinSpacing && (spacer._pinOffset = Math.round(self.progress * pinChange));
|
|
scrubTween && scrubTween.invalidate();
|
|
if (!isNaN(markerStartOffset)) {
|
|
markerStartOffset -= gsap2.getProperty(markerStartTrigger, direction.p);
|
|
markerEndOffset -= gsap2.getProperty(markerEndTrigger, direction.p);
|
|
_shiftMarker(markerStartTrigger, direction, markerStartOffset);
|
|
_shiftMarker(markerStart, direction, markerStartOffset - (pinOffset || 0));
|
|
_shiftMarker(markerEndTrigger, direction, markerEndOffset);
|
|
_shiftMarker(markerEnd, direction, markerEndOffset - (pinOffset || 0));
|
|
}
|
|
isFirstRefresh && !_refreshingAll && self.update();
|
|
if (onRefresh && !_refreshingAll && !executingOnRefresh) {
|
|
executingOnRefresh = true;
|
|
onRefresh(self);
|
|
executingOnRefresh = false;
|
|
}
|
|
};
|
|
self.getVelocity = function() {
|
|
return (scrollFunc() - scroll2) / (_getTime2() - _time2) * 1e3 || 0;
|
|
};
|
|
self.endAnimation = function() {
|
|
_endAnimation(self.callbackAnimation);
|
|
if (animation) {
|
|
scrubTween ? scrubTween.progress(1) : !animation.paused() ? _endAnimation(animation, animation.reversed()) : isToggle || _endAnimation(animation, self.direction < 0, 1);
|
|
}
|
|
};
|
|
self.labelToScroll = function(label) {
|
|
return animation && animation.labels && (start || self.refresh() || start) + animation.labels[label] / animation.duration() * change || 0;
|
|
};
|
|
self.getTrailing = function(name) {
|
|
var i = _triggers.indexOf(self), a = self.direction > 0 ? _triggers.slice(0, i).reverse() : _triggers.slice(i + 1);
|
|
return (_isString(name) ? a.filter(function(t) {
|
|
return t.vars.preventOverlaps === name;
|
|
}) : a).filter(function(t) {
|
|
return self.direction > 0 ? t.end <= start : t.start >= end;
|
|
});
|
|
};
|
|
self.update = function(reset, recordVelocity, forceFake) {
|
|
if (containerAnimation && !forceFake && !reset) {
|
|
return;
|
|
}
|
|
var scroll = _refreshingAll === true ? prevScroll : self.scroll(), p = reset ? 0 : (scroll - start) / change, clipped = p < 0 ? 0 : p > 1 ? 1 : p || 0, prevProgress2 = self.progress, isActive, wasActive, toggleState, action, stateChanged, toggled, isAtMax, isTakingAction;
|
|
if (recordVelocity) {
|
|
scroll2 = scroll1;
|
|
scroll1 = containerAnimation ? scrollFunc() : scroll;
|
|
if (snap) {
|
|
snap2 = snap1;
|
|
snap1 = animation && !isToggle ? animation.totalProgress() : clipped;
|
|
}
|
|
}
|
|
if (anticipatePin && pin && !_refreshing && !_startup2 && _lastScrollTime) {
|
|
if (!clipped && start < scroll + (scroll - scroll2) / (_getTime2() - _time2) * anticipatePin) {
|
|
clipped = 1e-4;
|
|
} else if (clipped === 1 && end > scroll + (scroll - scroll2) / (_getTime2() - _time2) * anticipatePin) {
|
|
clipped = 0.9999;
|
|
}
|
|
}
|
|
if (clipped !== prevProgress2 && self.enabled) {
|
|
isActive = self.isActive = !!clipped && clipped < 1;
|
|
wasActive = !!prevProgress2 && prevProgress2 < 1;
|
|
toggled = isActive !== wasActive;
|
|
stateChanged = toggled || !!clipped !== !!prevProgress2;
|
|
self.direction = clipped > prevProgress2 ? 1 : -1;
|
|
self.progress = clipped;
|
|
if (stateChanged && !_refreshing) {
|
|
toggleState = clipped && !prevProgress2 ? 0 : clipped === 1 ? 1 : prevProgress2 === 1 ? 2 : 3;
|
|
if (isToggle) {
|
|
action = !toggled && toggleActions[toggleState + 1] !== "none" && toggleActions[toggleState + 1] || toggleActions[toggleState];
|
|
isTakingAction = animation && (action === "complete" || action === "reset" || action in animation);
|
|
}
|
|
}
|
|
preventOverlaps && (toggled || isTakingAction) && (isTakingAction || scrub || !animation) && (_isFunction(preventOverlaps) ? preventOverlaps(self) : self.getTrailing(preventOverlaps).forEach(function(t) {
|
|
return t.endAnimation();
|
|
}));
|
|
if (!isToggle) {
|
|
if (scrubTween && !_refreshing && !_startup2) {
|
|
scrubTween._dp._time - scrubTween._start !== scrubTween._time && scrubTween.render(scrubTween._dp._time - scrubTween._start);
|
|
if (scrubTween.resetTo) {
|
|
scrubTween.resetTo("totalProgress", clipped, animation._tTime / animation._tDur);
|
|
} else {
|
|
scrubTween.vars.totalProgress = clipped;
|
|
scrubTween.invalidate().restart();
|
|
}
|
|
} else if (animation) {
|
|
animation.totalProgress(clipped, !!(_refreshing && (lastRefresh || reset)));
|
|
}
|
|
}
|
|
if (pin) {
|
|
reset && pinSpacing && (spacer.style[pinSpacing + direction.os2] = spacingStart);
|
|
if (!useFixedPosition) {
|
|
pinSetter(_round(pinStart + pinChange * clipped));
|
|
} else if (stateChanged) {
|
|
isAtMax = !reset && clipped > prevProgress2 && end + 1 > scroll && scroll + 1 >= _maxScroll(scroller, direction);
|
|
if (pinReparent) {
|
|
if (!reset && (isActive || isAtMax)) {
|
|
var bounds = _getBounds(pin, true), _offset = scroll - start;
|
|
_reparent(pin, _body2, bounds.top + (direction === _vertical ? _offset : 0) + _px, bounds.left + (direction === _vertical ? 0 : _offset) + _px);
|
|
} else {
|
|
_reparent(pin, spacer);
|
|
}
|
|
}
|
|
_setState(isActive || isAtMax ? pinActiveState : pinState);
|
|
pinMoves && clipped < 1 && isActive || pinSetter(pinStart + (clipped === 1 && !isAtMax ? pinChange : 0));
|
|
}
|
|
}
|
|
snap && !tweenTo.tween && !_refreshing && !_startup2 && snapDelayedCall.restart(true);
|
|
toggleClass && (toggled || once && clipped && (clipped < 1 || !_limitCallbacks)) && _toArray(toggleClass.targets).forEach(function(el) {
|
|
return el.classList[isActive || once ? "add" : "remove"](toggleClass.className);
|
|
});
|
|
onUpdate && !isToggle && !reset && onUpdate(self);
|
|
if (stateChanged && !_refreshing) {
|
|
if (isToggle) {
|
|
if (isTakingAction) {
|
|
if (action === "complete") {
|
|
animation.pause().totalProgress(1);
|
|
} else if (action === "reset") {
|
|
animation.restart(true).pause();
|
|
} else if (action === "restart") {
|
|
animation.restart(true);
|
|
} else {
|
|
animation[action]();
|
|
}
|
|
}
|
|
onUpdate && onUpdate(self);
|
|
}
|
|
if (toggled || !_limitCallbacks) {
|
|
onToggle && toggled && _callback(self, onToggle);
|
|
callbacks[toggleState] && _callback(self, callbacks[toggleState]);
|
|
once && (clipped === 1 ? self.kill(false, 1) : callbacks[toggleState] = 0);
|
|
if (!toggled) {
|
|
toggleState = clipped === 1 ? 1 : 3;
|
|
callbacks[toggleState] && _callback(self, callbacks[toggleState]);
|
|
}
|
|
}
|
|
if (fastScrollEnd && !isActive && Math.abs(self.getVelocity()) > (_isNumber(fastScrollEnd) ? fastScrollEnd : 2500)) {
|
|
_endAnimation(self.callbackAnimation);
|
|
scrubTween ? scrubTween.progress(1) : _endAnimation(animation, action === "reverse" ? 1 : !clipped, 1);
|
|
}
|
|
} else if (isToggle && onUpdate && !_refreshing) {
|
|
onUpdate(self);
|
|
}
|
|
}
|
|
if (markerEndSetter) {
|
|
var n = containerAnimation ? scroll / containerAnimation.duration() * (containerAnimation._caScrollDist || 0) : scroll;
|
|
markerStartSetter(n + (markerStartTrigger._isFlipped ? 1 : 0));
|
|
markerEndSetter(n);
|
|
}
|
|
caMarkerSetter && caMarkerSetter(-scroll / containerAnimation.duration() * (containerAnimation._caScrollDist || 0));
|
|
};
|
|
self.enable = function(reset, refresh) {
|
|
if (!self.enabled) {
|
|
self.enabled = true;
|
|
_addListener3(scroller, "resize", _onResize);
|
|
isViewport || _addListener3(scroller, "scroll", _onScroll3);
|
|
onRefreshInit && _addListener3(ScrollTrigger3, "refreshInit", onRefreshInit);
|
|
if (reset !== false) {
|
|
self.progress = prevProgress = 0;
|
|
scroll1 = scroll2 = lastSnap = scrollFunc();
|
|
}
|
|
refresh !== false && self.refresh();
|
|
}
|
|
};
|
|
self.getTween = function(snap3) {
|
|
return snap3 && tweenTo ? tweenTo.tween : scrubTween;
|
|
};
|
|
self.setPositions = function(newStart, newEnd, keepClamp, pinOffset) {
|
|
if (containerAnimation) {
|
|
var st = containerAnimation.scrollTrigger, duration = containerAnimation.duration(), _change = st.end - st.start;
|
|
newStart = st.start + _change * newStart / duration;
|
|
newEnd = st.start + _change * newEnd / duration;
|
|
}
|
|
self.refresh(false, false, {
|
|
start: _keepClamp(newStart, keepClamp && !!self._startClamp),
|
|
end: _keepClamp(newEnd, keepClamp && !!self._endClamp)
|
|
}, pinOffset);
|
|
self.update();
|
|
};
|
|
self.adjustPinSpacing = function(amount) {
|
|
if (spacerState && amount) {
|
|
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) {
|
|
reset !== false && self.revert(true, true);
|
|
if (self.enabled) {
|
|
self.enabled = self.isActive = false;
|
|
allowAnimation || scrubTween && scrubTween.pause();
|
|
prevScroll = 0;
|
|
pinCache && (pinCache.uncache = 1);
|
|
onRefreshInit && _removeListener3(ScrollTrigger3, "refreshInit", onRefreshInit);
|
|
if (snapDelayedCall) {
|
|
snapDelayedCall.pause();
|
|
tweenTo.tween && tweenTo.tween.kill() && (tweenTo.tween = 0);
|
|
}
|
|
if (!isViewport) {
|
|
var i = _triggers.length;
|
|
while (i--) {
|
|
if (_triggers[i].scroller === scroller && _triggers[i] !== self) {
|
|
return;
|
|
}
|
|
}
|
|
_removeListener3(scroller, "resize", _onResize);
|
|
isViewport || _removeListener3(scroller, "scroll", _onScroll3);
|
|
}
|
|
}
|
|
};
|
|
self.kill = function(revert, allowAnimation) {
|
|
self.disable(revert, allowAnimation);
|
|
scrubTween && !allowAnimation && scrubTween.kill();
|
|
id && delete _ids[id];
|
|
var i = _triggers.indexOf(self);
|
|
i >= 0 && _triggers.splice(i, 1);
|
|
i === _i && _direction > 0 && _i--;
|
|
i = 0;
|
|
_triggers.forEach(function(t) {
|
|
return t.scroller === self.scroller && (i = 1);
|
|
});
|
|
i || _refreshingAll || (self.scroll.rec = 0);
|
|
if (animation) {
|
|
animation.scrollTrigger = null;
|
|
revert && animation.revert({
|
|
kill: false
|
|
});
|
|
allowAnimation || animation.kill();
|
|
}
|
|
markerStart && [markerStart, markerEnd, markerStartTrigger, markerEndTrigger].forEach(function(m) {
|
|
return m.parentNode && m.parentNode.removeChild(m);
|
|
});
|
|
_primary === self && (_primary = 0);
|
|
if (pin) {
|
|
pinCache && (pinCache.uncache = 1);
|
|
i = 0;
|
|
_triggers.forEach(function(t) {
|
|
return t.pin === pin && i++;
|
|
});
|
|
i || (pinCache.spacer = 0);
|
|
}
|
|
vars.onKill && vars.onKill(self);
|
|
};
|
|
_triggers.push(self);
|
|
self.enable(false, false);
|
|
customRevertReturn && customRevertReturn(self);
|
|
if (animation && animation.add && !change) {
|
|
var updateFunc = self.update;
|
|
self.update = function() {
|
|
self.update = updateFunc;
|
|
_scrollers.cache++;
|
|
start || end || self.refresh();
|
|
};
|
|
gsap2.delayedCall(0.01, self.update);
|
|
change = 0.01;
|
|
start = end = 0;
|
|
} else {
|
|
self.refresh();
|
|
}
|
|
pin && _queueRefreshAll();
|
|
};
|
|
ScrollTrigger3.register = function register(core) {
|
|
if (!_coreInitted2) {
|
|
gsap2 = core || _getGSAP3();
|
|
_windowExists() && window.document && ScrollTrigger3.enable();
|
|
_coreInitted2 = _enabled;
|
|
}
|
|
return _coreInitted2;
|
|
};
|
|
ScrollTrigger3.defaults = function defaults(config) {
|
|
if (config) {
|
|
for (var p in config) {
|
|
_defaults[p] = config[p];
|
|
}
|
|
}
|
|
return _defaults;
|
|
};
|
|
ScrollTrigger3.disable = function disable(reset, kill) {
|
|
_enabled = 0;
|
|
_triggers.forEach(function(trigger) {
|
|
return trigger[kill ? "kill" : "disable"](reset);
|
|
});
|
|
_removeListener3(_win2, "wheel", _onScroll3);
|
|
_removeListener3(_doc2, "scroll", _onScroll3);
|
|
clearInterval(_syncInterval);
|
|
_removeListener3(_doc2, "touchcancel", _passThrough);
|
|
_removeListener3(_body2, "touchstart", _passThrough);
|
|
_multiListener(_removeListener3, _doc2, "pointerdown,touchstart,mousedown", _pointerDownHandler);
|
|
_multiListener(_removeListener3, _doc2, "pointerup,touchend,mouseup", _pointerUpHandler);
|
|
_resizeDelay.kill();
|
|
_iterateAutoRefresh(_removeListener3);
|
|
for (var i = 0; i < _scrollers.length; i += 3) {
|
|
_wheelListener(_removeListener3, _scrollers[i], _scrollers[i + 1]);
|
|
_wheelListener(_removeListener3, _scrollers[i], _scrollers[i + 2]);
|
|
}
|
|
};
|
|
ScrollTrigger3.enable = function enable() {
|
|
_win2 = window;
|
|
_doc2 = document;
|
|
_docEl2 = _doc2.documentElement;
|
|
_body2 = _doc2.body;
|
|
if (gsap2) {
|
|
_toArray = gsap2.utils.toArray;
|
|
_clamp2 = gsap2.utils.clamp;
|
|
_context2 = gsap2.core.context || _passThrough;
|
|
_suppressOverwrites = gsap2.core.suppressOverwrites || _passThrough;
|
|
_scrollRestoration = _win2.history.scrollRestoration || "auto";
|
|
_lastScroll = _win2.pageYOffset || 0;
|
|
gsap2.core.globals("ScrollTrigger", ScrollTrigger3);
|
|
if (_body2) {
|
|
_enabled = 1;
|
|
_div100vh = document.createElement("div");
|
|
_div100vh.style.height = "100vh";
|
|
_div100vh.style.position = "absolute";
|
|
_refresh100vh();
|
|
_rafBugFix();
|
|
Observer.register(gsap2);
|
|
ScrollTrigger3.isTouch = Observer.isTouch;
|
|
_fixIOSBug = Observer.isTouch && /(iPad|iPhone|iPod|Mac)/g.test(navigator.userAgent);
|
|
_ignoreMobileResize = Observer.isTouch === 1;
|
|
_addListener3(_win2, "wheel", _onScroll3);
|
|
_root2 = [_win2, _doc2, _docEl2, _body2];
|
|
if (gsap2.matchMedia) {
|
|
ScrollTrigger3.matchMedia = function(vars) {
|
|
var mm = gsap2.matchMedia(), p;
|
|
for (p in vars) {
|
|
mm.add(p, vars[p]);
|
|
}
|
|
return mm;
|
|
};
|
|
gsap2.addEventListener("matchMediaInit", function() {
|
|
_recordScrollPositions();
|
|
_revertAll();
|
|
});
|
|
gsap2.addEventListener("matchMediaRevert", function() {
|
|
return _revertRecorded();
|
|
});
|
|
gsap2.addEventListener("matchMedia", function() {
|
|
_refreshAll(0, 1);
|
|
_dispatch("matchMedia");
|
|
});
|
|
gsap2.matchMedia().add("(orientation: portrait)", function() {
|
|
_setBaseDimensions();
|
|
return _setBaseDimensions;
|
|
});
|
|
} else {
|
|
console.warn("Requires GSAP 3.11.0 or later");
|
|
}
|
|
_setBaseDimensions();
|
|
_addListener3(_doc2, "scroll", _onScroll3);
|
|
var bodyHasStyle = _body2.hasAttribute("style"), bodyStyle = _body2.style, border = bodyStyle.borderTopStyle, AnimationProto = gsap2.core.Animation.prototype, bounds, i;
|
|
AnimationProto.revert || Object.defineProperty(AnimationProto, "revert", {
|
|
value: function value() {
|
|
return this.time(-0.01, true);
|
|
}
|
|
});
|
|
bodyStyle.borderTopStyle = "solid";
|
|
bounds = _getBounds(_body2);
|
|
_vertical.m = Math.round(bounds.top + _vertical.sc()) || 0;
|
|
_horizontal.m = Math.round(bounds.left + _horizontal.sc()) || 0;
|
|
border ? bodyStyle.borderTopStyle = border : bodyStyle.removeProperty("border-top-style");
|
|
if (!bodyHasStyle) {
|
|
_body2.setAttribute("style", "");
|
|
_body2.removeAttribute("style");
|
|
}
|
|
_syncInterval = setInterval(_sync, 250);
|
|
gsap2.delayedCall(0.5, function() {
|
|
return _startup2 = 0;
|
|
});
|
|
_addListener3(_doc2, "touchcancel", _passThrough);
|
|
_addListener3(_body2, "touchstart", _passThrough);
|
|
_multiListener(_addListener3, _doc2, "pointerdown,touchstart,mousedown", _pointerDownHandler);
|
|
_multiListener(_addListener3, _doc2, "pointerup,touchend,mouseup", _pointerUpHandler);
|
|
_transformProp = gsap2.utils.checkPrefix("transform");
|
|
_stateProps.push(_transformProp);
|
|
_coreInitted2 = _getTime2();
|
|
_resizeDelay = gsap2.delayedCall(0.2, _refreshAll).pause();
|
|
_autoRefresh = [_doc2, "visibilitychange", function() {
|
|
var w = _win2.innerWidth, h = _win2.innerHeight;
|
|
if (_doc2.hidden) {
|
|
_prevWidth = w;
|
|
_prevHeight = h;
|
|
} else if (_prevWidth !== w || _prevHeight !== h) {
|
|
_onResize();
|
|
}
|
|
}, _doc2, "DOMContentLoaded", _refreshAll, _win2, "load", _refreshAll, _win2, "resize", _onResize];
|
|
_iterateAutoRefresh(_addListener3);
|
|
_triggers.forEach(function(trigger) {
|
|
return trigger.enable(0, 1);
|
|
});
|
|
for (i = 0; i < _scrollers.length; i += 3) {
|
|
_wheelListener(_removeListener3, _scrollers[i], _scrollers[i + 1]);
|
|
_wheelListener(_removeListener3, _scrollers[i], _scrollers[i + 2]);
|
|
}
|
|
} else if (_doc2) {
|
|
var onLoad = function onLoad2() {
|
|
ScrollTrigger3.enable();
|
|
_doc2.removeEventListener("DOMContentLoaded", onLoad2);
|
|
};
|
|
_doc2.addEventListener("DOMContentLoaded", onLoad);
|
|
}
|
|
}
|
|
};
|
|
ScrollTrigger3.config = function config(vars) {
|
|
"limitCallbacks" in vars && (_limitCallbacks = !!vars.limitCallbacks);
|
|
var ms = vars.syncInterval;
|
|
ms && clearInterval(_syncInterval) || (_syncInterval = ms) && setInterval(_sync, ms);
|
|
"ignoreMobileResize" in vars && (_ignoreMobileResize = ScrollTrigger3.isTouch === 1 && vars.ignoreMobileResize);
|
|
if ("autoRefreshEvents" in vars) {
|
|
_iterateAutoRefresh(_removeListener3) || _iterateAutoRefresh(_addListener3, vars.autoRefreshEvents || "none");
|
|
_ignoreResize = (vars.autoRefreshEvents + "").indexOf("resize") === -1;
|
|
}
|
|
};
|
|
ScrollTrigger3.scrollerProxy = function scrollerProxy(target, vars) {
|
|
var t = _getTarget(target), i = _scrollers.indexOf(t), isViewport = _isViewport3(t);
|
|
if (~i) {
|
|
_scrollers.splice(i, isViewport ? 6 : 2);
|
|
}
|
|
if (vars) {
|
|
isViewport ? _proxies.unshift(_win2, vars, _body2, vars, _docEl2, vars) : _proxies.unshift(t, vars);
|
|
}
|
|
};
|
|
ScrollTrigger3.clearMatchMedia = function clearMatchMedia(query) {
|
|
_triggers.forEach(function(t) {
|
|
return t._ctx && t._ctx.query === query && t._ctx.kill(true, true);
|
|
});
|
|
};
|
|
ScrollTrigger3.isInViewport = function isInViewport(element, ratio, horizontal) {
|
|
var bounds = (_isString(element) ? _getTarget(element) : element).getBoundingClientRect(), offset = bounds[horizontal ? _width : _height] * ratio || 0;
|
|
return horizontal ? bounds.right - offset > 0 && bounds.left + offset < _win2.innerWidth : bounds.bottom - offset > 0 && bounds.top + offset < _win2.innerHeight;
|
|
};
|
|
ScrollTrigger3.positionInViewport = function positionInViewport(element, referencePoint, horizontal) {
|
|
_isString(element) && (element = _getTarget(element));
|
|
var bounds = element.getBoundingClientRect(), size = bounds[horizontal ? _width : _height], offset = referencePoint == null ? size / 2 : referencePoint in _keywords ? _keywords[referencePoint] * size : ~referencePoint.indexOf("%") ? parseFloat(referencePoint) * size / 100 : parseFloat(referencePoint) || 0;
|
|
return horizontal ? (bounds.left + offset) / _win2.innerWidth : (bounds.top + offset) / _win2.innerHeight;
|
|
};
|
|
ScrollTrigger3.killAll = function killAll(allowListeners) {
|
|
_triggers.slice(0).forEach(function(t) {
|
|
return t.vars.id !== "ScrollSmoother" && t.kill();
|
|
});
|
|
if (allowListeners !== true) {
|
|
var listeners = _listeners.killAll || [];
|
|
_listeners = {};
|
|
listeners.forEach(function(f) {
|
|
return f();
|
|
});
|
|
}
|
|
};
|
|
return ScrollTrigger3;
|
|
})();
|
|
ScrollTrigger2.version = "3.15.0";
|
|
ScrollTrigger2.saveStyles = function(targets) {
|
|
return targets ? _toArray(targets).forEach(function(target) {
|
|
if (target && target.style) {
|
|
var i = _savedStyles.indexOf(target);
|
|
i >= 0 && _savedStyles.splice(i, 5);
|
|
_savedStyles.push(target, target.style.cssText, target.getBBox && target.getAttribute("transform"), gsap2.core.getCache(target), _context2());
|
|
}
|
|
}) : _savedStyles;
|
|
};
|
|
ScrollTrigger2.revert = function(soft, media) {
|
|
return _revertAll(!soft, media);
|
|
};
|
|
ScrollTrigger2.create = function(vars, animation) {
|
|
return new ScrollTrigger2(vars, animation);
|
|
};
|
|
ScrollTrigger2.refresh = function(safe) {
|
|
return safe ? _onResize(true) : (_coreInitted2 || ScrollTrigger2.register()) && _refreshAll(true);
|
|
};
|
|
ScrollTrigger2.update = function(force) {
|
|
return ++_scrollers.cache && _updateAll(force === true ? 2 : 0);
|
|
};
|
|
ScrollTrigger2.clearScrollMemory = _clearScrollMemory;
|
|
ScrollTrigger2.maxScroll = function(element, horizontal) {
|
|
return _maxScroll(element, horizontal ? _horizontal : _vertical);
|
|
};
|
|
ScrollTrigger2.getScrollFunc = function(element, horizontal) {
|
|
return _getScrollFunc(_getTarget(element), horizontal ? _horizontal : _vertical);
|
|
};
|
|
ScrollTrigger2.getById = function(id) {
|
|
return _ids[id];
|
|
};
|
|
ScrollTrigger2.getAll = function() {
|
|
return _triggers.filter(function(t) {
|
|
return t.vars.id !== "ScrollSmoother";
|
|
});
|
|
};
|
|
ScrollTrigger2.isScrolling = function() {
|
|
return !!_lastScrollTime;
|
|
};
|
|
ScrollTrigger2.snapDirectional = _snapDirectional;
|
|
ScrollTrigger2.addEventListener = function(type, callback) {
|
|
var a = _listeners[type] || (_listeners[type] = []);
|
|
~a.indexOf(callback) || a.push(callback);
|
|
};
|
|
ScrollTrigger2.removeEventListener = function(type, callback) {
|
|
var a = _listeners[type], i = a && a.indexOf(callback);
|
|
i >= 0 && a.splice(i, 1);
|
|
};
|
|
ScrollTrigger2.batch = function(targets, vars) {
|
|
var result = [], varsCopy = {}, interval = vars.interval || 0.016, batchMax = vars.batchMax || 1e9, proxyCallback = function proxyCallback2(type, callback) {
|
|
var elements = [], triggers = [], delay = gsap2.delayedCall(interval, function() {
|
|
callback(elements, triggers);
|
|
elements = [];
|
|
triggers = [];
|
|
}).pause();
|
|
return function(self) {
|
|
elements.length || delay.restart(true);
|
|
elements.push(self.trigger);
|
|
triggers.push(self);
|
|
batchMax <= elements.length && delay.progress(1);
|
|
};
|
|
}, p;
|
|
for (p in vars) {
|
|
varsCopy[p] = p.substr(0, 2) === "on" && _isFunction(vars[p]) && p !== "onRefreshInit" ? proxyCallback(p, vars[p]) : vars[p];
|
|
}
|
|
if (_isFunction(batchMax)) {
|
|
batchMax = batchMax();
|
|
_addListener3(ScrollTrigger2, "refresh", function() {
|
|
return batchMax = vars.batchMax();
|
|
});
|
|
}
|
|
_toArray(targets).forEach(function(target) {
|
|
var config = {};
|
|
for (p in varsCopy) {
|
|
config[p] = varsCopy[p];
|
|
}
|
|
config.trigger = target;
|
|
result.push(ScrollTrigger2.create(config));
|
|
});
|
|
return result;
|
|
};
|
|
var _clampScrollAndGetDurationMultiplier = function _clampScrollAndGetDurationMultiplier2(scrollFunc, current, end, max) {
|
|
current > max ? scrollFunc(max) : current < 0 && scrollFunc(0);
|
|
return end > max ? (max - current) / (end - current) : end < 0 ? current / (current - end) : 1;
|
|
};
|
|
var _allowNativePanning = function _allowNativePanning2(target, direction) {
|
|
if (direction === true) {
|
|
target.style.removeProperty("touch-action");
|
|
} else {
|
|
target.style.touchAction = direction === true ? "auto" : direction ? "pan-" + direction + (Observer.isTouch ? " pinch-zoom" : "") : "none";
|
|
}
|
|
target === _docEl2 && _allowNativePanning2(_body2, direction);
|
|
};
|
|
var _overflow = {
|
|
auto: 1,
|
|
scroll: 1
|
|
};
|
|
var _nestedScroll = function _nestedScroll2(_ref5) {
|
|
var event = _ref5.event, target = _ref5.target, axis = _ref5.axis;
|
|
var node = (event.changedTouches ? event.changedTouches[0] : event).target, cache = node._gsap || gsap2.core.getCache(node), time = _getTime2(), cs;
|
|
if (!cache._isScrollT || time - cache._isScrollT > 2e3) {
|
|
while (node && node !== _body2 && (node.scrollHeight <= node.clientHeight && node.scrollWidth <= node.clientWidth || !(_overflow[(cs = _getComputedStyle(node)).overflowY] || _overflow[cs.overflowX]))) {
|
|
node = node.parentNode;
|
|
}
|
|
cache._isScroll = node && node !== target && !_isViewport3(node) && (_overflow[(cs = _getComputedStyle(node)).overflowY] || _overflow[cs.overflowX]);
|
|
cache._isScrollT = time;
|
|
}
|
|
if (cache._isScroll || axis === "x") {
|
|
event.stopPropagation();
|
|
event._gsapAllow = true;
|
|
}
|
|
};
|
|
var _inputObserver = function _inputObserver2(target, type, inputs, nested) {
|
|
return Observer.create({
|
|
target,
|
|
capture: true,
|
|
debounce: false,
|
|
lockAxis: true,
|
|
type,
|
|
onWheel: nested = nested && _nestedScroll,
|
|
onPress: nested,
|
|
onDrag: nested,
|
|
onScroll: nested,
|
|
onEnable: function onEnable() {
|
|
return inputs && _addListener3(_doc2, Observer.eventTypes[0], _captureInputs, false, true);
|
|
},
|
|
onDisable: function onDisable() {
|
|
return _removeListener3(_doc2, Observer.eventTypes[0], _captureInputs, true);
|
|
}
|
|
});
|
|
};
|
|
var _inputExp = /(input|label|select|textarea)/i;
|
|
var _inputIsFocused;
|
|
var _captureInputs = function _captureInputs2(e) {
|
|
var isInput = _inputExp.test(e.target.tagName);
|
|
if (isInput || _inputIsFocused) {
|
|
e._gsapAllow = true;
|
|
_inputIsFocused = isInput;
|
|
}
|
|
};
|
|
var _getScrollNormalizer = function _getScrollNormalizer2(vars) {
|
|
_isObject(vars) || (vars = {});
|
|
vars.preventDefault = vars.isNormalizer = vars.allowClicks = true;
|
|
vars.type || (vars.type = "wheel,touch");
|
|
vars.debounce = !!vars.debounce;
|
|
vars.id = vars.id || "normalizer";
|
|
var _vars2 = vars, normalizeScrollX = _vars2.normalizeScrollX, momentum = _vars2.momentum, allowNestedScroll = _vars2.allowNestedScroll, onRelease = _vars2.onRelease, self, maxY, target = _getTarget(vars.target) || _docEl2, smoother = gsap2.core.globals().ScrollSmoother, smootherInstance = smoother && smoother.get(), content = _fixIOSBug && (vars.content && _getTarget(vars.content) || smootherInstance && vars.content !== false && !smootherInstance.smooth() && smootherInstance.content()), scrollFuncY = _getScrollFunc(target, _vertical), scrollFuncX = _getScrollFunc(target, _horizontal), scale = 1, initialScale = (Observer.isTouch && _win2.visualViewport ? _win2.visualViewport.scale * _win2.visualViewport.width : _win2.outerWidth) / _win2.innerWidth, wheelRefresh = 0, resolveMomentumDuration = _isFunction(momentum) ? function() {
|
|
return momentum(self);
|
|
} : function() {
|
|
return momentum || 2.8;
|
|
}, lastRefreshID, skipTouchMove, inputObserver = _inputObserver(target, vars.type, true, allowNestedScroll), resumeTouchMove = function resumeTouchMove2() {
|
|
return skipTouchMove = false;
|
|
}, scrollClampX = _passThrough, scrollClampY = _passThrough, updateClamps = function updateClamps2() {
|
|
maxY = _maxScroll(target, _vertical);
|
|
scrollClampY = _clamp2(_fixIOSBug ? 1 : 0, maxY);
|
|
normalizeScrollX && (scrollClampX = _clamp2(0, _maxScroll(target, _horizontal)));
|
|
lastRefreshID = _refreshID;
|
|
}, removeContentOffset = function removeContentOffset2() {
|
|
content._gsap.y = _round(parseFloat(content._gsap.y) + scrollFuncY.offset) + "px";
|
|
content.style.transform = "matrix3d(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, " + parseFloat(content._gsap.y) + ", 0, 1)";
|
|
scrollFuncY.offset = scrollFuncY.cacheID = 0;
|
|
}, ignoreDrag = function ignoreDrag2() {
|
|
if (skipTouchMove) {
|
|
requestAnimationFrame(resumeTouchMove);
|
|
var offset = _round(self.deltaY / 2), scroll = scrollClampY(scrollFuncY.v - offset);
|
|
if (content && scroll !== scrollFuncY.v + scrollFuncY.offset) {
|
|
scrollFuncY.offset = scroll - scrollFuncY.v;
|
|
var y = _round((parseFloat(content && content._gsap.y) || 0) - scrollFuncY.offset);
|
|
content.style.transform = "matrix3d(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, " + y + ", 0, 1)";
|
|
content._gsap.y = y + "px";
|
|
scrollFuncY.cacheID = _scrollers.cache;
|
|
_updateAll();
|
|
}
|
|
return true;
|
|
}
|
|
scrollFuncY.offset && removeContentOffset();
|
|
skipTouchMove = true;
|
|
}, tween, startScrollX, startScrollY, onStopDelayedCall, onResize = function onResize2() {
|
|
updateClamps();
|
|
if (tween.isActive() && tween.vars.scrollY > maxY) {
|
|
scrollFuncY() > maxY ? tween.progress(1) && scrollFuncY(maxY) : tween.resetTo("scrollY", maxY);
|
|
}
|
|
};
|
|
content && gsap2.set(content, {
|
|
y: "+=0"
|
|
});
|
|
vars.ignoreCheck = function(e) {
|
|
return _fixIOSBug && e.type === "touchmove" && ignoreDrag(e) || scale > 1.05 && e.type !== "touchstart" || self.isGesturing || e.touches && e.touches.length > 1;
|
|
};
|
|
vars.onPress = function() {
|
|
skipTouchMove = false;
|
|
var prevScale = scale;
|
|
scale = _round((_win2.visualViewport && _win2.visualViewport.scale || 1) / initialScale);
|
|
tween.pause();
|
|
prevScale !== scale && _allowNativePanning(target, scale > 1.01 ? true : normalizeScrollX ? false : "x");
|
|
startScrollX = scrollFuncX();
|
|
startScrollY = scrollFuncY();
|
|
updateClamps();
|
|
lastRefreshID = _refreshID;
|
|
};
|
|
vars.onRelease = vars.onGestureStart = function(self2, wasDragging) {
|
|
scrollFuncY.offset && removeContentOffset();
|
|
if (!wasDragging) {
|
|
onStopDelayedCall.restart(true);
|
|
} else {
|
|
_scrollers.cache++;
|
|
var dur = resolveMomentumDuration(), currentScroll, endScroll;
|
|
if (normalizeScrollX) {
|
|
currentScroll = scrollFuncX();
|
|
endScroll = currentScroll + dur * 0.05 * -self2.velocityX / 0.227;
|
|
dur *= _clampScrollAndGetDurationMultiplier(scrollFuncX, currentScroll, endScroll, _maxScroll(target, _horizontal));
|
|
tween.vars.scrollX = scrollClampX(endScroll);
|
|
}
|
|
currentScroll = scrollFuncY();
|
|
endScroll = currentScroll + dur * 0.05 * -self2.velocityY / 0.227;
|
|
dur *= _clampScrollAndGetDurationMultiplier(scrollFuncY, currentScroll, endScroll, _maxScroll(target, _vertical));
|
|
tween.vars.scrollY = scrollClampY(endScroll);
|
|
tween.invalidate().duration(dur).play(0.01);
|
|
if (_fixIOSBug && tween.vars.scrollY >= maxY || currentScroll >= maxY - 1) {
|
|
gsap2.to({}, {
|
|
onUpdate: onResize,
|
|
duration: dur
|
|
});
|
|
}
|
|
}
|
|
onRelease && onRelease(self2);
|
|
};
|
|
vars.onWheel = function() {
|
|
tween._ts && tween.pause();
|
|
if (_getTime2() - wheelRefresh > 1e3) {
|
|
lastRefreshID = 0;
|
|
wheelRefresh = _getTime2();
|
|
}
|
|
};
|
|
vars.onChange = function(self2, dx, dy, xArray, yArray) {
|
|
_refreshID !== lastRefreshID && updateClamps();
|
|
dx && normalizeScrollX && scrollFuncX(scrollClampX(xArray[2] === dx ? startScrollX + (self2.startX - self2.x) : scrollFuncX() + dx - xArray[1]));
|
|
if (dy) {
|
|
scrollFuncY.offset && removeContentOffset();
|
|
var isTouch = yArray[2] === dy, y = isTouch ? startScrollY + self2.startY - self2.y : scrollFuncY() + dy - yArray[1], yClamped = scrollClampY(y);
|
|
isTouch && y !== yClamped && (startScrollY += yClamped - y);
|
|
scrollFuncY(yClamped);
|
|
}
|
|
(dy || dx) && _updateAll();
|
|
};
|
|
vars.onEnable = function() {
|
|
_allowNativePanning(target, normalizeScrollX ? false : "x");
|
|
ScrollTrigger2.addEventListener("refresh", onResize);
|
|
_addListener3(_win2, "resize", onResize);
|
|
if (scrollFuncY.smooth) {
|
|
scrollFuncY.target.style.scrollBehavior = "auto";
|
|
scrollFuncY.smooth = scrollFuncX.smooth = false;
|
|
}
|
|
inputObserver.enable();
|
|
};
|
|
vars.onDisable = function() {
|
|
_allowNativePanning(target, true);
|
|
_removeListener3(_win2, "resize", onResize);
|
|
ScrollTrigger2.removeEventListener("refresh", onResize);
|
|
inputObserver.kill();
|
|
};
|
|
vars.lockAxis = vars.lockAxis !== false;
|
|
self = new Observer(vars);
|
|
self.iOS = _fixIOSBug;
|
|
_fixIOSBug && !scrollFuncY() && scrollFuncY(1);
|
|
_fixIOSBug && gsap2.ticker.add(_passThrough);
|
|
onStopDelayedCall = self._dc;
|
|
tween = gsap2.to(self, {
|
|
ease: "power4",
|
|
paused: true,
|
|
inherit: false,
|
|
scrollX: normalizeScrollX ? "+=0.1" : "+=0",
|
|
scrollY: "+=0.1",
|
|
modifiers: {
|
|
scrollY: _interruptionTracker(scrollFuncY, scrollFuncY(), function() {
|
|
return tween.pause();
|
|
})
|
|
},
|
|
onUpdate: _updateAll,
|
|
onComplete: onStopDelayedCall.vars.onComplete
|
|
});
|
|
return self;
|
|
};
|
|
ScrollTrigger2.sort = function(func) {
|
|
if (_isFunction(func)) {
|
|
return _triggers.sort(func);
|
|
}
|
|
var scroll = _win2.pageYOffset || 0;
|
|
ScrollTrigger2.getAll().forEach(function(t) {
|
|
return t._sortY = t.trigger ? scroll + t.trigger.getBoundingClientRect().top : t.start + _win2.innerHeight;
|
|
});
|
|
return _triggers.sort(func || function(a, b) {
|
|
return (a.vars.refreshPriority || 0) * -1e6 + (a.vars.containerAnimation ? 1e6 : a._sortY) - ((b.vars.containerAnimation ? 1e6 : b._sortY) + (b.vars.refreshPriority || 0) * -1e6);
|
|
});
|
|
};
|
|
ScrollTrigger2.observe = function(vars) {
|
|
return new Observer(vars);
|
|
};
|
|
ScrollTrigger2.normalizeScroll = function(vars) {
|
|
if (typeof vars === "undefined") {
|
|
return _normalizer2;
|
|
}
|
|
if (vars === true && _normalizer2) {
|
|
return _normalizer2.enable();
|
|
}
|
|
if (vars === false) {
|
|
_normalizer2 && _normalizer2.kill();
|
|
_normalizer2 = vars;
|
|
return;
|
|
}
|
|
var normalizer = vars instanceof Observer ? vars : _getScrollNormalizer(vars);
|
|
_normalizer2 && _normalizer2.target === normalizer.target && _normalizer2.kill();
|
|
_isViewport3(normalizer.target) && (_normalizer2 = normalizer);
|
|
return normalizer;
|
|
};
|
|
ScrollTrigger2.core = {
|
|
// smaller file size way to leverage in ScrollSmoother and Observer
|
|
_getVelocityProp,
|
|
_inputObserver,
|
|
_scrollers,
|
|
_proxies,
|
|
bridge: {
|
|
// when normalizeScroll sets the scroll position (ss = setScroll)
|
|
ss: function ss() {
|
|
_lastScrollTime || _dispatch("scrollStart");
|
|
_lastScrollTime = _getTime2();
|
|
},
|
|
// a way to get the _refreshing value in Observer
|
|
ref: function ref() {
|
|
return _refreshing;
|
|
}
|
|
}
|
|
};
|
|
_getGSAP3() && gsap2.registerPlugin(ScrollTrigger2);
|
|
export {
|
|
ScrollTrigger2 as ScrollTrigger,
|
|
ScrollTrigger2 as default
|
|
};
|
|
//# sourceMappingURL=gsap_ScrollTrigger.js.map
|